Thunder Client won its audience by being the opposite of Postman: a fast, free API client that lived inside VS Code and stored collections as JSON files in your repo. That deal has been shrinking for years. Git sync moved behind a paywall in 2023, and today’s free tier, per Thunder Client’s pricing page, is capped at 250 collection runs per month, with no Git sync, no CLI or CI runs, no custom scripting, no global environments, and no WebSocket, SSE, or gRPC support. Those all start on the paid plans, at $3, $7, and $16 per user per month billed annually.
Here’s the direct answer: Apidog is the best Thunder Client alternative, because it gives you everything Thunder Client charges for (unlimited collection runs, scripting, CLI and CI integration, WebSocket, SSE, gRPC and GraphQL) on a free plan that covers up to 4 users, and it adds the things a VS Code panel can never hold: a real spec editor, a smart mock server, automated test scenarios, and publishable API docs. The honest trade is that you leave the VS Code sidebar for a dedicated app. This article lays out what the free tier lost, what the paid tiers still don’t include, and exactly how to migrate your collections.
How the free tier got smaller
Thunder Client’s original pitch was lightweight and git-native: collections lived as JSON in a .thunder-tests folder, so API changes went through the same pull requests as code. In 2023 that storage model became a paid feature, and free users’ collections moved into VS Code’s internal extension storage: still local, but invisible to git, code review, and teammates. We covered that turn in detail when it happened, in Thunder Client Pro paywall: what changed.
The current free tier, as listed on the pricing page, draws the lines even more tightly:
- 250 collection runs per month. The collection runner, the feature that turns saved requests into a regression check, has a monthly meter.
- HTTP only. WebSocket, SSE, and gRPC requests are paid-plan features.
- No scripting. Custom pre-request and test scripting is reserved for paid tiers, so anything beyond basic assertions is out.
- No CLI, no CI. Running collections from a pipeline requires a paid plan.
- No Git sync, no global environments, VS Code only. JetBrains IDE support also starts on the paid tiers.
None of this is scandalous; a solo developer maintaining a useful extension is allowed to charge. But it means “Thunder Client because it’s free” is no longer a reason. If the free tier fits, you’re using a basic HTTP panel. The moment you need the runner without a meter, a script, a socket, or a pipeline, you’re choosing between Thunder Client’s paid tiers and an actual platform, so it’s worth comparing those directly.
What the paid tiers buy, and what they still don’t
Thunder Client’s paid pricing is genuinely cheap per seat: Starter is $3 per user per month billed annually (credit card only, capped at 10 seats), Business is $7, Enterprise is $16. Starter unlocks Git sync, the CLI and CI/CD runs, WebSocket/SSE/gRPC, and JetBrains support. But the run meter doesn’t disappear when you pay: Business raises the monthly collection-run cap to 500 per user, and unlimited runs arrive only at Enterprise. Encrypted environments and secrets-manager integration are Business features; SSO and audit logs are Enterprise.
The larger point is what isn’t on any tier. Thunder Client is a request client. There is no API spec editor at its center, no mock server for consumers, no hosted documentation, no visual test orchestration across APIs. Paying removes the meters on the client; it doesn’t grow the category of tool. That’s the same conclusion we reached comparing it against Postman in Postman vs Thunder Client, from the other direction.
The answer: Apidog
Apidog is an API development platform used by over 500,000 developers, covering design, debugging, testing, mocking, and documentation in one app driven by one spec.
For someone weighing it against Thunder Client specifically:
- The things behind Thunder Client’s paywall are free here. Unlimited collection and scenario runs, pre/post-request scripting, WebSocket, SSE, gRPC, and GraphQL requests, and CI execution via the Apidog CLI are all on the free plan, which covers up to 4 users. Paid plans start at $9 per user per month.
- Your requests get a spec. Requests you debug can be saved as documented endpoints with schemas, so the collection grows into an API definition instead of a pile of saved calls. Docs, mocks, and tests generate from it.
- A mock server exists at all. Apidog’s smart mock serves realistic schema-based responses the moment an endpoint is defined, no examples or setup required. Thunder Client has no equivalent at any price.
- Tests are a first-class feature, not a metered add-on. Visual test scenarios chain requests, assert on responses, validate against schemas, run data-driven cases, and run in CI, with no monthly cap to ration.
What the switch looks like feature by feature
The request client itself
Day-to-day request sending translates directly: collections, folders, environment variables, cookies, auth helpers, code generation. Apidog’s client handles HTTP, WebSocket, SSE, gRPC, and GraphQL on the free plan, where Thunder Client’s free tier is HTTP-only. If part of your team lives in JetBrains IDEs, Apidog Fast Request covers request sending there; there is no Apidog panel inside VS Code, which is the honest loss and covered below.
Scripting and the runner
Thunder Client’s filter-based tests cover simple assertions, with real scripting paid. Apidog supports pre- and post-request scripts (Postman-compatible syntax, so most snippets paste over), schema validation without writing assertions at all, and an unmetered runner. If your monthly 250 runs kept evaporating mid-sprint, this is the line item that ends it.
Git workflows
If you loved Thunder Client for the .thunder-tests folder era, be precise about what you want back. If it’s collections as reviewable files in the repo, a git-native client is the purist’s answer, and we compared the leading one in the best Bruno alternative. If it’s “my team sees the same collections without paying per seat for sync,” Apidog’s cloud workspace with branch-based versioning does that on the free plan, and the spec can still be exported to OpenAPI files for your repo whenever you want git history.
Beyond the client
This is the category jump: design the API visually or in code, publish interactive docs on your domain, hand consumers a mock URL, and wire scenarios into CI. Docs also publish alongside an MCP server so AI agents can read your spec directly; details in what is Apidog MCP Server.
Thunder Client vs Apidog at a glance
| Thunder Client | Apidog | |
|---|---|---|
| Form | VS Code extension (JetBrains on paid) | Desktop app + web (JetBrains plugin for requests) |
| Free collection runs | 250/month | Unlimited |
| WebSocket / SSE / gRPC | Paid plans | Free, plus GraphQL |
| Scripting | Paid plans | Free, Postman-compatible |
| CLI / CI runs | Paid plans | Free via Apidog CLI |
| Git sync | Paid plans | Cloud workspace + branch versioning; OpenAPI export |
| Mock server | No | Schema-aware smart mocks, free |
| API docs | No hosted docs | Published interactive docs, custom domain |
| Spec editing | No | Visual + code OpenAPI editors |
| Secrets/encrypted envs | Business ($7) | Vault integrations on paid plans |
| SSO, audit logs | Enterprise ($16) | Enterprise plan |
| Free seats | Per-user free tier | 4 users |
The seat math, honestly
Thunder Client is cheaper per seat, and pretending otherwise would insult your calculator. Annual bills for a team that needs Git sync, CI runs, and full protocol support (Thunder Client Starter at $3 per user per month billed annually, versus Apidog free for 4 then $9 per user per month):
| Team size | Thunder Client Starter per year | Apidog per year |
|---|---|---|
| 3 people | $108 | $0 (free plan) |
| 5 people | $180 | $540 |
| 10 people | $360 | $1,080 |
| 25 people | $2,100 (Starter caps at 10 seats; Business at $7) | $2,700 |
Read the table both ways. Under 5 people, Apidog is the cheaper option outright. Above that, Thunder Client wins on sticker price, but the two columns don’t buy the same thing: the left column is an unmetered-ish HTTP client in your IDE (runs stay capped until Enterprise), the right column is the client plus the mock server, docs platform, spec editor, and test orchestration you’d otherwise assemble from second and third tools. If those tools are Postman seats, the math flips again; see the best Postman alternative for that comparison.
Migrating from Thunder Client
Thunder Client’s own export makes this painless, per its import/export documentation:
- Export your collections from Thunder Client. Right-click a collection and choose Export. Pick Postman format (or OpenAPI, if your collections are clean enough to describe endpoints).
- Export environments the same way, so base URLs and variables come along.
- Import into Apidog. Project Settings, Manual Import, select the Postman or OpenAPI file. Requests, folders, and environments arrive structured; endpoints imported from OpenAPI get schemas, docs, and live smart mocks immediately.
- Paste your scripts. Apidog’s scripting is Postman-compatible, and Thunder Client’s Postman-format export carries request bodies and headers cleanly; rewrite any Thunder Client filter-style tests as assertions or let schema validation replace them.
- Reconnect CI. Replace the metered paid runner with Apidog CLI runs in your pipeline.
A typical setup (a few dozen requests, two environments) moves in well under an hour.
When Thunder Client still makes sense
If you’re a solo developer, you live in VS Code, your APIs are plain HTTP, 250 runs a month is genuinely enough, and you want zero new windows, Thunder Client’s free tier remains a tidy tool, and $3 a month is a fair price for the Starter unlocks. The in-editor experience is the one thing Apidog does not replicate for VS Code users. The switch pays off at the first mock server you need, the first WebSocket endpoint, the first CI pipeline, or the first teammate: the moments a request panel stops being an API workflow.
Frequently asked questions
Is Thunder Client still free?
There’s a free tier, but it’s metered and narrow: 250 collection runs per month, HTTP only, no Git sync, scripting, CLI, or CI runs. Those require paid plans at $3 to $16 per user per month billed annually, and unlimited collection runs only arrive on the $16 Enterprise tier.
Can I import Thunder Client collections into Apidog?
Yes, in two clicks: export from Thunder Client in Postman format (right-click the collection, Export), then import that file into Apidog. Environments export and import the same way. OpenAPI export also works if you want endpoints with schemas rather than plain requests.
Does Apidog have a VS Code extension like Thunder Client?
No. Apidog is a desktop and web app, with a JetBrains plugin (Apidog Fast Request) for in-IDE request sending. If an in-VS-Code panel is a hard requirement, that’s the one box Apidog doesn’t tick.
Do my Thunder Client scripts work in Apidog?
Apidog’s pre- and post-request scripting is Postman-compatible. Thunder Client’s paid custom scripts mostly translate directly; its built-in filter-style tests are usually better replaced by Apidog’s no-code assertions and automatic schema validation.
What does Apidog’s free plan include compared to Thunder Client’s?
Up to 4 users with unlimited collection and scenario runs, scripting, WebSocket/SSE/gRPC/GraphQL, the smart mock server, published docs, and CLI-based CI runs. Thunder Client’s free tier is a single-protocol client with a 250-run monthly cap and no team, sync, or pipeline features.
Stop rationing collection runs
Export your collections in Postman format, import them into Apidog, and run them as many times as you like, in the app or in CI. Download Apidog or start in the browser; a team of 4 pays nothing, and the mock server, docs, and test scenarios are waiting behind the same import.
