A REST API client that keeps requests in git
Build and send HTTP requests, organise them into collections and share them through your repository. Every request is a plain file, and response time is broken down by phase.
From a captured exchange to a collection
- 1
Take it from traffic
The “To requests” button opens a captured exchange in the client, minus the proxy’s service headers.
- 2
Edit and send
Change params, body and auth. ⌘↩ sends the request; pressing it again cancels.
- 3
Save to a collection
⌘S saves the request as a file in a collection folder, ready to commit alongside your code.
Everything for a request, right there
Params, headers, body, auth and variables in one tabbed editor.
Any body
JSON validated as you type, text, XML, x-www-form-urlencoded and multipart/form-data forms.
Authentication
Bearer token, Basic username and password, or an API key in a header or query parameter.
Environment variables
{{name}} is substituted into the URL, params, headers, body and auth.
Timing phases
DNS lookup, connect, TLS, waiting for the first byte and download, shown as a bar above the response.
Folder collections
Collection folders are plain directories; requests are .request.json files with readable names.
Send history
Every send is recorded, and clicking an entry opens a copy in a new tab.
cURL import and copy
Paste a cURL command straight into the URL bar and it becomes a request. “Copy cURL” gives you the command back, with variables filled in.
From a request to monitoring
The “To monitoring” button puts a request or a whole collection folder on a regular check.
Links from notes
Link to a saved request from a note — the link opens it in the client and survives renames.
In detail
Collections that live in your repository
Everything a person types is stored in files; everything that happened when sending is stored in the database. So collections can sit next to your code, go through review and arrive from teammates with a plain git pull.
- One request, one .request.json file named after the request
- Renaming or moving a request does not break open tabs
- Writes are atomic, so an interrupted save never leaves a half-written file
- Files added by hand or pulled from git are picked up immediately
Environments and variables
An environment is a named set of variables. The active one is picked on the tab bar and remembered per workspace — and that choice stays out of git, so every teammate has their own.
- Variables can reference each other up to five levels deep
- Built-in {{$timestamp}}, {{$isoTimestamp}}, {{$uuid}} and {{$randomInt}} are evaluated on every send
- An unknown variable does not block sending; it shows up in a warning above the response
- The “secret” flag hides a value in the interface, and the editor says plainly that it is not encrypted on disk
Sending without browser limits
Requests are executed by the app’s core, not by the web engine of the interface. There are no restrictions on headers or cross-origin calls, and timing is measured honestly from DNS lookup to the last byte.
- Type a URL without a scheme: external hosts go over HTTPS, localhost over HTTP
- Timeout, redirects and certificate checks are configured per request
- Responses up to 50 MB are stored in full — larger ones as a file next to the database — and Save writes the whole body
- Certificate checks can be disabled only for a single request, and only with a warning
From traffic in one click
No copying headers from one window to another. A captured exchange opens in the client in full, and a branch of the endpoint tree becomes a collection: a folder named after the host, subfolders for path segments and one request per path and method.
- Proxy service headers are dropped on transfer
- Sent requests appear only in the client history and never mix with captured traffic
cURL commands both ways
Paste a command from browser developer tools, documentation or your terminal right into the URL bar, or open it in a new tab with “Import cURL”. The other way, “Copy cURL” builds the command with the same code that sends requests, so it matches exactly what would go over the network.
- Understands method, headers, body, forms, auth, --json, -k, -L and other common options
- Anything that would be silently lost — files in the body, for example — is reported in a bar above the editor
- The copied command has the active environment’s variables and auth filled in
- A captured request is copied as a command right from the exchange panel on the traffic screen
Questions and answers
Can I keep request collections in git?
Yes. Each collection is a regular folder and each request is a separate .request.json file. Changes show up in your commit history and go through review just like code.
Where are environment secrets stored?
An environment is a file in the workspace. The “secret” flag hides the value in the interface but does not encrypt it on disk, and it will be committed with the file. The environment editor warns about this explicitly.
How do I replay a request my app sent?
Select the exchange on the traffic screen and click “To requests”. It opens in a new client tab with all headers and the body, ready to edit and send again.
How do I turn a cURL command into a request?
Paste the command into the URL bar and the open tab fills in with method, URL, headers and body. Or click “Import cURL” to open the result in a new tab. POSIX shell syntax is supported; Windows command prompt syntax is not.
Do requests to localhost work?
Yes. Without a scheme, requests to localhost, 127.0.0.1 and ::1 go over HTTP, because local development servers almost never run TLS.