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.
Kazi Khalid Hasan Tamim · 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 noalt, axe-core 4.10.2 WCAG 2.0/2.1 A and AA, horizontal overflow and axe'starget-sizerule 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.
| Check | Homepages | Share | Caught by |
|---|---|---|---|
| WCAG A/AA failure (axe-core, desktop) | 67 of 88 | 76 % | BugViso, WAVE, Lighthouse |
| Failed requests (4xx, 5xx or network error) | 41 of 88 | 47 % | BugViso, the DevTools Network panel |
| Console errors or uncaught exceptions | 40 of 88 | 45 % | BugViso, Lighthouse, an E2E test that listens for them |
Images with no alt attribute | 25 of 88 | 28 % | BugViso, WAVE, Lighthouse |
| Tap targets fail WCAG 2.2 SC 2.5.8 (mobile) | 24 of 88 | 27 % | BugViso, axe-based checkers |
| Broken links (404, 410 or 5xx) | 18 of 88 | 20 % | BugViso, Screaming Frog |
| Horizontal overflow at 412 px (mobile) | 4 of 88 | 5 % | BugViso, BrowserStack on a real phone |
| Clean on all 7 checks | 7 of 88 | 8 % | — |
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.
| Tool | Best for | QA jobs it covers | Starting price |
|---|---|---|---|
| BugViso | All-in-one QA audit of a live site, with a white-label PDF | Console errors, failed requests, broken links, WCAG, mobile layout, visual changes, speed, SEO | First report free, then $1.49 per report or from $29/month |
| Playwright | Scripted end-to-end tests in Chromium, Firefox and WebKit | Functional flows, screenshots | Free, open source (Apache 2.0) |
| Cypress | JavaScript teams who debug tests in the browser | End-to-end, component and API tests | App free (MIT); Cloud free for 500 results/month, Team $67/month billed annually |
| Selenium | Test suites in Java, Python, C#, Ruby, JavaScript or Kotlin | Functional flows, parallel runs on Grid | Free, open source (Apache 2.0) |
| BrowserStack | Real browsers and devices you don't own | Manual and automated cross-browser testing | Live from $12.50/month (100 minutes), Automate from $99/month, both billed annually |
| BugHerd | Client feedback pinned to page elements | Visual feedback, screenshots, task board | $50/month, or $42/month billed annually |
| Marker.io | Bug reports with session replay, sent to your tracker | Feedback widget, replay, light page monitoring | $39/month billed annually ($59 monthly) |
| WAVE | A visual accessibility review of one page | WCAG errors and alerts shown in the page | Free extension; API credits from $0.025 |
| Lighthouse | A quick lab check of one page | Performance, accessibility, SEO, best practices | Free, open source |
| Screaming Frog | Crawling a whole site for 404s and server errors | Broken links, redirects, on-page SEO | Free 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: best for crawling a whole site for broken links
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… | Use | Why |
|---|---|---|
| Prove signup, login and checkout still work | Playwright, Cypress or Selenium | Only scripted tests exercise multi-step flows |
| Find errors, broken links and WCAG failures nobody scripted | BugViso, WAVE or Lighthouse | Audits check pages against fixed rules |
| Send a client a branded QA report | BugViso | White-label PDF on agency plans |
| Reproduce a bug on a real iPhone or Android device | BrowserStack | Emulation is not a real device |
| Collect client comments on a staging site | BugHerd or Marker.io | Comments arrive with screenshots |
| Check every URL on a 10,000-page site for 404s | Screaming Frog | A 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.
- Functional flows. Run scripted tests, or click by hand, through every path that earns money or leads.
- 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.
- Links. Crawl staging for 404s, 5xx responses and links to the old domain.
- 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.
- 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.
- 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.
#!/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.
$ 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 pxHow 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
Kazi Khalid Hasan Tamim · 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.
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 where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.