We call the UI you use to view HTTP traffic the inspector. In the inspector, you can view HTTP requests from multiple endpoints - the URL to which you send HTTP traffic.

When you create an endpoint, we'll give you the associated endpoint URL. You can send any HTTP requests to this endpoint, from any source. You can configure the endpoint as the destination URL for a webhook or send HTTP traffic from your application - we'll accept any valid HTTP request.

Create an endpoint

Visit and click the Create A Request Bin button to create your first endpoint.

If you choose to make your endpoint private, you'll be required to sign in. For more details on private endpoints, see the section on Public vs. Private Endpoints below.

You should see your endpoint URL appear shortly. This URL should be a host on the domain


You can make any valid HTTP request to any protocol (HTTP or HTTPS), path or resource on this host. The host will always respond with a 200 OK, and will log the request in the inspector for further examination.

Signing into your RequestBin account

You'll notice an option to Sign In to the Inspector at the top-right. Signing in provides the ability to create Private Endpoints, which restricts other users from viewing data sent to your endpoint.

If you haven't yet created a RequestBin account, you'll be prompted to log in using either your Github or Google account. If you don't have an account with either service, they're both free and it only takes a couple of minutes to sign up!

Currently, there's no option to create a RequestBin account using a custom username and password - we rely on these third party identity providers for login today.

After signing in with your chosen identity provider, you'll be prompted to choose a username. This username is unique to RequestBin, but can be the same as your Github username or Google email address, as long as that username isn't already taken by another user.

Public vs. Private endpoints

Data sent to endpoints can be either public or private. Making an endpoint private requires signing into your RequestBin account.

"Private" in this context means: the account that created this endpoint is the only person that can view data sent to this endpoint in the Inspector. With public endpoints, anyone with the endpoint URL can view the data sent to that endpoint. If this isn't the behavior you want, you can sign into your RequestBin account and create a private endpoint.

Whether your endpoint is configured as public or private, anyone can send HTTP requests to the associated endpoint URL.

By default, endpoints created when you're logged into your RequestBin account are set to private. You can toggle this near the top-left of the Insector, making your endpoint public, if you choose:

toogle private public

If you've previously created a public endpoint when you are not signed into your RequestBin account, you cannot later make this endpoint private once signed in.

Naming endpoints

It can be difficult to distinguish between endpoint URLs when you're viewing your list of endpoints. Naming an endpoint can help identify their purpose. Near the top-left of the Inspector, you'll see an Untitled identifier after creating a new endpoint:

untitled endpoint

Double-click this text and rename the endpoint to the identifier of your choosing:

named endpoint

Recent endpoints, endpoints you own

To switch between endpoints, click on the dropdown menu at the top-left of the inspector, which will display Recent endpoints and My Endpoints:

list of endpoints


Recent endpoints are endpoints you've either created or viewed. For example, if a co-worker created an endpoint and sent that endpoint URL to you, that endpoint would appear in the Recent list after viewing.

My Endpoints

My Endpoints are endpoints you've created while signed into your RequestBin account. If you sign into your RequestBin account in another browser, you'll have access to these endpoints.

This list will not be available when you're logged out of your RequestBin account.

Sending HTTP requests

Below the endpoint URL, you'll see a table where you can observe the HTTP requests sent to this endpoint. Since we haven't sent an HTTP request, the table is empty. Let's make a test request to see what information populates:

curl --data-binary '{"key":"value"}' \
  -H "Content-Type: application/json" \
const headers = new Headers();
headers.append("Content-Type", "application/json");

const body = { key: "value" };
const options = {
  method: "POST",
  mode: "cors",
  body: JSON.stringify(body)

fetch([YOUR_PIPEDREAM_URL], options);
const https = require("https");

const data = JSON.stringify({
  key: "value"

const options = {
  hostname: [YOUR_PIPEDREAM_URL],
  port: 443,
  path: "/",
  method: "POST",
  headers: {
    "Content-Type": "application/json"

const req = https.request(options);
import httplib

conn = httplib.HTTPSConnection([YOUR_PIPEDREAM_URL])
conn.request("POST", "/", "{'key': 'value'}", {'Content-Type': 'application/json'})
import http.client

conn = http.client.HTTPSConnection([YOUR_PIPEDREAM_URL])
conn.request("POST", "/", "{'key': 'value'}", {'Content-Type': 'application/json'})

To reiterate, we'll issue a 200 OK response to any valid HTTP request. This means that you can send a request to any path or resource - a POST request with a JSON body, a GET request with data in the query string parameter, and more.

Examining requests

Once you've sent a test request to your endpoint, you should see data about that request appear in the inspector within a few seconds. No refresh of the page is required.

Each row of the table is tied to a request. Click on a row to dig into the details of a specific request.

You'll see the following data attached:

  • Date / time of the request
  • HTTP method
  • Path
  • Request headers
  • Request body

The time of request, method, path are listed on each row.

POST requests

Clicking on a specific POST request yields the Headers and Body tied to that request to the right:

request data with body

By default, we present a Structured view of the request body, e.g. to cleanly highlight the structure of a JSON document like above, or to break out the key-value pairs of data sent using the application/x-www-form-urlencoded Content-Type:

Structured POST form data

Switching the view to Raw will show the body as it was received by the endpoint, as a stream of bytes:

Raw JSON data

Pretty mode will format the body, e.g. by indenting nested objects and generally making it more readable:

Pretty JSON

Some content types cannot be "prettified", for example, multipart/form-data. In this case, we may only display the Raw body:

Raw body

By default, the Headers section is collapsed, but you can click on the arrow to the right to expand it and display all HTTP headers sent with the request:

HTTP headers

GET requests

HTTP GET requests contain no body, but meaningful data is typically passed as query string parameters on the end of the URL, e.g. .

For GET requests, we display any data sent in query string parameters in the Query section of the request details:

Query String Parameters


We make every attempt to retain data on the last 100 requests you've made to a specific endpoint in the inspector. Occasionally, older requests may be evicted, so fewer than 100 requests can appear.

You can use the search box to search through any attributes of the request: the method, path, headers, body and more.

For example, we can search for any request that contains the word "darth":

Darth Search

or any request of type application/json:

JSON search

Pausing the stream of requests

If you're sending requests to an endpoint at a high volume, it can be difficult to select a single one as it scrolls by. Luckily, you can pause the stream. Click the Pause button in the top-left of the event list:

Pause event stream

We'll stop requests from streaming to the UI and show you the number of requests that your endpoint has received since pausing the stream:

Number of requests since pausing

Click Live to resume the stream. Requests that came in while the stream was paused should show up immediately.

Events while you were away

If you have the inspector open in your browser, navigate to another tab, and receive an event to your endpoint, we'll notify you by changing the favicon:

Notification favicon

Keyboard shortcuts

We expose a few UI operations through keyboard shortcuts, which can be listed by pressing ?.

For example, you can pause and resume requests using Space, or navigate up and down the list of requests with j (down) and k (up).

Creating another endpoint

When you want to create another endpoint, simply click on the New button in the header. This will generate a completely new endpoint to which you can send data. The table of requests will be empty until you send data to the endpoint.

Deleting requests

Hover your mouse over a specific request, and you should see a trash can appear to the far right of the request in the list. Click on that button to delete an individual request.

The Delete All button at the bottom of the list of requests will allow you to delete all requests you've sent to this endpoint. You may want to use this to remove any test requests you've made, once you deploy your application.

Valid Requests

You can send a request to your endpoint using any valid HTTP method: GET, POST, HEAD, and more.

You can send data of any Media Type in the body of your request. For most common types (JSON, XML, etc.), we'll also format the body for easy examination.

The primary limit we impose is on the size of the request body: we'll issue a 413 Payload Too Large status when the body exceeds our specified limit.

See the Errors section for more information on interpreting errors you might receive when sending requests.

Cross-Origin HTTP Requests

We return the following headers on HTTP OPTIONS requests:

Access-Control-Allow-Origin: *
Access-Control-Allow-Methods: GET,HEAD,PUT,PATCH,POST,DELETE

Thus, your endpoint will accept cross-origin HTTP requests from any domain, using any standard HTTP method.


Occasionally, you may encounter errors when sending requests to your endpoint:

Request Entity Too Large

The endpoint will issue a 413 Payload Too Large status code when the body of your request exceeds 100kb.

In this case, the request will still appear in the inspector, with information on the specific error.

API key does not exist

Your API key is the host part of the endpoint, e.g. the eniqtww30717 in If you attempt to send a request to an endpoint that does not exist, we'll issue a 404 Not Found status.

Acceptable Use

Your use of endpoints is governed by the Acceptable Use policy articulated in the Terms of Service.

Still have questions?

We hope you find creative and novel ways to utilize the observability offered by these endpoints! Please reach out if you have any questions not answered in these docs, or want to suggest features that would help you be more productive.