Vercel and Netlify already give every pull request a running copy of your app. The question this guide answers is what tests that copy before merge, and how each tool gets past preview protection and back onto the PR.
On most teams the preview link gets a quick click from the reviewer, and that click is the whole test. At the volume coding agents produce, even the click often gets skipped.
What is preview deployment testing?
Preview deployment testing runs end-to-end tests against the temporary deployment that Vercel or Netlify builds for each pull request, then reports the result back on that pull request before merge.
Both platforms do the hard part. Vercel for GitHub deploys every push and makes the latest commit of each PR available at a unique preview URL, posted as a comment on the PR. Netlify builds a Deploy Preview for each pull request at an address such as deploy-preview-42--mysitename.netlify.app. A testing tool has three jobs left: know when that preview is ready, get through whatever protects it, and put a verdict where the reviewer will see it.
TL;DR
- Vercel and Netlify give every PR a live preview. Most teams look at it; few test it.
- A tool has to wait for the preview to finish, pick up its URL from GitHub, get past preview protection and report on the PR.
- Vercel previews are often behind Standard Protection, and Protection Bypass for Automation is the supported way in. Netlify has no equivalent, so private previews need a password scoped to previews or a public project.
- QA.tech's PR testing detects Vercel and Netlify previews automatically and posts a verdict as a required GitHub check. Checkly, Meticulous and Playwright in GitHub Actions each cover a narrower slice.
- Vercel's Deployment Checks gate production promotion, not the PR. Treat them as a second gate.
How testing tools hook into Vercel and Netlify previews
Every tool here follows the same chain; they differ in how much of it you build yourself.
PR opens → platform builds the preview → deploy record reaches success → tool reads the preview URL → bypass gets it past protection → tests run → verdict lands on the PR
Waiting for the preview and finding its URL
Vercel tells GitHub about each deployment through the deployment_status webhook event, which a GitHub Actions workflow can trigger on, reading the address from environment_url. Vercel's docs now encourage migrating to repository_dispatch events such as vercel.deployment.success, whose payload carries the deployment URL. One catch: those dispatch events only trigger a workflow that exists on the default branch.
Netlify reports through deploy notifications. GitHub commit statuses, PR comments and commit checks are on by default for new GitHub-connected sites, and a successful commit status links to the Deploy Preview. An outgoing webhook on "Deploy succeeded" is the other route.
Readiness is the subtle part: in a monorepo, a test that starts on the first green deploy can hit an app whose API is still building.
Getting past protected previews
On Vercel, Standard Protection protects every deployment except production domains, so a preview link opened by a test runner meets a login wall. Protection Bypass for Automation, available on all plans, issues a secret you send as the x-vercel-protection-bypass header. Browser tests add x-vercel-set-bypass-cookie: true so later page requests keep the bypass. You can create several named secrets per project, one per tool. Regenerating or deleting a secret invalidates previous deployments, so plan a redeploy when you rotate.
Netlify is stricter. Under project visibility, teams created on or after 28 July 2026 start new projects private, and previews stay private unless you change their visibility. Private means Netlify team login. Netlify documents no automation bypass, so a test runner has two options: a shared password with "Previews only" scope (Pro plans on credit-based pricing), or public previews.
Where the verdict lands
A result that lives only in a vendor dashboard gets ignored. It belongs in a GitHub check that branch protection can require, plus a PR comment that explains a failure. Vercel's Deployment Checks are a different gate: they hold a production deployment back from your custom domains until required GitHub checks pass. They protect the release after merge, which makes them a good second gate, not a substitute for testing the PR.
How we picked
Each tool had to integrate with Vercel or Netlify previews on its own live documentation, checked on 11 November 2026. We scored:
- Trigger: does it start when the preview is ready, without polling scripts?
- Protection: does it document a way past Vercel and Netlify preview protection?
- Verdict: does the result land on the PR as a check that can block the merge?
- What it proves: does it test a user journey, a page load, or a visual difference?
- Upkeep: who fixes the tests when an agent redesigns the page?
The best AI testing tools for Vercel and Netlify preview deployments
QA.tech
QA.tech is an AI testing platform whose QA agents test the running app toward a user goal, such as "complete checkout with a saved card", and post a verdict on the pull request.
How it hooks in. Install the GitHub App and Vercel or Netlify previews are detected automatically from the deployment records those platforms write to GitHub. QA.tech waits until every deploy record on the PR head commit is successful, and commit statuses whose name contains "deploy", "deployment" or "vercel" also count as gates. That closes the monorepo race: the review doesn't start on the frontend while the API preview is still pending.
Protection. For Vercel, you paste the bypass secret once into the application's preview defaults as custom headers for *.vercel.app, and QA.tech copies them onto every new preview environment. The secret stays in headers, never in the URL. For Netlify, the Netlify protection guide says plainly that there is no automation bypass: use a password scoped to previews, stored in QA.tech with a login test the others depend on, or make previews public.
Verdict. Once the preview is up, the QA agents look at what the PR changed, run the tests that already cover it, write tests for anything new and post the result. The verdict appears as a "QA.tech / PR Review" check that can be required in branch protection, plus a comment on the PR. It is anchored to the diff, so failures already on main are reported separately, and a run that never exercised the change returns "unverified" instead of a false green. Each failure includes screenshots and a video of the run, the network and console logs, and the agent's reasoning at each step.
Reality check. The agent works toward the goal on whatever page it finds, so a moved discount field doesn't break the test, but people still review the findings and decide which flows to pin as explicit, blocking steps. Before a PR exists, the MCP server lets Claude Code, Cursor or Codex run the same tests against a local dev server. Projects without previews can run the review after merge against staging. The free trial covers web and PR testing, and Starter is $89 a month (as of November 2026).
- Fits: teams on Vercel or Netlify who want every agent-written PR tested on its preview, with the verdict as a required check.
Checkly (Vercel integration)
Checkly runs Playwright-based browser checks and API checks, and its Vercel integration runs linked checks whenever a preview deploys, while they keep running on a schedule against production.
How it hooks in. Checkly links its checks to Vercel's Checks API, so results show in both tools, and "you can block your Vercel deployments if any of your checks fail or if the web vitals degrade." For other hosts, Checkly listens for successful GitHub deployment events and passes the preview address to browser checks as ENVIRONMENT_URL. Its docs don't mention Netlify by name.
Protection. Checkly's deployment protection guide uses Vercel's bypass secret in the request header.
Reality check. Checkly itself recommends its CLI in your CI pipeline over the connected integration, which lacks private locations and client certificates. You write and maintain the Playwright scripts. The Hobby plan needs no card (as of November 2026).
- Fits: Vercel teams that already script Playwright and want the same checks on previews and in production.
Meticulous
Meticulous records real sessions from your app and replays them against each PR's preview, before and after the change, to catch visual differences.
How it hooks in. Per its cloud replay docs, you install the Meticulous Vercel integration and link the project. Netlify works through a webhook on preview deploys, set up with Meticulous support.
Verdict. On GitHub it comments on the PR with the changes it found, and the check can be made blocking, so nobody merges a visual difference without acknowledging it.
Reality check. The homepage promises "Never write, fix or maintain a test again." Coverage depends on a recorder script running in your local, staging and preview environments, and a replay shows what changed on screen, leaving a person to judge whether the change was intended. The docs reviewed don't cover protected previews. Getting started goes through a demo booking.
- Fits: frontend-heavy web apps where unintended visual change is the main risk.
Playwright in GitHub Actions
The do-it-yourself route: a workflow that triggers on deployment_status (or Vercel's repository_dispatch), checks for a successful state and runs npx playwright test with the preview address as the base URL. Vercel's GitHub docs show both versions, and its bypass page includes a Playwright config that sends both headers.
Reality check. You own every piece: the readiness logic, unique job names (Vercel warns that duplicate names across workflows race with branch protection), the secrets and every selector. When a coding agent rebuilds the onboarding flow, someone rewrites the scripts.
- Fits: teams with test engineers who want full control and already maintain a Playwright suite.
The platform baseline: Vercel and Netlify's own tools
None of these tests a user journey, but they come with the platform and are worth switching on.
- Vercel Deployment Checks hold production promotion until selected GitHub checks pass on the merged commit, so a test failure can also stop the release.
- Vercel Comments let reviewers leave feedback on preview deployments made from GitHub PRs.
- Netlify Drawer lets your team comment, take screenshots and video and check mobile responsiveness on a Deploy Preview.
- Netlify's Lighthouse plugin audits performance, SEO and accessibility and puts scores in the PR's deploy comment. It doesn't support paths behind a login, so it can't reach the checkout.
- Fits: every team, as the floor under PR testing.
Setup checklist for testing Vercel and Netlify previews
-
Bypass secret. On Vercel, create a named Protection Bypass for Automation secret per tool, send it as a header and add
x-vercel-set-bypass-cookie: truefor browser tests. Store it as a secret, never in a URL, and redeploy after rotating. On Netlify, choose a previews-only password or public previews before you connect a tool. - Readiness gate. Start tests only when every deploy for the PR head commit is green. Don't add your own deployment records on top of a platform integration that already reports success, and point records at the PR head SHA, not the merge commit.
- Required checks. Make the PR testing check required in branch protection. For the release, add the GitHub check that runs on the merged commit to Vercel Deployment Checks, so production promotion waits for it too. Give every job a unique name.
- A short pinned set. Pin sign-up, login, checkout and billing as blocking flows; let dynamic and exploratory tests report on everything else.
AI testing tools for Vercel and Netlify previews compared
| Tool | Vercel previews | Netlify previews | Protected previews | Verdict on the PR | Who maintains tests | How you start (Nov 2026) |
|---|---|---|---|---|---|---|
| QA.tech | Detected automatically | Detected automatically | Bypass headers copied to every preview; Netlify password or public | Required "QA.tech / PR Review" check plus comment, diff-anchored | QA agents follow the goal; you pin critical flows | Free trial; self-serve Starter |
| Checkly | Connected integration or CLI | Not documented | Bypass header in your scripts | Vercel checks; optional PR comment from GitHub deployment runs | Your team (Playwright) | Free Hobby plan, no card |
| Meticulous | Vercel integration | Webhook, set up with support | Not documented | PR comment; blocking check optional | Generated from recorded sessions | Demo first |
| Playwright in Actions |
deployment_status or repository_dispatch
|
Commit status or webhook | Bypass header in config | Whatever check you build | Your team | Your own GitHub Actions |
| Platform tools | Deployment Checks, Comments | Drawer, Lighthouse plugin | Not applicable | Production gate; scores in comment | Not applicable | Included |
How to choose a testing tool for preview deployments
Start from what escapes. If agents ship broken journeys, such as a sign-up that loops after email confirmation, you need a tool that walks the journey on the preview. If the risk is unintended visual change, Meticulous fits. If it's a slow or broken page load, Checkly or Lighthouse.
Check protection first. Open a preview in a private window. If you meet a login, confirm the tool's documented way through before connecting it.
Ask how a skipped change is reported. A pass on a preview where the changed code never ran proves nothing; ask vendors how they mark that case.
Count the upkeep. Scripted suites, yours or a vendor's, need someone to fix them after every redesign. Be wary of "self-healing" as the answer: QA.tech's piece on self-healing misconceptions covers how a wrong repair can stay green.
Try it on live previews. QA.tech and Checkly can both be started without a sales call. Connect one and leave it running on a week of real PRs before you decide.
FAQ
How do I run tests on Vercel preview deployments?
Trigger on the event Vercel sends to GitHub, deployment_status or repository_dispatch with vercel.deployment.success, and use the URL it carries as your base URL. Tools like QA.tech and Checkly handle the trigger for you.
How do I bypass Vercel deployment protection for automated tests?
Turn on Protection Bypass for Automation in the project's Deployment Protection settings, available on all plans, and send the secret in the x-vercel-protection-bypass header. Browser tests also send x-vercel-set-bypass-cookie: true.
Can automated tests access private Netlify Deploy Previews?
Not easily: private previews sit behind Netlify team login, and Netlify documents no automation bypass. Set a shared password with "Previews only" scope (Pro) and have your tool enter it, or make previews public.
Do Vercel Deployment Checks test pull requests?
No. They hold a production deployment back from your domains until selected GitHub checks pass. Pair them with a required PR testing check, so testing gates both the merge and the release.
Does Netlify's Lighthouse plugin replace end-to-end testing?
No. It scores performance, SEO and accessibility on pages it can reach, not behind a login, and won't tell you whether checkout still completes.
What's the best AI testing tool for Vercel and Netlify previews?
For testing user journeys on every preview with a required verdict on the PR, QA.tech detects both platforms automatically and applies your Vercel bypass secret to every preview once you set it. Checkly suits teams that script Playwright on Vercel, and Meticulous suits visual regression on frontend apps.

Top comments (0)