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.

Start free Read the docs
Free while in beta · No credit card
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.

nanostack-dev/echopoint-cli CLI for flows, collections, and CI runs nanostack-dev/echopoint-runner The runner that executes flows — cloud, self-hosted, or ephemeral
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.

Flows with assertions

Chain Request, Delay, and Module nodes on a visual canvas. 14 assertion operators, every result recorded with expected vs actual.

Flow builder

Run anywhere

Managed cloud runners by default. Self-host on your own infrastructure, or run ephemeral one-shot executions in CI.

CLI & GitHub Action

OpenAPI import & sync

Upload a spec to generate a collection of requests, then keep it continuously reconciled with drift and sync history.

OpenAPI sync

Echopoint 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 Request, Delay, and Module nodes onto the canvas, 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 equals to regex to between — 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
Explore flows
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 Request, Delay, and Module nodes onto a canvas and connect them with success and error edges. Extract values with JSONPath, then assert on every response — expected vs actual is recorded even when an assertion passes.

Three node types: Request, Delay, and Module 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

Sign in

GitHub, Google, or email. Your workspace is provisioned on first sign-in — nothing to configure.

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 Request, Delay, and Module nodes, 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.

Three node types

Request, Delay, and Module. A Module node runs another flow as a child execution — reuse, not copy-paste.

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 can run them in parallel — locally or in CI.

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. Sign in with GitHub, Google, or email and your workspace is provisioned on first sign-in.

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.

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 — sign in with GitHub, Google, or email, and your workspace is provisioned on first sign-in.

Start free Read the docs