FetchSandbox

The "remembers what breaks" line is the whole reason I clicked. The APIs I integrate never fail cleanly. They pass in dev, pass in review, then throw a 500 once a week in production for reasons I can never reproduce on demand. Does FetchSandbox help with that kind of intermittent break, or is it aimed more at catching hard contract changes when a provider ships a new version? And does it cover webhook and callback flows, or just the requests I make outbound? Those inbound calls are where I get burned most and they're the hardest to test.

The worst production bugs are always the ones that look completely fine until a second system reacts. Your own code passes, the API returns 200, and then three hours later a duplicate webhook fires and someone gets charged twice. Curious what the most common failure pattern is across your 60 plus APIs, is there one class of bug that shows up regardless of which API you're testing?

the most-tests-stop-at-200 framing is exactly right. the bugs never live in the happy path, they live in the retry that fires twice and the webhook that lands out of order. good to see a tool pointed at that part specifically.

The "verify what happens after the 200 OK" framing is the actual gap for me — most of my integration bugs live in retries and webhook ordering, not the happy path. Two things I'd want to pin down before wiring it into a Claude Code loop: when I connect over MCP, does the failure library and my recorded scenarios live locally per-project or in your cloud, and can I pin a specific failure (say a Stripe webhook-out-of-order case) so a CI run replays it deterministically instead of re-deriving it each run? Determinism is what decides whether I'd gate a merge on it.

Congrats on the launch. I integrate several AI provider APIs in my product, and the painful breakages are never the loud ones. It's when the same endpoint quietly starts returning a slightly different shape, or a model name stops resolving one day. Does FetchSandbox catch that kind of quiet drift, or is it focused on hard failures?

Congrats Raj! It looks amazing and I wish you all the best here

The "verify what happens next" framing is exactly the gap — 200 OK tells you nothing about the retry/webhook/state mess that actually breaks in prod.Two things I'd want to know as someone wiring these into agents:When an agent drives this over MCP, does it get to discover the failure library as callable scenarios — enumerate and pick which failure to inject — or is scenario selection still human-curated and the agent just runs what you set up?And "remembers what breaks" — is that memory per-project, and does it auto-replay the known-break scenarios as a regression gate on the next change, so a fix that regresses gets caught without me re-describing the bug? @rnagulapalle

the dropped-vs-mid-response-timeout distinction @omri_ben_shoham1 raised is the one I'd want too. adjacent question: do you simulate variable latency (webhook arrives 3s vs 30s late) or is timing binary right now, on-time vs late?

the dedup/idempotency scenarios are the ones I'd actually use. when two CI runs hit the same sandboxed Stripe API concurrently, is state isolated per run, or can one job's retry storm bleed into another's results?

@Raj shipping duplicate/redelivery with the same event id is the one that matters most imo - idempotency bugs are the ones that actually cost people money in prod, way more than a webhook just being late. nice that you got that out fast. curious if dropped events also simulate a partial timeout (connection dies mid-response) vs a clean non-delivery, since those two failure modes get handled very differently in most retry logic

Hey bro The website icon is showing of Next.js default icon . It would be great if that shows your website's logo .

I have spent time debugging APIs where the request worked perfectly but the webhook created unexpected issues later. A tool that can consistently recreate those situations would have saved a lot of time. Nice work on tackling such a common challenge.

Love that it covers async edge cases most testing tools miss, the MCP integration with Cursor is super smooth. One thing that would make this a no-brainer for me: built-in support for replaying recorded webhook sequences against different environments, so I can validate that a staging deploy handles the exact same payload ordering as production without re-running the whole test suite.

the webhook replay feature is genuinely useful, finally a way to test retry logic without stubbing out half my codebase

the failure-library angle is interesting but the thing I'd want proven before trusting it: who keeps the simulated failure behavior itself honest against the real API over time? stripe changes retry semantics or adds a new webhook edge case, and if fetchsandbox's simulation of that api lags the real one, you get a false sense of security - green in the sandbox, still breaks in prod, just a different flavor of the same problem you're trying to solve. is that drift something you actively monitor per-API, or does it rely on someone reporting a mismatch?