Skip to content

HTTP / REST

The bread and butter. Restura’s HTTP client supports every method, every body shape, and gives you the full request/response timeline with timing breakdown.

GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, and custom methods — WebDAV (PROPFIND, MKCOL, REPORT), QUERY, cache PURGE, LINK/UNLINK, and so on. Open the method picker and type the method into the Custom… field. The desktop app, a self-hosted server, and the CLI send any custom method you type; the hosted web app supports a fixed list (see below).

Custom methods must be a valid HTTP method token (RFC 9110: letters, digits and a few symbols such as -, _, ., !, no spaces). They’re sent exactly as typed, case included; the seven standard methods are always sent in upper case. Custom methods survive OpenCollection, Postman and HAR import (HAR keeps the case too) and OpenCollection and Postman export. Workflows and AI Lab accept them, and the CLI runs them. Postman stores methods in upper case, so a mixed-case custom method comes back upper-cased from a Postman round trip. OpenAPI 3.0 has no slot for custom methods, so an OpenAPI export skips those requests and warns.

Hosted web app: the Cloudflare Workers runtime can only send a fixed set of methods: the standard ones, PURGE, the WebDAV/DeltaV set (COPY, LOCK, MKCOL, MOVE, PROPFIND, PROPPATCH, UNLOCK, ACL, REPORT, MKACTIVITY, CHECKOUT, MERGE), SEARCH, QUERY, NOTIFY, SUBSCRIBE, UNSUBSCRIBE, MSEARCH and BAN. They go out in upper case. Any other method, LINK included, fails with a clear error. Use the desktop app or a self-hosted server for those.

CONNECT, TRACE and TRACK are always refused, whatever the casing. CONNECT would turn the proxy into a raw tunnel, and TRACE (and its IIS alias TRACK) echoes your request headers, credentials included, back in the response. Importing a collection that uses them falls back to GET and shows a warning.

  • none
  • JSON — the Beautify button formats the body and keeps {{variable}} references exactly as written, including bare ones like "id": {{id}}.
  • raw — plain text (UTF-8), sent with Content-Type: text/plain unless you set your own.
  • XML — syntax highlighted; sent with Content-Type: application/xml unless you set your own.
  • form-data (multipart/form-data) — supports file inputs. Text field values resolve {{variables}}; field names are sent as typed (restura run resolves them too) and file fields as picked.
  • x-www-form-urlencoded — edit as a key/value table, or switch to Text to edit the encoded string directly. Values resolve {{variables}}; keys are sent as typed (restura run resolves them too).
  • GraphQL — query and variables editors that send a standard GraphQL JSON body (the dedicated GraphQL request type adds schema tooling).
  • binary — pick any file with Choose file; Restura sends its bytes as the body ({{variables}} are never substituted).

Switching the body type to or from binary sets the other content aside: a toast offers Undo, and switching back restores it.

GET with a body: a body you write on a GET is sent, not silently dropped — on desktop and with restura run. The hosted web app and self-hosted server send through fetch(), which forbids it, so the request fails with an explicit 400 (“This proxy cannot send a request body with GET”); remove the body, change the method, or use desktop/CLI. A GET whose body editor is empty sends no body. HEAD never sends one.

There is no Protobuf body type: to send protobuf over HTTP use binary, or use the gRPC client.

  • Query parameters — kept in sync with the URL. Type or paste ?a=1&b=2 into the URL bar and the rows appear in Params; edit a row and the URL updates. Disabled rows stay in the table and are left out of the URL. Values go out exactly as typed: +, :, ,, / and existing %XX escapes are not rewritten (a pasted %2B stays %2B, a + stays +); only a space is encoded, as %20. Repeated keys (?id=1&id=2) are all sent, in order.

  • Paste a cURL command into the URL bar to fill in the method, URL, headers and body. A toast offers Undo.

  • Removing a row — deleting a param or header row names it in a toast with Undo, which puts it back where it was.

  • Bulk edit — switch params or headers to a text view with one key: value per line. Prefix a line with // to disable it.

  • Variables — hover a {{variable}} in the URL or a param value to see its value and where it comes from (environment, collection, folder, globals). Secret values are masked. If the URL, params, headers or body reference a variable that won’t resolve in the active environment, a N unresolved chip next to Send lists them (hover for the names); the request is still sent with the references as-is.

  • Headers — autocompletion for standard names + values where applicable. Repeated header rows are all kept: they combine into one header separated by , (; for Cookie) instead of the last row winning.

  • Cookies — per-request override, plus a session-wide cookie jar. When a response sends several Set-Cookie headers (a session cookie plus a CSRF token, say), every one is kept: the cookie jar stores each, the response Headers tab shows each on its own row, scripts see them all, and restura run results list them all. Streaming responses (SSE, NDJSON) have no Headers tab, but their cookies still reach the jar. On the web they travel in an x-restura-set-cookies header, so the browser never stores them for the Restura site. The network console lists each response cookie’s name and attributes with the value redacted. The jar follows RFC 6265: Max-Age wins over Expires (zero or negative deletes the cookie), a Domain attribute must domain-match the host and may not be a public suffix, cookies without Domain are host-only, and the default path is derived per the RFC. A Cookie header you set yourself merges with the jar (your names win). On redirects, cookies set by each hop are sent on the later hops and stored against the URL that set them — on the web/self-hosted proxy and on desktop alike.

  • URL problems — an invalid URL disables Send and says what’s wrong: an unsupported scheme, a missing host, spaces in the host, or a port outside 1–65535.

  • Tab badges — Scripts is badged with the phases that have code (Pre, Test, Pre+Test) and Settings with Custom when the request overrides the global settings.

Every auth scheme Restura sends works on HTTP: Bearer, Basic, API Key, OAuth 2.0 (authorization code always uses PKCE S256; the other three grants do not; the auth-code ‘Get token’ flow is web-only), OAuth 1.0a (HMAC-SHA1, HMAC-SHA256, or PLAINTEXT), AWS Signature v4, WSSE, Digest (answered after the server’s 401 challenge), and, on desktop, NTLM and mTLS. See the auth guide.

Click the </> icon next to the URL, or run Copy as cURL from the command palette. Snippets resolve variables from every scope and include the request’s auth, including auth inherited from a folder or collection.

Mask secrets is on by default: secret variables stay as {{name}} references and credentials become placeholders such as <token>. Values stored in the desktop keychain are never printed. Auth that’s computed per request (Digest, NTLM, AWS Signature v4, OAuth 1.0, WSSE) and binary bodies are noted as comments rather than generated. Multipart form-data is generated for cURL, Python and JavaScript. The last language you picked is remembered.

Available languages:

  • curl.
  • Python (requests).
  • JavaScript (fetch).
  • Node.js (axios).
  • Go (net/http).
  • Ruby.
  • PHP.
  • More languages added in releases — open an issue if your stack is missing.

web and self-hosted When you send a request whose Accept header asks for text/event-stream, application/x-ndjson or application/jsonl, the response panel switches to a streaming viewer instead of waiting for the whole body. SSE events and NDJSON lines are listed as they arrive (a response with another content type is shown as raw text chunks), with a running event and byte count; pause the view to read without it scrolling (a pill shows how many events are buffered). The viewer keeps the most recent 5,000 events. A streamed request has no client-side timeout. Its scripts run as for any other send: the pre-request script runs before anything is sent (its variables and header edits apply, and pm.execution.skipRequest() stops the stream), and when the stream ends the test script runs against the whole streamed text (pm.response.text(); the first 10 MB, with a note if it was cut short), with its results under the panel’s Tests tab. The request is added to history then too. The send stays in flight while the stream runs, so Send becomes Cancel; a cancelled stream runs no tests and isn’t added to history. On desktop the HTTP client buffers the full response; use the dedicated SSE client there, which also handles reconnect and filtering.

Every send is recorded to history with status, timing, request hash, and a quick way to resend. Per-response, you get:

  • Status and status text. Hover or focus the status for a plain-language explanation.
  • Timing: the Timeline tab breaks the total into phases.
    • Everywhere: Waiting (time to response headers, including any redirects), Download (the body), and the remaining overhead. On the web this is the round trip to the Restura Proxy; on desktop it’s App time such as scripts and IPC.
    • Desktop only: DNS and Connect + TLS are also measured for direct connections. They’re left out when a proxy is used, because they would describe the connection to the proxy.
  • Size: the decoded body size.
  • HTTP desktop only: the protocol the connection actually negotiated (HTTP/2 or HTTP/1.1, from TLS ALPN, or HTTP/2 for h2c). It’s shown when known, so it’s absent on the web and for plain http:// HTTP/1.1. See HTTP version below.
  • Compression: compressed bodies are decoded before display. On desktop this covers gzip, br, deflate and zstd, including stacked codings such as Content-Encoding: gzip, br. If a response uses a coding the app can’t decode, the raw bytes are shown with a notice above the body, and the Content-Encoding header is kept. The same happens when a response stacks more than three codings. The 10 MB response size limit applies to the decoded body and is checked after every decoding step. zstd bodies that need more than an 8 MB window are refused. HEAD, 204 and 304 responses and empty bodies are never decoded.
  • Headers: filter by name or value; Copy all copies one Name: value line per value.
  • Body:
    • pretty-printed JSON with a collapsible Tree view (Copy path gives a JSONPath you can paste into the JSONPath box)
    • syntax-highlighted XML
    • Download, saved under the request’s name with the right extension
  • Compare with previous: once a request has an earlier response in history, a toolbar button diffs the two side by side.
  • Cancel: while a request runs, the response panel shows the elapsed time and a Cancel button. GraphQL can be cancelled too. Loading and Cancel are per tab: you can switch tabs and send another request while one is in flight, and Cancel only stops the visible tab’s send.
  • The SSRF guard blocks requests to RFC 1918, RFC 6598 (CGNAT), link-local, loopback, IPv4-mapped IPv6, cloud metadata endpoints (169.254.169.254), IPv6 unique-local, and other special-use ranges such as multicast and reserved space (see Security model) — unless explicitly allowed (e.g. ENVIRONMENT=development in the Worker, --allow-localhost in the CLI).
  • The desktop client also enforces a pre-flight DNS guard against DNS-rebind: hostnames are resolved before connecting, and every record is validated.
  • Custom CAs, disabled TLS verification, client certificates (mTLS), and SOCKS4/5 proxies are desktop only — the browser sandbox doesn’t expose them.
  • Proxy settings (the global HTTP proxy and a request’s Custom Proxy for this Request) are desktop only (http.proxy.perRequest); the web client connects directly and badges the setting. restura run applies a request’s own HTTP(S) proxy and refuses a SOCKS one.
  • HTTP version desktop only — in a request’s Settings tab, choose Auto (h2 offered via ALPN over TLS, the default), HTTP/1.1 only, HTTP/2 only (the request fails if the server can’t negotiate h2; on direct and SOCKS connections this is checked before anything is sent, but through an HTTP proxy (including one from HTTP_PROXY/HTTPS_PROXY) only after the response, so the request may already have gone out over HTTP/1.1), or HTTP/2 cleartext (h2c, prior knowledge) for http:// servers that speak HTTP/2 without an Upgrade. The protocol actually used shows as the HTTP stat on the response. h2c works on direct connections and through SOCKS, but not through an HTTP proxy. On the web the runtime negotiates the protocol, so the setting stays on Auto. The setting is saved with the request and round-trips through OpenCollection (x-restura-http); importing it changes only the HTTP version, not the request’s other settings. restura run doesn’t apply it and prints a warning instead.