GraphQL

Set a Composer request's Content-Type to application/graphql+json and the Body tab turns into a GraphQL explorer: a query editor with syntax highlighting and schema-aware autocomplete, a separate variables editor, an introspection-backed docs tree, and a refresh button. Everything is optional — the editor works fully even when no schema is available.

Turning on GraphQL mode

On any request, open the Body sub-tab and set the content-type selector to GraphQL (application/graphql+json). The body area splits into two panes:

Query — your GraphQL document (query, mutation, or subscription).
Variables — a JSON object of variables, edited separately from the query.

On send, Probe composes the two into the standard GraphQL-over-HTTP envelope and POSTs it as JSON:

{ "query": "query($id: ID!) { user(id: $id) { name } }", "variables": { "id": 42 } }

If the Variables pane is empty, the variables key is omitted. If it holds anything that isn't a JSON object, the send is stopped before leaving your machine and Probe shows "GraphQL variables must be a valid JSON object." — fix the JSON and send again.

Introspecting the schema

Autocomplete and the docs tree are powered by the endpoint's schema, fetched via a standard GraphQL introspection query. Probe fetches it two ways:

Automatically the first time you open a GraphQL request whose endpoint has no cached schema.
On demand with the Refresh button in the toolbar.

The introspection request is a normal Composer send under the hood, so it inherits the request's headers, auth, and proxy routing — an authenticated endpoint introspects with the same Bearer token your other requests use, and the call shows up in the traffic log like any other. The distilled schema (types → fields → args, plus the root operation names) is cached per endpoint on disk; the raw introspection payload is never stored.

If introspection fails (endpoint down, introspection disabled, auth missing), nothing breaks — you just author without autocomplete until the next successful refresh. The toolbar reads No schema until one is cached, then shows the indexed type count.

Autocomplete

As you type in the query editor, Probe suggests from the cached schema based on where the cursor is:

Root fields — inside the operation's outer { }, it offers the Query (or Mutation / Subscription) fields.
Nested fields — inside a field's selection set, it walks the brace path and offers that type's fields.
Argument names — inside a field's ( ), it offers that field's argument names, each with its type.

Each suggestion shows the field's return type (or the argument's type) on the right. Press ↑/↓ to move, Enter to accept, Esc to dismiss. Autocomplete deliberately stays quiet where it can't be certain — inside fragment spreads (...), on alias targets, and inside string values it offers nothing rather than a wrong guess.

Docs tree

Click Docs in the toolbar to open a side panel that renders the schema as an explorable tree: the root operations (Query, Mutation, Subscription) at the top, each expanding to its fields. Every field row shows its argument preview and return type, and fields whose type has its own fields expand further so you can drill into the graph. It's the same cached schema the autocomplete uses, so a Refresh updates both at once.

Out of scope (for now)

Mapping GraphQL bodies through the Postman importer/exporter isn't wired up yet — a GraphQL request imported from Postman lands as a raw body, and exporting doesn't emit Postman's GraphQL body mode. Author GraphQL requests directly in Composer for now.

Composer Overview Where the Body tab and content-type selector live.

Environments & Variables Use {{var}} inside the query and variables, resolved at send time.

Authentication Introspection reuses the request's auth — set a Bearer token once.