Inspect¶
Select a session and the Inspect tab (F8) shows it: a header line with method, URL,
session number, duration and process, then a Request and a Response card, each
with its own row of views.
- By default the request is above the response. Switch any time with View → Request Above Response / Request Beside Response. In a narrow pane they go above each other automatically.
- Drag the splitter between them to change the proportions.
- The response card shows the status as a badge.

Sections and views¶
Each card has two rows of tabs:
- Sections: Headers, Body, Cookies, Auth, Raw, always in this order. Headers and Cookies show how many there are, and Auth has a dot when the message carries authentication. Sections with nothing in them are faint but can still be opened. For WebSockets and SSE streams, Body is called Messages.
- Views of the section: for Body, only the views that fit the content, the best one first. For example, Formatted · Tree · Plain Text for JSON, SOAP · Formatted · Tree · Plain Text for a SOAP envelope, and Image · Hex for a PNG. The other views are under Other: first those that may help (such as Hex for text), then those that do not fit the content, marked so. They stay selectable in case the content is mislabelled. On responses, Headers has a second view, Caching.
Quena does not trust the Content-Type alone. It also looks at the start of the body,
decoded: a SOAP Envelope, an Atom feed/entry, OData metadata (edmx:Edmx), OData JSON,
plain JSON, XML or HTML. A plain XML document sent as text/xml therefore opens in
Formatted with the XML tree, not in the SOAP view, and JSON sent as text/plain gets the
JSON tree.
Alt 1…Alt 5 choose the section and Alt ←/Alt → the view; see
Keyboard shortcuts.
Prefer the single row of views? Settings → General → Inspector views → Flat brings back the strip of all views from earlier versions. The views, and which view is remembered, are the same in both.
Right-click¶
| Where | Menu |
|---|---|
| Header row | Copy value, name, the header or all headers; Show only this header in the table; add it as a list column; filter sessions with this header value |
| Body, Raw, Hex, Image | Copy (selection), Select All, Copy Body, Save Body…; in the body also Wrap and Format |
| JSON tree | Copy value, key or JSONPath; Expand / Collapse All; change or remove this value, or append a broken element to this list, in later messages of the same URL (adds a rewrite rule) |
| XML tree (also SOAP) | Copy text, XPath or the element as XML; Expand / Collapse All |
| Tables (form data, cookies, encoding) | Copy value, row or all rows (tab-separated); Decode Value… |
| WebSocket frame, SSE event, multipart part | Copy the message / data / event; save the part |
| Text fields and editors | Undo, Redo, Cut, Copy, Paste, Select All |
Elsewhere a right-click shows nothing, or Copy for selected text. Decode Value… (header rows, tables) and Decode Selection… (selected text anywhere) open the Text Tools with the likely decoding chosen: Base64, URL encoding, HTML entities, hex, JavaScript escapes, a JWT or a Unix time.
Views¶
| View | Request | Response | Shows |
|---|---|---|---|
| Headers | ✅ | ✅ | Start line and a header table in wire order, with a filter box, topic tags (auth, cookie, cache, cors, body, conn, fetch, policy), optional A–Z sorting, a raw mode and Copy. Double-click a value to copy it. |
| Plain Text | ✅ | ✅ | The body as plain text. |
| Body | ✅ | ✅ | The body with syntax highlighting and a Format switch for pretty-printing (JSON, XML …). |
| Params | ✅ | The query parameters of the URL as a table, decoded, in their order (under Headers). | |
| Form Data | ✅ | URL-encoded form fields as a table. | |
| Hex | ✅ | ✅ | Hex dump of any size; jump to an offset (hex or decimal). |
| Auth | ✅ | ✅ | Authentication headers, decoded (see below). |
| Cookies | ✅ | ✅ | Cookies sent, or cookies set with their attributes. |
| Raw | ✅ | ✅ | The message as it went over the wire. |
| JSON | ✅ | ✅ | JSON as a collapsible tree. |
| XML | ✅ | ✅ | XML as a collapsible tree. |
| Encoding | ✅ | How the response body is encoded (compression, chunking). | |
| Image | ✅ | The image. | |
| Preview | ✅ | The response rendered in a sandboxed frame without scripts, forms or network access. | |
| Caching | ✅ | The response's caching headers (Cache-Control, Expires, validators). |
The body views have Wrap, Format (where available) and Save… (save the body to a file). Compressed bodies (gzip, deflate, brotli, zstd) are shown decoded; the Decode toggle in the toolbar switches this off, and a banner then offers to decode again. The recorded bytes are never changed — decoded and formatted views are derived from them.
Views for special content¶
These views appear only when the content fits:
| View | Appears for | Shows |
|---|---|---|
| WebSocket | WebSocket sessions | the frame log with direction, type, size and payload; All frames, Text messages or one direction, Hide ping/pong, a search; for Socket.IO the event name or packet type per message and its arguments as JSON; ✎ changed and ✕ dropped by rules; messages compressed with permessage-deflate (as browsers and many clients negotiate) are shown inflated |
| Socket.IO | Socket.IO long-polling (/socket.io/?…transport=polling) |
the Engine.IO / Socket.IO packets of the request or response body (protocol v4 and v3), with events, namespaces, acks and arguments |
| SSE | text/event-stream responses |
the stream split into events, live |
| gRPC | gRPC, gRPC-Web and Protobuf messages | message frames and their fields; with a schema field names, types and enum values |
| LLM | calls to LLM APIs (OpenAI, Anthropic, Gemini, Claude on Vertex AI and Amazon Bedrock, the Bedrock Converse API, Ollama, OpenAI-compatible) | the conversation, tool calls, the answer (also from a stream), tokens and estimated cost — see LLM traffic |
| MCP | exchanges with an MCP server (MCP headers, stdio:// sessions from quena-cli mcp-tap, paths such as /mcp, /sse, /messages) |
the method, the tool called with its arguments and result, the tools a server offers with what they cost in tokens, and the tool call trail from the model's answer to the server and back — see MCP servers and skills |
| MessagePack | application/msgpack, x-msgpack, vnd.msgpack |
the values as a tree, like JSON, plus binary data, extension types and timestamps |
| Parts | multipart/* bodies, including MTOM |
the parts of multipart/related, form-data and mixed |
| SOAP | SOAP envelopes | SOAP version, action, operation, body and SOAP faults |
| Atom/OData | Atom feeds and OData (v2/v3 Atom) | entity sets and types, entries, properties and links |
SOAP and Atom/OData also work on the output of decoder plugins, e.g. Fast Infoset. Plugins can add further views, such as Fast Infoset and GraphQL.
Which view opens¶
- With flat views, the views are ordered by how well they fit the content: Headers first, then the special and plugin views, then Body, and so on. As many views as fit the width are shown as tabs; the rest are under More. The active view is always visible.
- Until you choose a view for a kind of content, the one that fits opens: LLM for LLM API
calls; MCP only when the exchange is surely MCP (recognised by Quena, MCP headers, or
recorded by
quena-cli mcp-tap) — a path like/messagesalone only offers the view; SOAP for SOAP, gRPC for gRPC, WebSocket for WebSockets, Image for images, Form Data for form requests, Body for JSON, XML, HTML, JavaScript, CSS and text, Hex for binary content, Headers when there is no body. - Quena remembers the view you choose per kind of content, separately for request and response. Choose XML once for a SOAP response, and every SOAP response opens in XML; JSON can stay on Body at the same time.
The memory can be switched off, or cleared, in Settings → General → Inspector views. With it off, the last view chosen is used for every session.
Character encodings¶
Text is shown in the character encoding (charset) the message is in, determined the way browsers do it:
- a byte order mark (UTF-8, UTF-16) at the start of the body;
- the
charsetof theContent-Typeheader; - the document's own declaration —
<?xml … encoding="…"?>in XML,<meta charset>in HTML; - the default of the type: UTF-8 for JSON and XML; other text is UTF-8 when it is valid
UTF-8, else windows-1252.
ISO-8859-1andlatin1mean windows-1252, as in browsers.
The toolbar of Plain Text and Body shows the result, e.g. windows-1252 · header
(where it came from: BOM, header, document or default). If characters look wrong —
typically � for a body declared UTF-8 that is really Latin-1 — choose another charset in
the menu next to it. The choice applies to that message's views (text, Raw, JSON, XML,
SOAP, Atom, SSE, the large-body viewer and its search) until you select another session.
Parts shows each multipart part in its own charset, with its own menu; Form Data
decodes the fields in the form's charset (the Content-Type charset, else a _charset_
field, else UTF-8).
UTF-16 bodies are converted to UTF-8 for display and formatting; the recorded bytes are
never changed (Hex and Save… show them as they are). Find Sessions and Find in
body search the text in each body's charset. In Headers, parameters encoded after RFC
8187 (filename*=UTF-8''%E2%82%AC.pdf) are shown decoded below the value.
Large bodies¶
Bodies are read from disk in windows, so even multi-gigabyte bodies open instantly:
- Up to 8 MB (after decoding), a body opens in the regular editor.
- Larger bodies, and responses that are still arriving, open in the large-body viewer:
it shows size and line count (indexing runs in the background), jumps to a line, and
searches the whole body with Find in body and
↑/↓through the hits. - Hex works on bodies of any size.
- Save… writes the whole body to a file.
Auth view¶
The Auth view shows Authorization/Proxy-Authorization (request) and
WWW-Authenticate/Proxy-Authenticate (response) headers in readable form:
- Basic: the decoded
user:password. - Negotiate, Kerberos and NTLM: with the bundled Kerberos / NTLM plugin, the tokens are decoded (SPNEGO; Kerberos AP-REQ, AP-REP, KRB-ERROR; NTLM Type 1, 2 and 3). A Negotiate exchange that fell back to NTLM is flagged.
- JWT: with the bundled JWT plugin, JSON Web Tokens in Bearer or DPoP authorization,
cookies,
Set-Cookieand common token headers (X-Access-Token,X-Id-Token…) are decoded: header (alg, typ, kid …), claims with the registered ones explained,exp,nbfandiatas dates with "expired 3 h ago" / "valid for 12 min", and the signature algorithm. Signatures are not verified. Encrypted tokens (JWE) show their header.
Tokens a plugin recognises in cookies or other headers are listed below the authentication headers.
SAML messages of a single sign-on are decoded too: SAMLRequest / SAMLResponse in the
URL (HTTP-Redirect binding, inflated), in a form body (HTTP-POST binding) and in the
auto-submitting form of an identity provider's HTML answer. The table shows the message type,
ID, destination, InResponseTo, issuer, status, NameID, the validity of the conditions, the
audience, the attributes, whether it is signed and whether the assertion is encrypted, plus
RelayState; the XML is below. Signatures are not checked.
gRPC and Protobuf with a schema¶
Without a schema the gRPC view shows field numbers and guesses the types from the wire
format (a varint, a string or a nested message). With the .proto files of the service it
shows what the fields are:
- field names next to their numbers, the schema types (
int64,sint32,double, …), enum values by name (GREEN (2)), nested messages with their type, repeated fields as lists; - fields the schema does not know (a newer server, an extension) stay, by number.
Adding the schema: Settings → Bodies & Storage → Protobuf schemas → Add .proto files…
or Add folder… (searched for .proto files). Imports are resolved against the folders
added and the Import paths; well-known types (google/protobuf/*.proto) are built in. The
line below shows how many files, message types and services were loaded, or the compiler's
error.
Which message type: for gRPC Quena takes the method from the URL
(/package.Service/Method): its input type for the request, its output type for the
response. The Schema line in the view says which type was used. For a plain Protobuf body
(application/x-protobuf, a REST API) there is no method — choose the type in the field
next to it; the choice holds for that message until you select another session.
Server reflection: many gRPC servers can tell their schema themselves. Switch on Allow
fetching schemas from gRPC servers in the settings; the gRPC view then has Fetch schema
from server. Quena asks the session's server (grpc.reflection.v1, else v1alpha) for
the service's files and their imports, through the upstream proxy and host remapping like
other traffic, and keeps them in protobuf-reflection in the data directory. This sends a
request to that server, so it only happens when you click.
Also decoded: messages compressed per message (grpc-encoding: gzip, deflate, zstd,
…), the trailers of gRPC-Web in the last frame (grpc-status, grpc-message), and
application/grpc-web-text (base64).
GraphQL¶
With the bundled GraphQL plugin, a GraphQL view appears for GraphQL requests
(application/graphql, or JSON with query/variables/operationName, batches and
persisted queries), showing the operation with the query pretty-printed, and for GraphQL
JSON responses, with the errors first.
Inspecting from elsewhere¶
- Enter or a double-click in the session list opens Inspect.
- Right-click → Properties… shows a session's metadata: state, process and PID, client and server addresses, TLS versions, ciphers, SNI and ALPN, HTTP/2 stream and all timers.
- Right-click → Compare with two sessions selected — see Analyze.