Both the Apidog CLI and the Hoppscotch CLI run API tests from a terminal, and both fit into a CI/CD pipeline. They come from different places, though. Hoppscotch is an open-source API ecosystem, and its CLI is a focused collection runner. Apidog is an all-in-one API platform, and its CLI is the terminal entry point to a larger design-test-mock-document workflow.
Quick verdict
- Pick the Hoppscotch CLI if open source and self-hosting matter most, you already use Hoppscotch, and a JUnit report covers your reporting needs.
- Pick the Apidog CLI if you want CLI, HTML, and JSON reports, data-driven runs over CSV and JSON, cloud-hosted reports, and an integrated platform behind the CLI.
Side-by-side
| Apidog CLI | Hoppscotch CLI | |
|---|---|---|
| Install | Apidog runner / apidog CLI |
npm i -g @hoppscotch/cli (Node v22+) |
| Runs | Test scenarios and collections | Hoppscotch collections |
| Source | Apidog project, or OpenAPI import | Collection JSON file or instance ID |
| Data-driven | -d CSV and JSON |
--iteration-data CSV + --iteration-count |
| Reporters | CLI, HTML, JSON + cloud upload | JUnit XML |
| Scripting | Pre/post-processors, assertions | Pre-request + pw.test() / pw.expect() |
| Spec linting | No standalone linter (validates on import) | No (it’s a runner) |
| Resources as code | Endpoints, schemas, branches, merge requests | No |
| Open source | No (free tier) | Yes, self-hostable |
| Wider platform | Design, mock, docs, test in one app | Part of the Hoppscotch ecosystem |
Installation and runtime
The Hoppscotch CLI installs from npm and needs Node.js v22 or newer (Node 20 users stay on CLI v0.26.0):
npm i -g @hoppscotch/cli
hopp test ./collection.json -e ./staging.env.json
The Apidog CLI comes through the Apidog runner and authenticates with a login or access token, then runs scenarios by ID:
apidog run -t <scenario-id> -e <env-id> --access-token <token>
Neither install is heavy. The one gotcha is Hoppscotch’s hard Node v22 requirement, which bites on older CI images. The Apidog CLI installation guide covers the runner setup if you’re starting fresh.
What each one runs
The Hoppscotch CLI runs a Hoppscotch collection. You either pass a local collection JSON file or pull one from a Hoppscotch instance by ID with a token:
hopp test <collection-id> --token <access_token> --server https://hoppscotch.your-company.com
For each request it runs the pre-request script, sends the request, and evaluates the test script with pw.test() and pw.expect(). A failing assertion produces a non-zero exit code.
The Apidog CLI runs test scenarios built in your Apidog project, which can chain steps, share variables, and assert across responses. Because the CLI is part of the platform, the same scenarios you design and debug in the app are the ones you run in CI; there’s no separate export step. See the Apidog CLI complete guide for the scenario model and test a REST API from the command line for a hands-on run.
Data-driven testing
Both tools iterate a test over a dataset, which is the feature most teams care about.
Hoppscotch uses CSV iteration data plus a count:
hopp test ./collection.json --iteration-data ./users.csv --iteration-count 5
Apidog accepts CSV and JSON datasets with -d:
apidog run -t <scenario-id> -d ./users.csv -r cli,html
The practical difference is format flexibility. Hoppscotch reads CSV; Apidog reads CSV and JSON, which matters when your fixtures are nested or already live as JSON. The Apidog CLI data-driven testing guide shows the CSV and JSON patterns side by side.
Reporting
This is the clearest split. The Hoppscotch CLI writes JUnit XML:
hopp test ./collection.json --reporter-junit ./report.xml
JUnit is widely supported, so most CI systems display the results natively. But it’s the one structured format the CLI produces.
The Apidog CLI emits CLI, HTML, and JSON reports, and can push results to the cloud for a hosted, shareable link:
apidog run -t <scenario-id> -r cli,html,json
apidog run -t <scenario-id> --upload-report
If you want a self-contained HTML artifact for a PR reviewer, or a hosted report URL to drop in a Slack channel, Apidog covers more formats. The Apidog CLI test reports guide walks through each. If JUnit into your CI dashboard is all you need, Hoppscotch is fine.
Open source and self-hosting
Here Hoppscotch wins on its own terms. The whole ecosystem is open source and self-hostable, so you can run the backend yourself and keep request data off any vendor cloud. For teams with strict data-residency rules or a preference for open tooling, that’s a real, defensible reason to choose it. The Hoppscotch alternatives roundup and Postman vs Hoppscotch cover the wider ecosystem.
Apidog is not open source. It has a free tier, and its pitch isn’t “more open”; it’s “more integrated.”
Beyond running tests
This is where the Apidog CLI stops being just a runner. It manages API resources as code: importing OpenAPI, and working with endpoints, schemas, environments, branches, and merge requests from the terminal. That makes the CLI part of a Git-style workflow rather than a one-shot test command.
It’s also the terminal face of a full platform. The same project drives API design, mock servers, documentation, and tests. The Hoppscotch CLI, by design, runs collections and nothing more; you bring design, mocking, and docs from elsewhere.
Honesty note: the Apidog CLI does not have a standalone OpenAPI linter or style-guide command. It validates specs on import, but it doesn’t lint them the way a dedicated linter does. If terminal spec-linting is a hard requirement, neither of these runners is your linter; a tool like Redocly CLI or Spectral is. Compare the runner trade-offs in Apidog CLI vs Newman.
Who should pick which
- Solo dev or open-source-first team, already on Hoppscotch: the Hoppscotch CLI. Free, self-hostable, JUnit into CI, done.
- Team that wants one platform for design, mock, docs, and test, with data-driven runs over CSV/JSON and HTML/JSON/cloud reports: the Apidog CLI. Download Apidog and import an existing collection to try it.
- Just need a quick collection run in CI with no other needs: either works; pick by which app your collections already live in.
FAQ
Do both support data-driven testing? Yes. Hoppscotch uses --iteration-data (CSV) with --iteration-count; Apidog uses -d with CSV or JSON.
Which has better reports? Hoppscotch writes JUnit XML. Apidog writes CLI, HTML, and JSON, plus hosted cloud reports. If you need more than JUnit, Apidog covers more formats.
Is the Hoppscotch CLI free and open source? Yes, and it’s self-hostable. The official docs and GitHub repo have the details. Apidog has a free tier but isn’t open source.
Can I move my Hoppscotch collections into Apidog? Yes. Export the collection and import it, then run with apidog run. The migration guide covers the command mapping.
Both runners do the core job well. Choose the Hoppscotch CLI for open source and self-hosting; choose Apidog when you want the runner to be one part of an integrated API platform with richer data-driven runs and reports.
