httpbun APIhttpbun.com ↗
Inspect requests, headers, origin IPs, status codes, and custom response headers via the httpbun.com API. Five endpoints for debugging HTTP client behavior.
What is the httpbun API?
The httpbun.com API provides 5 endpoints for inspecting HTTP request and response behavior, covering everything from raw headers and origin IP to arbitrary status code responses. The inspect_request endpoint returns the method, parsed query arguments, all forwarded headers, origin IP, and full URL as seen server-side — making it useful for validating how proxies and middleware shape outbound requests.
curl -X GET 'https://api.parse.bot/scraper/deca630b-b6ad-4b68-a070-0fe91eef112c/inspect_request?query_params=test%3Dhello' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace httpbun-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: httpbun SDK — HTTP testing utility endpoints."""
from parse_apis.httpbun_com_api import Httpbun, InvalidStatusCode
client = Httpbun()
# Inspect a request with custom query parameters
info = client.request_infos.inspect(query_params="color=blue,size=large")
print(f"Method: {info.method}, Origin: {info.origin}")
print(f"URL: {info.url}")
print(f"Args: {info.args}")
# Get request headers as seen by the server
header_set = client.header_sets.get()
print(f"Headers seen by server: {header_set.headers}")
# Get the origin IP address
ip = client.ip_addresses.get()
print(f"Origin IP: {ip.origin}")
# Request a specific status code and inspect the response
status = client.status_responses.get(status_code="200")
print(f"Requested: {status.requested_code}, Got: {status.actual_status_code}")
# Typed error handling for invalid status code
try:
bad = client.status_responses.get(status_code="999")
print(f"Got: {bad.actual_status_code}")
except InvalidStatusCode as exc:
print(f"Invalid status code: {exc}")
# Get custom response headers
resp_hdrs = client.custom_headers.get(headers_param="X-App=myapp,X-Version=2")
print(f"Response headers: {resp_hdrs.response_headers}")
print("exercised: request_infos.inspect / header_sets.get / ip_addresses.get / status_responses.get / custom_headers.get")
Inspect how a GET request appears to the server. Returns the method, query arguments, headers, origin IP, and full URL as seen by the httpbun server. Useful for debugging HTTP client behavior and verifying how requests are shaped after proxies, load balancers, or middleware modify them.
| Param | Type | Description |
|---|---|---|
| query_params | string | Comma-separated key=value pairs to send as query parameters (e.g. 'foo=bar,baz=123'). Each pair is split on '=' and sent as a separate query parameter. |
{
"type": "object",
"fields": {
"url": "string",
"args": "object of query parameter key-value pairs",
"method": "string",
"origin": "string",
"headers": "object of request header key-value pairs"
},
"sample": {
"data": {
"url": "https://httpbun.com/get?test=hello",
"args": {
"test": "hello"
},
"method": "GET",
"origin": "142.111.191.33",
"headers": {
"Host": "httpbun.com",
"Accept": "text/html",
"User-Agent": "Mozilla/5.0"
}
},
"status": "success"
}
}About the httpbun API
What the API Covers
The httpbun.com API is an HTTP testing utility with five GET endpoints. Each endpoint targets a specific aspect of request or response inspection. inspect_request is the broadest: it accepts optional query_params (comma-separated key=value pairs) and returns url, args, method, origin, and headers — a full picture of how the server received the request. get_headers returns only the headers object, useful when you want a clean view of every header including those injected by proxies or TLS termination layers.
Status Code and Header Testing
get_status_code accepts a status_code integer (100–599) and responds with that actual HTTP status. The response shape includes requested_code, actual_status_code, response_body, and a json_response object (or null) with a code and description — useful for exercising client-side error handling, redirect logic, or retry behavior. get_response_headers takes a headers_param of comma-separated key=value pairs and sets those as response headers, returning the full set of response headers in the body. This lets you test how clients parse non-standard or edge-case header names and values.
Origin IP Endpoint
get_ip returns a single origin field containing the IP address as seen by the httpbun server after any forwarding. This is useful for confirming which IP a proxy or VPN presents to a remote server, or verifying that a specific egress IP is in use.
The httpbun API is a managed, monitored endpoint for httpbun.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when httpbun.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official httpbun.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Verify which headers a proxy or load balancer adds to outbound requests using
get_headers. - Confirm the egress IP of a proxy configuration with
get_ip. - Test client-side redirect and error handling by requesting specific 3xx, 4xx, or 5xx codes via
get_status_code. - Validate that query parameters survive encoding and forwarding with
inspect_request. - Check how an HTTP client parses non-standard response headers using
get_response_headers. - Debug middleware behavior by comparing
url,args, andheadersfrominspect_requestbefore and after a middleware change. - Simulate custom response header scenarios for frontend or SDK integration testing.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does httpbun.com have an official developer API?+
What does `inspect_request` return that `get_headers` does not?+
inspect_request returns the full url, args (parsed query parameters as a key-value object), method, and origin IP in addition to headers. get_headers returns only the headers object — nothing else.Does `get_status_code` always respond with exactly the requested code?+
requested_code and actual_status_code as separate fields precisely because they can differ. Some status codes (for example, certain 1xx codes) may not be deliverable by the underlying HTTP stack, so the actual code received can differ from the one requested.