View all services
Talk to QA Advisor
Browse the Knowledge Hub211 resources
/Tools Library/Applitools
Tools Library · Review and guide

Applitools review: pricing, alternatives and setup

Applitools Eyes is a commercial visual testing service. SDKs for Playwright, Cypress, Selenium, WebdriverIO, Storybook and others capture checkpoints from your existing tests, and Applitools’ Visual AI compares them with approved baselines, aiming to ignore rendering noise while catching differences a person would notice. The Ultrafast Grid re-renders one captured page across many browsers and devices in Applitools’ cloud.

QAble has evaluated this tool and works alongside it. The factual sections are complete; our view is bounded to what we have actually seen rather than a long-term verdict.

last reviewed
13 October 2026
version covered
Applitools Eyes, Playwright SDK 1.49
licence
Commercial

Reviewed by Viral Patel

Co-Founder, QAbleLast reviewed 13 October 2026

At a glance

Applitools at a glance

Official site
Vendor
Applitools
Category
Visual testing
Licence
Commercial
Platforms
Cross-platform
Integrates with
Playwright, Cypress, Selenium, Appium, Storybook
First released
2013
Version reviewed
Applitools Eyes, Playwright SDK 1.49

Verdict

Our verdict on Applitools

Strengths

  • Match levels such as Dynamic and Layout tolerate expected change without masking whole pages
  • The Ultrafast Grid renders one captured page across many browsers, viewports and devices in parallel
  • Adds to existing Playwright, Cypress, Selenium or WebdriverIO tests rather than replacing them
  • Branch-aware baselines keep feature-branch approvals out of the main baseline
  • Its Playwright fixture routes existing toHaveScreenshot assertions to Eyes with an import change

Weaknesses

  • Annual plans measured in checkpoints; the pricing page shows a free trial, not a free plan
  • Screenshots or DOM snapshots go to Applitools’ cloud unless you pay for private deployment
  • Ultrafast Grid renders from a snapshot, so JavaScript-driven responsive layouts need extra configuration
  • Baseline review becomes a process someone must own, or approvals turn into rubber stamps

Our take

The case for paying for visual testing rather than rolling your own pixel comparison is the false positive rate. Naive screenshot diffing fails on anti-aliasing, font rendering and dynamic content, and the review burden usually kills the practice within months. Applitools attacks that directly with match levels, region controls and branch-aware baselines, and the Ultrafast Grid turns one local run into cross-browser visual coverage. QAble has evaluated Applitools rather than maintained a long-running suite on it, so treat this as a bounded take. Watch three things: the pricing page lists annual plans measured in page or component checkpoints, with a free trial rather than a free plan; every checkpoint uploads a screenshot or DOM snapshot to Applitools’ cloud unless you buy a private deployment; and baselines need an owner and a review habit, or approvals become rubber stamps.

We have evaluated this tool rather than maintained a long-running suite on it, so this is a bounded view rather than a long-term verdict. The rest of this page is factual.

How it works

How Applitools works

Checkpoints compared against baselines

Each call to eyes.check in a test creates a checkpoint. The first time a test runs in a given environment, its checkpoints become the baseline and the test is reported as new. On later runs, each checkpoint is compared with the baseline and any difference is flagged as unresolved until someone accepts it, which updates the baseline, or rejects it as a bug. Applitools identifies a baseline by application name, test name and an environment made of operating system, browser and viewport size. Changing any of those, for example renaming a test or resizing the viewport, creates a new baseline rather than a comparison, which is the most common source of confusing new results.

Visual AI and match levels

The comparison is not a pixel diff. Match levels set what counts as a difference. Strict aims to flag changes the human eye would notice in text, fonts, colours, graphics and position, while ignoring rendering differences between machines. Layout checks only the relative positions of elements and ignores their content. Ignore Colors behaves like Strict without colour. Dynamic recognises text patterns such as dates, email addresses and URLs, so a changed date in a valid format is not flagged; Applitools documents it as the default for web tests on supported SDK versions. Exact is a pixel-for-pixel comparison that the documentation does not recommend for ordinary verification.

Classic runner versus the Ultrafast Grid

With the classic runner, the SDK takes a screenshot in the browser your test is driving and uploads it, so cross-browser coverage means running the test in every browser. With the Ultrafast Grid, the SDK instead captures a DOM snapshot with the page’s HTML, CSS, images and other resources, uploads it, and Applitools renders it on its own browsers and devices in parallel; the local browser is used only to determine what the page needs. Unchanged resources are cached between checkpoints. The result is broad coverage from one local run, with one caveat in the documentation: the local viewport must be compatible with the target configurations, or captured content can differ.

Fixtures, batches and when tests fail

In Playwright, the recommended integration since SDK 1.32 is a custom fixture: tests import test from @applitools/eyes-playwright/fixture and receive an eyes object alongside page. Configuration lives under eyesConfig in playwright.config.ts, and results for a run are grouped into a batch in the Eyes dashboard. The failTestsOnDiff setting decides when a visual difference fails Playwright: after each test, after all tests, or never. The fixture’s source defaults it to afterAll when the CI environment variable is set and afterEach otherwise, so the same suite reports differences at different moments locally and in CI.

Strengths

What it does well

Fewer false alarms than pixel diffs

Match levels, applied per checkpoint or per region, let a test tolerate exactly the change it should. A news feed region can be checked at Layout while the rest of the page stays Strict, and Dynamic accepts changed dates and emails in valid formats. That precision is what keeps a visual suite trusted after the first month.

Cross-browser visual coverage from one run

The Ultrafast Grid renders each captured DOM snapshot in configured desktop browsers, including Chrome, Firefox, Safari and Edge and their previous versions, in Chrome device emulation, and on iOS devices. One Playwright run in Chromium can therefore produce visual results for a matrix of browsers and screen sizes that would otherwise need many test runs.

Fits existing test code

Eyes adds checkpoints to tests you already have rather than replacing your framework. Current JavaScript SDKs cover Playwright, Cypress, WebdriverIO, Selenium, TestCafe and Storybook, with SDKs published for Java, Python and .NET as well. The Playwright fixture even routes existing toHaveScreenshot assertions through Eyes when expect is imported from the fixture.

Region-level control

Checkpoints accept ignore regions for content that should never be compared, such as adverts, layout regions for areas whose content changes but whose structure should not, strict regions for areas that must not change at all, and an option to ignore displacement when content merely shifts. Targeted regions are far safer than lowering the match level for the whole page.

Baselines that follow Git branches

Setting branchName and parentBranchName lets a feature branch get its own baselines, starting from the parent’s, so differences accepted on the branch do not change main until it is merged. Without this, a change approved for an unmerged feature would immediately become the expected result for everyone else.

More than visual comparison

The Starter plan lists accessibility testing, Figma and Storybook integrations, automated maintenance and root cause analysis alongside visual validation. Higher plans add AI-driven functional testing and natural-language authoring through Applitools Autonomous, codeless API testing and test data generation, so the platform can grow beyond visual checks if a team wants it to.

Pricing

Applitools pricing and licensing

Applitools is commercial, sold as annual plans with unlimited users and measured in checkpoints. On 13 October 2026 the pricing page listed Starter at $667 a month paid annually as a list price, covering 100,000 component checkpoints or 1,000 page checkpoints. Professional and Enterprise are priced on request and sized by active pages and components. The page offers a free trial rather than a free plan, and the SDK documentation points new users to a free account for an API key.

  • Licence: commercial service; the SDKs are distributed under Applitools’ own SDK licence agreement, not an open-source licence.
  • Starter: visual validation with Visual AI, cross-browser and device testing, Storybook and Figma integrations, CI integrations, accessibility testing, and standard support.
  • Professional: adds unlimited browsers and devices per Visual AI check, AI-driven functional testing, natural-language test authoring, codeless API testing and priority support.
  • Enterprise: adds dedicated or private cloud, SSO and SAML, custom SLAs and premier support, with real iOS and Android devices and on-premises deployment as add-ons.
  • How cost scales: by checkpoints and active pages, so the number of checks per test and, below Professional, the browser matrix drive usage. Review time for diffs is the hidden cost.

Checked against the vendor’s own pages on 13 October 2026. Pricing changes; confirm on the official site before buying.

Getting started

Getting started with Applitools

Setup, step by step

  1. Start from a Playwright Test project and install @applitools/eyes-playwright as a dev dependency.
  2. Run npx eyes-setup, which updates imports, adds eyesConfig to playwright.config.ts and adds a demo test.
  3. Set APPLITOOLS_API_KEY as an environment variable rather than writing it into the config.
  4. Add an eyes.check call to one existing test after the page reaches a stable state.
  5. Run npx playwright test twice: the first run creates baselines, the second compares against them.
  6. Open the batch in the Eyes dashboard and accept or reject any differences.

Install

npm install -D @applitools/eyes-playwright
npx eyes-setup
export APPLITOOLS_API_KEY=your_api_key_here
npx playwright test

A first example

// tests/home.visual.spec.ts
// test comes from the Eyes fixture, not from @playwright/test
import { test, expect } from '@applitools/eyes-playwright/fixture'

test('home page looks right', async ({ page, eyes }) => {
  await page.goto('https://example.com/')
  // Check only once the page is in a stable state
  await expect(page.getByRole('heading', { level: 1 })).toBeVisible()

  // First run creates the baseline; later runs compare against it
  await eyes.check('Home page', {
    fully: true,          // full-page capture, not just the viewport
    matchLevel: 'Dynamic' // tolerate changed dates, emails and URLs
  })
})

What trips people up first

The first run passes and the second one fails. The first run creates baselines, so everything is new and nothing is compared; the second run is the first real comparison, and it exposes anything that differs between runs, such as timestamps, rotating banners, carousels or data from a shared environment. Handle those with Dynamic or Layout match levels on the affected regions, or ignore regions for content that should never be compared, then accept the cleaned-up baseline. A related early mistake is a test still importing test from @playwright/test, which leaves the eyes fixture undefined.

In practice

Using Applitools in practice

One eyesConfig for the whole suite

Keep Eyes configuration in playwright.config.ts so every test shares the same application name, batch, browsers and branch settings. Choose the Ultrafast Grid with type ufg when you want cross-browser coverage from a single Playwright project, and list the renderings in browsersInfo. Name the batch after the pipeline run so results group sensibly in the dashboard. Read the branch name from CI so feature branches get their own baselines, with main as the parent. Leave failTestsOnDiff at its default unless you have a reason: per-test failures locally, one failure after the run in CI.

// playwright.config.ts (excerpt)
import { defineConfig } from '@playwright/test'
import type { EyesFixture } from '@applitools/eyes-playwright/fixture'

export default defineConfig<EyesFixture>({
  reporter: '@applitools/eyes-playwright/reporter',
  use: {
    eyesConfig: {
      appName: 'Shop web',
      // Render each checkpoint in Applitools' cloud, not just locally
      type: 'ufg',
      browsersInfo: [
        { name: 'chrome', width: 1280, height: 800 },
        { name: 'firefox', width: 1280, height: 800 },
        { name: 'safari', width: 1280, height: 800 },
        { iosDeviceInfo: { deviceName: 'iPhone 15' } },
      ],
      batch: { name: process.env.GITHUB_RUN_ID ? `CI run ${process.env.GITHUB_RUN_ID}` : 'Local' },
      // Feature branches get their own baselines, starting from main
      branchName: process.env.GIT_BRANCH || 'main',
      parentBranchName: 'main',
    },
  },
})

Checkpoints that survive dynamic content

Most false diffs come from a handful of regions: timestamps, adverts, personalised greetings, carousels and live data. Deal with them at the checkpoint rather than by lowering the match level for the whole page. Ignore regions remove an area from comparison entirely; layout regions keep checking structure while allowing content to change; strict regions protect areas that must not move, such as a price or a legal notice. Also stabilise what you can before checking: wait for fonts and data, close cookie banners, and freeze animations. Where a test is about one area, checking that region rather than the full page also makes failures easier to read.

// tests/product.visual.spec.ts
import { test, expect } from '@applitools/eyes-playwright/fixture'

test('product page', async ({ page, eyes }) => {
  await page.goto('/product/42')
  await expect(page.getByTestId('price')).toBeVisible()
  await page.getByRole('button', { name: 'Accept cookies' }).click()

  await eyes.check('Product page', {
    fully: true,
    matchLevel: 'Strict',
    // Never compared: changes every request
    ignoreRegions: ['[data-testid="ad-slot"]', '[data-testid="last-viewed"]'],
    // Structure checked, content allowed to change
    layoutRegions: ['[data-testid="recommendations"]'],
    // Must not change at all
    strictRegions: ['[data-testid="price"]'],
  })
})

Running visual checks in GitHub Actions

Visual tests run as ordinary Playwright tests, so the pipeline needs only the API key as a secret and the branch name for baseline branching. With the Ultrafast Grid, one Chromium install is enough, because rendering in other browsers happens in Applitools’ cloud. Because failTestsOnDiff defaults to afterAll in CI, expect individual tests to pass and the run to fail at the end when there are unresolved differences; the Eyes reporter and dashboard show which ones. Applitools also offers a GitHub integration that reports results as checks on the pull request.

# .github/workflows/visual.yml
name: visual
on: [pull_request]
jobs:
  eyes:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7
      - uses: actions/setup-node@v7
        with:
          node-version: 24
          cache: npm
      - run: npm ci
      # Ultrafast Grid renders other browsers remotely
      - run: npx playwright install --with-deps chromium
      - run: npx playwright test tests/visual
        env:
          APPLITOOLS_API_KEY: ${{ secrets.APPLITOOLS_API_KEY }}
          GIT_BRANCH: ${{ github.head_ref || github.ref_name }}

Owning baselines and the review loop

Visual testing succeeds or fails on review discipline. Decide who reviews differences, usually the developer of the change with a designer or QA lead for intentional redesigns, and how quickly unresolved results must be cleared, since they block the pipeline. Accept differences on the feature branch, where branch baselines keep them isolated, and let them reach main when the branch merges. Reject differences that are bugs so they stay visible on the next run. Avoid accepting in bulk without looking at each difference. Rename tests and change viewports deliberately, since either creates new baselines.

Deciding what deserves a checkpoint

Checkpoints cost money and review time, so place them where a visual regression would hurt and functional assertions are weak: key templates, design system components, marketing pages, checkout and anything with complex responsive behaviour. Prefer one well-placed full-page checkpoint per state over a check after every step. For component libraries, the Storybook SDK checks stories directly, which suits the component checkpoints the pricing page describes. For responsive designs whose layout changes through JavaScript rather than CSS, configure layoutBreakpoints so the SDK captures a snapshot at each width instead of letting the grid render one snapshot at sizes it was not built for.

Pitfalls

Common pitfalls

The eyes fixture is undefined

Why it happens: The test still imports test from @playwright/test, which knows nothing about Eyes. eyes-setup rewrites imports where it can but cannot when test comes from another package.

The fix: Import test, and expect if you want toHaveScreenshot routed to Eyes, from @applitools/eyes-playwright/fixture, or extend your own fixture from it.

Every run reports differences on the same areas

Why it happens: Timestamps, adverts, carousels and shared test data change between runs, and a whole-page Strict checkpoint flags each change.

The fix: Stabilise data and close overlays before checking, then use ignore, layout or strict regions for the affected areas instead of loosening the whole page.

Visual failures appear only at the end of the CI run

Why it happens: The fixture sets failTestsOnDiff to afterAll when the CI variable is present, so tests pass individually and the run fails afterwards, unlike locally.

The fix: Expect that pattern and read the Eyes summary or dashboard for the failing checkpoints, or set failTestsOnDiff to afterEach if per-test failures matter more than speed.

Feature-branch approvals changing main’s baseline

Why it happens: Without branchName and parentBranchName, every run shares one baseline, so accepting a difference for an unmerged branch changes the expectation for all branches.

The fix: Pass the Git branch into branchName and set parentBranchName to main, so branches start from main’s baseline and merge their accepted changes back.

Unexpected new baselines instead of comparisons

Why it happens: A baseline is identified by application name, test name, operating system, browser and viewport. Renaming a test or changing a viewport starts a new one.

The fix: Treat test names and viewports as part of the visual contract, change them deliberately, and use a baseline environment name when environments must share one baseline.

Responsive layouts rendering wrongly on the Ultrafast Grid

Why it happens: The grid renders a DOM snapshot captured at the local viewport. Layouts that JavaScript changes by width may not match what that browser would really show.

The fix: Keep the local viewport compatible with the target configurations, and enable layoutBreakpoints so a snapshot is captured at each configured width.

Compared

Applitools alternatives compared

ToolRenderingPricing modelBrowsersLicence
ApplitoolsLocal screenshot or Ultrafast Grid cloudAnnual plans by page or component checkpointsChrome, Firefox, Safari, Edge, emulated and iOS devicesCommercial, proprietary SDK licence
PercyDOM snapshot rendered in Percy’s cloudScreenshots per month, free plan availableDesktop browsers; mobile on higher planCommercial, part of BrowserStack
ChromaticSnapshots rendered in Chromatic’s cloudSnapshots per month, free 5,000 a monthChrome free; Safari, Firefox, Edge on paidCommercial
BackstopJSLocal headless browser, optional DockerFreeHeadless browsers via Playwright or PuppeteerMIT open source

FAQ

Frequently asked questions

What are the best Applitools alternatives?

The alternatives most often weighed against Applitools are Percy, Chromatic and BackstopJS. The comparison on this page sets them side by side on rendering, pricing model, browsers and licence, and the verdict above says where Applitools is the wrong choice and which of them to pick instead.

Is Applitools free?

No. Applitools is a commercial service sold as annual plans. On 13 October 2026 its pricing page listed Starter at $667 a month paid annually as a list price, with Professional and Enterprise on request. The page offers a free trial rather than a free plan, and the SDK documentation mentions a free account for obtaining an API key. Open-source alternatives such as BackstopJS or Playwright’s toHaveScreenshot cost nothing but use pixel comparison.

Applitools or Playwright’s toHaveScreenshot?

Playwright’s built-in screenshot assertions are free and need no account, but they compare pixels against images stored in your repository, so rendering differences between machines and dynamic content cause false failures that you manage with thresholds and masks. Applitools adds match levels, region controls, a review dashboard, branch-aware baselines and cross-browser rendering. Its Playwright fixture can take over existing toHaveScreenshot calls, so moving between the two is not a rewrite.

Applitools or Percy?

Both add visual checkpoints to existing tests and render in the cloud. Percy captures a DOM snapshot and renders it across browsers and widths, is priced by screenshots per month with a free plan, and is part of BrowserStack. Applitools offers match levels such as Dynamic and Layout, region-level controls and branch baselines, and is priced in checkpoints on annual plans. Trial both against your noisiest pages before deciding.

What is the Applitools Ultrafast Grid?

It is Applitools’ cloud rendering service. Instead of taking a screenshot in each browser, the SDK captures the page’s DOM and resources once and uploads them, and Applitools renders that snapshot on its own browsers and devices in parallel, then compares each rendering with its baseline. One local test run can therefore cover Chrome, Firefox, Safari, Edge, emulated devices and iOS devices.

Which match level should I use?

Use the default for most web checks: Dynamic, which Applitools documents as the default for web tests on supported SDK versions and which tolerates changed dates, emails and URLs. Use Strict where text and styling must not change, and Layout for regions whose content changes constantly, such as feeds. Apply Layout to regions rather than whole pages so the rest stays protected, and avoid Exact, which the documentation does not recommend for ordinary checks.

Does Applitools work with Cypress, Selenium or Java?

Yes. Applitools publishes JavaScript SDKs for Cypress, WebdriverIO, Selenium, TestCafe and Storybook alongside Playwright, and SDKs for Java, Python and .NET. Each adds checkpoints to tests in that framework and sends them to the same Eyes service, so a mixed estate can share one dashboard and one set of baselines per application.

Where does Applitools store my screenshots?

Checkpoints, screenshots in the classic runner or DOM snapshots with resources in the Ultrafast Grid, are uploaded to the Eyes server, which is Applitools’ public cloud unless your account uses a private deployment. The Enterprise plan lists a dedicated or private cloud and an on-premises option. Teams testing sensitive data should confirm deployment and retention terms with Applitools before uploading production-like pages.

Alternatives

Applitools alternatives worth weighing

Percy

Visual review platform integrating with CI to surface rendering changes as part of pull requests.

Chromatic

Visual testing and review built specifically around Storybook component libraries.

BackstopJS

Open source visual regression testing using headless Chrome and configurable scenarios.

Resources

Where to go next

Ready

Picking the wrong tool costs more than picking late.

QAble advises on toolchain decisions and then implements them, with engineers who have run these tools on real delivery. Start with a free QA audit.

Talk to QA Advisor