Applitools pricing is checkpoint-based: every screenshot captured during a test run counts as one checkpoint (snapshot). Based on aggregated contract data from Vendr and public comparisons as of June 2026, teams running 500,000 checkpoints/month on mid-market plans are paying roughly $0.003 to $0.006 per checkpoint, putting the monthly bill in the $1,500 to $3,000 range before overages. Enterprise contracts compress that rate but require annual commitment and custom negotiation.
Snapshots add up faster than most teams expect. A single test run covering five browsers and three viewports already generates fifteen checkpoints per test. Run that suite three times a day in CI and you have forty-five checkpoints per test per day. Across a suite of 200 tests, that is 9,000 checkpoints daily, or roughly 270,000 per month from one browser-matrix layer alone. Add more viewports, more test cases, more environments, and the number climbs well above the volumes where Applitools' published pricing tiers start to matter.
This post models what Applitools' checkpoint billing actually costs at realistic engineering-team scale. The per-unit numbers are estimates built from public contract aggregators and market reference points (Chromatic's public per-snapshot pricing, Vendr deal data), not from an official Applitools price list. Applitools is enterprise-gated for most plans, so any figure here comes with appropriate uncertainty.
How Applitools Bills
Applitools calls its unit of measurement a checkpoint. A checkpoint is a single screenshot captured and compared during a test run. Every time your test calls the Eyes SDK to take a snapshot, that is one checkpoint. The billing model means that checkpoint volume, not test count, is the lever that controls your bill.
Applitools publishes limited public pricing. The free tier offers 100 checkpoints per month (useful only for evaluation). Beyond that, tiers move to annual contracts and the rates are negotiated. Based on publicly cited ranges from Vendr aggregate data and customer discussions in the QA community, the structure looks roughly like this:
| Plan | Monthly checkpoints | Estimated monthly cost | Approx. per-checkpoint rate | Contract type |
|---|---|---|---|---|
| Free | 100 | $0 | N/A | No commitment |
| Starter / SMB | ~10,000 | ~$200/mo | ~$0.020 | Annual |
| Growth | ~100,000 | ~$500–$800/mo | ~$0.005–$0.008 | Annual |
| Mid-market | ~500,000 | ~$1,500–$3,000/mo | ~$0.003–$0.006 | Annual |
| Enterprise | 1M+ | Custom | Custom (compressed) | Annual |
Source: Modeled estimates from Vendr aggregate contract data and community-reported ranges. Applitools does not publish an official public rate card as of June 2026. Rates vary by region, negotiation, and add-ons (Ultrafast Grid, root-cause analysis features, etc.).
The rate-compression effect at volume is real: a team on the mid-market tier is paying roughly one-third to one-quarter the per-checkpoint rate of a Starter team. But you need to commit to the annual contract and hit the volume threshold for that rate to apply.
One important add-on to factor in: the Ultrafast Grid (cross-browser rendering). If you use Applitools' cloud-rendered Ultrafast Grid to run tests across Chrome, Firefox, Safari, and Edge simultaneously, each browser constitutes a separate checkpoint per snapshot. Four browsers equals four times the checkpoint burn.
Cost Per Snapshot at Scale
Here is a worked volume example that mirrors a real mid-sized engineering team.
The setup: 200 automated UI tests, running across 3 browsers (Chrome, Firefox, Safari), 2 viewports (desktop, mobile), 3 CI runs per day (morning, midday, pre-merge), five days per week.
The multiplication:
- Checkpoints per test per run: 3 browsers x 2 viewports = 6 checkpoints
- Total checkpoints per CI run: 200 tests x 6 = 1,200 checkpoints
- Daily checkpoints: 1,200 x 3 runs = 3,600 checkpoints/day
- Weekly checkpoints: 3,600 x 5 = 18,000 checkpoints/week
- Monthly checkpoints (4.3 weeks): 18,000 x 4.3 = ~77,400 checkpoints/month
At the Growth tier rate of $0.005 to $0.008 per checkpoint, that is $387 to $619 per month. Add one more viewport (tablet) and the checkpoint volume jumps to 115,500/month and the bill moves to $577 to $924/month.
Now scale to a larger team: 500 tests, 4 browsers (Ultrafast Grid), 3 viewports, 4 runs/day. That is 500 x 4 x 3 x 4 = 24,000 checkpoints per day, or roughly 516,000 per month. At a mid-market rate of $0.004/checkpoint, the bill lands around $2,064/month, plus any add-on costs for root-cause analysis or integrations.
The inflection point to watch is the step from Growth (~100k checkpoints) to mid-market (~500k). Teams that run a modest suite but cover many browsers and viewports can jump that gap faster than expected, moving from $600/month to $2,000/month because of a single matrix change.
How Autonoma Approaches Verification Cost
The checkpoint billing model works because Applitools is doing something specific: it is comparing pixel renderings of your UI against a baseline, screenshot by screenshot. That is genuinely useful for catching CSS regressions, font rendering drift, and layout breakage that functional tests miss. The cost is that every screenshot is a metered unit, and coverage scales linearly with cost.
Autonoma is a different layer. Our agents verify behavior: does the checkout flow complete, does the login form accept valid credentials, does the dashboard load data correctly. The Planner agent reads your codebase and plans test cases from routes and components. The Executor runs those cases against a live preview environment per PR. The Reviewer classifies results as real bugs, agent errors, or plan mismatches. The Diffs Agent maintains the suite as code changes, adding and deprecating tests automatically from PR diffs. Autonoma is not billed by screenshot checkpoints. Its managed tier is Free & Pay As You Go: $0 to start, 100K credits free, then $100 per 150K credits, with optional auto top-up and no minimum. Self-hosted is Free, forever with no limits and no usage costs.
To be direct: Autonoma is not a visual-regression replacement for Applitools. If your primary concern is pixel-level rendering consistency across browsers and viewports, that is not what we built. What we address is the adjacent question: many teams pay for high checkpoint volumes because they are using visual diffs as a proxy for functional correctness. If a button moves 2px, did the feature break? Usually not. If the button no longer triggers the payment flow, that is a bug. Behavioral E2E catches the second case without metering every screenshot.
Teams often end up running both layers: visual testing for rendering consistency, behavioral E2E for functional integrity. The question is whether the checkpoint volume you are accumulating is buying you the coverage you actually need, or whether it is over-indexing on visual fidelity for flows where behavior matters more.
For more on open-source alternatives in this space, the open-source Applitools alternative post covers tools that take a different approach to visual regression without enterprise checkpoint contracts.
Estimating Your Applitools Cost
A quick heuristic for sizing your own bill before getting a quote:
Start with your test count. Multiply by the number of browsers in your matrix. Multiply by the number of viewports. That gives you checkpoints per CI run. Multiply by daily run frequency and by 22 working days. That is your monthly checkpoint volume.
Map it to the tier table above. If you land between 10,000 and 100,000 checkpoints/month, you are in Growth territory. Between 100,000 and 500,000, expect mid-market rates and likely an annual commitment conversation. Above 500,000, you are in enterprise negotiation territory.
Variables that compress rates: multi-year contracts, larger upfront commitments, bundling Ultrafast Grid at contract time rather than as an add-on. Variables that inflate actual cost versus quoted rate: overages from test suite growth mid-contract, adding viewports after signing, integrations billed separately.
One useful market reference point is Chromatic (Percy's rebranded form), which publishes a public per-snapshot rate of $0.004/snapshot on paid plans. Applitools' enterprise rates are often cited as reaching similar per-unit levels at high volume, which provides a rough ceiling for what "competitive" looks like in this category.
Final Thoughts
Applitools is a mature visual testing platform with real infrastructure (Ultrafast Grid, root-cause analysis, Storybook integration) behind its pricing. The checkpoint model is predictable once you understand it. The opacity around rates before you enter a sales conversation is real but typical for enterprise tooling at this price point.
The number to internalize: checkpoint volume is the product of your test count, your browser matrix, your viewport count, and your CI frequency. Each of those multipliers compounds. A modest suite at a wide browser matrix can generate more checkpoints per month than a large suite running narrow.
If you are modeling the decision, run the multiplication from the worked example above against your own numbers. Get the annual commitment figure. Then weigh it against what percentage of your verification budget should be visual-diff coverage versus behavioral coverage.
Autonoma sits on the behavioral side of that equation. Four agents, codebase-first test generation, per-PR execution on live preview environments, and no screenshot-checkpoint billing unit. Managed Autonoma is credit-based after 100K free credits; Self-hosted is Free, forever with no limits and no usage costs. For teams asking whether their checkpoint bill is buying the right kind of coverage, it is worth modeling both layers before signing an annual visual-testing contract.
FAQ
Applitools does not publish an official public rate card as of June 2026. Based on aggregated contract data from Vendr and community-reported pricing, small teams on annual plans pay roughly $200/month for ~10,000 checkpoints. Mid-market teams at ~500,000 checkpoints/month are in the $1,500 to $3,000/month range. Enterprise contracts above 1 million checkpoints/month are fully custom. All plans beyond the 100-checkpoint free tier require annual commitment.
A checkpoint is a single screenshot captured and visually compared during a test run using the Applitools Eyes SDK. Every time your test calls the Eyes API to take a snapshot of the UI, that is one checkpoint. Checkpoints are the core billing unit: your monthly bill is determined by how many checkpoints you capture, not by how many tests you have or how many test runs you execute.
Yes. Applitools offers a free tier that includes 100 checkpoints per month. This is sufficient for small-scale evaluation or a personal project but not for a real CI pipeline. Most teams exceed 100 checkpoints within a single test run once they add browser-matrix coverage. Moving beyond 100 checkpoints requires an annual subscription.
Percy (now Chromatic) publishes a public per-snapshot rate of $0.004 on paid plans, which makes it easier to model cost upfront. Applitools is enterprise-gated for most meaningful volumes, which means you negotiate rates rather than reading a price page. At high volumes (500k+ checkpoints/month), Applitools enterprise rates are reportedly comparable to Chromatic's public rates, but you need to commit to an annual contract to reach those compressed per-unit prices. For teams that want pricing transparency before a sales conversation, Chromatic's published rate card is a practical advantage.
At scale, visual testing cost is driven by the checkpoint volume formula: test count x browsers x viewports x daily CI runs x working days. A team running 500 tests across 4 browsers, 3 viewports, and 4 CI runs per day generates roughly 516,000 checkpoints per month. At mid-market rates of $0.003 to $0.006 per checkpoint, that puts the monthly bill at $1,548 to $3,096. Enterprise rates can bring that below $0.003 per checkpoint with annual commitment. The inflection point most teams hit unexpectedly is adding a new browser or viewport mid-contract, which can push volume from one tier to the next.
