Getting started

This guide takes you from a fresh account to a flow running in CI. Every step uses the real UI labels and commands.

Go to app.echopoint.dev/sign-up and sign in with Google, GitHub, or email. Your workspace and organization are provisioned automatically on first sign-in — there is no setup wizard. Echopoint is free while in beta; no credit card required.

2. Capture your first webhook

Open Webhooks in the sidebar and create an endpoint. The only required field is a name. You immediately get a capture URL:

https://api.echopoint.dev/webhook/{id}

Keep the endpoint page open — when the live stream is active the UI shows Live stream connected. Then send a request from your terminal:

curl -X POST https://api.echopoint.dev/webhook/wh_9f2k81 \
  -H "Content-Type: application/json" \
  -d '{"event":"payment_intent.succeeded","amount":4200}'

The request appears in the list in real time, and the endpoint answers with a JSON receipt containing message, request_id, and received_at. Click the request to inspect its headers, query parameters, body, and received_at timestamp. Details in Webhook testing.

3. Import an OpenAPI spec and execute a request

Open API → Requests and create a collection, then use Import OpenAPI to upload a spec. Each operation becomes a saved request in the collection. Open one in the workbench, adjust the Params, Headers, Auth, or Body tabs, and execute it — requests run server-side, and the response body and headers appear next to the editor. See Request workbench and OpenAPI import & sync.

4. Build your first flow

Open Flows and create a flow on the visual canvas:

Add a Request node — for example POST /payments against your API.
On the node, add an output extractor: type jsonPath, expression $.id, named payment_id. Downstream nodes can reference it as {{payment_id}}.
Add an assertion: statusCode equals 201. Every assertion is recorded with expected vs actual on each run — including passing runs.
Add a second Request node and connect the two with a success edge.

Click Run flow to execute it, and Run history to review past executions. When the flow is ready, Publish creates an immutable version you can pin and restore. More in Building flows and Outputs & assertions.

5. Set environment variables and launch

Open Environment and set organization defaults — for example BASE_URL — then add a named overlay such as staging to override values per target. When you launch a flow, pick the environment key; values are resolved into the execution inputs.

Launch the flow with the staging environment and watch the canvas: node-by-node progress streams live over SSE as each node starts, completes, or fails. See Environments & variables and Executions & live runs.

6. Create a CI API key

Open API Keys and create a key with the ci preset, which curates the scopes a pipeline needs — including flows:execute and runner:complete (add flows:read if you launch by tag). Keys are org-scoped, support expiration, and the secret is shown once at creation. Copy it now. See API keys & permissions.

7. Run from CI

Install the CLI (macOS/Linux, checksum-verified, installs to ~/.local/bin, no sudo):

curl -fsSL https://raw.githubusercontent.com/nanostack-dev/echopoint-cli/main/install.sh | sh

Authenticate with the API key and run your flows ephemerally — the flow executes inside the CI process and results are published back:

export ECHOPOINT_API_KEY=<your key>
export ECHOPOINT_ORGANIZATION_ID=<your org id>
echopoint flows run --tag smoke --environment staging

Exit codes: 0 success, 1 a flow failed, 3 contract or API error — ready for pipeline gating. In GitHub Actions, the same run is one step:

- uses: nanostack-dev/echopoint-cli@v1
  with:
    api-key: ${{ secrets.ECHOPOINT_API_KEY }}
    organization-id: ${{ secrets.ECHOPOINT_ORG_ID }}
    tags: smoke

Next steps

Webhook testing — live stream, inspection, analytics
Building flows — node types, edges, and the canvas
CLI — full command reference and CI auth
GitHub Action — all inputs and outputs