Apidog CLI vs Hoppscotch CLI: Which Runner for CI/CD?

Both the Apidog CLI and the Hoppscotch CLI let you run API tests from a terminal and plug those tests into CI/CD. The difference is workflow: Hoppscotch CLI is an open-source collection runner, while Apidog CLI is the command-line entry point for a broader API design, test, mock, and documentation platform.

Try Apidog today

Quick verdict

• Use Hoppscotch CLI if you want open source tooling, self-hosting, and JUnit reports are enough.
• Use Apidog CLI if you need CLI/HTML/JSON reports, CSV and JSON data-driven runs, hosted report links, and an integrated API workflow 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 is a runner
Resources as code	Endpoints, schemas, branches, merge requests	No
Open source	No; free tier available	Yes, self-hostable
Wider platform	Design, mock, docs, test in one app	Part of the Hoppscotch ecosystem

1. Install the CLI

Hoppscotch CLI

Hoppscotch CLI installs from npm and requires Node.js v22 or newer. If your CI image still uses Node 20, stay on CLI v0.26.0.

npm i -g @hoppscotch/cli

Run a local collection with an environment file:

hopp test ./collection.json -e ./staging.env.json

Apidog CLI

Apidog CLI runs through the Apidog runner. Authenticate with a login or access token, then run a scenario by ID:

apidog run -t <scenario-id> -e <env-id> --access-token <token>

If you are setting it up from scratch, follow the Apidog CLI installation guide.

CI tip: check your base image before choosing Hoppscotch CLI. The Node v22 requirement can break older GitHub Actions, GitLab CI, Jenkins, or Docker images.

2. Run collections or scenarios

Run a Hoppscotch collection

Hoppscotch CLI runs a Hoppscotch collection from either:

• a local collection JSON file
• a collection ID from a Hoppscotch instance

Example using a self-hosted instance:

hopp test <collection-id> \
  --token <access_token> \
  --server https://hoppscotch.your-company.com

For each request, Hoppscotch CLI:

1. runs the pre-request script
2. sends the request
3. evaluates the test script with pw.test() and pw.expect()
4. exits with a non-zero status if an assertion fails

That makes it straightforward to fail a CI job when API behavior changes.

Run an Apidog test scenario

Apidog CLI runs test scenarios from your Apidog project:

apidog run -t <scenario-id> -e <env-id>

Use this when your tests need to:

• chain multiple API steps
• share variables between requests
• assert against response data
• reuse scenarios created and debugged in the Apidog app

Because the CLI runs the same scenarios stored in the Apidog project, you do not need a separate collection export step for CI.

For more implementation details, see the Apidog CLI complete guide and the guide to testing a REST API from the command line.

3. Add data-driven testing

Data-driven runs are useful when you want to execute the same test against multiple users, payloads, IDs, or edge cases.

Hoppscotch: CSV iteration data

Hoppscotch CLI uses CSV data plus an iteration count:

hopp test ./collection.json \
  --iteration-data ./users.csv \
  --iteration-count 5

Use this when your fixtures fit cleanly into flat CSV rows.

Apidog: CSV or JSON datasets

Apidog CLI accepts CSV and JSON datasets with -d:

apidog run -t <scenario-id> \
  -d ./users.csv \
  -r cli,html

For JSON fixtures:

apidog run -t <scenario-id> \
  -d ./users.json \
  -r cli,json

The practical difference is fixture format. Hoppscotch supports CSV iteration data. Apidog supports CSV and JSON, which is useful when test data is nested or already maintained as JSON.

See the Apidog CLI data-driven testing guide for CSV and JSON examples.

4. Generate reports in CI

Reporting is the clearest difference between the two CLIs.

Hoppscotch: JUnit XML

Hoppscotch CLI writes JUnit XML:

hopp test ./collection.json \
  --reporter-junit ./report.xml

JUnit works well with most CI dashboards. If your only requirement is to show pass/fail test results in CI, this is usually enough.

Apidog: CLI, HTML, JSON, and cloud reports

Apidog CLI can emit multiple report formats:

apidog run -t <scenario-id> -r cli,html,json

It can also upload results and generate a hosted report link:

apidog run -t <scenario-id> --upload-report

Use this when you want:

• terminal output for CI logs
• a self-contained HTML artifact for reviewers
• JSON output for automation
• a hosted report URL to share with teammates

The Apidog CLI test reports guide explains the available formats.

5. Decide based on hosting and openness

Hoppscotch has the advantage if open source and self-hosting are hard requirements.

The Hoppscotch ecosystem is open source and self-hostable, so teams can run the backend themselves and keep request data away from vendor cloud infrastructure. That matters for teams with strict data-residency requirements or an open-source-first policy.

For broader context, see the Hoppscotch alternatives roundup and Postman vs Hoppscotch.

Apidog is not open source. It has a free tier, but its main value is integration: design, mocking, documentation, and testing in one workflow.

6. Use Apidog CLI beyond test execution

Apidog CLI is not only a runner. It can also work with API resources as code, including:

• importing OpenAPI
• working with endpoints
• managing schemas
• using environments
• working with branches and merge requests

That makes it closer to a Git-style API workflow from the terminal.

The same Apidog project can drive:

• API design
• mock servers
• documentation
• test scenarios
• CI test execution

Hoppscotch CLI is intentionally narrower: it runs collections. For design, mocking, and documentation, you bring other tools.

Important limitation: Apidog CLI does not provide a standalone OpenAPI linter or style-guide command. It validates specs on import, but it is not a replacement for tools like Redocly CLI or Spectral. Hoppscotch CLI is also not a spec linter.

For another runner comparison, see Apidog CLI vs Newman.

Recommended setup by use case

• Solo developer or open-source-first team already using Hoppscotch: use Hoppscotch CLI. It is free, self-hostable, and outputs JUnit for CI.
• Team that wants one API platform for design, mock, docs, and testing: use Apidog CLI. It supports CSV/JSON data-driven runs and CLI/HTML/JSON/cloud reports. Download Apidog and import an existing collection to try it.
• Team that only needs a quick CI collection run: either works. Pick the CLI that matches where your collections or scenarios already live.

FAQ

Do both support data-driven testing?

Yes. Hoppscotch uses --iteration-data with CSV plus --iteration-count. Apidog uses -d with CSV or JSON.

Which has better reports?

Hoppscotch writes JUnit XML. Apidog writes CLI, HTML, and JSON reports, and can upload hosted cloud reports. If you need more than JUnit, Apidog covers more formats.

Is Hoppscotch CLI free and open source?

Yes. It is open source and self-hostable. See the official docs and GitHub repo for details.

Apidog has a free tier but is not open source.

Can I move Hoppscotch collections into Apidog?

Yes. Export the Hoppscotch collection, import it into Apidog, then run it with apidog run. The migration guide covers the command mapping.

Bottom line

Choose Hoppscotch CLI if open source, self-hosting, and JUnit reporting are your priorities.

Choose Apidog if you want the CLI to be part of a larger API platform with richer data-driven testing and reporting options.