Best Website Grader Tools 2027: Top 10 and 231 Sites Graded
The 10 best website grader tools for 2027, plus our own test: 231 sites graded three ways, and 79% got a different letter grade from the weighting alone.
Kazi Khalid Hasan Tamim · BugViso Team
16 min read
The best website grader tools for 2027 are HubSpot Website Grader and PageSpeed Insights for a free first score, Seobility for on-page SEO, GTmetrix for speed from many locations, three free security graders, and BugViso for a multi-page grade with fixes. No two graders score the same checks, so the grade depends on the tool.
We measured how much. Our own grader ran the same 18 checks on 231 real homepages and scored them three ways. Only the weighting changed, yet 182 of the 231 sites (79 %) got a different letter grade on desktop.
By the end you will know what each tool really measures, which one fits your question, and how to grade a site yourself with a tested script that shows every point it takes away.
Data used: 240 homepages that returned HTML in our earlier crawl of a random sample (seed
20261003) from ranks 1,001–50,000 of the Tranco top-sites list, graded on 2026-11-19 with Playwright 1.52 (Chromium). Each site was loaded on desktop (1350×940, unthrottled) and mobile (Pixel 7 emulation with Lighthouse's mobile throttling preset: 150 ms latency, 1.6 Mbps down, 4× CPU slowdown). Failures were retried once; 231 sites were graded on both devices. Tests ran from one machine in Dhaka, Bangladesh, 4 sites at a time, desktop first. Tool facts come from each vendor's own page, fetched the same day. Sites are not named. We make BugViso, one of the tools listed.
Best Website Grader Tools at a Glance
Pick a grader by the question you want answered: speed, SEO, security or the whole site.
| Tool | Best for | What it grades | Result | Price |
|---|---|---|---|---|
| BugViso | A whole-site grade with fixes and a PDF | 74 checks across 25 engines, every crawled page | 0–100, A–F, points lost by area | First report free with an account, then $1.49 per report or monthly plans |
| HubSpot Website Grader | A quick free score for marketers | Performance, mobile, SEO, security (17+ metrics) | Score with recommendations | Free, asks for an email |
| PageSpeed Insights | A free speed grade with real-user data | Lighthouse lab test plus 28 days of CrUX field data | Four 0–100 category scores | Free |
| Lighthouse (Chrome DevTools) | Staging or logged-in pages | Performance, accessibility, SEO and more | Four 0–100 category scores | Free |
| GTmetrix | Speed from many locations | Lighthouse report and Web Vitals in real Chrome | Scores, Web Vitals, waterfall | Free account; paid plans |
| Seobility SEO Checker | A free on-page SEO grade | 200+ SEO factors on one URL | Percentage | Free, 5 checks a day |
| LocaliQ Website Grader | Local businesses | Site quality, social and local presence, ads | 0–100 per area | Free |
| Mozilla HTTP Observatory | A security grade with a published formula | HTTP headers and security settings | A+ to F | Free |
| Security Headers | A one-glance header check | HTTP response headers | A+ to F | Free |
| Qualys SSL Labs | HTTPS and TLS | Protocols, key exchange, ciphers | A to F (A+ and T shown too) | Free |
Why Do Website Graders Give Different Scores?
Website graders give different scores because each one picks its own checks and its own weights, and the weighting alone can move a site by a whole letter. We kept 18 checks fixed and changed only how much each category counted: equal (25 % each for performance, SEO, mobile and accessibility, and security), SEO-led (SEO 50 %) and speed-led (performance 60 %). Letters used the common bands: A from 90, B from 80, C from 70, D from 60, F below.
| Same 18 checks, desktop | Equal | SEO-led | Speed-led |
|---|---|---|---|
| Median score | 72.1 | 73.7 | 68.0 |
| Grade A | 17 | 23 | 20 |
| Grade F | 21 | 29 | 80 |
Changing only the weighting gave 182 of 231 sites (79 %) a different letter on desktop, and 184 of 231 (80 %) on mobile. The SEO-led and speed-led grades disagreed on 170 sites (74 %), by a median of 12.2 points and up to 39. They even ranked the sites differently (Spearman correlation 0.44), so "which site is better" depends on the grader too.
| What changed between two grades | Sites with a different letter |
|---|---|
| Weighting only, any of the three (desktop) | 182 of 231 (79 %) |
| Equal vs SEO-led | 100 of 231 (43 %) |
| Equal vs speed-led | 147 of 231 (64 %) |
| SEO-led vs speed-led | 170 of 231 (74 %) |
| Device only, equal weights | 67 of 231 (29 %) |
| Device only, speed-led weights | 78 of 231 (34 %) |
Across all six setups (three weightings on two devices), only 29 sites (13 %) kept one letter. For 121 sites (52 %), the best and worst letters were two or more grades apart, such as B and D.
Speed was the least stable part. LCP missed Google's 2.5 s line on 147 desktop loads (64 %) and 191 throttled mobile loads (83 %), partly because distant servers look slow from Dhaka. Removing the LCP check didn't change the finding: 184 of 231 (80 %) still changed letter with the weighting.
The same page changes grade between runs, too
A grade with speed checks in it can change between runs of an unchanged page. Our script graded example.com four times on 2026-11-19: desktop LCP came in at 3,764 ms, 452 ms, 656 ms and 6,708 ms for the same 2 KB page, so the equal-weight grade went D, C, C, D. Google's Lighthouse scoring guide gives the same advice: treat a performance score as a distribution, not one number.
The 10 Best Website Grader Tools, One by One
BugViso: best for a whole-site grade with fixes
BugViso grades a whole site, not one URL: it crawls 75 to 300 pages per scan, depending on plan, in a real browser and runs 74 checks across 25 audit engines. The report shows an overall score and a separate SEO score, each 0–100 with an A–F grade, plus the points each area lost, so a low grade traces back to findings. Where others go further: the free tools below need no account, while every BugViso scan needs sign-in and only a new account's first report is free.
HubSpot Website Grader: best quick free score for marketers
HubSpot Website Grader is a free, Lighthouse-powered tool that checks 17+ metrics across performance, mobile, SEO and security in under 30 seconds, according to its own page. You enter a website and an email address, and HubSpot uses that information to contact you about its content and products. It suits a fast first look.
PageSpeed Insights: best free speed grade with real-user data
PageSpeed Insights runs Lighthouse for Performance, Accessibility, Best Practices and SEO, and adds 28 days of real-user Core Web Vitals from the Chrome UX Report when a page has enough traffic. Google's PageSpeed Insights documentation puts 90 and above in the good band and below 50 in the poor band. Our page speed test tools comparison shows how much its lab score moves between runs.
Lighthouse in Chrome DevTools: best for staging and logged-in pages
Lighthouse is the open-source engine behind PageSpeed Insights, and its DevTools panel can audit pages behind a login. Its performance score is a weighted blend: Total Blocking Time 30 %, LCP 25 %, CLS 25 %, First Contentful Paint 10 % and Speed Index 10 %.
GTmetrix: best for speed from many locations
GTmetrix runs Lighthouse-based tests in real Chrome and lists 33 test locations, with Seattle as the default in its test form. Location matters: distance from the server adds to every load, as our Dhaka numbers show. A free account needs no credit card; paid plans start with Lite (50 on-demand tests a month, 5 locations).
Seobility SEO Checker: best free on-page SEO grade
Seobility's free SEO Checker grades one URL as a percentage, with 80 % and above labelled a strong SEO foundation and under 30 % critical. It covers meta information, page quality, link structure, server configuration and external factors, over 200 factors by its own count. The free Basic plan allows 5 checks a day and one project crawled up to 100 pages; Premium costs €59.90 a month.
LocaliQ Website Grader: best for local businesses
LocaliQ's tool scores Website Quality, Social and Local Presence, and Digital Advertising on 0–100 scales built from about 20 weighted metrics. It is free with no credit card, and a free account unlocks the detailed report. Pick it for "how does this local business look online", not "what is broken".
Mozilla HTTP Observatory: best security grade with a published formula
The HTTP Observatory on MDN starts every site at 100, subtracts penalties, adds bonuses only from 90 up, and maps the result to grades from A+ (100+) down to F (0–24). The scoring table is public, so you can see exactly why you lost points. It covers HTTP headers and related security settings only.
Security Headers: best one-glance header grade
Security Headers grades a URL's HTTP response headers from A+ to F, and its homepage counts over 400 million scans. Use it to confirm a deploy kept Strict-Transport-Security and Content-Security-Policy. In our sample, 157 of 231 homepages (68 %) sent no CSP header. The website scan tool guide covers what header checks miss.
Qualys SSL Labs: best for grading HTTPS and TLS
SSL Labs' SSL Server Test is a free service that scores a server's TLS setup from 0 to 100 and maps it to letters, with A from 80. Its rating guide weights protocol support 30 %, key exchange 30 % and cipher strength 40 %. Run it after certificate or CDN changes; it says nothing about SEO or speed.
How to Choose a Website Grader
Choose by the decision the grade will drive, then check which checks and weights produce it.
- "Is my site in decent shape?" Start with HubSpot or PageSpeed Insights and read the sub-scores, not the headline.
- "Is my site secure?" Use the Observatory, Security Headers and SSL Labs together: they grade different layers.
- "Which pages need work, and what is the fix?" Use a multi-page tool that lists findings per page, such as BugViso.
- "Is the grade comparable over time?" Keep the same tool, device and location. Our data shows that changing any of them moves the letter.
For what the number itself means, see what a good website health score is.
Run It Yourself: A Grader That Shows Its Working
This script grades one URL with 18 pass/fail checks on desktop and throttled mobile, then prints the grade under all three weightings. It is the script behind our study, trimmed to one site, and needs Python 3.10+ and Playwright.
#!/usr/bin/env python3
"""Website grader you can read: 18 pass/fail checks in real Chromium, desktop and mobile,
scored three ways so you can see how much the grade depends on the weighting.
Usage: python3 website_grader.py https://example.com
Needs: pip install playwright && playwright install chromium
"""
from __future__ import annotations
import asyncio
import sys
from playwright.async_api import async_playwright
# Lighthouse's mobile preset: 150 ms RTT, 1.6 Mbps down, 750 Kbps up, 4x CPU slowdown.
MOBILE_NET = {"offline": False, "latency": 150, "downloadThroughput": 1_600_000 / 8,
"uploadThroughput": 750_000 / 8}
CATEGORY = {"perf": ["lcp", "cls", "weight", "requests"],
"seo": ["title", "description", "one_h1", "canonical", "lang", "indexable"],
"mobile_a11y": ["viewport", "img_alt", "no_overflow"],
"security": ["https", "hsts", "csp", "nosniff", "no_mixed"]}
WEIGHTS = {"equal": {"perf": 25, "seo": 25, "mobile_a11y": 25, "security": 25},
"seo_led": {"perf": 20, "seo": 50, "mobile_a11y": 15, "security": 15},
"speed_led": {"perf": 60, "seo": 15, "mobile_a11y": 15, "security": 10}}
OBSERVE = """
window.__lcp = 0; window.__cls = 0;
new PerformanceObserver(l => { for (const e of l.getEntries()) window.__lcp = e.startTime; })
.observe({type: 'largest-contentful-paint', buffered: true});
new PerformanceObserver(l => { for (const e of l.getEntries()) if (!e.hadRecentInput) window.__cls += e.value; })
.observe({type: 'layout-shift', buffered: true});
"""
DOM = """() => {
const m = n => document.querySelector(`meta[name="${n}" i]`)?.content || '';
return {
lcp: window.__lcp, cls: window.__cls,
title: document.title.trim().length,
description: m('description').trim().length,
h1: document.querySelectorAll('h1').length,
canonical: !!document.querySelector('link[rel="canonical"]'),
lang: !!document.documentElement.lang,
robots: m('robots').toLowerCase(),
viewport: !!m('viewport'),
img_no_alt: [...document.images].filter(i => !i.hasAttribute('alt')).length,
overflow: document.documentElement.scrollWidth > window.innerWidth + 1,
};
}"""
async def visit(browser, pw, url: str, device: str) -> dict:
opts = pw.devices["Pixel 7"] if device == "mobile" else {"viewport": {"width": 1350, "height": 940}}
ctx = await browser.new_context(**opts, ignore_https_errors=True)
page = await ctx.new_page()
await page.add_init_script(OBSERVE)
cdp = await ctx.new_cdp_session(page)
await cdp.send("Network.enable")
if device == "mobile":
await cdp.send("Network.emulateNetworkConditions", MOBILE_NET)
await cdp.send("Emulation.setCPUThrottlingRate", {"rate": 4})
stats = {"bytes": 0, "requests": 0, "http": 0}
def done(e):
stats["bytes"] += e.get("encodedDataLength", 0)
def req(r):
stats["requests"] += 1
stats["http"] += r.url.startswith("http://") and not r.is_navigation_request()
cdp.on("Network.loadingFinished", done)
page.on("request", req)
doc = {} # last main-document response, kept even when the load event times out
page.on("response", lambda r: doc.update(r=r) if r.request.is_navigation_request() and r.frame == page.main_frame else None)
try:
resp = await page.goto(url, wait_until="load", timeout=60_000)
except Exception as exc: # a timed-out load is still graded on what arrived
if "Timeout" not in type(exc).__name__ and "Timeout" not in str(exc):
await ctx.close()
return {"error": str(exc).splitlines()[0][:120]}
resp = None
await page.wait_for_timeout(3000) # let LCP and late layout shifts land
d = await page.evaluate(DOM)
headers = (await doc["r"].all_headers()) if doc else {}
final = page.url
await ctx.close()
checks = {
"lcp": 0 < d["lcp"] <= 2500, "cls": d["cls"] <= 0.1,
"weight": stats["bytes"] <= 2_000_000, "requests": stats["requests"] <= 100,
"title": 0 < d["title"] <= 60, "description": d["description"] > 0,
"one_h1": d["h1"] == 1, "canonical": d["canonical"], "lang": d["lang"],
"indexable": "noindex" not in d["robots"] + headers.get("x-robots-tag", "").lower(),
"viewport": d["viewport"], "img_alt": d["img_no_alt"] == 0, "no_overflow": not d["overflow"],
"https": final.startswith("https://"), "hsts": "strict-transport-security" in headers,
"csp": "content-security-policy" in headers,
"nosniff": headers.get("x-content-type-options", "").lower() == "nosniff",
"no_mixed": final.startswith("https://") and stats["http"] == 0,
}
raw = {"lcp_ms": round(d["lcp"]), "cls": round(d["cls"], 3), "bytes": stats["bytes"],
"requests": stats["requests"], "loaded": resp is not None}
return {"checks": checks, "raw": raw}
def score(checks: dict, weights: dict) -> float:
return sum(w * sum(checks[c] for c in CATEGORY[cat]) / len(CATEGORY[cat])
for cat, w in weights.items()) * 100 / sum(weights.values())
def letter(s: float) -> str:
return "A" if s >= 90 else "B" if s >= 80 else "C" if s >= 70 else "D" if s >= 60 else "F"
assert letter(90) == "A" and letter(89.9) == "B" and letter(59.9) == "F"
async def main() -> None:
url = sys.argv[1] if "://" in sys.argv[1] else f"https://{sys.argv[1]}"
async with async_playwright() as pw:
browser = await pw.chromium.launch()
for dev in ("desktop", "mobile"):
r = await visit(browser, pw, url, dev)
if "error" in r:
print(dev, "error:", r["error"])
continue
print(f"\n{dev.upper()} {r['raw']}")
for cat, names in CATEGORY.items():
print(f" {cat:12}", " ".join(f"{n}={'ok' if r['checks'][n] else 'FAIL'}" for n in names))
for name, w in WEIGHTS.items():
s = score(r["checks"], w)
print(f" grade ({name:9}): {s:5.1f} {letter(s)}")
await browser.close()
if __name__ == "__main__":
asyncio.run(main())The desktop half of our fourth example.com run, unedited:
DESKTOP {'lcp_ms': 6708, 'cls': 0, 'bytes': 2026, 'requests': 2, 'loaded': True}
perf lcp=FAIL cls=ok weight=ok requests=ok
seo title=ok description=FAIL one_h1=FAIL canonical=FAIL lang=ok indexable=ok
mobile_a11y viewport=ok img_alt=ok no_overflow=ok
security https=ok hsts=FAIL csp=FAIL nosniff=FAIL no_mixed=ok
grade (equal ): 66.2 D
grade (seo_led ): 61.0 D
grade (speed_led): 71.5 CChange WEIGHTS to match what you care about. If the letter flips when you move 10 points between categories, the failed checks are the useful part, not the grade.
How BugViso Turns a Grade Into a Fix List
BugViso's score starts at 100 and subtracts points for each finding, capped per category so one bad signal can't sink the grade, and the report shows how many points each area lost. That is the idea behind the script above, scaled to 74 checks and every crawled page.
The checks cover Core Web Vitals (CrUX field data when Google has it, lab otherwise), technical SEO and structured data, axe-core WCAG 2.0, 2.1 and 2.2 A and AA, security headers and TLS, mobile layout on emulated iPhone 16 Pro and Pixel 9, broken links, console errors and AI search readiness. Each finding gets an AI-written fix in a ranked list, and the PDF can be white-labelled on agency plans. The site crawl and white-label reports page shows the report.
Frequently Asked Questions
What is a good website grader score?
There is no universal good score, because every tool uses its own checks and weights. On a 0–100 scale, 80 and above is usually treated as good and 90 and above as excellent. In our study the median desktop score was 72.1 with equal weights, and only 60 of 231 sites (26 %) reached B or better.
Are website graders accurate?
Website graders are accurate about the individual checks they run, such as a missing title or security header, but the overall grade is a judgement call. In our test, 182 of 231 sites (79 %) got a different letter just from changing the weights. Trust the list of failed checks more than the letter.
What does a website grader check?
Most check four areas: page speed (Core Web Vitals such as LCP and CLS, against Google's thresholds of 2.5 s and 0.1), SEO basics (title, meta description, headings, canonical), mobile readiness (viewport, layout) and security (HTTPS and headers). Specialist tools go deeper on one area, such as SSL Labs for TLS.
Is HubSpot Website Grader free?
Yes. HubSpot Website Grader is free and powered by Google Lighthouse, but it asks for your email address along with the website, and HubSpot uses that information to contact you about its content and products. It suits a quick first look, then you need a tool that lists fixes.
Is there a free website grader for SEO and speed?
Yes. PageSpeed Insights grades speed and SEO for free, with Lighthouse's Performance and SEO categories in one report. HubSpot Website Grader also covers both, and Seobility's free checker goes deeper on SEO with 5 checks a day.
The Grade Is a Summary: Read the Failed Checks
A grade is only as useful as the checks behind its letter, and our 231-site test showed the letter shifts with weighting, device and even the run. Pick the tool that matches your question, keep the setup the same between runs, and act on the failed checks rather than the grade, which is what a BugViso site audit lists for every page it crawls.
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.