Cheaper and Simpler Alternative to Percy

Percy — now part of BrowserStack — is a capable visual testing platform. Both tools take screenshots of your pages and show you what changed, so the real questions are what you have to set up and maintain to get there, and what it costs per screenshot once you do.

Pricing

Percy defines a screenshot as a rendering of a page or component in one browser and responsive width combination — so two pages across two browsers and three widths is twelve screenshots. Diffy sells its plans in screenshots per month as well, counting each page at each breakpoint.

Here is what each one costs today.

Diffy

Screenshots per month	Billed annually	Month-to-month
2,000	$67/mo	$80/mo
8,000	$125/mo	$150/mo
30,000	$250/mo	$300/mo

Percy

Screenshots per month	Billed annually	Month-to-month
10,000 (Desktop)	$199/mo	$249/mo
25,000 (Desktop)	$449/mo	$549/mo
25,000 (Desktop & Mobile)	$599/mo	$729/mo

Two things stand out.

The entry point. Percy’s cheapest paid plan is $199/mo for 10,000 screenshots, and plenty of teams do not need anywhere near that. A 20-page site at three breakpoints, run daily, is about 1,800 screenshots a month — $67/mo on Diffy. Double the site to 40 pages and you are at roughly 3,600, which is Diffy’s 8,000 plan at $125/mo: still a third less than Percy’s entry price, for a plan you have room to grow into.

The ceiling. Compare the closest volumes at the top: Diffy gives you 30,000 screenshots for $250/mo, Percy gives you 25,000 desktop screenshots for $449/mo. That is 20% more coverage for 44% less money.

Percy prices as published on browserstack.com/pricing in August 2026. Check both pricing pages before you commit — everyone changes prices eventually.

Going over your plan

Percy charges overage per screenshot once you pass your monthly allowance: $0.036 each on the Desktop plans, $0.048 on Desktop & Mobile. Percy does let you set usage notifications so you get alerted at a threshold, but the billing model means an unusually large run costs you money rather than stopping.

Diffy does not bill you for overage. If your usage outgrows your plan, we get in touch and ask you to move up a tier. Your invoice is the number on your plan.

Setup: a browser tab vs. a terminal

It is worth being accurate about this, because Percy is often described as SDK-only and that is not true. Percy gives you two routes:

1. Inside your test suite. Install @percy/cli plus the SDK for your framework, add snapshot calls to your test code, and run the suite through the Percy CLI. This is the route Percy is designed around, and it is a genuinely good fit if you already maintain a Cypress or Playwright suite.
2. From a URL list, no test code. Install @percy/cli and run percy snapshot against a sitemap URL, a local sitemap, or a YAML/JSON file listing your pages. Options like waits and selectors go in that file or in a .percy.yml.

So Percy can absolutely test a list of URLs. What it still asks for is a terminal: a Node package installed somewhere, an API token in the environment, a file of URLs kept up to date in a repo, and something to run the command on a schedule.

Diffy’s equivalent is a browser tab. You paste the URLs into the project, pick your breakpoints, and press a button — the URL list, the waits, the selectors to mask and the schedule are all fields in the UI, editable by whoever needs to change them. That matters most when the person who wants visual testing is a designer, a site owner, or an agency PM rather than someone comfortable in a terminal.

When you do want automation, Diffy’s CLI and GitHub Action are there — but they are optional, not the price of entry.

Environments, not just build baselines

This is the deeper difference between the two products, and it is not about features.

Percy is organised around builds and git branches. Each run creates a build, and Percy picks the baseline to compare it against using your repository — the fork point from your configured base branch, the previous build on the same branch, or the last approved build if you have configured approval-required branches. It is a model built for “did this pull request change the UI?”

Diffy is organised around environments. Production, staging and development are first-class, and you can add custom ones. The question it answers naturally is “do these two deployed sites look the same?”:

• Does staging still match production before we go live?
• Did anything on production change overnight, without a deploy? Scheduled monitoring runs daily or weekly and compares an environment against itself over time.
• Does this Pantheon or Tugboat multidev match production?

Neither model is strictly better — they are aimed at different questions. If your visual testing is gated on pull requests, Percy’s git-aware baselines are a real advantage. If you are comparing deployed environments, or watching a live site you did not just deploy to, that is Diffy’s native shape. For agencies and teams running CMS sites, this usually matters more than any single feature.

Handling real-world pages without writing code

Most of the effort in visual testing is not taking screenshots, it is stopping them from being noisy. In Percy, the answers to these problems generally live in your test code or config file. In Diffy, they are settings in the UI:

• Log in before the screenshot. Presets for Drupal, WordPress and Netlify, plus a custom option; Diffy opens the login page, fills the credentials and continues. No test code required.
• Mock dynamic content. Give Diffy a list of selectors and it replaces their contents with placeholder text — the standard fix for sites that publish new articles between runs and can never be perfectly synced across environments.
• Remove or mask elements. Removal drops the element from the DOM; masking paints a visible rectangle over it, so reviewers can see what was hidden. Embedded videos and maps are masked by default.
• Inject custom CSS or JavaScript, set HTTP headers, cookies, and a custom User-Agent.
• Retina and dark mode are checkboxes.
• Any breakpoint between 240px and 3000px, as many as you like.
• Throttle the crawl by limiting concurrent workers, or route it through a single IP address so it can be allowlisted.

Comparison that understands vertical shifts

Pixel-perfect diffing has a well-known failure mode: change the height of something near the top of a page and every pixel below it moves, so the whole page lights up red.

Diffy runs a custom algorithm alongside pixel-perfect comparison that recognises vertical shifts. Add a line to your header and Diffy highlights the header — not the other 4,000 pixels that merely moved down. You can still switch to strict pixel-perfect comparison, and you can tune comparison sensitivity, when that is what you want.

A review UI built for hundreds of screenshots

Reviewing is where teams actually spend their time, so the UI is built for volume:

• Thumbnail view, with approval directly from thumbnails
• The same change grouped across every screenshot it appears in, so you approve it once
• Approve an individual change, a screenshot, or a page across all breakpoints
• Before/after slider
• Keyboard shortcuts for moving through a large set
• HTML source and the JavaScript console for the screenshot, for debugging
• Shareable links that work for people without a Diffy account

Integrations

• CLI tool for CI/CD, with examples for Pantheon, Tugboat and others
• GitHub Action that posts results back to the pull request
• Notifications via email, Slack and webhooks, with configurable thresholds
• Zapier, so a diff can open a ticket in your tracker
• Figma — pull design screenshots in and compare the build against the design
• Upload screenshots from Playwright or any other functional testing framework and use Diffy purely as the comparison and review layer
• Claude plugin, so you can create projects, capture screenshots and compare environments from a conversation — see below

Driving Diffy from Claude

Diffy publishes a Claude plugin that lets you run visual testing from a conversation instead of a dashboard or a CI config. It installs from the plugin marketplace in two lines:

/plugin marketplace add diffywebsite/diffy-skills
/plugin install diffy@diffy

That gives you ten skills under the /diffy: namespace, covering the whole loop rather than just capture:

• Project setup — create-project builds a project from base URLs, pages and breakpoints; get-project-settings exports the current config as YAML; update-project-settings changes pages, environments, breakpoints, masks, login settings and schedules
• Capture — remote-screenshot runs on Diffy’s servers, upload-screenshot captures a locally running app through the screenshot-worker container, and get-screenshot-info tells you when a capture finished
• Comparison — compare-screenshots diffs two screenshot sets, and get-diff-info returns the summary: percentage changed, a per-page table, and a JUnit report
• End to end — visual-diff runs a local before/after regression pass, and compare-environments compares two environments server-side

The distinction worth knowing is local versus remote. Local mode captures an app running on your own machine and needs Docker for the screenshot worker. Remote mode runs entirely on Diffy’s infrastructure, so there is nothing to install beyond the plugin itself.

In practice this is most useful in the middle of a change. You are already in Claude working on a template; asking it to compare staging against production and tell you which pages moved is faster than switching to a browser, and the JUnit output drops straight into a CI job when you want to make it permanent. It does not replace the UI — reviewing a few hundred screenshots is still a job for the review dashboard — but it removes the context switch when you just want to know whether something broke.

The plugin is MIT licensed and developed in the open at github.com/DiffyWebsite/diffy-skills.

Configuration you can version

Project settings export to YAML and import back, and Diffy keeps a revision history of settings changes, so you can see what was altered and when. Bulk operations let you trigger comparisons across many projects at once — useful if you maintain dozens of sites.

Where Percy is the better fit

We would rather you pick the right tool than the one that emails you.

• Real mobile devices. Percy’s Desktop & Mobile plan runs on real mobile devices and mobile browsers. Diffy tests responsive breakpoints in Chrome and WebKit — real engines, but desktop-rendered viewports, not physical handsets.
• More browser engines. Percy covers Chrome, Firefox, Edge and Safari. Diffy runs Chrome and WebKit.
• Component libraries. Percy tests individual components as well as full pages, and counts a component render as a screenshot. Diffy works at the page level, so a design-system library is a better fit for Percy.
• Longer build history. Percy retains 12 months on paid plans; Diffy retains 6 months.
• Enterprise controls. Percy offers SSO, access control, a 99% uptime SLA and a dedicated CSM through its Enterprise add-on.

Drupal and WordPress experts

We know a lot about Drupal and WordPress hosting environments and development workflows — it is why Diffy ships login presets for both, and why the CLI documentation has worked examples for Pantheon and Tugboat. If that is your stack, we will make sure you get a reliable testing setup, and you can talk to the people who built Diffy when something looks wrong.

Try it

Create an account, paste your URLs, and run your first comparison. Most teams have real results inside 10 minutes, and there is nothing to uninstall if it is not for you.