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 workflow automation, minus the glue scripts.

Start free Read the flows docs

Request · Delay · Module 14 assertion operators 69 dynamic variables

Visual canvas

A canvas with exactly three node types

Request, Delay, Module. A Request node is an HTTP step. A Delay node waits. A Module node runs another flow as a child execution step — flow reuse instead of copy-paste. That's the entire vocabulary, which is why API testing flows built here stay readable six months later.

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.

Request, Delay, and Module nodes — nothing opaque
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: jsonPath (RFC 9535), xmlPath (XPath), statusCode, 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.

Dynamic variables

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 per execution, so a failing run reproduces with the same data instead of a new roll of the dice.

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.

How it works here

Compose, extract, assert, publish

Compose

Drag Request, Delay, and Module nodes onto the canvas; 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.