LaunchedEditorial Listing

TestSprite

TestSprite · TestSprite: AI Testing Agent for End-to-End and API Tests

Open TestSprite

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.

PricingFreemium
Setupeasy
Runs onWeb
Open sourceNo
DocsYes
CategoryCoding
QA TestingEnd-to-End TestingAPI TestingRegression TestingTest GenerationAuto-HealPlaywrightCLIMCPCI/CDGitHubClaude CodeCursor

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

Capabilities

  • Agent explores your live web app in a watchable browser, or learns your API with real calls, before proposing a test plan
  • Plans tests from a plain-language brief, a PRD, Jira or Linear tickets, your repository, or a code diff
  • Every proposed test states its expectation in plain language; applying a plan, starting a run or anything else that changes the project or spends credits waits on an approval card
  • Frontend tests cover user journeys, forms, visual states and sign-in, with test-account, one-time-code and saved SSO session logins (SSO in beta)
  • Backend tests cover multi-request API flows, schemas, auth and data integrity, with automatic token refresh before each run
  • Tests run in parallel cloud browsers and end as Passed, Failed or Blocked, with the agent judging whether the app, the test or the environment is at fault
  • Failure bundles with step-by-step replay, screenshots, video, expected versus actual, and a suggested cause and fix
  • Auto-Heal updates test steps when the UI changes without changing what a test expects
  • Generated tests are Playwright code in Python and can be exported to a GitHub repository
  • Open-source CLI (Apache 2.0) with JSON output for coding agents and skills for Claude Code, Codex, Cursor, Windsurf, GitHub Copilot, Cline, Kiro and Antigravity
  • Tests apps running on localhost through a CLI tunnel
  • MCP server for Cursor, Claude Code, VS Code, Windsurf, Trae and GitHub Copilot
  • GitHub integration that tests each pull request's preview deployment, posts results to the PR and can block the merge until tests pass
  • Test lists, scheduled runs, Slack run summaries, and one-click Jira or Linear bug tickets with recovery comments when a test passes again

Limitations

  • Only the CLI is open source; the MCP server npm package is licensed BUSL-1.1. Planning, execution and results live on TestSprite's hosted service and require an account and an API key
  • Credit-based plans: the pricing page lists monthly credits per plan but not how many credits a test run uses, and an agent session stops when the workspace runs out of credits
  • Covers web frontends and backend APIs. No native iOS or Android app testing is documented
  • Tests run on TestSprite's machines against a URL they can reach. The hosted agent cannot browse localhost while planning, and local apps need a CLI tunnel
  • CLI 0.17 routes test writing through TestSprite's new agent, and its agent commands exit with an error until that agent is enabled for your account; TestSprite advises staying on CLI 0.16 until then
  • SSO sign-in for UI projects is in beta
  • Lower plans are limited: Free has one environment, one GitHub repository and 30 days of run history, and Jira and Linear integrations start on the Standard plan
  • Cursor's default "Run in Sandbox" mode blocks the MCP server's testing tools until you change the setting
  • No self-hosted deployment is documented. Enterprise offers a single-tenant deployment

Use cases

  • Having a coding agent run TestSprite from the CLI after each change and fix what the failure bundle points to
  • Gating pull requests on a regression suite run against each preview deployment
  • Building an end-to-end and API test suite for an app that has none, from a PRD and the live app
  • Testing a feature on localhost through a tunnel before it is deployed
  • Running nightly or pre-release regression schedules and posting results to Slack
  • Filing failed tests as Jira or Linear tickets with the probable cause attached

Our take

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.

Strengths

  • Tests the running app rather than mocks, and test expectations change only with your approval
  • Works from a web portal, terminal, IDE and pull requests, with the same results in one place
  • Failure bundles with replay, evidence and a suggested cause are built for a coding agent to act on
  • Generated tests export as Playwright Python code, which limits lock-in
  • Free tier and low-cost paid plans make it easy to try on a real app

Weaknesses

  • Hosted, credit-based service; only the CLI is open source
  • Credit usage per run is not published on the pricing page
  • No native mobile app testing documented
  • The new agent in CLI 0.17 is not yet enabled on every account

TestSprite pricing

Free

$0

Billed monthly

  • 150 credits/month
  • 1 environment, 30 days of run history
  • Agent chat, CLI and IDE plugin (MCP)
  • GitHub PR auto-test on 1 repo
  • Slack notifications

Starter

$19

Billed monthly

  • First month free
  • 400 credits/month
  • Auto-heal, advanced backend testing, scheduled runs
  • GitHub PR auto-test on 3 repos

Standard

$39

Billed monthly

  • 800 credits/month
  • 3 environments, 90 days of run history
  • Advanced agent model and per-project agent memory
  • Jira and Linear integrations
  • GitHub PR auto-test on 5 repos

Pro

$69

Billed monthly

  • 1,600 credits/month
  • Unlimited environments, run history and GitHub PR auto-test
  • Most capable agent model and workspace-wide memory
  • Priority test execution

Enterprise

From $199

Billed monthly

  • From 10 seats and 5,000 credits/month
  • Single-tenant deployment and customized AI model
  • SSO/SAML, SCIM, audit logs, IP allowlisting and data residency
  • Named CSM and SLA; also sold on AWS Marketplace

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.

Technical specs

Modalities

Web frontend (browser), Backend APIs

Where TestSprite excels

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. competitors

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.

Frequently asked questions

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.

Integrations & fit

GitHubGitHub ActionsSlackJiraLinearClaude CodeOpenAI CodexCursorVS CodeWindsurfGitHub CopilotTraeClineKiroGoogle AntigravityPlaywrightMCPAWS Marketplace
Good fit forSolo / individual, Startup / small team, Enterprise
Pricing modelFreemium· Free tier available
See pricing on TestSprite →

Alternatives to consider

About TestSprite

TestSprite'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.

Updates from TestSprite

New FeatureCLI 0.17 moves test writing to the project agent

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.

IntegrationTestSprite 3.2 adds GitHub, Slack, Jira and Linear integrations

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 →