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.
Visit requestbin.com 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 pipedream.net.
TIP
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.
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.
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 requestbin.com 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:
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.
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:
Double-click this text and rename the endpoint to the identifier of your choosing:
To switch between endpoints, click on the dropdown menu at the top-left of the inspector, which will display Recent endpoints and My 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 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.
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" \
[YOUR_PIPEDREAM_URL]
const headers = new Headers();
headers.append("Content-Type", "application/json");
const body = { key: "value" };
const options = {
method: "POST",
headers,
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);
req.write(data);
req.end();
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.
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:
The time of request, method, path are listed on each row.
POST
requestsClicking on a specific POST
request yields the Headers and Body tied to that request to the right:
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:
Switching the view to Raw will show the body as it was received by the endpoint, as a stream of bytes:
Pretty mode will format the body, e.g. by indenting nested objects and generally making it more readable:
Some content types cannot be "prettified", for example, multipart/form-data
. In this case, we may only display the 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:
GET
requestsHTTP GET
requests contain no body, but meaningful data is typically passed as query string parameters on the end of the URL, e.g. https://test.x.pipedream.net/?key1=val2&key2=val2 .
For GET
requests, we display any data sent in query string parameters in the Query
section of the request details:
TIP
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":
or any request of type application/json
:
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:
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:
Click Live to resume the stream. Requests that came in while the stream was paused should show up immediately.
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:
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).
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.
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.
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.
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:
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.
Your API key is the host part of the endpoint, e.g. the eniqtww30717
in eniqtww30717.x.pipedream.net
. If you attempt to send a request to an endpoint that does not exist, we'll issue a 404 Not Found
status.
Your use of endpoints is governed by the Acceptable Use policy articulated in the Terms of Service.
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.