TestSprite

TestSprite

TestSprite is an AI testing agent that turns plain-language briefs, PRDs or API specs into end-to-end frontend and backend tests, runs them against your live app, gates pull requests and returns each failure with evidence and a suggested fix. Free plan; paid plans from $19/month.

0.0 (0)
Visit Website
Founder
TestSprite
Active
PlanFree - $0 - 150 credits/month, 1 environment, 30-day history, PR auto-test on 1 repo · Starter $19/month (400 credits) · Standard $39/month (800 credits, 3 environments, Jira/Linear) · Pro $69/month (1,600 credits, unlimited environments and PR auto-test) · Enterprise - from $199/month (from 10 seats) - from 5,000 credits, SSO/SCIM, audit logs, single-tenant, data residency, SLA
BusinessB2B

About TestSprite

What TestSprite is

TestSprite is an AI testing agent that checks a web app or API against what it is supposed to do. You describe what matters in plain words, or point it at product requirement documents (PRDs), tickets or an OpenAPI file; the agent explores the running app, writes end-to-end tests for the frontend and the backend, runs them in real browsers or against the live API, and keeps the passing tests as a suite that grows with the product. The pitch is aimed squarely at teams whose code is now written partly by Cursor, Claude Code or Codex: the coding agent writes the change, and a separate agent verifies it independently.

The company behind it is TestSprite, based in Seattle and founded in 2024 by Yunhao Jiao (CEO) and Rui Li (CTO), according to its seed investor Trilogy Equity Partners. In October 2025 it announced a $6.7M seed round led by Trilogy, with Techstars, Jinqiu Capital, MiraclePlus, Hat-trick Capital, Baidu Ventures and EdgeCase Capital Partners participating, bringing total funding to $8.1M. TestSprite 4.0, launched on Product Hunt on November 19, 2026, introduces a new testing agent that, in the company's words, remembers what your app should do and checks all of it, every time.

How it works

  • Brief the agent. In the web portal you tell the agent what to test or hand it PRDs and tickets. It proposes a project, the environments it tests on and how it signs in, then explores the app and proposes tests grounded in what it saw.
  • Run against the real app. TestSprite says dozens of agents open the app at once and work through features like a user would, driving a real browser or calling a live API, rather than asserting against mocks. Every run is recorded and can be replayed as video.
  • Failures come back as one bundle. For each failure it returns the failing step and its neighbours, screenshots, DOM snapshots, the test source, a root-cause hypothesis and a suggested fix, and classifies it as a real bug, a test problem or an environment issue.
  • Coverage compounds. Passing tests are kept and rerun on every change; Auto-Heal repairs tests when the interface drifts, which the company says is driven by logic rather than DOM selectors.
  • Four ways in. The browser agent for the whole team; an open-source CLI for coding agents and terminals; an MCP server for IDEs; and a GitHub integration that re-checks every pull request against the full suite and posts the result to the PR. Linear and Jira turn failures into tickets, Slack gets run summaries, and schedules rerun suites hourly, nightly or weekly.

We installed the CLI and ran it

The CLI is the piece that is open source (Apache 2.0, TestSprite/testsprite-cli, about 5,200 GitHub stars when we checked). On November 20, 2026 we installed the current release in a clean Node 22 sandbox, without an API key, to see what an agent actually gets:

$ npm i @testsprite/[email protected]
added 5 packages, and audited 6 packages in 1s
$ npx testsprite --version
0.17.0
$ npx testsprite doctor
  [OK]   CLI version       0.17.0
  [OK]   Node.js           v22.23.5 (supported range: 20.19+, 22.13+, or 24+)
  [OK]   API endpoint      https://api.testsprite.com
  [FAIL] Credentials       no API key found; run `testsprite setup` (or set TESTSPRITE_API_KEY)
  [WARN] Verify skill      not installed here; run `testsprite setup` so your agent verifies its changes

$ npx testsprite --dry-run --output json run --project demo-proj --wait
[dry-run] sample response — not from the server
{ "runs": [], "results": [],
  "summary": { "total": 0, "passed": 0, "failed": 0, "skipped": 0, "timedOut": 0 },
  "dryRun": true,
  "requests": [{ "method": "POST", "path": "/api/cli/v1/projects/demo-proj/runs",
                 "body": { "maxConcurrency": 50 } }],
  "thenPoll": "/api/cli/v1/results?run=<run-id>&status=passed,failed,running,blocked,cancelled" }

What we took from it:

  • Small footprint. The package is 2.4 MB installed with four runtime dependencies (commander, undici, valibot and a yamux library for its tunnel), and it requires Node 20.19+, 22.13+ or 24+.
  • Built for agents to parse. --output json and the --dry-run flag, which emits a canned response matching the OpenAPI contract without touching the network, let a coding agent learn the shapes before spending credits. A project run asks for up to 50 parallel test executions by default.
  • Everything real needs the cloud. Planning, running and reading results all go through api.testsprite.com with a workspace API key; the CLI is a client, not a local test runner. testsprite tunnel exists so the cloud can reach an app running on your machine.
  • CI scaffolding is built in. testsprite ci init github writes a workflow that runs the project's tests against each pull request's preview deployment, using a TESTSPRITE_API_KEY repository secret; its help text warns that each run spends credits.

Pricing (checked November 20, 2026)

PlanPriceCredits per monthNotable limits
Free$01501 environment, 30 days of history, PR auto-test on 1 repo
Starter$19/month (first month free)400Auto-heal, schedules, advanced backend testing, PR auto-test on 3 repos
Standard$39/month8003 environments, 90 days of history, Jira/Linear, advanced agent model, 5 repos
Pro$69/month1,600Unlimited environments, history and PR auto-test, most capable model, priority execution
EnterpriseFrom $199/month (from 10 seats)From 5,000SSO/SCIM, audit logs, single-tenant deployment, data residency, SLA; also sold on AWS Marketplace

Yearly billing is advertised as saving 35%. Dividing the monthly price by the included credits, a credit costs about 4.8 cents on Starter ($19 / 400), 4.9 cents on Standard ($39 / 800), 4.3 cents on Pro ($69 / 1,600) and about 4 cents at the Enterprise entry point ($199 / 5,000). The step from Standard to Pro doubles the credits for $30 more, so a team that regularly exhausts Standard is better off on Pro than buying its way around the limit.

TestSprite vs the alternatives

TestSpritePlaywright (self-written)heal.devAppxiom
What it isHosted AI agent that writes, runs and maintains end-to-end testsOpen-source browser automation library and test runnerAI agent for end-to-end testsBug detection and monitoring for mobile and web apps
Who writes the testsThe agent, from plain language, PRDs or an API specYour engineers (or your coding agent)An agentNot a test writer; it detects issues in real usage
Where tests runTestSprite's cloud browsers and API runnersYour machines or CIVendor cloudIn your production app through an SDK
Backend/API testingYes, from an OpenAPI file or docsYes, with its request APIFocused on UI flowsTracks API failures seen by users
Cost modelMonthly plan with creditsFree; you pay for compute and maintenance timeSee vendorPer app, by usage slab

TestSprite's own FAQ addresses the obvious question, how it differs from Playwright and the Playwright MCP, and says you do not need to throw away an existing Playwright suite. The practical difference is ownership: with Playwright you own every selector and assertion; with TestSprite you own a description of what the product should do and pay credits for the agent to keep the tests in step.

Who it's for

Small teams and solo developers who ship with coding agents and have no dedicated QA; product teams that want a merge gate and nightly regression without maintaining a test codebase; and QA engineers who would rather review and steer generated suites than hand-write them. The company says more than 150,000 developers and 50,000 teams use the platform and that its MCP server and CLI have passed 600,000 npm installs; those figures are its own.

Limits and trade-offs

  • Credit cost per test is not published. The pricing page lists credits per plan but not how many credits a test, a run or a planning session consumes, so monthly cost is hard to predict before a trial. Starting on Free (150 credits) is the only way to measure it.
  • Only the CLI is open source. The CLI is Apache 2.0, but the npm package for the MCP server, @testsprite/testsprite-mcp, declares the Business Source License (BUSL-1.1), and the agent, runners and dashboard are a hosted service.
  • Your app must be reachable. Tests run in TestSprite's cloud, so staging or preview URLs must be reachable, or you open the CLI's tunnel to a local app. Teams with strict data rules should look at the Enterprise single-tenant and data-residency options.
  • Generated tests still need review. An agent that infers intended behaviour from a PRD can encode a misunderstanding as a passing test. The replay videos and plan approval step help, but someone has to read the plan.
  • Customer numbers are the vendor's. Usage figures, testimonials and the CLI's leaderboard claim come from TestSprite's own site and README.

Related on TechLogHub

Value & Audience

Value Proposition

Independent verification of every code change, including changes written by coding agents, without writing or maintaining a test suite by hand.

Problem Solved

AI coding agents ship code faster than teams can write and maintain end-to-end tests, so regressions slip through and red test runs take hours to triage.

Share this product

Product founder?

Get Badge

Tech Stack

Social & Links

Loading ratings...

Loading comments...

Gallery

TestSprite screenshot 1

Feedback & Roadmap

Loading feedback…

TestSprite FAQ

Common questions about TestSprite's features, pricing, and use cases

Is TestSprite free to use?

TestSprite has a free tier plus paid plans, starting at Free - $0 - 150 credits/month, 1 environment, 30-day history, PR auto-test on 1 repo. Plans listed: Free - $0 - 150 credits/month, 1 environment, 30-day history, PR auto-test on 1 repo; Starter $19/month (400 credits) · Standard $39/month (800 credits, 3 environments, Jira/Linear) · Pro $69/month (1,600 credits, unlimited environments and PR auto-test); Enterprise - from $199/month (from 10 seats) - from 5,000 credits, SSO/SCIM, audit logs, single-tenant, data residency, SLA.

What are some alternatives to TestSprite?

Popular Testing & QA alternatives to TestSprite include TheySaid, heal.dev and BotGauge.

TestSprite appears in

Newsletter

One email a week

TechLogHub tracks 917 tools and 611 open-source projects. Get the week's new launches, release roundups and open-source picks — nothing else.

Get the TechLogHub digest

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.