Percy Alternatives: Applitools, Chromatic and Argos Compared
Comparing Percy alternatives? See how Applitools, Chromatic and Argos differ on comparison method, frameworks and review, with Playwright code and a pilot plan.

The main Percy alternatives are Applitools, Chromatic and Argos. Applitools suits teams that want AI-assisted visual comparison across many browsers and apps. Chromatic suits teams that build UI in Storybook and want component-level visual review. Argos suits teams that want an open-source, pull-request-first service for Playwright, Cypress or Storybook screenshots. None of them is the best for everyone, so pick by how your team captures screenshots and reviews changes.
This guide explains what Percy does, the criteria that matter when you replace it, how each alternative works, and a one-week pilot plan you can run on your own test suite. Product details come from each vendor's public documentation. SoftwareTestPilot has not benchmarked these tools, and no prices are listed because they change often.
What Percy does, and what you are actually replacing
Percy is a visual testing service owned by BrowserStack. Your tests or Storybook stories send page snapshots to Percy, it renders them in its cloud browsers, compares each one with an approved baseline and shows the differences for a person to approve or reject.
When you look for a replacement, you are really replacing four jobs:
- Capture: how snapshots are taken (inside Playwright, Cypress, Selenium or Storybook).
- Render: where pages are drawn (your CI machine or the vendor's cloud browsers).
- Compare: how differences are found (pixel diff, smarter diff, or AI-based comparison).
- Review: where people approve changes (vendor dashboard, pull request check, or both).
A good alternative does not need to beat Percy at all four. It needs to fit the job that hurts most in your team today.
Why teams look for Percy alternatives
Percy works well for many teams, so a switch is usually driven by a specific need:
- Too many noisy diffs. Anti-aliasing, fonts or dynamic content flag changes nobody cares about, and reviewers start approving without looking.
- Component focus. The team builds a design system in Storybook and wants every story checked on each pull request.
- Open source or data control. The team prefers a platform whose code is public.
- Wider coverage. The team also needs to check native mobile apps, PDFs or many browser and screen combinations.
- Simpler review. Developers want visual changes as a normal pull request check instead of a separate dashboard habit.
Write down which of these applies to you before reading any feature page. It keeps the comparison honest.
How to compare visual testing tools: six criteria
| Criterion | Question to ask | Why it matters |
|---|---|---|
| Framework fit | Does it plug into the framework you already use? | Rewriting tests to adopt a tool rarely pays off. |
| Comparison method | Pixel diff, tuned diff or AI comparison? | Decides how much noise reviewers see. |
| Rendering | Your CI or vendor cloud browsers? | Cloud rendering gives consistent output; local capture is simpler to debug. |
| Review workflow | Pull request check, dashboard, or both? | Changes that are hard to review get rubber-stamped. |
| Baselines and branches | How are baselines chosen for feature branches? | Bad baseline logic creates false failures after merges. |
| Flakiness handling | Waits for fonts, images and animations? Ignore regions? | Flaky visual tests are the main reason teams abandon them. |
Score each tool 1 to 5 on the criteria that matter to you, and give your most painful criterion double weight.
Percy alternatives at a glance
Documented capabilities only. "Best fit" describes the use case each product's documentation focuses on, not a measured score. Check current documentation before deciding.
| Tool | Main approach | Works with | Review style | Best fit |
|---|---|---|---|---|
| ACCELQ | Codeless functional automation across web, mobile and API | Its own codeless platform | Execution reports | Teams wanting codeless end-to-end automation; confirm visual-check coverage in its docs |
| Applitools | AI-based visual comparison (Visual AI) | Many SDKs, including Selenium, Playwright, Cypress and Storybook | Dashboard with grouping of similar changes | Teams with many pages, browsers or apps and lots of noise |
| Chromatic | Cloud-rendered snapshots with pixel diffing | Storybook, Playwright, Cypress | Review app linked to Git commits | Design-system and Storybook-first teams |
| Argos | Open-source screenshot comparison against a Git-based baseline | Playwright, Cypress, Storybook, Vitest, any screenshot pipeline | Pull request check | Teams wanting open source and PR-first review |
Applitools: AI-assisted comparison for broad coverage
Applitools Eyes compares screenshots using what the company calls Visual AI. Instead of flagging every changed pixel, it tries to judge changes the way a person would, which is meant to reduce noise from rendering differences. Its SDKs cover web frameworks such as Selenium, Playwright and Cypress, plus mobile and component testing; its Ultrafast Grid renders one captured page across many browser and viewport combinations. See the Applitools documentation for the current list.
Where it fits
- Large apps with many pages and screen sizes.
- Teams whose main pain is false positives from pixel diffs.
- Organisations that test web and native mobile in one place.
Limitations to check
- It is a full platform, so setup and learning take longer than a simple screenshot service.
- AI comparison levels (strict, layout, content) need tuning; the wrong level can hide real bugs.
- Confirm data-handling and hosting options with the vendor if your screens contain sensitive data.
Chromatic: visual review for Storybook and design systems
Chromatic comes from the team that maintains Storybook. It renders each story in cloud browsers, compares the new snapshot with the baseline and asks you to approve or reject changes (Chromatic visual testing docs). It also integrates with Playwright and Cypress: while your end-to-end tests run, it saves an archive of the page (DOM, styles and assets) and snapshots it in the cloud, so you can inspect a failure without rerunning locally (Chromatic for Cypress).
Where it fits
- Teams already writing Storybook stories for every component state.
- Design-system teams who need component-level review before pages change.
- Teams that want to combine component snapshots with a few end-to-end page checks.
Limitations to check
- Its strongest value appears when you use Storybook. Without stories, compare it carefully with page-level tools.
- Comparison is pixel-based with tolerance settings, so plan ignore regions for dynamic data.
Argos: open-source visual testing on the pull request
Argos is an open-source visual testing platform. Your CI captures screenshots, uploads them, Argos compares them with a baseline build picked from your Git history, and the result appears as a check on the pull request (Argos documentation). The platform code is MIT-licensed on GitHub; the vendor runs it as a managed cloud service, and self-hosting is not officially supported.
For Playwright, the Argos Playwright quickstart replaces committed snapshot images: you call argosScreenshot() and Argos handles baselines, and it waits for fonts, images and loaders before capturing.
Where it fits
- Playwright or Cypress teams who are tired of committing baseline PNGs.
- Teams that want visual review inside the normal pull request flow.
- Teams that value open-source code they can read.
Limitations to check
- Comparison runs on screenshots your CI takes, so keep CI browsers and fonts consistent.
- It has fewer enterprise-scale features than a large platform; check what your organisation requires.
Worked example: one Playwright check, three ways
This illustrative example shows how the same checkout-page check looks with Playwright's built-in snapshots and with Argos. It was written for this article and has not been run by us; replace the URL with your own staging address.
1. Playwright built-in comparison (no service):
import { test, expect } from "@playwright/test";
test("checkout page looks right", async ({ page }) => {
await page.goto("https://staging.example.com/checkout"); // placeholder URL
// Hide the live order number so it does not cause a false diff
await expect(page).toHaveScreenshot("checkout.png", {
mask: [page.locator("[data-test=order-id]")],
maxDiffPixelRatio: 0.01,
});
});
Baseline images are committed next to the test, one per platform. Updating them means rerunning with --update-snapshots.
2. Argos (service, Git-based baseline):
import { test } from "@playwright/test";
import { argosScreenshot } from "@argos-ci/playwright";
test("checkout page looks right", async ({ page }) => {
await page.goto("https://staging.example.com/checkout"); // placeholder URL
await argosScreenshot(page, "checkout");
});
The Argos reporter in playwright.config.ts uploads screenshots when ARGOS_TOKEN is set in CI. Keep that token in your CI secrets, never in code.
3. Applitools or Chromatic follow the same idea: you add their SDK or plugin, and a snapshot call inside the test sends the page to their cloud for comparison. The test logic stays the same, which is why migrating between visual tools is usually less work than people fear.
Decision guide: which Percy alternative fits your team?
| If your situation is... | Start your pilot with |
|---|---|
| Many pages, browsers and devices, lots of noisy diffs | Applitools |
| Component library in Storybook | Chromatic |
| Playwright tests, want PR checks and open source | Argos |
| Small app, a handful of key pages, tight budget | Playwright toHaveScreenshot() first, a service later |
| Want codeless end-to-end automation rather than a visual tool | ACCELQ, after confirming its visual-check coverage |
Two tools can also work together: component snapshots in Chromatic for the design system, and a few page-level checks in your end-to-end suite.
A one-week pilot plan
- Day 1: choose 10 screens. Pick pages users see most (login, search, cart, checkout) plus one page with dynamic data.
- Day 2: set up two tools. Install the SDKs on a branch and capture baselines.
- Day 3: plant real bugs. Change a button colour, shift a layout by 8px and hide an icon. Record which tool catches each one.
- Day 4: plant noise. Change only a timestamp or a random avatar. Count false alarms.
- Day 5: review as a team. Ask two developers and one tester to review changes in each tool and time them.
- Days 6 and 7: score. Fill the six-criteria table and check the vendor's plan limits against your snapshot volume.
The tool that catches the planted bugs with the fewest false alarms and the fastest review is usually the right one for you.
Common mistakes when switching visual testing tools
- Snapshotting everything. Hundreds of snapshots per build slow review. Start with critical screens.
- Ignoring dynamic content. Dates, ads, carousels and avatars cause constant diffs. Mask them or use test data.
- Different fonts on CI. Install the same fonts in your CI image, or rely on cloud rendering.
- Approving without looking. Make one person responsible for visual review on each pull request.
- Testing before the page is ready. Wait for network idle, fonts and loaders, and disable animations.
- Treating visual tests as functional tests. A picture shows a button exists, not that it works. Keep functional assertions.
How to migrate from Percy without losing coverage
- List your current snapshots. Export or note every Percy snapshot name and the pages or stories behind it, so nothing silently disappears.
- Run both tools in parallel for a short period. Keep Percy active while the new tool captures the same screens. Compare what each flags on the same pull requests.
- Recreate ignore rules. Every masked region or CSS hiding rule you used in Percy needs an equivalent in the new tool, or old noise returns on day one.
- Approve a clean baseline. Capture baselines from your main branch after a green build, and have one person review them before the team relies on them.
- Update the CI pipeline and secrets. Add the new token to CI secrets, remove the old one when you switch off Percy, and update your pull request rules so the new check is required.
- Tell the team how review works now. A two-line note on who approves visual changes, and where, prevents changes being merged unreviewed.
When staying with Percy is the right call
Switching has a cost: new setup, new baselines and a new review habit. Staying is often sensible when your team already uses BrowserStack for cross-browser runs and likes having one vendor, your reviewers trust the current diffs, and the real problem is test design rather than the tool. Many noisy-diff problems are fixed by masking dynamic content, stabilising test data and waiting for fonts, whichever service you use. Fix those first; if the pain remains, then trial an alternative.
Interview angle: "How would you choose a visual testing tool?"
"I'd first check how we build UI and where our tests run. If we use Storybook, a component tool like Chromatic fits; if we mostly have Playwright end-to-end tests, a pull-request tool like Argos or Playwright's own snapshots may be enough; if we have many browsers and lots of noise, an AI comparison tool like Applitools is worth trialling. Then I'd run a short pilot with planted bugs and planted noise and compare catch rate, false alarms and review time."
Follow-up questions to prepare for: How do you stop flaky visual tests? What is a baseline and who approves changes? When is visual testing not worth it?
Next step
If visual testing is new to you, start with the free method first: read our visual regression testing tools guide and set up one Playwright snapshot. Build the automation basics with our free QA courses, and if you are still choosing a framework, the Cypress vs Playwright vs Selenium decision matrix helps. For running checks across many browsers, see our BrowserStack alternatives guide.
Already moved away from Percy? Share what decided it for your team in the SoftwareTestPilot QA Community.
References
- 1Percy by BrowserStack— browserstack.com
- 2Applitools documentation— applitools.com
- 3Chromatic visual testing docs— chromatic.com
- 4Argos documentation— argos-ci.com
- 5Playwright visual comparisons— playwright.dev
