The SEO & GEO audit checklist

How to use this

You don't need to be technical to get through this. Every item below is explained in plain language, with a free tool to check it, no agency jargon assumed. Go through each section against your own site. Anything you can't check off in a couple of minutes, write it down and move on, don't stop to fix it mid-audit. Fix everything after you've seen the full picture, so you're prioritizing against the whole list instead of whichever issue you happened to find first. Check items off as you go, your progress is saved in this browser, so you can leave and pick up where you stopped.

1. Crawlability & indexing

This category is just: can Google (and the AI systems that now answer buyer questions) actually find and read your pages? If they can't, nothing else on this list matters, a beautifully written page nobody can reach doesn't rank or get cited.

• robots.txt is a small text file at yoursite.com/robots.txt that tells crawlers which pages they're allowed to visit. Open that URL and check it loads, and that it isn't accidentally telling Google to skip pages you actually want found.
• An XML sitemap is a list of your pages you hand directly to Google, at a URL like yoursite.com/sitemap.xml. Check it exists, and that robots.txt points to it.
• A canonical tag is a line of code on each page saying "this is the real, official version of this page." Every important page should have its own, pointing to itself, not to a different page.
• noindex is an instruction that tells Google not to show a page in search results at all. Make sure it isn't sitting on a page you actually want found, that's usually a mistake from a redesign or a CMS default, not an intentional choice.
• Click through your own main navigation and a sample of internal links. None should lead to a broken "page not found" (404).
• A redirect sends visitors from an old URL to a new one. One redirect is fine; a chain of three or four stacked on top of each other slows things down and can confuse crawlers.
• Right-click any key page and choose "View Page Source." Your main heading and body text should be visible in that raw code, not just empty placeholders that only fill in after the page finishes loading. Some crawlers don't wait around for that.

2. Core Web Vitals & performance

This category is about page speed, and about how stable the page feels while it loads, does text jump around, does a click register right away. Google measures three specific numbers, taken from real visitors' browsers, not a lab test:

• Largest Contentful Paint (LCP): how long the biggest visible thing on the page, usually a hero image or headline, takes to actually appear. Aim for under 2.5 seconds.
• Interaction to Next Paint (INP): how quickly the page responds when someone clicks or taps something. Aim for under 200 milliseconds, fast enough that it feels instant.
• Cumulative Layout Shift (CLS): how much the page visually jumps around while it loads, like an image popping in late and shoving the text you were about to read further down. Aim for under 0.1.
• Nothing should be forcing the browser to wait before showing content, things like fonts or scripts loaded from another site before anything on the page appears.
• Images should have their dimensions set in the code so the browser reserves space for them before they load, that's what stops the layout jumping around.
• Files that don't change often (your styling, scripts, fonts, images) should be set up so a returning visitor's browser doesn't have to re-download them every time.

3. Structured data

Structured data (people also call it "schema markup") is a hidden block of code on a page that spells out, in a format a machine can read directly, exactly what that page is: a product, an article, a local business, a person. Without it, Google and AI systems have to guess that from your words alone.

• The structured data on each page needs to be written correctly (valid JSON-LD is the usual format), one stray character breaks the whole block.
• The type of schema should match what's actually on the page: don't label a pricing page as a blog "Article," or vice versa.
• Any dates in the schema (like when a page was published or last updated) should be real dates, not the same placeholder date copy-pasted onto every page.
• No leftover placeholder text, like an unfilled [Business Name] that never got replaced with the real one.
• Somewhere on the site, there should be schema identifying you or your company as an entity, this is what lets Google and AI systems connect your different pages to the same real business.

4. Content & on-page

This is the part most people think of as "SEO": the actual words on the page, and the handful of settings that control how it shows up in search results.

• The title tag and meta description are the blue headline and grey snippet Google shows for your page in search results. Every page should have its own, none should be sharing the same generic text.
• Every page should have exactly one main heading (an <h1>), with the headings underneath it in a logical order, not jumping from a top-level heading straight to a small subheading.
• Every image should have a short, honest description in its alt text, not a wall of keywords stuffed in to try to rank.
• The page should say more, and say it better, than the thinnest competing page currently ranking for the same search, not be padded out to hit a word count.
• No two pages on the site should be saying substantially the same thing in substantially the same words.
• Claims should be specific, a real number, a named source, an actual example, rather than a generic adjective like "leading" or "innovative."

5. AI visibility (GEO)

The newest category, and the one most checklists still skip entirely: whether ChatGPT, Perplexity, and Google's AI Overviews can find you, trust you, and actually mention you when a buyer asks a relevant question.

• Names like GPTBot, ClaudeBot, PerplexityBot, Google-Extended, and OAI-SearchBot are simply the crawlers different AI companies use to read your site for their AI products. Check your robots.txt isn't blocking them, unless you're deliberately choosing to opt out.
• If you sell something, the price should be stated in plain text somewhere on the page, not locked behind a form or a sales call, AI systems generally won't cite what they can't read directly.
• Key pages should carry a real, recent date. AI systems weigh recency when deciding what to trust and cite.
• Important claims should be backed by a specific number or source, not just asserted.
• Actually go ask ChatGPT, Perplexity, and Google a handful of real questions your buyers would ask, and see whether you show up. Don't assume it from your Google ranking position alone, the two have measurably diverged. More on that in what generative engine optimization actually is.

How often to run this

Every three to six months for an active site is the general rhythm, and immediately after any major change: a redesign, a CMS migration, or a sudden, unexplained drop in traffic or rankings. A checklist run once and never revisited catches a moment in time, not an ongoing state.

Bonus: automate the crawl with a free Python script

If you'd rather not click through every page by hand, this short script does the boring part of section 1 and 4 for you: it reads your sitemap, visits every URL, and flags pages with a bad status code, a missing or oversized title tag, a missing meta description, or images with no alt text. You don't need to be a developer to run it, if you can install Python and paste a command into a terminal, this works. Hand it to whoever maintains your site if that's not you.

import requests
from xml.etree import ElementTree
from bs4 import BeautifulSoup

SITEMAP_URL = "https://yourdomain.com/sitemap.xml"

def get_urls(sitemap_url):
    xml = requests.get(sitemap_url, timeout=10).text
    root = ElementTree.fromstring(xml)
    ns = {"sm": "http://www.sitemaps.org/schemas/sitemap/0.9"}
    return [loc.text for loc in root.findall(".//sm:loc", ns)]

def check_page(url):
    issues = []
    try:
        r = requests.get(url, timeout=10)
    except requests.RequestException as e:
        return [f"Could not load page: {e}"]

    if r.status_code != 200:
        issues.append(f"Status code {r.status_code}")

    soup = BeautifulSoup(r.text, "html.parser")

    title = soup.find("title")
    if not title or not title.text.strip():
        issues.append("Missing title tag")
    elif len(title.text) > 60:
        issues.append(f"Title too long ({len(title.text)} chars)")

    meta_desc = soup.find("meta", attrs={"name": "description"})
    if not meta_desc or not meta_desc.get("content", "").strip():
        issues.append("Missing meta description")

    images_missing_alt = [img for img in soup.find_all("img") if not img.get("alt", "").strip()]
    if images_missing_alt:
        issues.append(f"{len(images_missing_alt)} image(s) missing alt text")

    return issues

if __name__ == "__main__":
    urls = get_urls(SITEMAP_URL)
    report_lines = [f"Checking {len(urls)} pages from {SITEMAP_URL}\n"]

    for url in urls:
        issues = check_page(url)
        if issues:
            report_lines.append(url)
            for issue in issues:
                report_lines.append(f"  - {issue}")
        else:
            report_lines.append(f"{url} — OK")

    report_text = "\n".join(report_lines)
    print(report_text)

    with open("seo-report.txt", "w") as f:
        f.write(report_text)
    print("\nSaved to seo-report.txt in this same folder.")

Save the code above into a file named check.py, then edit the SITEMAP_URL line near the top to point at your own site.

• On Mac: open Terminal (search for it with Spotlight, Cmd + Space), navigate to the folder where you saved the file (cd ~/Downloads, for example, if that's where it is), then run pip3 install --user requests beautifulsoup4 followed by python3 check.py. If pip3 refuses with an "externally-managed-environment" error, that --user flag is what fixes it.
• On Windows: install Python from python.org first if you don't already have it, and make sure to tick "Add Python to PATH" during setup. Then open Command Prompt (search "cmd"), navigate to the folder with cd (for example cd Downloads), then run pip install requests beautifulsoup4 followed by python check.py.

It'll print every URL from your sitemap with any issues found underneath it, or "OK" if a page is clean. It's a starting point, not a replacement for Screaming Frog or PageSpeed Insights above, but it's a genuinely free, five-minute way to catch the most common on-page mistakes across an entire site at once.

Core Web Vitals thresholds per Google's official web.dev documentation. Accessed July 29, 2026.