SEO Checker: 14 Checks and What 237 Homepages Failed

An SEO checker tests titles, meta tags, H1s, canonicals and sitemaps. We ran 14 checks on 237 homepages: only 13 passed all and 40.5% failed five or more.

· BugViso Team

18 min read

An SEO checker fetches a page and tests the signals search engines read first: the title, meta description, H1, canonical, robots directives, structured data, image alt text, robots.txt and sitemap. We ran the same 14 checks on 237 real homepages. Only 13 (5.5 %) passed all of them, and 96 (40.5 %) failed five or more.

The checks are the easy part. The hard part is knowing which failures cost you rankings and which are noise, and spotting when the checker itself is wrong. By the end of this page you will know what each check means, which fixes to do first, why a raw-HTML checker misreads JavaScript sites, and you will have a 100-line script that runs all 14 checks on any URL.

Data used: 420 domains drawn at random (seed 20261003) from ranks 1,001–50,000 of the Tranco top-sites list 947V2, fetched on 2026-11-16 with Python httpx 0.28.1 and a declared research user agent. 237 returned a 200 HTML homepage and form the sample. Homepages with no H1 or under 100 words were re-checked in headless Chromium 136 (Playwright) with a 3 s settle time. Sites are not named.

What an SEO Checker Actually Tests

An SEO checker reads the HTML your server sends and compares it with a list of rules. Most free checkers run some version of the 14 checks below. They are the same checks this study used and the script further down runs.

CheckPass conditionWhy it matters
HTTPSFinal URL is https:// after redirectsBrowsers flag plain HTTP as "Not secure"
TitleOne <title>, 30–60 charactersThe main source of the blue link in results
Meta description70–160 charactersOften used as the snippet under the link
H1Exactly one <h1>Tells readers and crawlers what the page is about
Canonicalrel="canonical" points to the page itselfPicks the URL that gets the ranking signals
IndexableNo noindex in meta robots or X-Robots-Tagnoindex removes the page from results
lang<html lang="…"> setLanguage for screen readers and search engines
Viewport<meta name="viewport"> presentWithout it, phones render a zoomed-out desktop page
Open Graphog:title and og:imageControls the preview card when the link is shared
Structured dataAt least one JSON-LD blockFeeds rich results and entity understanding
Image altEvery <img> has an alt attributeAccessibility, and image search context
robots.txt/robots.txt returns 200Crawl rules live here (RFC 9309)
Sitemap lineSitemap: declared in robots.txtLets every crawler find the sitemap
Raw HTML text100+ words before JavaScript runsShows whether content needs rendering

The 30–60 and 70–160 character ranges are conventions, not Google rules. Google's documentation says there is no limit on the length of a <title> element, and the title link is truncated as needed to fit the device width. It says the same about meta descriptions in its snippet guidelines. Keep that in mind when a checker turns a long title red.

What 237 Homepages Failed on a 14-Point SEO Check

The median homepage failed 4 of the 14 checks, and structured data, Open Graph and sitemap declarations were missing most often. Every percentage below uses the 237 homepages that returned HTML as the denominator.

FindingHomepagesShare
No JSON-LD structured data12854.0 %
Missing og:title or og:image11548.5 %
No Sitemap: line in robots.txt9941.8 %
No canonical tag8937.6 %
No H1 in the raw HTML8033.8 %
Title under 30 characters7330.8 %
Neither a Sitemap: line nor /sitemap.xml7029.5 %
Meta description over 160 characters6125.7 %
Title over 60 characters5924.9 %
At least one image with no alt attribute5724.1 %
Meta description missing4217.7 %
Under 100 words of text in the raw HTML3916.5 %
No lang attribute3414.3 %
More than one H13012.7 %
No robots.txt3012.7 %
More than one <title> element208.4 %
No viewport meta tag187.6 %
Title missing73.0 %
Not on HTTPS after redirects62.5 %
noindex on the homepage41.7 %

Across the 206 homepages that had images, 834 of 10,036 <img> tags (8.3 %) had no alt attribute at all. The median homepage weighed 115.5 KB of HTML and took 2.42 s to arrive, including a median of one redirect.

The spread is wide. 13 homepages passed all 14 checks, 31 failed one, and 22 failed eight. These are sites in the top 50,000 of the web, so a failed check is clearly not the same as a site that can't rank.

💡 Rule of thumb: a checker score measures how many conventions a page follows. It doesn't measure rankings. Read the failures, not the score.

Which SEO Checker Failures Matter and Which Are Noise

Fix anything that stops a page being indexed first, then anything that changes what Google shows in results, then everything else. The tiers below sort the 14 checks by how much damage a failure can do, with the share of our sample that hit each one.

TierFailureShare of sampleWhat it costs
P0noindex on a page you want ranked1.7 %The page leaves Google entirely
P0Canonical points to another URL4.2 %Signals go to the other URL
P0Title missing3.0 %Google writes its own title link
P0Not on HTTPS2.5 %"Not secure" warning, lost trust
P1No H1 after renderingsee next sectionWeak topic signal for readers and crawlers
P1Meta description missing17.7 %Google picks a snippet from the page text
P1No sitemap declared or found29.5 %New pages are found later
P1No viewport or no lang7.6 % / 14.3 %Broken mobile layout; wrong language signals
P2Title or description outside the length ranges24.9–30.8 %Truncation or a thin snippet, not a penalty
P2More than one H112.7 %Usually harmless if the main H1 is clear
P2No Open Graph or JSON-LD48.5 % / 54.0 %Worse share cards, no rich results

P0 failures are rare but serious. A homepage with noindex or a canonical pointing elsewhere is asking Google not to rank it. Google's guide to blocking indexing is explicit: with noindex, Google drops the page from results even if other sites link to it. If a checker finds either on a page you care about, stop and fix it today.

P1 failures change how you appear. A missing meta description doesn't hide the page, but Google has to build a snippet from whatever text it finds. Our guide to writing title tags covers how to make the title and snippet earn the click once the page ranks.

P2 failures are conventions. A 67-character title will be cut off on some screens, and that is the whole cost. Spend an hour on P0 and P1 before you spend a minute shortening titles.

Why a Raw-HTML SEO Checker Gets JavaScript Sites Wrong

Most free SEO checkers read only the HTML the server sends, so on sites that build content with JavaScript they report missing H1s and thin pages that Google may see perfectly well after rendering. Google itself processes JavaScript pages in three phases: crawling, rendering and indexing. A raw-HTML checker stops after the first.

We measured how often that causes a false alarm. Every homepage that failed the H1 check or the 100-word check in raw HTML went back through headless Chromium. 84 of the 89 rendered successfully.

Raw-HTML failureRe-checked in ChromiumFixed by renderingStill failing
No H17611 (14.5 %)65 (85.5 %)
Under 100 words368 (22.2 %)28 (77.8 %)

Two things follow. First, roughly one in seven "no H1" results from a raw-HTML checker was a JavaScript H1 that the checker never saw. Second, most of the missing H1s were real: 65 homepages had no H1 even after rendering. Many sites put the brand in a logo image and never write a heading.

The thin pages were the more interesting group. When we looked at what Chromium actually showed for the 28 that stayed under 100 words, many were not homepages in any useful sense: login screens, "verifying you are not a robot" walls, "page not found" errors and certificate notices. An SEO checker that reports "thin content" on those is technically right and practically useless. The real finding is that the server shows visitors a login or a bot check instead of a page.

Bot protection also blocks the checker itself. Of the 336 domains that answered HTTP at all, 73 (21.7 %) returned 403 Forbidden to our declared research user agent before any check could run. A free checker on those sites shows an error or an empty report, even when Googlebot is let through. If your report is blank, test whether your firewall is blocking the tool before you trust the result. The JavaScript SEO guide for single-page apps explains how to check what Googlebot gets.

How to Fix the Failures an SEO Checker Finds

Most checker failures are one-line fixes in the <head> or in robots.txt. These are the patterns behind the most common failures in the sample.

A missing description, a missing canonical and no Open Graph tags usually travel together:

html
<!-- ❌ Broken: no description, no canonical, no share card -->
<head>
  <title>Home</title>
</head>
html
<!-- ✅ Fixed: a real title, a snippet, a self-canonical and Open Graph -->
<head>
  <title>Acme Payroll: Run Payroll for Teams of 5 to 500</title>
  <meta name="description" content="Acme runs payroll, tax filing and benefits for teams of 5 to 500 in 12 countries. See pricing and book a 20-minute demo.">
  <link rel="canonical" href="https://www.acme-payroll.example/">
  <meta property="og:title" content="Acme Payroll: Run Payroll for Teams of 5 to 500">
  <meta property="og:image" content="https://www.acme-payroll.example/og/home.png">
</head>

The canonical must be the exact URL you want ranked: the same protocol, host and trailing-slash form that your redirects end on. A canonical that disagrees with your own redirect was the 4.2 % P0 failure in the table.

The sitemap fix is one line in robots.txt, and it covered 41.8 % of the sample:

text
# ❌ Broken: crawlers must guess where the sitemap is
User-agent: *
Disallow: /cart/
text
# ✅ Fixed: every crawler that reads robots.txt finds it
User-agent: *
Disallow: /cart/

Sitemap: https://www.acme-payroll.example/sitemap.xml

Google's sitemap documentation lists the Sitemap: line as one way to submit a sitemap, alongside Search Console. The line also reaches Bing and the AI crawlers, which never see your Search Console settings. Our XML sitemap guide covers what belongs inside the file.

For the H1, make the main heading real text in the HTML, not a logo image or a heading injected after load:

html
<!-- ❌ Broken: the only "heading" is an image -->
<a href="/"><img src="/logo.svg"></a>

<!-- ✅ Fixed: the logo keeps alt text, and the page gets a real H1 -->
<a href="/"><img src="/logo.svg" alt="Acme Payroll home"></a>
<h1>Payroll for teams of 5 to 500</h1>

Run It Yourself: A Free SEO Checker Script

The script below runs the same 14 checks on any URL with the Python standard library and nothing to install. It reads the raw HTML, so it shares the blind spot described above: run it on a JavaScript-heavy site and treat a missing H1 or thin text as "check after rendering", not as a verdict.

python
#!/usr/bin/env python3
"""SEO checker: 14 raw-HTML checks on one page, plus robots.txt.

Usage: python3 seo_checker.py https://example.com
Standard library only. Reads the HTML the server sends (no JavaScript).
"""
import re
import sys
import urllib.request
from html.parser import HTMLParser
from urllib.parse import urljoin, urlparse

UA = "Mozilla/5.0 (compatible; SEOCheck/1.0)"


def fetch(url):
    req = urllib.request.Request(url, headers={"User-Agent": UA})
    with urllib.request.urlopen(req, timeout=15) as r:
        return r.geturl(), dict(r.headers), r.read().decode("utf-8", "replace")


class Page(HTMLParser):
    def __init__(self):
        super().__init__(convert_charrefs=True)
        self.title, self.titles, self.in_title = "", 0, False
        self.meta, self.links, self.text = {}, [], []
        self.h1 = self.imgs = self.no_alt = self.jsonld = self.skip = 0
        self.lang = None

    def handle_starttag(self, tag, attrs):
        a = {k.lower(): v or "" for k, v in attrs}
        if tag == "html":
            self.lang = a.get("lang")
        elif tag == "title":
            self.titles += 1
            self.in_title = True
        elif tag == "meta":
            key = (a.get("name") or a.get("property") or "").lower()
            self.meta.setdefault(key, a.get("content", ""))
        elif tag == "link":
            self.links.append(a)
        elif tag == "h1":
            self.h1 += 1
        elif tag == "img":
            self.imgs += 1
            self.no_alt += "alt" not in a
        elif tag in ("script", "style", "noscript", "template"):
            self.skip += 1
            self.jsonld += "ld+json" in a.get("type", "").lower()

    def handle_endtag(self, tag):
        if tag == "title":
            self.in_title = False
        elif tag in ("script", "style", "noscript", "template") and self.skip:
            self.skip -= 1

    def handle_data(self, data):
        if self.in_title and self.titles == 1:
            self.title += data
        elif not self.skip:
            self.text.append(data)


def main(url):
    try:
        final, headers, html = fetch(url)
    except Exception as e:  # 403 bot wall, TLS error, timeout
        sys.exit(f"Could not fetch {url}: {e}")
    p = Page()
    p.feed(html)
    title = " ".join(p.title.split())
    desc = " ".join(p.meta.get("description", "").split())
    canon = next((l.get("href") for l in p.links
                  if "canonical" in l.get("rel", "").lower().split()), None)
    same = lambda u: urlparse(u).netloc.removeprefix("www.") + urlparse(u).path.rstrip("/")
    robots_meta = (p.meta.get("robots", "") + headers.get("X-Robots-Tag", "")).lower()
    words = len(re.findall(r"\w+", " ".join(p.text)))
    base = f"{urlparse(final).scheme}://{urlparse(final).netloc}"
    try:
        robots_txt = fetch(base + "/robots.txt")[2]
    except Exception:
        robots_txt = None

    checks = [
        ("HTTPS", final.startswith("https://")),
        (f"Title 30-60 chars ({len(title)})", 30 <= len(title) <= 60),
        (f"Meta description 70-160 chars ({len(desc)})", 70 <= len(desc) <= 160),
        (f"Exactly one H1 ({p.h1})", p.h1 == 1),
        ("Self-referencing canonical", bool(canon) and same(urljoin(final, canon)) == same(final)),
        ("Indexable (no noindex)", "noindex" not in robots_meta),
        ("lang attribute on <html>", bool(p.lang)),
        ("Viewport meta tag", "viewport" in p.meta),
        ("og:title and og:image", "og:title" in p.meta and "og:image" in p.meta),
        (f"JSON-LD structured data ({p.jsonld} blocks)", p.jsonld > 0),
        (f"Every <img> has alt ({p.no_alt} of {p.imgs} missing)", p.no_alt == 0),
        ("robots.txt reachable", robots_txt is not None),
        ("Sitemap: line in robots.txt",
         bool(robots_txt and re.search(r"(?im)^\s*sitemap\s*:", robots_txt))),
        (f"100+ words in raw HTML ({words})", words >= 100),
    ]
    print(final)
    for label, ok in checks:
        print(f"  {'PASS' if ok else 'FAIL'}  {label}")
    print(f"{sum(ok for _, ok in checks)}/14 passed")


if __name__ == "__main__":
    main(sys.argv[1])

This is the real, unedited output for python.org on 2026-11-16. It's a site with enormous authority, and it fails five checks:

bash
$ python3 seo_checker.py https://www.python.org
https://www.python.org
  PASS  HTTPS
  FAIL  Title 30-60 chars (21)
  FAIL  Meta description 70-160 chars (52)
  FAIL  Exactly one H1 (5)
  FAIL  Self-referencing canonical
  PASS  Indexable (no noindex)
  PASS  lang attribute on <html>
  PASS  Viewport meta tag
  PASS  og:title and og:image
  PASS  JSON-LD structured data (1 blocks)
  PASS  Every <img> has alt (0 of 1 missing)
  PASS  robots.txt reachable
  FAIL  Sitemap: line in robots.txt
  PASS  100+ words in raw HTML (1027)
9/14 passed

All five are P1 or P2 conventions, and none blocks indexing. That's the right way to read any SEO checker: triage the failures by tier, and ignore the score.

How BugViso Runs These SEO Checks Across a Whole Site

BugViso runs these checks in a real browser on every crawled page, so JavaScript-built titles, H1s and links are checked after rendering, not guessed from raw HTML. The audit loads the site in Playwright, seeds the crawl from the sitemap and rendered links, and checks titles, meta descriptions, Open Graph, headings, canonicals, hreflang, structured data and image SEO on each page. That's the same list as the script above, without the raw-HTML blind spot.

Each scan runs 25 audit engines and 74 checks, covering Core Web Vitals, accessibility (axe-core WCAG 2.2 A and AA), security headers and AI search readiness as well as SEO. Findings come back as a 0–100 score and a ranked fix list, with AI-written fixes (rewritten titles, meta descriptions and JSON-LD) in the PDF. The SEO checks in BugViso's audit list every rule and what triggers it.

Limits of This SEO Checker Study

The sample covers homepages of popular sites, checked once, mostly as raw HTML. Treat the numbers as a snapshot of common practice, not as a benchmark for your site.

  • Homepages only. Inner pages usually do worse on titles and descriptions, because templates fill them in automatically.
  • One fetch, one user agent. Sites that blocked our user agent (73 with a 403) or didn't answer (84) are not in the 237. Sites with strict bot protection may differ systematically from the rest.
  • Raw HTML first. Only the 89 homepages that failed the H1 or word-count check were rendered. Checks such as JSON-LD and canonical were not re-tested after JavaScript, so sites that inject them client-side count as failures here.
  • Shadow DOM is invisible to both passes. Headings inside web components' shadow roots were not counted.
  • Conventions, not ranking factors. The 30–60 and 70–160 character ranges come from typical display widths. Google sets no limit on either.

Frequently Asked Questions

What is an SEO checker?

An SEO checker is a tool that fetches a web page and tests it against common search engine optimisation rules: whether it has a title and meta description, one H1, a canonical tag, no noindex, structured data, image alt text, a robots.txt file and a sitemap. It reports each check as a pass or a fail, often with an overall score.

Is a free SEO checker accurate?

A free SEO checker is accurate about what it can see, which is usually only the raw HTML. In our test, 14.5 % of homepages reported with no H1 did have one after JavaScript ran, and 21.7 % of responding sites blocked the checker with a 403. Confirm surprising results in a rendering tool before acting on them.

What is a good SEO score?

No SEO score is a Google metric, so "good" depends on the tool. Use it as a to-do list instead: a page with zero P0 failures (no noindex, correct canonical, a title, HTTPS) is in good shape even if conventions like title length pull the score down. In our sample, the median homepage failed 4 of 14 checks.

Does title length affect SEO rankings?

Google's documentation says there is no limit on how long a title element can be. Long titles are truncated in results to fit the device width. Title length changes how much of your title people see, which can affect clicks, but there is no documented penalty for a long title.

How often should I run an SEO checker on my website?

Run one after every release that touches templates, and at least once a month otherwise. Most P0 failures, such as a stray noindex or a wrong canonical, arrive with a deploy, not over time. Regular checks catch them before Google recrawls the page.

Why does my SEO checker say my page has no H1?

Either the page really has no H1 (in our sample, 65 of 76 homepages still had none after rendering), or the H1 is added by JavaScript and the checker reads only raw HTML. View the page source: if the <h1> isn't there but appears in DevTools, it's JavaScript-rendered.

The One Check to Run Before Trusting Any SEO Checker

Before you act on a checker's report, confirm it saw the same page Google sees: fetched without a 403, rendered where your content needs JavaScript, and indexable. Once that's settled, fix P0 failures the same day and leave the conventions for later. A BugViso audit runs the same checks after rendering every crawled page, so it settles the first question for you.

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.