Flows with assertions
Nine node kinds on a visual canvas, from Request and Delay to Branch, Loop, Poll, and SSE. 14 assertion operators, every result recorded with expected vs actual.
Flow builder API flow automation
Automate and test your APIs with visual flows.
Chain API calls into visual flows with a real assertions engine, then run the same suite from the cloud, your own infrastructure, or CI — with live node-by-node progress.
On GitHub
The CLI and runner are public on GitHub.
Install in one line — checksum-verified, no sudo, straight to
~/.local/bin. Self-update with echopoint update.
Install the CLI macOS / Linux
curl -fsSL https://raw.githubusercontent.com/nanostack-dev/echopoint-cli/main/install.sh | sh Platform
From first request to green build.
Build flows with a real assertions engine, run them anywhere, keep collections synced to your OpenAPI spec, and let Echopoint AI help on the canvas.
Run anywhere
Managed cloud runners by default. Self-host on your own infrastructure, or run ephemeral one-shot executions in CI.
CLI & GitHub ActionOpenAPI import & sync
Upload a spec to generate a collection of requests, then keep it continuously reconciled with drift and sync history.
OpenAPI syncEchopoint AI copilot
Ask Echopoint AI to inspect a flow or propose the next change on the canvas. It applies edits as restorable snapshots, so you can undo any AI run.
Echopoint AI Flows · Flow Builder
Flows that check their own work.
Drag nodes onto the canvas — nine kinds, from Request and Delay to Branch, Loop, Poll, and SSE — wire success and error paths between them, and let assertions decide whether a run passes.
- Extract outputs per node with jsonPath, xmlPath, statusCode, header, or body
- 14 assertion operators, from
equalstoregextobetween— every result recorded with expected vs actual, even on passing runs - 69 built-in dynamic variables like
{{$uuid}}and{{$email}}, deterministically seeded per execution - Module nodes run another flow as a child execution — reuse, not copy-paste
- Publish immutable versions, restore snapshots, pin a version at launch — and ask Echopoint AI to inspect the flow or propose the next change
CI/CD · CLI + GitHub Action
The same flows, green in CI.
Tag flows into suites and run them from the GitHub Action or the CLI — with live node-by-node progress, strict exit codes, and no secrets in your logs.
api-tests.yml GitHub Action
name: API tests
on: pull_request
jobs:
smoke:
runs-on: ubuntu-latest
steps:
- uses: nanostack-dev/echopoint-cli@v1
with:
api-key: ${{ secrets.ECHOPOINT_API_KEY }}
organization-id: ${{ secrets.ECHOPOINT_ORG_ID }}
tags: smoke
parallel: '3' Any other CI, or your terminal CLI
echopoint flows run --tag smoke --environment staging- Exit codes
- 0 success · 1 flow failed · 3 contract or API error
- Secret boundary
- API key auto-masked; resolved env values are never logged
- Action outputs
- execution-id · status · success · results-json
Product
One workspace, four surfaces.
Flows, CI/CD, OpenAPI Sync, and Requests — the same product from first request to green build.
Chain requests into visual flows
Drag nodes onto a canvas and connect them with success and error edges — nine node kinds, from Request and Delay to Branch, Loop, Poll, and SSE. Extract values with JSONPath, then assert on every response — expected vs actual is recorded even when an assertion passes.
Nine node kinds, including Module nodes for flow reuse
14 assertion operators, from equals to regex to between
69 built-in dynamic variables, deterministic per execution
How it works
Four steps to a green run.
STEP 01
Join the waitlist
Drop your work email. We let you in as your spot opens. Then sign in with GitHub, Google, or email.
STEP 02
Bring in your API
Import an OpenAPI spec to generate a collection of requests, or build requests by hand in the workbench.
STEP 03
Build a flow
Chain requests with Branch, Loop, Poll, and the other node kinds, extract outputs, and add assertions that record expected vs actual.
STEP 04
Run it in CI
Tag the flow, then run the suite with the GitHub Action or echopoint flows run --tag smoke.
Capabilities
The details, shipped.
Everything below is in the product today.
Assertions engine
14 operators, from equals to regex to between. Every assertion records expected vs actual — even when it passes.
Nine node kinds
Request, Delay, and Module cover the basics; Branch, Loop, Poll, SSE, Set Variable, and Assert give flows real control flow.
Success and error paths
Wire edges for both outcomes. Always-steps run even after an upstream failure — built for cleanup.
Skip-with-reason
Skipped nodes record a skip reason and missing inputs, so you know exactly why a step did not run.
69 dynamic variables
{{$uuid}}, {{$email}}, {{$creditCard}} and more — faker-backed, deterministically seeded per execution.
Live run progress
Node-by-node execution progress streams onto the canvas in real time over SSE — no refresh, no polling.
Immutable versions
Publish snapshots you can view and restore; launches can pin an exact version of a flow.
Run anywhere
Managed cloud runners, self-hosted runners on your own infrastructure, or ephemeral one-shot runs in CI.
Tag-based suites
echopoint flows run --tag smoke selects up to 50 flows and runs them in parallel — locally, in CI, or on a schedule as a monitor with failure email alerts.
OpenAPI import & sync
Upload a spec to generate a collection, then keep it continuously reconciled with drift and sync history.
Scoped API keys
Org-scoped keys with scoped permissions and a curated ci preset — shown once, rotatable, with expiration.
Instant webhook endpoints
Need to capture a webhook? Create an endpoint with just a name and watch requests stream in live over SSE.
FAQ
Frequently asked questions
What is Echopoint?
Echopoint is an API flow automation and testing platform. You build visual API flows with a real assertions engine, then run the same suite from the cloud, your own infrastructure, or CI. It can also capture webhooks on instant endpoints when you need to inspect incoming requests.
Is Echopoint free?
Yes — Echopoint is free while in beta, with no credit card required. Join the waitlist. When your spot opens, sign in with GitHub, Google, or email and your workspace is provisioned.
Can I run flows in CI?
Yes. Use the nanostack-dev/echopoint-cli@v1 GitHub Action, or run echopoint flows run --tag smoke from any CI. Exit codes report the result (0 success, 1 flow failed, 3 contract or API error), the API key is auto-masked, and resolved secrets are never logged.
Can I run flows on a schedule?
Yes. Schedules — called monitors in the app — run a tagged flow suite on a recurring basis. Each monitor can be paused and resumed, keeps its own run history, and emails the recipients you configure when a scheduled run fails.
Do you support OpenAPI?
Yes. Import an OpenAPI spec to generate a collection of requests, then enable per-collection OpenAPI Sync to keep it reconciled as the spec changes, with drift and sync history.
Can I self-host runners?
Yes. Flows run on managed cloud runners by default, but self-hosted runners on your own infrastructure claim jobs with lease-based claiming and heartbeats — the app shows live runners with load and heartbeat freshness. CI and CLI runs can use ephemeral one-shot runners, and resolved values go only to the launched execution and are never logged.
Can I capture and inspect webhooks?
Yes. Create an endpoint with just a name to get a capture URL at api.echopoint.dev/webhook/{id}. It accepts GET, POST, PUT, PATCH, and DELETE with no auth required, and requests stream into the app live over SSE where you can inspect headers, query params, and body, and search the history.
Build your first flow.
Watch it pass in CI.
Free while in beta. Join the waitlist. When your spot opens, sign in with GitHub, Google, or email and your workspace is provisioned.