Skip to Content
Public Beta: Direct engineering support available. Join Discord →

Mockbin.io vs. Slashbin: Request Bins and Webhook Delivery

What is mockbin?

mockbin is a free request-bin service: you get a URL, point anything at it, and read back the full request — method, headers, query, body. It was built as part of the Mashape/Kong tooling and needs no signup.

Three facts worth knowing before you rely on it:

  • mockbin.org is gone. The original host is dead. The live service is mockbin.io .
  • It is free and requires no account. Create a bin, use it, walk away.
  • It inspects; it does not deliver. mockbin shows you the request. It does not forward, transform, retry, or replay it to another system.

The live tool people mean when they say “mockbin” today is mockbin.io , by Zuplo — a free, no-signup rebuild written explicitly because the original went away. Their README says it plainly: “At Zuplo we were big fans of mockbin.org and used it for testing APIs and doing demos. Unfortunately, it was shut down.” It’s MIT-licensed and self-hostable.

Slashbin isn’t a drop-in replacement for either of them, and it shouldn’t be. mockbin gives you a throwaway URL that captures a request so you can look at it, and mocks an API response so you can develop against it. Slashbin is the piece you keep after that: a gateway that transforms, validates, and delivers those webhooks to real destinations, with retries and replay when something breaks. If all you need is to see one request right now, mockbin.io is faster than us and always will be.

Need an endpoint that is still there tomorrow? Slashbin’s Free plan takes an account, not a card.

Start Free

(opens in a new tab)

What mockbin is better at

  • Zero signup, zero configuration, zero cost. Open mockbin.io, create a bin, get a URL, paste it into a vendor’s dashboard. No account, no card, no project setup. Slashbin’s Free plan asks for no card either, but it still asks for an account and a data stream before the first webhook lands — for a ten-second question, that’s the wrong trade.
  • Mocking an API, not just capturing one. You can specify the status code, headers, and JSON body a bin returns, or upload an OpenAPI 3.1 document and get mocks generated from its schemas and examples. Slashbin has no mocking feature at all — it receives real vendor traffic, it doesn’t pretend to be a vendor.
  • Free and open source, and you can run it yourself. zuplo/mockbin is MIT-licensed: a Next.js frontend plus an API that persists to S3-compatible storage, deployable on your own infrastructure. Slashbin has no open-source component and no self-hosted option.
  • Nothing to lose. A bin is disposable by design. There’s no configuration to migrate, no schema to maintain, and nothing to turn off when you’re finished.

What Slashbin is better at

  • Being the permanent piece. A bin is a scratchpad — on mockbin.io the bin IDs live in your browser’s local storage, so the list is gone the moment you switch machines or clear it. Slashbin is infrastructure your production pipeline depends on tomorrow, not a URL you throw away this afternoon.
  • Transform and validate against one schema. Every inbound event is reshaped and checked against a Golden Model you define. Downstream code reads one canonical shape no matter which vendor sent it, and when a vendor renames a field, validation fails loudly at the boundary instead of quietly corrupting what’s downstream.
  • Deliver to real destinations with per-destination isolation. One inbound event fans out to every consumer that needs it, and a destination that starts failing is circuit-broken on its own without back-pressuring the others. See Fan-out.
  • Retries you didn’t have to write. Backoff, per-destination circuit breaking, and a dead-letter queue that holds the full payload until you fix the cause.
  • Replay from stored history. The original payload is kept byte-for-byte. When you fix a transform, Replay re-runs stored events through the current pipeline — you don’t ask the vendor to re-send.
  • Auditable delivery log per attempt. For every attempt to every destination: response code, body, timing, retry count. That’s the evidence that answers “did this event actually land?” three weeks later.

The short version: mockbin is where you look at a request once. Slashbin is where a request lives on its way to production destinations.

If you move from inspecting requests to running them in production, the schema becomes yours to own. You define one Golden Model per topic, and every inbound event is validated against it at the boundary. A vendor field rename then fails at that boundary with the raw payload kept, instead of reaching your code. The Stripe webhook transform recipe builds one from a real vendor payload.

When to use which

  • Is this vendor even sending anything, and what does it look like? → mockbin.io. Faster than signing up for anything, ours included.
  • I need an endpoint that returns a specific response so I can build against it. → mockbin.io. That’s mocking, and Slashbin doesn’t do it.
  • My mockbin.org URL stopped working and I need it back. → mockbin.io is the like-for-like replacement, and it’s free. Come to Slashbin when the integration graduates from “does this work” to “this must keep working.”
  • I want to run the bin on my own infrastructure. → zuplo/mockbin, MIT. We have no self-hosted option.
  • A production pipeline I rely on tomorrow. → Slashbin. Retries, replay, transform, fan-out, and a delivery log survive incidents; a disposable bin doesn’t.
  • Every vendor sends a different shape and my downstream code is full of adapter glue. → Slashbin. One Golden Model, validated at ingest, is the whole point.
  • I need to prove what happened three weeks ago. → Slashbin. Stored payload, stored transform result, stored delivery attempts.

Plenty of engineers use both, and the sequence is usually the same one: a bin during vendor onboarding, a gateway once the integration is real.

Feature comparison

Verified on 2026-07-30 against mockbin.io  and the zuplo/mockbin repository (MIT, last pushed 2026-06-09), plus Kong/insomnia-mockbin for the original project’s status. mockbin.org did not resolve in DNS on that date. Slashbin rows verified against the live product and pricing page the same day.

Capabilitymockbin (mockbin.io)Slashbin
Instant capture URL, no signupYesNo — account required
PriceFreeFree $0/mo (10,000 webhooks, no card) · Lite $10/mo (15,000)
Open source and self-hostableYes — MIT (zuplo/mockbin)Not offered today
Mock an API response, or a whole OpenAPI documentYes — OpenAPI 3.1Not the product model
Where your list of endpoints livesBrowser local storage onlyYour account, in the Console
Published retention window for captured requestsNot published3-day on Free, 7-day replay window on Lite, 30-day on Pro
Transform and validate against a canonical schemaNot the product modelYes — Golden Model
Deliver one event to N destinations with per-destination filtersNot the product modelYes — Fan-out
Retries with backoff and a dead-letter queueNot the product modelYes
Replay a stored raw payload through the current pipelineNot the product modelYes — Replay
Per-attempt delivery log (response code, body, timing)Not the product modelYes

“Not the product model” means the tool isn’t trying to do that job. mockbin is a capture-and-mock surface; it is not a delivery gateway, and it doesn’t claim to be. That’s a different shape of product, not a defect — and in the other direction, Slashbin genuinely can’t mock an API for you.