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 create | A bin: a URL such as https://nnbin.net/b/k7xq2mbn9tfa |
| What it records | Every 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 back | 200 and {"status":"accepted"}, at once |
| Forwarding | On Starter, Pro and Custom, a bin can also send each request on to your own https URL (Forwarding) |
| Console | https://bins.nimbusnexus.net |
| API base URL | https://bins.nimbusnexus.net/v1 |
| Authentication | Authorization: Bearer <key>, a key created in the account console with Request Bins as the product |
| Identifier every route takes | The bin id, for example bin_3f9a1c7e5b2d8f4a6c0e9b17 — not its URL |
| Find a bin by its URL | GET /v1/bins?url=<url> |
| Read what arrived | GET /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 limits | The Request Bins reference |
How it works
- 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. - 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
curlit yourself. Anything after the slug is yours to choose: a request tohttps://nnbin.net/b/k7xq2mbn9tfa/orders/42is recorded with the path/orders/42. - 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,fieldandmethodin 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}/pathsdoes the same in the API (Requests by path). All bins in the console, andGET /v1/requestsin the API, list what every bin recorded in one list, with the same search. - 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, withRetry-After, when the sender or the bin is over its per-minute limit;503, withRetry-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,
truncatedistrue, andsize_bytesstill says how large it really was. - Credentials are redacted. The values of
Authorization,Proxy-Authorization,Cookie,Set-CookieandX-API-Keyare 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
| Free | Starter | Pro | Custom | |
|---|---|---|---|---|
| Price | $0 | $9 a month, or $86.40 a year | $29 a month, or $278.40 a year | by contract |
| Bins at once | 1 | 5 | 25 | 250 |
| Requests recorded per month | 1,000 | 25,000 | 250,000 | 5,000,000 |
| More requests, bought with credit | 10,000 for $4 | 10,000 for $4 | 10,000 for $4 | by contract |
| Kept for (retention) | 1 day | 7 days | 30 days | 90 days |
| Bin lifetime | 24 hours | until deleted, or up to 7 days if you set one | until deleted, or up to 30 days | until deleted, or up to a year |
| Read over the API | no (console only) | yes | yes | yes |
| Forwarding, per bin | no | 60 requests a minute | 300 requests a minute | 600 requests a minute |
| Distinct senders per bin | 50 | 200 | 500 | 2,000 |
| Browser form posts per bin | 3 | 5 | 5 | 10 |
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
200with{"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}/requestswithsince, 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.