Diffy vs Applitools: Pricing, Setup and Features Compared

Applitools is a serious visual regression testing platform built around Visual AI. It is genuinely good at what it is designed for, and for some teams it is the right answer. But it is designed around a particular shape — an SDK living inside your automated test suite, priced for engineering organisations — and plenty of teams want something narrower and cheaper. This page lays out where the two products differ, honestly, so you can tell which shape you are.

If you are still shortlisting rather than comparing these two, our round-up of Applitools alternatives compares eight tools, including the open-source ones.

What Applitools actually is

Applitools’ visual testing product is Eyes, and its headline feature is Visual AI, which Applitools describes as emulating the human eye and brain: instead of comparing pixel by pixel, it is designed to ignore harmless rendering noise and highlight real visual, structural and content changes. Around Eyes sits the Ultrafast Grid: your test opens the page once, the SDK sends its DOM and resources to Applitools, and the page is re-rendered on Edge and Internet Explorer on Windows, Safari on macOS, other browsers on Linux, emulated Android devices and iOS simulators. Applitools also sells Autonomous, which builds functional tests from plain English, a recorder or a crawl of your sitemap.

The important thing to understand is how you drive it. Eyes is integrated into your test code through an SDK for your framework (Selenium, Cypress, Playwright, WebdriverIO and others), where you add eyes.check() calls to an existing functional test. Autonomous’s recorder and crawler are a different route, but the centre of gravity of Eyes is the SDK in your test suite. Diffy’s centre of gravity is a browser tab. That single difference drives most of what follows.

Pricing

Diffy sells plans in screenshots per month, counting each page at each breakpoint. Applitools sells checkpoints, split into page checkpoints (full pages) and component checkpoints (individual UI elements). Its pricing page doesn’t say how checkpoints are counted across the browsers and viewports you test, so ask Applitools before you compare volumes.

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

Diffy also has a free plan (two environments, one month of data retention).

Applitools

Plan	Price	Allowance
Starter	$667/mo (paid annually)	1,000 page checkpoints or 100,000 component checkpoints
Professional	Contact sales	From 150 active pages / 1,500 components
Enterprise	Contact sales	From 350 active pages / 1,500 components

Two things stand out.

The entry point. Applitools’ cheapest published plan is $667/mo and allows 1,000 page checkpoints. A 20-page site at three breakpoints, checked daily, is about 1,800 screenshots a month, which is Diffy’s 2,000 plan at $67/mo billed annually. If each page at each breakpoint counts as one page checkpoint, the same volume is past Applitools’ Starter allowance and into a sales conversation. Even within Starter, that is a tenfold difference in entry price.

Above Starter, the price is a conversation. Applitools publishes exactly one number. Professional and Enterprise are “contact sales”, and their allowances are quoted in active pages rather than a monthly checkpoint count, so you cannot self-serve your way to a larger plan or know what it costs without talking to someone. Diffy’s three tiers are all listed, all self-serve, and you can upgrade in the dashboard.

To be fair to Applitools: the Starter plan is not only those 1,000 page checkpoints. It also includes the 100,000 component checkpoint option, unlimited users, cross-browser and device testing, accessibility testing, Storybook and Figma integrations in the same subscription. You are paying for a much broader platform. The question is whether you need that platform, or whether you need screenshots of your pages compared between environments.

Applitools prices as published on applitools.com/platform-pricing on 19 October 2026; Diffy prices as on diffy.website/pricing. Both companies change prices eventually, so check both pages before you commit.

Setup: a browser tab vs. an SDK in your test suite

Applitools is at its best when it lives inside a test suite you already run. You install the SDK for your framework, add eyes.check() calls at the points you want validated, wire in your API key, and run the suite — locally or in CI — pointing the renders at the Ultrafast Grid. If you already maintain a Cypress or Playwright suite and have engineers who own it, this is a good fit and the Visual AI is a real payoff.

Diffy’s equivalent is a browser tab. You paste the URLs into a project, pick your breakpoints, and press a button — the URL list, the waits, the elements 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 who writes and maintains automated tests.

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

Environments, not test batches

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

Applitools is organised around test runs. Each run is a batch of checkpoints from your suite, compared against a baseline identified by the app and test name, browser, operating system and viewport, with support for branches. It is a model built to answer “did this test run change the UI?” — and it ties visual testing tightly to the functional test that produced it.

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 Multidev or Tugboat preview match production?

Neither model is strictly better — they are aimed at different questions. If your visual testing is a step inside your automated tests, Applitools’ batch-and-baseline model is where it belongs. 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. Applitools handles a lot of this automatically: its Visual AI is designed to ignore harmless rendering noise, and where it needs help you set match levels and regions. Diffy handles the same problems as 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 covers it on the screenshot. A “Stabilize dynamic elements” setting, on by default, freezes videos, map embeds, sliders and captchas.
• Inject custom CSS or JavaScript, set HTTP headers, cookies, and a custom User-Agent.
• Retina images and night mode are checkboxes.
• Any breakpoint between 240px and 2000px, 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. Applitools solves this with Visual AI and its match levels. Diffy solves it with a purpose-built diff algorithm.

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 — without reasoning about match levels in code.

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 integration that reports results on the pull request as a check
• 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 on Diffy’s infrastructure, so all you need is the plugin and the Diffy CLI.

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 Applitools is the better fit

We would rather you pick the right tool than the cheaper one.

• Cross-browser and cross-device rendering. The Ultrafast Grid re-renders one test run on Edge, Internet Explorer, Safari and other browsers, emulated Android devices and iOS simulators. Diffy tests responsive breakpoints in Chromium and WebKit: real engines, but a narrower matrix.
• Component and design-system testing. Applitools counts component checkpoints and integrates with Storybook, so a component library is a much better fit for Applitools than for Diffy’s page-level model.
• One platform for visual, accessibility, functional and API testing. Accessibility testing is in Starter; AI-driven functional testing and codeless API testing come with Professional. If you want visual checks embedded in a broader automated test suite, that is what Applitools is built for.
• Visual AI and no-code AI authoring. Visual AI is designed to separate real changes from rendering noise, and Autonomous builds tests from plain English, a recorder or a crawl of your sitemap. If that is the workflow you want, Diffy does not do it.
• Enterprise controls. Applitools offers dedicated or private cloud, SSO/SAML, on-premises deployment and custom SLAs on its higher tiers.

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. The free plan includes 500 screenshots a month, and there is nothing to uninstall if it is not for you.