Modify
Compose & replay
Compose (Ctrl/⌘ 3) is Akev's request editor. Build a request from scratch, paste a cURL
command, or open any captured request with Edit in Compose and change it. Every request you
send is recorded in Traffic like any other exchange.
From the traffic list you can also replay a request as it was captured, and copy any request as code for 20 tools and languages.
Tabs
Compose works like a browser: each request has its own tab, and a dot marks a tab with unsaved
changes. Double-click a tab to rename it, middle-click to close it. Right-click it to
Duplicate, Rename… (F2), Save, Close others, Close tabs to the right or
Reopen closed tab. Closing a tab with unsaved changes shows an Undo toast.
| Action | Desktop app | Browser UI |
|---|---|---|
| New request tab | Ctrl/⌘ T |
Alt/⌥ T |
| Close tab | Ctrl/⌘ W |
Alt/⌥ W |
| Reopen closed tab | Ctrl/⌘ Shift T |
Alt/⌥ Shift T |
Browsers keep Ctrl/⌘ T and W for their own tabs, so the browser UI shows the Alt/⌥
variants. Both work in the desktop app. All Compose shortcuts are listed in
keyboard shortcuts.
The response sits below the request or to its right (Ctrl/⌘ Shift D switches); by default
it moves to the right when the window is wide enough. Ctrl/⌘ B hides the sidebar.
Build a request
Pick the method, then type the URL (Ctrl/⌘ L focuses it). Press Enter in the URL bar or
Ctrl/⌘ Enter anywhere in the request to send it. The tabs under the URL bar hold the rest:
| Tab | What it holds |
|---|---|
| Params | The query string as a table, synced with the URL both ways. Unchecked parameters stay in the table but aren't sent. |
| Headers | Your headers, sent in the order listed. Paste Name: value lines to add several at once; Common adds frequent ones (Accept, Cache-Control, User-Agent…). Above them, Auto-generated headers show what Akev adds itself. |
| Body | The request body, in one of the modes below. |
| Auth | None, Basic (username and password) or Bearer (sent as Authorization: Bearer <token>). |
| Code | The request as a code snippet, see copy as code. |
The auto-generated headers are Host (from the URL), Authorization (from the Auth tab),
Content-Type (from the body mode; you can switch it off) and Content-Length (calculated
when sent). Add a header with the same name to override one.
Body modes
| Mode | Sent as |
|---|---|
| None | No body. |
| JSON | The text you type, with a live Valid JSON check. Format (Shift Alt/⌥ F) pretty-prints it. |
| Text | Plain text, XML, HTML, JavaScript, CSS, YAML, GraphQL or CSV; the choice sets the Content-Type. |
| Form | application/x-www-form-urlencoded fields; values are encoded for you. |
| Multipart | multipart/form-data, each field a text value or a file. |
| File | A file you drop or choose, sent as the raw body. The Content-Type follows the file type. |
Each mode keeps its own content, so switching modes never loses work. Akev warns you when you
add a body to a method that doesn't usually carry one (GET, for example).
Variables and environments
Write {{name}} anywhere in a request (URL, parameters, headers, body, auth) and Akev
substitutes the value when it sends. Typing {{ in the URL bar suggests the names you have.
Variables live in environments: open the environment menu at the right end of the tab bar
and choose Manage environments…. Globals always apply; the active environment
overrides them. A value can use other variables (baseUrl = {{scheme}}://{{host}}).
Dynamic variables get a fresh value for every occurrence:
| Variable | Value |
|---|---|
{{$uuid}}, {{$guid}} |
A random UUID v4 |
{{$timestamp}} |
Unix time in seconds |
{{$timestampMs}} |
Unix time in milliseconds |
{{$isoTimestamp}} |
The current time, ISO 8601 |
{{$randomInt}} |
A random integer from 0 to 1000 |
An undefined variable is left as written and the request is sent with a warning. If the URL can't be built without it, Akev doesn't send and offers to define it.
Request options
The sliders button next to Send opens the Request options for the tab. A dot on the button means something differs from the defaults; Reset restores them.
| Option | Default | What it does |
|---|---|---|
| Apply rules | On | Sends the request through your rules: mocks, rewrites and breakpoints apply. Turn it off to send straight to the server. |
| Follow redirects | Off | Follows 3xx responses (up to 20) and shows the final one. Each hop is recorded as its own exchange. |
| Ignore TLS errors | Off | Accepts expired, self-signed or mismatched server certificates for this request. |
| HTTP version | Auto | Auto, HTTP/1.1, HTTP/2 or HTTP/3, see below. |
| Timeout | Empty | How long to wait for the response to start, from 0.1 s to an hour. Left empty, the default of 60 seconds applies. |
HTTP version decides how Akev talks to the server:
- Auto: HTTP/2 when the server offers it, HTTP/3 as set in Settings → Proxy.
- HTTP/1.1: never HTTP/2 or HTTP/3.
- HTTP/2: over TCP, HTTP/2 when the server offers it, otherwise HTTP/1.1. Never HTTP/3.
- HTTP/3: over QUIC first, whatever the settings say. If the server doesn't answer over
QUIC, Akev falls back to TCP (like
curl --http3).
The response shows the version actually used. HTTP/3 only applies to https:// URLs and never
goes through an upstream proxy; see HTTP/3.
The response
The response pane shows Body, Headers, Cookies (when there are any), Raw, and
for recorded exchanges Timing and Connection, with the same viewers as Traffic.
Esc cancels a request that is still waiting.
- Open in Traffic jumps to the recorded exchange.
- After you send the same tab again, Compare with the previous response opens the compare view with the previous send as A and the latest as B.
- When a send fails, Akev explains why and offers a fix: Retry ignoring TLS errors for certificate problems, Retry with a 60 s timeout after a timeout, Edit URL when the host can't be found or reached, and Proxy settings when the upstream proxy failed.
While recording is paused, or when the host is in Settings → Capture → Ignored hosts, the request is still sent but not stored: the response can't be opened in Traffic, compared or restored after a reload.
History and saved requests
The sidebar has two sections:
- History lists the last 500 requests you sent, with status and duration. Click one to
open it,
Ctrl/⌘-click to open it in a new tab. Right-click for Open in Traffic, Copy URL, Save… and Remove from history. Bodies larger than 64 KB aren't kept in history. - Saved holds the requests you save, in folders.
Ctrl/⌘ Ssaves the current tab; the first time it asks for a name and folder, after that it updates the saved request.Ctrl/⌘ Shift Ssaves a copy under a new name. Right-click a saved request to rename, duplicate, move or delete it.
Both sections have a search box. Tabs, history, saved requests and environments are kept with your settings, so they survive restarts and are shared between the desktop app and the browser UI. Attached files larger than 256 KB aren't kept: pick them again after a reload or restart.
Import cURL and other commands
Paste a command into the URL bar and Compose turns it into a request:
- cURL, as copied from browser DevTools or written by hand: bash/zsh quoting, Windows
cmd(^continuations) and PowerShellcurl.execommands. - fetch() calls (DevTools Copy as fetch).
- PowerShell
Invoke-WebRequest/Invoke-RestMethodcommands (DevTools Copy as PowerShell).
The first command replaces the current tab's request (undo from the toast). Several commands at once, as from Copy all as cURL, open one tab each.
The cURL importer understands the usual options: method (-X), headers (-H), data (-d,
--data-raw, --data-binary, --data-urlencode, --json), forms (-F), basic auth
(-u), cookies (-b), user agent, referer, -I, -G, --compressed and --url. Unknown
options are ignored. Like curl, -d without a Content-Type sends a form, and a URL without
a scheme gets http://. @file references are kept as literal text, and file parts of -F
are sent empty.
The command palette (Ctrl/⌘ K) has two more ways in:
- Paste cURL from clipboard imports what's on the clipboard.
- Import requests… opens a dialog for commands and files. Drop or choose a HAR file, a Postman collection (v2.0 or v2.1) or an OpenAPI 3 / Swagger 2 spec (JSON), and its requests are added to Saved as folders. Postman collection variables become a new environment.
Edit in Compose and replay
Two actions start from a captured exchange. Use the buttons at the top of the exchange details, right-click it in the traffic list, or press the shortcut with it selected.
| Action | Shortcut | What happens |
|---|---|---|
| Edit in Compose | Ctrl/⌘ E |
Opens the request in a new Compose tab, named after its method and path, with the decoded body in the matching body mode. Change anything and send. |
| Replay | Ctrl/⌘ R |
Sends the request again straight away and records the result as a new exchange. A toast shows the status, with a link to the new exchange. |
Edit in Compose uses the request as Akev forwarded it, including any changes rules or
breakpoints made. Replay resends the request as the client originally sent it, and sends it
directly: rules don't apply, redirects aren't followed and the server's certificate is
verified. Headers meant for Akev as a proxy (Proxy-Authorization, Proxy-Connection) are
left out.
Select several exchanges and press Ctrl/⌘ R (or right-click → Replay) to replay up to
200 at once. Tunnels and TLS failures have no request to edit or replay. A request whose body
was only partly captured can't be replayed.
Repeat a request
Repeat… (next to Send, or the command palette) sends the current request many times:
| Field | What it does |
|---|---|
| Times | How many requests to send, up to 10,000. |
| At once | How many are in flight at the same time (concurrency), up to 64. |
| Pause | How long each of those workers waits between its requests. |
Akev itself sends them, so the browser's limit on connections per host doesn't apply. While it runs, the dialog shows progress, a count per status code, failures by kind, and the minimum, average, p50, p95 and maximum latency. Stop, or closing the dialog, cancels the run, requests in flight included. Open the slowest jumps to the slowest exchange. Every request is recorded in Traffic like any other.
From the traffic list, Repeat… in a row's menu resends a captured request as it was. Over the
API, it is POST /api/send/repeat.
Copy as code
Akev turns any request into a ready-to-run snippet:
- In the exchange details, the Copy as button copies the request with the last target you used. Its menu lists popular targets and, under All targets, every one.
- The request's Code tab shows the snippet with syntax highlighting. Pick a target, copy it,
or save it as a file (
Ctrl/⌘ S).Alt/⌥ Ztoggles line wrapping. - In the traffic list, right-click → Copy as cURL (
Ctrl/⌘ Shift C) or Copy as… for the other targets. With several exchanges selected you get one cURL command per exchange, separated by blank lines. - In Compose, the Code tab shows the current request, with variables already substituted, and updates as you type. The command palette's Copy request as cURL copies it.
The Code tab and Copy as remember the same target.
Targets
| Group | Target | Notes | API id |
|---|---|---|---|
| Shell | cURL | bash / zsh quoting | curl |
| Shell | cURL (Windows cmd) | cmd.exe quoting |
curl-windows |
| Shell | Wget | GNU Wget 1.15+ and Wget2 | wget |
| Shell | HTTPie | the http command |
httpie |
| Shell | PowerShell · Invoke-WebRequest | PowerShell 7+ | powershell |
| JavaScript | JavaScript · fetch | browser fetch |
js-fetch |
| Node.js | Node.js · fetch | built-in fetch, Node.js 18+ |
node-fetch |
| Node.js | Node.js · Axios | node-axios |
|
| Python | Python · requests | python-requests |
|
| Python | Python · HTTPX | python-httpx |
|
| Go | Go · net/http | go-net-http |
|
| Rust | Rust · reqwest | async, tokio | rust-reqwest |
| Java | Java · HttpClient | java.net.http, Java 15+ |
java-http-client |
| Kotlin | Kotlin · OkHttp | OkHttp 4+ | kotlin-okhttp |
| C# | C# · HttpClient | .NET 7+ | csharp-http-client |
| PHP | PHP · cURL | ext-curl | php-curl |
| Ruby | Ruby · Net::HTTP | ruby-net-http |
|
| Swift | Swift · URLSession | async/await | swift-url-session |
| Dart | Dart · http | package:http |
dart-http |
| HTTP | Raw HTTP/1.1 | the request as HTTP/1.1 text | raw-http |
What goes into a snippet
- The request as the client sent it. For a captured exchange, a snippet uses the original request, before any rule changed it, with the body decoded.
- Every header that matters, including credentials.
CookieandAuthorizationheaders are kept, so a snippet can carry session cookies and tokens: treat it like a password. Headers the client library manages itself are left out:Content-Length,Content-Encoding, HTTP/2 pseudo-headers, hop-by-hop headers (Connection,Keep-Alive,Proxy-Connection,Proxy-Authorization,Transfer-Encoding,TE,Trailer,Upgrade) andExpect.Hostis kept only when it differs from the URL. Raw HTTP/1.1 is different: it keeps the captured headers, putsHostfirst and writes a freshContent-Lengthfor the decoded body. - Compression. The cURL targets add
--compressedinstead of anAccept-Encodingheader, and Raw HTTP/1.1 keeps the header as captured. The other targets drop it and let the client handle compression. - Bodies of any size, never placeholders. Text bodies are inlined with the right escaping.
JSON bodies become native objects in JavaScript, Python, Ruby and PHP when that keeps the
value exact, and form bodies use those languages' form support. Binary bodies are embedded as
base64 and decoded when the snippet runs (written as a byte string in Rust). In
Raw HTTP/1.1, bytes that aren't valid text show as
�. - Notes instead of silent changes. When a client can't reproduce part of the request (for
example, browser
fetchcan't setCookieorHost, and some clients can't send a body withGET), the snippet says so in aNote:comment. - Snippets don't end with a newline, so pasting one into a terminal doesn't run it straight away. Raw HTTP/1.1 is the exception.
API and MCP
Everything here is available over the HTTP API: POST /api/send (Compose),
POST /api/import/curl, POST /api/exchanges/:id/replay,
GET /api/exchanges/:id/snippet?target=…, POST /api/codegen and
GET /api/codegen/targets. See Compose in the API reference.
Through the API, applyRules is off unless you set it.
AI agents can do the same through MCP: akev_snippet is free, while
akev_send_request and akev_replay are write tools that need
Akev Pro.