Best Website QA Testing Tools 2027: Top 10 Compared

The 10 best website QA testing tools for 2027, matched to the bugs each one catches. We QA-tested 88 real homepages: only 7 of 88 passed all seven checks.

· BugViso Team

15 min read

The best website QA testing tools for 2027 are BugViso for a full QA audit of a live site with a white-label PDF, Playwright, Cypress and Selenium for scripted tests, BrowserStack for real devices, BugHerd and Marker.io for client feedback, WAVE and Lighthouse for one-page checks, and Screaming Frog for site-wide broken links.

No single tool does every job, and our test shows why. We ran a one-page QA pass on 88 real homepages: 76 % (67 of 88) failed at least one WCAG A/AA rule, 45 % (40 of 88) logged console errors, and only 7 were clean on all seven checks.

By the end you will know which tool covers which bug, how to build a small QA stack, and how to run the same checks yourself.

Data used: 180 random domains (seed 20261003) from ranks 1,001–50,000 of the Tranco list L5KW4, tested on 2026-11-19; 88 homepages loaded as real pages on desktop and mobile. Headless Chromium 136 via Playwright 1.52 at 1366 × 900, then 412 × 924 with mobile emulation. Checks: console errors, failed requests, broken links (up to 60 per page; 404, 410, 5xx), images with no alt, axe-core 4.10.2 WCAG 2.0/2.1 A and AA, horizontal overflow and axe's target-size rule on mobile. We make BugViso, one of the tools listed, and name no site from the sample.

What a One-Page QA Pass Found on 88 Homepages

Accessibility failures were the most common problem and mobile horizontal overflow the rarest. Here is how often each check fired and which website QA testing tools would catch it.

CheckHomepagesShareCaught by
WCAG A/AA failure (axe-core, desktop)67 of 8876 %BugViso, WAVE, Lighthouse
Failed requests (4xx, 5xx or network error)41 of 8847 %BugViso, the DevTools Network panel
Console errors or uncaught exceptions40 of 8845 %BugViso, Lighthouse, an E2E test that listens for them
Images with no alt attribute25 of 8828 %BugViso, WAVE, Lighthouse
Tap targets fail WCAG 2.2 SC 2.5.8 (mobile)24 of 8827 %BugViso, axe-based checkers
Broken links (404, 410 or 5xx)18 of 8820 %BugViso, Screaming Frog
Horizontal overflow at 412 px (mobile)4 of 885 %BugViso, BrowserStack on a real phone
Clean on all 7 checks7 of 888 %—

Most sites failed more than one check: the median homepage hit 3 of the 7 categories, and 45 of 88 (51 %) hit three or more. That is the case against a one-tool QA process. An end-to-end test that clicks through signup passes on a page full of contrast failures, because nobody wrote an assertion for contrast.

The most common accessibility failures were color-contrast (43 of 88), link-name (30 of 88) and image-alt (19 of 88). All three are rule-based, cheap to fix and invisible to a functional test.

The 10 Best Website QA Testing Tools at a Glance

Pick website QA testing tools by job, then by price. Prices were checked on each vendor's site on 2026-11-19; "billed annually" means the monthly equivalent of a yearly plan.

ToolBest forQA jobs it coversStarting price
BugVisoAll-in-one QA audit of a live site, with a white-label PDFConsole errors, failed requests, broken links, WCAG, mobile layout, visual changes, speed, SEOFirst report free, then $1.49 per report or from $29/month
PlaywrightScripted end-to-end tests in Chromium, Firefox and WebKitFunctional flows, screenshotsFree, open source (Apache 2.0)
CypressJavaScript teams who debug tests in the browserEnd-to-end, component and API testsApp free (MIT); Cloud free for 500 results/month, Team $67/month billed annually
SeleniumTest suites in Java, Python, C#, Ruby, JavaScript or KotlinFunctional flows, parallel runs on GridFree, open source (Apache 2.0)
BrowserStackReal browsers and devices you don't ownManual and automated cross-browser testingLive from $12.50/month (100 minutes), Automate from $99/month, both billed annually
BugHerdClient feedback pinned to page elementsVisual feedback, screenshots, task board$50/month, or $42/month billed annually
Marker.ioBug reports with session replay, sent to your trackerFeedback widget, replay, light page monitoring$39/month billed annually ($59 monthly)
WAVEA visual accessibility review of one pageWCAG errors and alerts shown in the pageFree extension; API credits from $0.025
LighthouseA quick lab check of one pagePerformance, accessibility, SEO, best practicesFree, open source
Screaming FrogCrawling a whole site for 404s and server errorsBroken links, redirects, on-page SEOFree up to 500 URLs; £199 per year

BugViso: best for all-in-one QA audits agencies hand to clients

BugViso loads a live site in a real Chromium browser, crawls it, and turns console errors, failed requests, broken links, WCAG failures, mobile layout problems and visual changes into one scored report with a ranked fix list. It needs no test scripts, so it catches bugs nobody writes assertions for.

Agency plans add a white-label PDF with your logo and colours, plus scheduled re-scans. A new account's first full report is free; after that it costs $1.49 per report, or from $29 a month for 20 audits. It doesn't script logins or checkouts, test physical devices or collect client comments; pair it with tools that do.

Playwright: best for scripted end-to-end tests

Playwright drives Chromium, Firefox and WebKit from one API, in TypeScript, Python, .NET or Java, and is free under the Apache 2.0 licence. It suits new end-to-end suites: it waits for elements on its own and runs headless in CI. It tests only what you tell it to: a checkout flow that completes passes, even if the page logs ten errors on the way.

Cypress: best for JavaScript teams who debug in the browser

The Cypress app is free and MIT-licensed, runs end-to-end, component and API tests in a real browser, and lets you step back through each command (Time Travel). Cypress Cloud adds parallel runs, flaky-test detection, Test Replay and accessibility checks. Cloud is free for 500 test results a month; Team starts at $67 a month billed annually.

Selenium: best for multi-language test suites

Selenium WebDriver controls a real browser from Java, Python, C#, Ruby, JavaScript or Kotlin, and Selenium Grid runs those sessions in parallel across many environments. It is free under Apache 2.0 and the safe choice when a QA team already owns years of Selenium tests.

BrowserStack: best for real browsers and devices

BrowserStack rents you real desktop browsers and mobile devices in the cloud, for manual sessions (Live) or automated tests (Automate). Live starts at $12.50 a month billed annually for 100 minutes; Live Desktop is $29 for one user. Use it for bugs that only appear in Safari on iOS or on Android phones you don't own.

BugHerd: best for client feedback on agency builds

BugHerd lets clients click any element on a page and leave a comment that arrives with a screenshot, browser, operating system and screen resolution, as a task on a Kanban board. Clients join as guests without a paid seat. Standard costs $50 a month ($42 billed annually) for 5 members and unlimited guests.

Marker.io: best for bug reports that land in your tracker

Marker.io adds a feedback widget that sends bug reports with session replay and developer data into trackers such as Linear, GitHub and Asana; Jira needs the Team plan or above. Starter is $39 a month billed annually ($59 monthly) for 3 members, with a 15-day free trial.

WAVE: best for a visual accessibility review of one page

WAVE, from WebAIM, marks accessibility errors and alerts directly on the page in Chrome, Firefox or Edge, and the extension runs entirely in your browser. It checks one page at a time; a paid API, from $0.025 per credit, covers more.

Lighthouse: best for a quick one-page lab check

Lighthouse is Google's open-source page auditor, with audits for performance, accessibility, SEO and more, built into Chrome DevTools and also available as a CLI and a Node module. Its results come from one lab load of one page: a smoke test, not site QA. The Lighthouse overview documents the four ways to run it.

Screaming Frog SEO Spider is a desktop crawler for Windows, macOS and Linux that finds broken links (404s) and server errors across a site and exports them with their source pages. The free version crawls 500 URLs; a licence costs £199 a year. Our broken link checker comparison for large sites sets its limits next to six other crawlers.

How Do I Choose a Website QA Tool That Gives Actionable Fixes?

Choose a website QA tool by the bugs you need to catch and who has to read the result.

If you need to…UseWhy
Prove signup, login and checkout still workPlaywright, Cypress or SeleniumOnly scripted tests exercise multi-step flows
Find errors, broken links and WCAG failures nobody scriptedBugViso, WAVE or LighthouseAudits check pages against fixed rules
Send a client a branded QA reportBugVisoWhite-label PDF on agency plans
Reproduce a bug on a real iPhone or Android deviceBrowserStackEmulation is not a real device
Collect client comments on a staging siteBugHerd or Marker.ioComments arrive with screenshots
Check every URL on a 10,000-page site for 404sScreaming FrogA crawler reaches every page

Then check that each finding names the element and the fix (forty color-contrast violations with no selector cost more time than they save), and that someone who didn't write the test can read the result. A client reads a PDF, not a CI log.

How Do I QA Test a Website Before Launch?

QA test a website before launch in six passes: functional flows, runtime errors, links, accessibility, mobile layout and cross-browser behaviour, in that order, on staging. A JavaScript error can break the checks that follow it.

  1. Functional flows. Run scripted tests, or click by hand, through every path that earns money or leads.
  2. Runtime errors. Load each key template with DevTools open and record console errors and failed requests. Our guide to which JavaScript console errors hurt SEO explains which to fix first, and our JavaScript SEO tools comparison shows how to check whether those errors hide content from crawlers.
  3. Links. Crawl staging for 404s, 5xx responses and links to the old domain.
  4. Accessibility. Run axe-core or WAVE, then test with a keyboard: automated rules cover only part of WCAG, as our two-pass accessibility audit explains.
  5. Mobile layout. Check for horizontal scrolling and tap targets under 24 × 24 CSS pixels, the minimum in WCAG 2.2 Success Criterion 2.5.8.
  6. Cross-browser. Repeat the key flows in Safari and on a real Android phone.

Run a One-Page QA Check Yourself

This Playwright script runs the same checks as our study on any URL and exits with code 1 when it finds a problem, so it fits a pre-launch checklist or a scheduled job.

python
#!/usr/bin/env python3
"""One-page website QA check: console errors, failed requests, broken links,
images without alt, and mobile layout (overflow + small tap targets).

Usage: pip install playwright && playwright install chromium
       python qa_check.py https://example.com
"""
import asyncio
import sys
from urllib.parse import urldefrag

from playwright.async_api import async_playwright

MAX_LINKS = 60  # politeness cap per page

PAGE_JS = """() => ({
  links: [...new Set([...document.querySelectorAll('a[href]')]
           .map(a => a.href).filter(h => h.startsWith('http')))],
  noAlt: [...document.querySelectorAll('img:not([alt])')].map(i => i.currentSrc || i.src),
})"""

# WCAG 2.2 SC 2.5.8 candidates: visible targets under 24x24 CSS px, not inline
# in text. SC 2.5.8 still passes small targets with enough spacing.
TAP_JS = """() => [...document.querySelectorAll('a[href],button,input,select,[role=button]')]
  .filter(el => {
    const r = el.getBoundingClientRect();
    if (!r.width || !r.height || el.offsetParent === null) return false;
    const inText = el.tagName === 'A' && getComputedStyle(el).display === 'inline'
      && [...el.parentElement.childNodes].some(n => n.nodeType === 3 && n.textContent.trim());
    return !inText && (r.width < 24 || r.height < 24);
  }).length"""


async def main(url):
    console, failed = [], []
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        ctx = await browser.new_context(viewport={"width": 1366, "height": 900})
        page = await ctx.new_page()
        page.on("console", lambda m: m.type == "error" and console.append(m.text))
        page.on("pageerror", lambda e: console.append(f"Uncaught: {e}"))
        page.on("requestfailed", lambda r: "ERR_ABORTED" not in (r.failure or "")
                and failed.append(f"{r.failure} {r.url}"))
        page.on("response", lambda r: r.status >= 400 and failed.append(f"{r.status} {r.url}"))
        await page.goto(url, wait_until="load", timeout=30000)
        await page.wait_for_timeout(2500)  # let late scripts log their errors
        info = await page.evaluate(PAGE_JS)

        broken = []
        for href in [urldefrag(h)[0] for h in info["links"]][:MAX_LINKS]:
            try:
                r = await ctx.request.get(href, timeout=10000, fail_on_status_code=False)
                if r.status in (404, 410) or r.status >= 500:
                    broken.append(f"{r.status} {href}")
            except Exception as e:
                broken.append(f"unreachable {href} ({type(e).__name__})")

        mobile = await browser.new_context(viewport={"width": 412, "height": 924},
                                           is_mobile=True, has_touch=True,
                                           device_scale_factor=2.625)
        mpage = await mobile.new_page()
        await mpage.goto(page.url, wait_until="load", timeout=30000)
        await mpage.wait_for_timeout(1500)
        overflow = await mpage.evaluate("document.documentElement.scrollWidth - document.documentElement.clientWidth")
        small = await mpage.evaluate(TAP_JS)
        await browser.close()

    report = [("Console errors", console), ("Failed requests", failed),
              (f"Broken links (of {min(len(info['links']), MAX_LINKS)} checked)", broken),
              ("Images without alt", info["noAlt"])]
    for title, items in report:
        print(f"\n{title}: {len(items)}")
        for item in items[:10]:
            print("  -", item[:160])
    print(f"\nMobile (412 px): horizontal overflow {max(overflow, 0)} px, "
          f"{small} tap-target candidates under 24x24 px")
    return sum(len(items) for _, items in report) + (overflow > 1)


if __name__ == "__main__":
    if len(sys.argv) != 2:
        sys.exit(__doc__)
    sys.exit(1 if asyncio.run(main(sys.argv[1])) else 0)

We ran it on bugviso.com on 2026-11-19. It flagged one broken link, an outbound badge to a third-party directory that now returns 404, and nothing else.

text
$ python qa_check.py https://bugviso.com
Console errors: 0

Failed requests: 0

Broken links (of 31 checked): 1
  - 404 https://www.codehype.ai/product/bugviso?utm_source=codehype_badge

Images without alt: 0

Mobile (412 px): horizontal overflow 0 px, 0 tap-target candidates under 24x24 px

How BugViso Runs These Checks Across a Whole Site

BugViso runs the checks from the script above on every crawled page and adds what a short script can't: stack traces for console errors, axe-core WCAG 2.0, 2.1 and 2.2 A and AA rules, and mobile emulation on iPhone 16 Pro and Pixel 9 profiles. Its tap-target check applies WCAG 2.2 SC 2.5.8 with the spacing exception, and it flags horizontal overflow per page.

Each finding lands in a ranked fix list with AI-written code fixes, and SSIM screenshot comparison plus clipped-text and overlap checks catch layout breaks. The Developer Visual & Code QA engine page lists every runtime check. Agencies get a white-label PDF, and each re-audit shows what was fixed, what is new and what got worse.

What These Numbers Don't Tell You

A homepage test is a floor, not the full picture. Inner pages and forms usually get less polish, so a full crawl would likely find more.

  • Lab, not field. One headless load per viewport; some errors only appear after consent, scrolling or input.
  • 92 of 180 sampled domains were excluded because they did not resolve, timed out, failed the mobile load, or served a bot challenge or error page.
  • Automated accessibility rules are partial. W3C's guidance on selecting web accessibility evaluation tools says tools alone can't determine whether a site is accessible; a page with zero axe violations can still fail a keyboard user.
  • Link checks stopped at 60 links per page, and 492 responses of 401, 403, 429 or 999 counted as bot blocking, not dead links.

Frequently Asked Questions

What is website QA testing?

Website QA testing checks that a site works as intended before and after launch: flows complete, pages load without JavaScript errors, links resolve, content meets WCAG and layouts hold on mobile and in major browsers. It combines scripted tests, automated audits and manual review.

Can website QA testing be automated?

Most of it can. Frameworks such as Playwright automate functional flows, and audit tools automate rule-based checks for console errors, broken links, WCAG failures and mobile layout. Usability, content accuracy and parts of accessibility, such as whether alt text fits the image, still need a person.

What is the best free website testing tool?

For scripted tests, Playwright is the strongest free option: open source, three browser engines and four languages. For a no-code check of one page, Lighthouse in Chrome DevTools and the WAVE extension are free. So is the script above.

How do you test a website for bugs?

Load each key page in a real browser with DevTools open, record console errors and failed requests, click through every form and checkout path, crawl for broken links, run an axe-core or WAVE accessibility scan, and check the layout at phone width. Then repeat the critical flows in Safari and on Android.

What is the best QA testing tool for agencies?

For agencies, the best QA testing tool is usually a pair: an audit tool that checks client sites without test code and produces a report clients can read, such as BugViso with its white-label PDF, plus BugHerd or Marker.io for client feedback during the build.

Pick Tools by the Bug, Not the Brand

On 88 real homepages, 92 % (81 of 88) failed at least one of seven basic checks, so a website QA stack needs one tool for the flows you script and one for the bugs nobody scripted. Start with the second: a BugViso audit runs those checks on every crawled page and hands you the fix list.

Written by

· BugViso Team

Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.

Found this useful? Share it.

Summarise with AI

Open this guide in your assistant.

Follow BugViso

New guides and audit data as we publish them.

AI visibility tracker

Is your brand in AI answers?

See how often AI assistants mention you, cite your site and rank you against your competitors.

  • ChatGPT
  • Gemini
  • Perplexity
  • Claude
  • AI Overviews
See how it works

See where your site stands

Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.