CI/CD · CLI, GitHub Action, runners

Run API flows in CI

API tests in CI without a harness to maintain: install the CLI or drop in the GitHub Action, run your smoke tests by tag, and let exit codes decide the merge. Each run executes on an ephemeral runner that exists only for that job.

Start free GitHub Action docs

exit 0 success · 1 flow failed · 3 contract/API error up to 50 flows per tag run

Echopoint CLI

API testing from the CLI, in one command

The CLI installs with a single checksum-verified script — no sudo, straight to ~/.local/bin, with a PowerShell one-liner for Windows. Authenticate locally with echopoint auth login (browser OAuth), or in CI with the ECHOPOINT_API_KEY and ECHOPOINT_ORGANIZATION_ID environment variables.

echopoint flows run executes flows as one-shot ephemeral runs: pass flow IDs or --tag smoke to resolve a suite (repeatable, --match-mode any|all, up to 50 flows per run). Add --verbose for live node-by-node status in the terminal, -o json for machine-readable results, and --poll-timeout if a suite needs more than the default 30 minutes.

installmacOS / Linux

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

run locallyterminal

echopoint auth login
echopoint flows run --tag smoke --environment staging --verbose

run in ciapi key auth

ECHOPOINT_API_KEY=<key> ECHOPOINT_ORGANIZATION_ID=<org> \
  echopoint flows run --tag smoke -o json

GitHub Action

GitHub Action API testing, four lines of `with:`

nanostack-dev/echopoint-cli@v1 wraps the same ephemeral execution in a single step. Point it at one flow-id, a list of flow-ids, or tags with match-mode any|all; choose the environment, pin a version-id, and tune parallel and poll-timeout (default 300 seconds).

Your API key is auto-masked in logs, and resolved secrets are never logged. The step's outputs hand downstream jobs everything they need.

.github/workflows/api-smoke-tests.ymlyaml

name: api-smoke-tests
on: [push]

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'

Action outputs

execution-id(s) Identifiers of the launched executions

status completed · failed · error

success Boolean — true when every flow passed

results-json Full results payload for downstream steps

CLI exit codes

0 All flows passed

1 A flow failed

3 Contract or API error

--idempotency-key Guards launches so re-run jobs don't double-launch

Scopes & secrets

Scoped keys and a hard secret boundary

Create an org-scoped API key with the curated ci preset: flows:execute to launch, runner:complete so the ephemeral runner can publish results, and flows:read if you resolve suites by tag. Keys support expiration and are shown once at creation — create, rotate, move on.

The secret boundary is structural: the ephemeral runner receives a flow snapshot and resolved inputs, publishes results back, and exits. Resolved environment values go only to that launched execution. They are never logged.

Runners

Smoke tests on every push — from our cloud or your network

By default each CI run is ephemeral: a one-shot runner inside your job, nothing persistent to babysit. When flows must run from inside your network, run the self-hosted echopoint-runner on your own infrastructure — lease-based job claiming, heartbeats, and live runner status with load and heartbeat freshness in the app.

Either way you keep the same controls: --environment to pick a staging or prod overlay, --version-id to pin the exact published flow, and --parallel to fan out a suite.

Ephemeral: flow snapshot + resolved inputs in, results out, process ends
Self-hosted: lease-based claiming, heartbeats, live load in the UI
Version pinning and environment selection on every launch

How it works here

Four steps to a merge gate

Create a ci key

API Keys → preset "ci": flows:execute, runner:complete, flows:read.

Tag your suite

Tag flows "smoke" — lowercase, up to 32 tags per flow — to group them into suites.

Add one step

Drop in the GitHub Action, or call echopoint flows run --tag smoke from any CI.

Gate the merge

Exit 0 passes. 1 means a flow failed. 3 means a contract or API error.

Make --tag smoke your merge gate.

Install the CLI, create a ci key, and your first pipeline run is minutes away. Free while in beta, no credit card.