API testing

API testing that reads like your API, not a script

Explore responses as a tree, assert against a schema, pull secrets from a vault, mask the sensitive bits, run setup and teardown with hooks, and chain it all into visual flows. Everything runs locally first, and the same tests run headless in CI.

Inizia Get the desktop app

Object tree: read any response at a glance

Responses render as an expandable tree, so a deeply nested JSON or XML payload is something you navigate instead of scroll. Collapse the noise, drill into the one array that matters, and copy a value or its path in a click.

Click any node to turn it into an assertion. No hand-written path expressions, no guessing whether it is data[0].items[2].price. The tree writes the path for you.

  • Expand, collapse, and search large payloads
  • Click a node to assert its value or type
  • Copy value or JSONPath without typing it
The response tree: click a node to assert on it. · click to enlarge

Schema validation: catch drift before your users do

Validate a response against a JSON Schema or an OpenAPI definition and fail the test the moment the shape changes. A renamed field, a string that became a number, a missing required property, all caught automatically rather than three incidents later.

Point a request at a schema once and every run checks it. Contract drift stops being a surprise and becomes a failing assertion with a clear message.

  • Validate against JSON Schema or OpenAPI
  • Required fields, types, formats, and enums
  • Readable failures that name the offending field
A response checked against its schema, with the mismatch flagged. · click to enlarge

Vault integration: use secrets without storing them

Reference a secret where you need it, for example {{vault:secret/data/oauth#clientId}}, and it is fetched at send time from your provider. The value never gets written into the collection, the environment file, or your git history.

HashiCorp Vault and OpenBao, AWS Secrets Manager, Azure Key Vault, GCP Secret Manager, and 1Password are all supported through the same inline reference syntax.

  • Inline refs: vault:, aws:, azure:, gcp:, op://
  • Resolved at send time, never persisted
  • Same refs work on the desktop app and in CI
A vault reference resolved into an OAuth token at send time. · click to enlarge

Masking: share runs without leaking data

Define patterns for the values that must never appear in plaintext, and API Spector masks them in the response viewer, the logs, and exported reports. Share a run with a teammate or attach it to a ticket without the token, the card number, or the email going with it.

Masking is applied to live streamed frames too, so what you see on screen matches what leaves the app.

  • Mask tokens, PII, and secrets in views and reports
  • Applied to logs and exported artifacts
  • Consistent across live and buffered responses
Sensitive values masked in the response and in the exported report. · click to enlarge

Hooks: set up and tear down around every run

Run logic before and after a request, a folder, or the whole collection with beforeAll, before, after, and afterAll hooks. Seed a record, fetch a token, clean up what you created, all without copying a script into every request.

Pre-request and post-response scripts use a small, documented sp.* API to set variables, read responses, and assert, so setup stays close to the thing it sets up.

  • beforeAll / before / after / afterAll scopes
  • Pre-request and post-response scripting
  • Seed data and tokens, then clean up automatically
A beforeAll hook fetching a token the whole run reuses. · click to enlarge

Flows: chain requests into something you can see

Build a visual flow that calls one request, passes a value into the next, branches on a result, and loops over data. A real sequence, drawn on a canvas, instead of a pile of scripts that only the author understands.

Run a flow from the app, headless from the CLI, or in the cloud. The same flow powers a quick manual check and a scheduled run, so there is one definition to maintain.

  • Chain requests and pass data between steps
  • Branch and loop over data sets
  • Run in the app, from the CLI, or in the cloud
A flow passing data from one request into the next. · click to enlarge

How a test comes together

  1. 1

    Send and explore

    Fire the request and read the response as a tree. Click the nodes you care about to turn them into assertions.

  2. 2

    Validate and secure

    Attach a schema so drift fails the run, reference secrets from your vault, and mask anything sensitive.

  3. 3

    Wrap in hooks and flows

    Add setup and teardown hooks, then chain the requests into a flow that models the real sequence.

  4. 4

    Run anywhere

    Run it locally while you build, then headless in CI with the same definition and get a report back.

Frequently asked questions

Do I need to write code to assert on a response?

No. Click a node in the response tree to assert on its value or type. Scripting is available through the sp.* API when you want it, but it is not required for everyday assertions.

What schemas can I validate against?

JSON Schema and OpenAPI. Attach one to a request and every run checks the response shape, so a renamed or retyped field fails the test instead of slipping through.

Are my secrets stored in the collection?

No. A vault reference is resolved at send time from your provider and the resolved value is never written to the collection, the environment, or git. Masking keeps it out of logs and reports too.

Can the same tests run in CI?

Yes. Collections and flows run headless from the CLI, so the test you build in the app is the test that runs in your pipeline, with a report you can publish.

Explore more

Contract testing

Contract testing →

Mocking

API mocking →

Performance

Performance testing →

Inizia gratis. Paga quando ti fa risparmiare tempo.

The desktop app is free and open source. Add the cloud when you want hosted mocks, monitoring, and a shared broker.