TestSprite · TestSprite: AI Testing Agent for End-to-End and API Tests
TestSprite is an AI testing agent that plans, writes and runs end-to-end frontend and API tests against your running web app, explains each failure, and re-runs the growing suite on every pull request or schedule. It is aimed at developers and teams shipping code written by coding agents such as Claude Code, Cursor or Codex who want an independent check before merging, and it can be driven from a web portal, an open-source CLI, an MCP server or GitHub.
Best for
Developers and small teams shipping web apps with coding agents who want an independent, approval-based end-to-end and API regression suite that runs on every pull request without writing test code
Not ideal for
Teams that need native mobile app testing, a fully self-hosted or open-source test runner, or a fixed and predictable testing budget for heavy usage
Who it's for
Developers using coding agents, startup engineering teams, and QA teams that want AI-generated and maintained end-to-end and API tests for web apps
TestSprite is built around a sensible idea for teams leaning on coding agents: keep the verifier separate from the code writer, and do not let a failing test be quietly rewritten to pass. Approval-gated test plans, evidence-rich failure bundles and the CLI's JSON output make it practical to put into an agent's own loop, and Playwright export eases lock-in worries. What to check before committing is cost and scope. Plans are cheap to start, but credits per run are not published, so measure a few real runs first; and it covers web and API testing only, so mobile teams will need another tool. The accuracy figures on its homepage come from TestSprite's own benchmark.
Who should use it
Developers and small teams whose coding agents produce more code than they can review by hand, startups without dedicated QA that want PR-gated regression tests, and QA teams that want to define expected behavior in plain language and let an agent write and maintain the tests.
Who should skip it
Teams that test native mobile apps, organizations that require a fully self-hosted or open-source testing stack outside an Enterprise contract, and teams with large suites on a tight fixed budget who cannot absorb variable credit usage.
Free
$0
Billed monthly
Starter
$19
Billed monthly
Standard
$39
Billed monthly
Pro
$69
Billed monthly
Enterprise
From $199
Billed monthly
Free tier limits: 150 credits per month, 1 environment, 1 test list, 30 days of run history and GitHub PR auto-test on 1 repository.
Note: Prices shown are monthly; the pricing page says yearly billing saves 35%. Plans are credit-based, and the pricing page does not state how many credits a test run or agent session consumes.
Modalities
Web frontend (browser), Backend APIs
Verifying a coding agent's changes before merge
The CLI returns JSON failure bundles with evidence and a suggested fix, so an agent like Claude Code or Codex can run the tests, fix the code and re-run without a person reading test logs.
PR-gated regression testing on preview deployments
The GitHub integration waits for a preview deployment, runs the full suite against it, posts results to the pull request and can block the merge until tests pass.
Bootstrapping test coverage for an untested web app
The agent explores the live app and a PRD to propose frontend and API tests in plain language, so a team can approve a suite instead of writing one from scratch.
TestSprite vs. Momentic Mo
Momentic Mo runs many agents in exploratory bug bashes across web, iOS simulators and Android emulators and files the bugs it can reproduce, without a test suite. TestSprite builds and keeps an approved regression suite of web and API tests that re-runs on every change, with an open-source CLI and MCP server for coding agents.
TestSprite vs. Heal
Heal reads your repository, builds a production-like sandbox with mocked third-party services, and hunts for defects it can prove with a failing test. TestSprite tests your deployed or locally tunneled app against an approved test plan and keeps that suite running on pull requests and schedules.
TestSprite vs. Claude Code
Claude Code writes and runs code, including tests, and can drive a browser through MCP, but on its own it is the same agent that wrote the code and judges whether its tests should pass. TestSprite plugs into Claude Code through its CLI skills or MCP server as a separate verifier whose test expectations change only with your approval.
What does TestSprite do?
TestSprite is an AI testing agent. You describe what to test in plain language or point it at a PRD, tickets or your repo; it explores the running app, proposes end-to-end frontend and API tests for your approval, runs them in cloud browsers, and returns each failure with a replay, the failing step, expected versus actual, and a suggested cause and fix.
Is TestSprite open source?
Partly. The TestSprite CLI (github.com/TestSprite/testsprite-cli) is open source under the Apache 2.0 license. The MCP server package on npm is licensed under the Business Source License (BUSL-1.1), which is source-available rather than open source. The agent, test execution and dashboard are a hosted, proprietary service that needs a TestSprite account and API key.
How much does TestSprite cost?
There is a free plan with 150 credits a month. Paid plans are Starter at $19/month (first month free, 400 credits), Standard at $39/month (800 credits) and Pro at $69/month (1,600 credits). Enterprise starts at $199/month with a 10-seat minimum and 5,000+ credits. Yearly billing saves 35%. The pricing page does not say how many credits a test run uses.
Which coding agents and IDEs does TestSprite work with?
The CLI works with any agent that can run a command and installs skills for Claude Code, Codex, Cursor, Windsurf, GitHub Copilot, Cline, Kiro and Antigravity. The MCP server docs list Cursor, Claude Code, VS Code, Windsurf, Trae and GitHub Copilot, and the homepage also names Antigravity. It also runs in GitHub Actions and other CI.
Can TestSprite test an app running on localhost?
Yes, through the CLI. A run with --local <port> or a saved local environment opens a TestSprite tunnel so the cloud runner can reach your app. The hosted agent cannot browse localhost while planning, so you give it a diff or requirements file instead.
Does TestSprite replace Playwright?
Not necessarily. TestSprite says it can run beside an existing Playwright suite, and the tests it generates are Playwright code in Python that can be exported to GitHub. The difference is that TestSprite's agent writes, runs and maintains the tests against an approved plan, rather than you or your coding agent writing them.
Is TestSprite secure?
TestSprite says it maintains SOC 2 compliance, that stored test credentials are encrypted and never shown to the AI, and that access is scoped per workspace with owner, admin and member roles. Tests run on TestSprite's machines, and it recommends pointing them at staging or preview deployments rather than production. Enterprise adds SSO/SAML, SCIM, audit logs, IP allowlisting, data residency and single-tenant deployment.

Momentic
Product and engineering teams that ship frequently, often with AI-assisted development, and want exploratory and regression QA on web, iOS, and Android without writing or maintaining test scripts
PaidHeal (MYIA SAS)
Product engineering teams running a web app with an API and database, especially ones shipping a lot of AI-written code, who already have AI code review on pull requests and want a weekly or pre-release run that proves user-facing bugs, performance issues and runtime vulnerabilities with failing tests
FreeAnthropic
Developers and teams who want deep codebase reasoning, multi-file changes, and persistent project instructions in a terminal-friendly or IDE-native workflow
PaidTestSprite's pitch is that the agent that wrote the code should not be the one deciding whether it works. Its agent keeps its own record of what your product is supposed to do and tests the running app against it. You start a project in the web portal by pasting your app's URL, ideally attaching a PRD (the docs call it the biggest lever on test quality), a repository and a test account. The agent explores the live app in a browser you can watch, or makes real calls to your API, saves what it learns to shared project notes, and proposes a test plan. Each proposed test states in plain language what it expects. The agent reads, explores and drafts on its own, but anything that changes the project or spends credits, such as creating the project, applying a test plan or starting a run, waits for your approval on a card in the chat. Tests then run in TestSprite's cloud, many browsers at once, and each result ends as Passed, Failed or Blocked, with the agent judging whether the app is wrong, the test is wrong or something got in the way. Failures come with a step-by-step replay, screenshots and video, the failing step, and a suggested cause and fix. Auto-Heal updates test steps when the UI changes, but what a test expects only changes with your approval, and the generated tests are Playwright code in Python that you can export to GitHub. Developers can work outside the portal. The CLI (`@testsprite/testsprite-cli`, Apache 2.0) lets a coding agent plan, run and read results from the terminal, installs skills for Claude Code, Codex, Cursor, Windsurf, GitHub Copilot, Cline, Kiro and Antigravity, and can test an app on localhost through a tunnel. An MCP server brings the same workflow into Cursor, Claude Code, VS Code, Windsurf, Trae and GitHub Copilot. The GitHub integration runs the suite against a pull request's preview deployment and can block the merge until it passes, with schedules, Slack summaries and Jira or Linear tickets around it. The tradeoffs: only the CLI is open source (the MCP server package is published under the Business Source License), while planning and execution run on TestSprite's hosted service and need an account and credits; testing covers web frontends and backend APIs, with no native mobile testing documented; the pricing page does not say how many credits a run uses; and CLI 0.17's agent commands work only once TestSprite has enabled its new agent for your account.
TestSprite CLI v0.17.0 routes test writing through the project's TestSprite agent: plan asks it for tests, apply saves them, and run is now the single launch command. Agent commands require the new agent to be enabled for the account.
TestSprite 3.2 rebuilt the GitHub integration around preview deployments with an option to block a PR until tests pass, launched Slack run summaries and Jira or Linear ticketing, added SSO sign-in for UI projects in beta, and introduced a live run map.
Are you the founder? Claim this listing →