DocsCompose & replay

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/⌘ S saves the current tab; the first time it asks for a name and folder, after that it updates the saved request. Ctrl/⌘ Shift S saves 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 PowerShell curl.exe commands.
  • fetch() calls (DevTools Copy as fetch).
  • PowerShell Invoke-WebRequest / Invoke-RestMethod commands (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/⌥ Z toggles 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. Cookie and Authorization headers 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) and Expect. Host is kept only when it differs from the URL. Raw HTTP/1.1 is different: it keeps the captured headers, puts Host first and writes a fresh Content-Length for the decoded body.
  • Compression. The cURL targets add --compressed instead of an Accept-Encoding header, 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 fetch can't set Cookie or Host, and some clients can't send a body with GET), the snippet says so in a Note: 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.

Type to search guides, the CLI and the API.