Skip to content
NimbusNexus

Request Bins

NimbusNexus Request Bins gives you bins: public URLs that record every HTTP request sent to them, with any method, to any path under the URL, with any body. Point whatever sends HTTP at one — a webhook provider, your own app, a script, a CI job — and read exactly what arrived: the method, path, query, headers, body and the address it came from, in the console or over the REST API.

Not the page you wanted? A bin records what it receives and answers every sender the same way. On a paid plan it can also pass each request on to one URL of yours, as it arrived (Forwarding), but it doesn't check signatures or deliver to several endpoints. To verify a provider's webhooks and deliver them as events to your endpoints, with a dead-letter queue and redelivery, use a Webhooks source.

At a glance

What you createA bin: a URL such as https://nnbin.net/b/k7xq2mbn9tfa
What it recordsEvery request to that URL or any path under it, with any method (GET, POST, WebDAV's PROPFIND, a sender's own), any headers and any body
What a sender gets back200 and {"status":"accepted"}, at once
ForwardingOn Starter, Pro and Custom, a bin can also send each request on to your own https URL (Forwarding)
Consolehttps://bins.nimbusnexus.net
API base URLhttps://bins.nimbusnexus.net/v1
AuthenticationAuthorization: Bearer <key>, a key created in the account console with Request Bins as the product
Identifier every route takesThe bin id, for example bin_3f9a1c7e5b2d8f4a6c0e9b17 — not its URL
Find a bin by its URLGET /v1/bins?url=<url>
Read what arrivedGET /v1/bins/{id}/requests, or GET /v1/requests for every bin at once (paid plans; Free reads in the console)
Every route, what a bin URL answers, roles and limitsThe Request Bins reference

How it works

  1. Create a bin — in the console with Create a bin (New bin once you have one), or with POST /v1/bins. Its URL records from that moment.
  2. Send it requests. Give the URL to whatever you want to watch — a provider's webhook settings, your app's configuration, a script, a CI job — or curl it yourself. Anything after the slug is yours to choose: a request to https://nnbin.net/b/k7xq2mbn9tfa/orders/42 is recorded with the path /orders/42.
  3. Read what arrived. It appears in the console within seconds, and on paid plans at GET /v1/bins/{id}/requests. To find one request among many, search for text in paths, headers and bodies, or in only one of them, one header or one field of a JSON body, or keep only some methods: Search, Search in and the method chips above the list in the console, q, in, header, field and method in the API (Captured requests). To see which paths a sender used, switch the list to By path: it counts the requests to each path, and picking one lists them. GET /v1/bins/{id}/paths does the same in the API (Requests by path). All bins in the console, and GET /v1/requests in the API, list what every bin recorded in one list, with the same search.
  4. Delete the bin when you are done, or let it expire.

The quickstart does all four.

Use the url exactly as the API returns it. Bin URLs live on their own domain, nnbin.net, not on nimbusnexus.net.

What a sender gets back

A bin answers every request at once with 200 and the body {"status":"accepted"}, whether it recorded the request or not. A bin that is disabled, suspended or past its plan's monthly requests answers the same way, and so does a URL whose bin never existed or was deleted. That is deliberate: a sender that gets an error may stop sending, or switch your webhook off, and a different answer for a live bin would let anyone probe for bins.

A bin URL answers anything else only when nothing was recorded:

  • 429, with Retry-After, when the sender or the bin is over its per-minute limit;
  • 503, with Retry-After, when the request couldn't be stored just now, so the sender should send it again;
  • 404, when the slug in the URL isn't one Request Bins could ever have issued.

The reference has the details: what a bin URL answers.

What is recorded

For each request, a bin keeps the method, the path after the slug, the query string, the headers in the order they arrived, the body, the address it came from, and when it arrived. A few rules shape what you read back:

  • Bodies are stored whole, up to 1 MiB. A larger body keeps its first 1 MiB, truncated is true, and size_bytes still says how large it really was.
  • Credentials are redacted. The values of Authorization, Proxy-Authorization, Cookie, Set-Cookie and X-API-Key are replaced with [redacted] before anything is stored. Every other header is kept as sent, signature headers included, since a signature is what you need to see when verifying one fails.
  • Nothing is changed or run. A body is stored as the bytes that arrived, and the console shows it as text, never as markup.
  • Every request is a row of its own. A request sent again, with the same method, path, query string and body, is stored again, with its own headers, address and time, so each of a sender's retries can be opened on its own.

Forwarding

On Starter, Pro and Custom, a bin can also send each request it records on to your own server. Give it a forward URL, and the method, path, query, headers and body go on to that URL as they arrived, while the sender still gets the bin's 200 at once. The bin tries again when your server fails, and keeps what your server answered beside the request, so you see what a sender sent and what your endpoint made of it. Credentials aren't forwarded: the headers a bin redacts never leave it. Forwarding has the rules, the retries, the limits and the address forwards come from.

Plans and limits

FreeStarterProCustom
Price$0$9 a month, or $86.40 a year$29 a month, or $278.40 a yearby contract
Bins at once1525250
Requests recorded per month1,00025,000250,0005,000,000
More requests, bought with credit10,000 for $410,000 for $410,000 for $4by contract
Kept for (retention)1 day7 days30 days90 days
Bin lifetime24 hoursuntil deleted, or up to 7 days if you set oneuntil deleted, or up to 30 daysuntil deleted, or up to a year
Read over the APIno (console only)yesyesyes
Forwarding, per binno60 requests a minute300 requests a minute600 requests a minute
Distinct senders per bin502005002,000
Browser form posts per bin35510

Free is enough to see exactly what any app, script or service sends: one bin, 1,000 requests a month, read in the console.

The month is a calendar month in UTC, and every request a bin records counts. As the month's requests run out, credit in your workspace buys more, unless you switch that off (More requests with credit). Without it, past the month's requests, bins keep answering 200 and record nothing until the next month begins; requests refused that way don't count. One bin may use only part of the month, bought requests included — all of it on Free, half on Starter, 40% on Pro and a quarter on Custom — so one busy or leaked URL can't use up the requests of the workspace's other bins.

The last two rows are abuse limits, described under Suspended bins.

More requests with credit

Credit is a balance your workspace keeps for NimbusNexus products to spend when their month runs out. You add it in the account console, under Billing, where the Credit card also switches each product's spending on or off. It is on for Request Bins until you switch it off.

When 90% of the month's requests are used and fewer than 10,000 are left, Request Bins buys 10,000 more with credit for $4, on Free, Starter and Pro, for as long as the balance lasts. On Custom, more requests come by contract. Bought requests count for the rest of the month, each bin's share included, and lapse when it ends: a partly used block isn't refunded. The reference has the details.

Suspended bins

A bin URL is public: anyone who has it can send to it. That would make a bin a convenient place to collect what a phishing page's form submits, or data taken from strangers' machines, so a bin is suspended when its traffic looks like that:

  • it hears from more distinct addresses than the plan's distinct senders; or
  • it receives more form posts from web browsers than the plan's browser form posts, from at least three addresses.

A suspended bin keeps answering 200 and records nothing. The console says why, and so does suspended_code in the API. A suspension is ours, not your switch: enabling the bin doesn't lift it, so contact support if you think one is a mistake. Bins are also held back, without being deleted, when a plan change leaves the workspace more bins than the new plan allows, and while the workspace is suspended for an unpaid charge; each comes back once its cause is resolved.

To report a bin URL that is being abused, write to [email protected] with the full URL.

Getting access

Open the console at https://bins.nimbusnexus.net and sign in with your NimbusNexus account, or add Request Bins from Add a product in any NimbusNexus console. The first visit by a workspace owner or admin adds Request Bins to the workspace; other members can open it from then on. A personal workspace starts on Free, and a team workspace starts with a 7-day Starter trial.

Keys are not issued by the Request Bins API. Create one in your account console under API keys, with Request Bins as the product. A key is a JWT, so it begins eyJ. Present it as Authorization: Bearer <key> or X-API-Key: <key>.

Choose its permission when you create it: Read reads bins and what they recorded, and Read & write can also create, change, empty and delete bins. On Free a key can manage bins, but reading what they recorded over the API needs Starter or above; the console reads it on every plan. Who can do what has the full table, workspace roles included.

What it will not do

  • It does not answer with your response. Every bin answers 200 with {"status":"accepted"}; a status, headers or body of your choosing is not built.
  • It does not replay. A recorded request can't be sent again on demand. Forwarding sends each request on once, as it arrives.
  • It does not push. There is no stream and no callback: poll GET /v1/bins/{id}/requests with since, as the console does every 3 seconds.
  • It is not an archive. A request is deleted when the plan's retention runs out, and everything in a bin goes when the bin is deleted or expires.
  • It does not split a workspace by project. Request Bins serves whole workspaces, so guest seats and keys limited to one project are refused.

What's next

  • Quickstart — create a bin, send it a request, read it back.
  • Forwarding — send each request on to your own server, and see what it answered.
  • Request Bins reference — every route and field, what a bin URL answers, roles, scopes and limits.
  • Request Bins API — every operation, with the request in curl, TypeScript, Python or Go.
  • Errors — the error shape and the codes the API sends.