Flows · Flow Builder

API flows with a real assertions engine

Chain API requests on a visual canvas and assert on every response. Echopoint records expected vs actual for each check — even when it passes. API flow automation, minus the glue scripts. Your agent can create and update flows through MCP or the CLI; you can review the same flow on the canvas.

Read the flows docs

Visual request chaining 14 assertion operators Generated test data

Visual canvas

Chain API requests with visible control flow

Request, Delay, and Module cover the basics: an HTTP step, a wait, and a child flow run as a step — flow reuse instead of copy-paste. Other nodes make control flow first-class on the canvas: Set Variable, Assert, Branch for conditional paths, Loop, Poll to repeat a request until a condition holds, and SSE to subscribe to a server-sent-events stream. Each kind has its own canvas UI, so the logic is visible on the graph instead of buried in a script.

Nodes connect with success and error edges, so the failure path is explicit on the canvas instead of buried in a script. Steps marked run_when: always run even after an upstream failure — the cleanup pattern: revoke the token, delete the test record. And when a node doesn't run, it tells you why: skipped nodes record a skip_reason and the missing_inputs behind it.

Start with the flow-building guide for nodes, edges, and request variables.

Request chaining, reusable Module nodes, and explicit control-flow steps
Success and error edges between nodes
run_when: always for cleanup steps; skip-with-reason on every skipped node

Assertions engine

API assertions with receipts: expected vs actual, always

Pull values out of any response with five extractor types: json_path (RFC 9535), xml_path (XPath), status_code, header, and body. Then assert on what you extracted with 14 operators.

equalsnotEqualscontainsnotContainsstartsWithendsWithregexemptynotEmptygreaterThanlessThangreaterThanOrEquallessThanOrEqualbetween

Every assertion is recorded with expected, actual, and passed — on passing runs too. When someone asks why last night's run was green, you show them the values it saw, not a checkmark. See how to configure outputs and assertions.

Dynamic variables

Dynamic test data, deterministic per execution

Need a fresh UUID, a plausible email, a card number that passes validation? Flows ship built-in dynamic variables — faker-backed and deterministically seeded within each execution, with every resolved value recorded in the node results. When a run fails, you see exactly what data it sent — no guessing.

Everything uses the same {{double_brace}} syntax, alongside your own flow-level variables and the environment values resolved at launch.

request bodyresolved at run time

{
  "payment_id": "{{$uuid}}",
  "customer_email": "{{$email}}",
  "customer_name": "{{$fullName}}",
  "card_number": "{{$creditCard}}",
  "client_ip": "{{$ipv4}}",
  "created_at": "{{$timestamp}}"
}

Publish & versions

Publish immutable versions — with an AI copilot on the canvas

Publishing a flow creates an immutable version. View any snapshot, restore it, or pin a launch to a specific version-id so CI runs exactly what you reviewed. Tags — lowercase, up to 20 characters, 32 per flow — plus full-text search keep a growing library findable.

Echopoint AI lives in the canvas: ask it to inspect a flow or propose the next change. It applies edits with restorable snapshots, so an AI run is something you can undo, not something you have to trust.

API test flow example

Create a record, check it, clean it up

For an API with create, read, and delete endpoints, build this four-step smoke test. These paths are illustrative; use your own API and a test environment.

Create and extract

Send POST /orders. Assert that the status is 201 and extract $.id into an output named order_id on the node with ID create_order.

Chain the response value

Connect a Request node to call GET /orders/{{create_order.order_id}}. The next request uses the ID returned by the create step.

Assert on the result

Check that the read returns 200 and $.status equals your expected value, such as created. Open the result to inspect expected and actual values.

Delete the test record

Add DELETE /orders/{{create_order.order_id}} with run_when: always for cleanup after a failed check. If a required ID is missing, inspect the recorded skip reason.

Configure environment values for your base URL and auth, follow the extractor examples, then run the smoke flow in CI.

How it works here

Compose, extract, assert, publish

Compose

Drag nodes onto the canvas — Request and Delay through Branch, Loop, Poll, and SSE — and wire success and error edges.

Extract

Capture statusCode, headers, or jsonPath values as outputs for downstream nodes.

Assert

Add checks with 14 operators. Expected and actual are stored on every run.

Run & publish

Run flow, read run history node by node, then publish an immutable version.

Make your next green run mean something.

Join the waitlist for access to the visual flow builder. When your spot opens, build your first smoke test. Free while in beta, no credit card.