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.
A canvas with nine node kinds — and real 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. Six more kinds 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.
- Nine node kinds: Request, Delay, Module, Set Variable, Assert, Branch, Loop, Poll, SSE
- Success and error edges between nodes
run_when: alwaysfor cleanup steps; skip-with-reason on every skipped node
API assertions with receipts: expected vs actual, always
Pull values out of any response with five extractor types:
jsonPath (RFC 9535),
xmlPath (XPath),
statusCode,
header, and
body. Then assert on what you extracted
with 14 operators.
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.
69 dynamic variables, deterministic per execution
Need a fresh UUID, a plausible email, a card number that passes validation? Flows ship 69 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.
{
"payment_id": "{{$uuid}}",
"customer_email": "{{$email}}",
"customer_name": "{{$fullName}}",
"card_number": "{{$creditCard}}",
"client_ip": "{{$ipv4}}",
"created_at": "{{$timestamp}}"
}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.
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.
Build a flow on the visual canvas, assert on everything, and keep the evidence. Free while in beta, no credit card.