Slow 2G latency
Hold every request for 2,000ms so you can prove your loading spinners appear — and stay visible long enough that nobody double-submits.
10:24:07.114 chaosbull · interceptor online
Break your frontend
on purpose.
ChaosBull is a Chrome extension that injects latency, dropped connections, HTTP 500s and corrupted payloads straight into your browser’s network traffic — so you can prove your error states, spinners and rollbacks work before a real outage does it for you.
FAULT INJECTION CONSOLE
api-gateway
auth-svc
cart-svc
payment-api
orders-db
redis-cache
--:--:--.--- awaiting steady-state…
// why chaosbull
Your happy path is the only path you’ve tested
Everything works on the office fibre. Then a real user opens the app on a phone in a tunnel — the request stalls, the server 500s, the payload arrives half-written — and the states you never exercised are the ones that ship broken. ChaosBull induces those failures on demand, in the browser, so you meet them on your terms.
In the page, not a proxy
ChaosBull swaps window.fetch and XMLHttpRequest in the page context. No proxy, no DevTools throttling profile, no config server — just the real faults, exactly where your code handles them.
Blast-radius aware
A preset is a hammer that breaks everything. A custom rule is a scalpel: one endpoint glob, one probability, one fault type. Break the payment call at 30% and leave the rest of the app fast.
Instant rollback
The master switch pauses every interception without losing your configured rules. One click back to steady state — so you can tell your bug from ChaosBull’s in seconds.
// the fault library
Four faults, one scalpel
Every failure mode a flaky network throws at a real user, on a switch. Fire them across the whole tab as a preset, or scope them to a single endpoint with a custom rule.
Offline mode
Block requests outright and throw a real TypeError: Failed to fetch, so your “you’re offline” state is tested, not assumed.
HTTP 500 injection
Return a genuine 500 Internal Server Error response so your frontend has to read the status code and render the fallback you wrote.
Corrupted JSON payload
Answer 200 OK with a deliberately malformed body — the fastest way to find out whether your parse path is wrapped in try/catch.
Surgical target rules
Match a URL glob like *api/v1/payment*, set latency, and fire only a percentage of the time. Break the checkout call, leave the images alone.
Live traffic logger
A terminal-style stream of every request ChaosBull touched on the tab — which fault hit, how long it was held, and where.
// interactive demo
Pull the trigger yourself
A sandboxed request, routed through the same fault types ChaosBull injects in a real page. Pick a fault, fire the request, and read exactly what your code would receive.
SELECT FAULT
runs against a mock endpoint — same code path as a live page
chaosbull — simulator
$ pick a fault and hit simulate…// the loop
How a chaos experiment works
A chaos experiment is a fixed sequence, not a set — so these steps are numbered on purpose. Target the blast radius, inject the fault, observe the reaction, roll back.
- 01
Target
Pick the blast radius. A preset hits every request; a custom rule scopes the fault to one endpoint glob and a probability.
- 02
Inject fault
ChaosBull replaces window.fetch and XMLHttpRequest, then delays, blocks, 500s, or corrupts the matching traffic in-page.
- 03
Observe
Watch the app react in real time and read the activity log. Did the spinner show? Did the retry banner fire? Did the tab survive?
- 04
Roll back
Flip the master switch off — or hit Reset Toolkit — and traffic passes straight through, unmodified, instantly.
// load unpackedDownload ZIP
Install the extension
ChaosBull ships as an unpacked developer extension — no Web Store listing, no auto-update, nothing running until you load it yourself. Eight steps, about a minute.
chaosbull · v1.0 · .zip
Extract, then load the folder in Chrome.
permissions: activeTab · storage — no network access of its own.
- 01Download the ChaosBull extension ZIP.
- 02Extract the downloaded file.
- 03Open Google Chrome.
- 04Go to chrome://extensions.
- 05Enable Developer Mode (top-right toggle).
- 06Click Load unpacked.
- 07Select the extracted ChaosBull folder.
- 08Extension installed and ready.
// in practice
What you’d actually catch
Concrete failures teams ship without noticing — because the happy path never surfaced them.
Prove the retry button works
Force an HTTP 500 on your data call and confirm the “Try again” control actually re-fetches instead of sitting dead.
Catch the double-submit bug
Add 2s of latency to a checkout POST and watch whether an un-disabled button lets an impatient user fire the order twice.
Harden the parse path
Return corrupted JSON to the one screen that renders it and find out if a single bad payload takes down the whole tab.
Rehearse the outage
Scope offline mode to a third-party API and confirm your app degrades to a calm empty state instead of a white screen.
// what’s next
More ways to break things, soon
ChaosBull is just getting started. New faults, more browsers, and shareable presets are in the works — get on the list to hear the moment they land.
coming soon
More faults are on the way
ChaosBull v1 is just the first four faults. Join the waitlist and we’ll email you once — when the next release lands. No spam, no newsletter, unsubscribe with a reply.
- Firefox & Edge builds
- Chrome Web Store one-click install
- Save & share fault presets
- Scheduled / recurring chaos runs
// faq
Questions from the console
The things a developer running experiments in production actually asks.
No. Every fault is simulated inside the browser tab. ChaosBull replaces window.fetch and XMLHttpRequest in the page — it never sends anything to your backend, so a 500 or an offline error is fabricated locally and your real server never sees the request.
It ships as an unpacked developer extension today. You download the ZIP, extract it, and load the folder from chrome://extensions with Developer Mode on. Nothing runs until you load it, and nothing auto-updates behind your back.
Yes — that’s what custom target rules are for. Give it a glob like *api/v1/payment*, a latency, a probability, and a fault type. Only matching requests are intercepted at that probability; everything else passes through untouched.
It’s the chance the fault fires on any matching request. Set 30% and, on average, 3 of every 10 matching requests fail while 7 succeed — useful for reproducing the intermittent failures that are hardest to catch.
Flip the master switch off and every interception pauses instantly while your rules stay configured — so you can tell whether a bug is yours or ChaosBull’s. Reset Toolkit wipes rules, presets and logs back to defaults.
Anything the page makes through fetch or XMLHttpRequest on the active tab. You can watch exactly what it touched — URL, method, status, applied fault and delay — in the live activity log.