API testing for AI agents

The API testing layer for your AI agent.

Give your agent a way to build API test flows, run them against your app, and inspect the results through MCP or the CLI. Keep the same tests visible on the canvas and repeatable in CI.

Connect your agent
Waitlist access · Free while in beta
Your agent Create a flow · run it · inspect results
MCP / CLI

Illustrative test run. Your API, test data, and assertions define the result.

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
From agent conversation to repeatable test

Give your agent results it can inspect.

Your agent writes the code and decides what to change. Echopoint gives it API test flows, execution results, and recorded assertions to work with.

01

Connect your agent

Use the stdio MCP server with a compatible AI client, or give a terminal-capable agent the CLI. Calls use your authenticated account and permissions.

02

Build a test flow

Ask your agent to create requests, extract response values, and add assertions. Review the resulting flow on the visual canvas.

03

Run and inspect

Execute against a test environment. Your agent can inspect node results and failed assertions, then rerun after changes to your code or tests, under the permissions you give it.

04

Keep it in CI

Reuse the flow in a tagged smoke suite with the GitHub Action or CLI. Keep a repeatable check after the agent conversation ends.

A terminal agent can use the same CLI you do

After you have access, authenticate and choose an existing flow and test environment. Replace the placeholder ID; the JSON run output includes node results and recorded assertions.

Set up MCP or CLI access
validate · run · read JSON resultsCLI
echopoint flows validate <flow-id>
echopoint flows run <flow-id> --environment staging -o json
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 your agent use the same testing tools.

Flows with assertions

Chain requests on a visual canvas, extract response values, and use Branch, Loop, Poll, and SSE nodes. 14 assertion operators, every result recorded with expected vs actual.

Visual API test flows

Run anywhere

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

API tests in CI

OpenAPI import & sync

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

OpenAPI import & sync

Your agent, your tests

Connect an MCP-compatible agent or use the CLI to create flows, run tests, and inspect results with your account permissions.

Agent setup
Flows · Flow Builder

Flows that check their own work.

Drag nodes onto the canvas, 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 equals to regex to between — every result recorded with expected vs actual, even on passing runs
  • 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
See an API request-chaining example
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

Set up API tests in CI Follow the pull-request testing guide

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 — nodes 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.

Request and control-flow nodes, including reusable Modules
14 assertion operators, from equals to regex to between
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.

Visual control flow

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.

Dynamic test data

{{$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

Can my own AI agent use Echopoint?

Yes. The Echopoint CLI includes a stdio MCP server for compatible AI clients, using your authenticated account and permissions. Agents with terminal access can also create flows and run them with the CLI. Your agent controls the conversation and any code changes; Echopoint provides test execution and results.

What is Echopoint?

Echopoint is an API testing layer for AI agents and developers. Connect your agent through MCP or the CLI to create API test flows, run them, and inspect results. The same flows are visible on a canvas and run from the cloud, your infrastructure, or CI.

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.

Read the docs