ChatGPT SEO Audit Prompts That Actually Work (2026)

ChatGPT SEO audit prompts are everywhere — Medium posts listing 50 "power prompts," Twitter threads with screenshot bait, listicles that all start with "Act as an SEO expert." And most of them return the same thing: vague, generic suggestions that could apply to any page on the internet. "Optimize your meta description." "Add relevant keywords." "Improve your page speed." Thanks.

The problem isn't ChatGPT. It's the prompts. A language model produces output proportional to the specificity of its input. Feed it a URL and ask for "an SEO audit" and you get a surface-level checklist. Feed it your page's actual source HTML with a constrained output format and you get findings you can fix in the next commit.

I spent three weeks testing prompts against real client pages — tracking which ones returned findings that matched what a crawl-based audit tool would flag. The 12 prompts below are the ones that consistently produced actionable, accurate results. They share a structure: specific input, constrained output format, and a severity filter that eliminates noise.

The Problem With Generic SEO Prompts

Most prompt lists fail for three reasons that have nothing to do with ChatGPT's capabilities:

1. They don't include the actual page content. Asking ChatGPT to "audit example.com/pricing" without pasting the HTML is asking it to guess. Even with browsing enabled, ChatGPT fetches a rendered snapshot — it cannot access server response headers, follow redirect chains, or compare against other pages on the site.

2. They don't constrain the output format. "Audit this page for SEO" invites a rambling essay. "Return a table with columns: Issue, Severity (Critical/High/Medium/Low), Current State, Fix Code" forces structured output you can paste into a ticket.

3. They ask for everything at once. A single prompt asking for "all SEO issues" hits context-length limits and produces shallow coverage across too many areas. A focused prompt asking only about heading hierarchy and content structure goes deeper on one layer and actually catches things.

Cyrus Shepard's 2024 research on content quality signals found that pages ranking in the top 3 share specific structural patterns — proper heading hierarchy, sufficient depth per section, and clear topical focus. Generic "audit this" prompts never check for those specific patterns because they're not told to look for them. The prompts below are told exactly what to look for.

Prompt Type	Typical Generic Version	What It Returns	Structured Version (below)	What It Returns
Meta tags	"Check my meta tags"	"Your title could be more engaging"	HTML input + table format + character counts	Exact character counts, truncation risk, rewritten tags
Content quality	"Improve my content for SEO"	"Add more keywords naturally"	HTML input + heading extraction + word-per-section counts	Thin sections identified by word count, specific expansion suggestions
Schema markup	"Check my structured data"	"Add schema markup to your page"	HTML input + schema type recommendations with JSON-LD output	Complete JSON-LD blocks ready to paste
Internal links	"Analyze my internal linking"	"Add more internal links"	HTML input + anchor text extraction + orphan detection	Specific anchors flagged, replacement text suggested

Prompts That Extract Actionable Technical Findings

Each prompt below follows the same structure: (1) paste your page's view-source HTML, (2) a specific analysis instruction, (3) a constrained output format. Copy them verbatim — the constraint line at the end is what makes them work.

Prompt 1: Meta Tag Audit With Rewrite

Here is the full HTML source of a page. Analyze the title tag, meta description, and Open Graph tags.

For each element, report:
- Current value and character count
- Whether it will be truncated in Google SERPs (title: 60 chars, description: 155 chars)
- A rewritten version that stays within limits and includes the primary keyword: [YOUR KEYWORD]

Format output as a markdown table. Only flag issues — do not comment on elements that are already correct.

[PASTE YOUR HTML HERE]

This works because it gives ChatGPT the exact character thresholds Google uses (documented in Google Search Central's title link documentation) and a binary decision criterion: truncation risk or not. No room for vague "could be improved" responses.

Prompt 2: Heading Hierarchy and Content Depth

Extract the complete heading hierarchy (H1 through H6) from this HTML source. Then analyze:

1. Is there exactly one H1? If multiple, flag each.
2. Are headings in sequential order (no H2→H4 skips)?
3. For each H2 section: count the words between this H2 and the next H2 (or end of content). Flag any section under 150 words as "thin."
4. Does the H1 contain the primary keyword: [YOUR KEYWORD]?

Output: a numbered heading tree, followed by a table of thin sections with their word counts and suggestions for expansion.

[PASTE YOUR HTML HERE]

The word-count-per-section analysis is where this prompt earns its keep. A page might have 2,000 total words but three H2 sections with only 40 words each — those are the sections Google's helpful content signals penalize for shallow treatment.

Prompt 3: Schema Markup Gap Analysis

Analyze this HTML source for structured data (JSON-LD, Microdata, or RDFa).

1. List all existing structured data types found.
2. Based on the page content, identify which additional schema types should be present but are missing. Reference the Google Search Central documentation on structured data for eligible types.
3. For each missing schema type, generate the complete JSON-LD block I can paste into the page head.

Only recommend schema types that Google actively uses for rich results. Do not suggest types that have no SERP feature benefit.

[PASTE YOUR HTML HERE]

The constraint "only recommend schema types that Google actively uses for rich results" prevents ChatGPT from suggesting obscure schema.org types that look correct but produce no visible benefit. Google's Search Gallery lists the types that actually trigger rich results — this prompt forces alignment with that list.

Prompt 4: Internal Link Anchor Text Analysis

Extract every internal link (same-domain href) from this HTML source. For each link, report:
- The anchor text used
- The destination URL
- Whether the anchor text is generic ("click here," "read more," "learn more," "this article")
- Whether the anchor text describes the destination page's likely topic

Flag all generic anchors. For each flagged link, suggest a descriptive replacement anchor that includes a relevant keyword for the destination page.

Format: markdown table with columns Anchor Text | Destination | Issue | Suggested Replacement

[PASTE YOUR HTML HERE]

Generic anchor text is one of the most common internal linking mistakes — and one of the easiest to fix. This prompt catches every instance in one pass and provides the replacement text.

Prompt 5: Image Optimization Audit

Find every <img> tag in this HTML source. For each image, report:
- Whether it has an alt attribute (empty alt="" counts as present-but-empty for decorative images)
- Whether the alt text is descriptive (more than just the filename repeated)
- Whether width and height attributes are set (prevents CLS)
- Whether it uses loading="lazy" (all images below the fold should)

Flag images missing alt text, images with non-descriptive alt text, and images without explicit dimensions.
Output: markdown table. Only list images with issues, not clean ones.

[PASTE YOUR HTML HERE]

Prompt Chains — Combining Multiple Passes for Full Coverage

A single prompt catches what it is told to look for. Prompt chaining catches what no single prompt would — because findings from one pass inform the next.

Here's the four-pass chain I use on every client page. Each pass takes 30-60 seconds:

Pass 1: Content structure (Prompt 2 above) — establishes heading hierarchy, identifies thin sections, confirms primary keyword placement.

Pass 2: Technical on-page (Prompts 1, 4, and 5 combined) — meta tags, internal links, image optimization. After this pass, you have a complete picture of on-page HTML-level issues.

Pass 3: Schema validation (Prompt 3) — identifies missing structured data based on the content structure established in Pass 1. This ordering matters because schema recommendations depend on understanding what the page content actually covers.

Pass 4: Competitive content gap — this is where prompt chaining shows its real value:

I just analyzed my page about [TOPIC]. The H2 sections cover: [LIST YOUR H2s FROM PASS 1].

Here is the HTML source of a competitor page ranking #1 for [YOUR KEYWORD].
Compare their H2 structure to mine. Identify:
1. Topics they cover that I do not
2. Topics I cover that they do not (my advantages to keep)
3. Sections where they go deeper (more words, more subpoints)

Format: comparison table with columns Topic | My Coverage | Their Coverage | Action Needed

[PASTE COMPETITOR HTML]

This four-pass approach produces a content-layer audit that takes about 4 minutes total and catches issues across structure, meta, links, schema, and competitive gaps. For a complete example of structuring findings into a deliverable report, see our SEO audit report template guide.

What No Prompt Can Fix — The Infrastructure Blind Spots

Every prompt above operates on a single page's HTML source. That is the boundary of what language models can analyze. The following audit dimensions require live HTTP requests, multi-URL crawling, or server-side access — no prompt will ever reach them:

• Redirect chains and loops — require following HTTP 301/302 responses across multiple hops
• Core Web Vitals (LCP, CLS, INP) — require rendering the page in a browser and measuring performance metrics
• Cross-page duplicate content — require comparing HTML across hundreds or thousands of URLs simultaneously
• Crawl budget waste — requires analyzing server logs or running a full-site crawl to see what Googlebot actually requests
• Orphan pages — require mapping the entire internal link graph to find pages with zero inbound links
• SSL/certificate issues — require establishing a real TLS connection to the server

We documented this boundary in detail in our pillar article on whether ChatGPT can do a full SEO audit — where a single page test showed 9 accurate content-layer findings alongside 14 infrastructure issues that no prompt could detect. If you are building a workflow around ChatGPT prompts, understanding where they stop is as important as knowing where they work.

The practical workflow is to use prompts for fast content-layer triage (the 4 minutes above) and then run a crawl-based tool for the infrastructure layer. MendMySEO handles both layers in a single audit — 54 technical checks plus content analysis with paste-ready fix code for each finding.

FAQ

What is the single best ChatGPT prompt for an SEO audit?

There is no single best prompt — that framing is the problem. A single "audit this page" prompt produces shallow results across too many areas. The most effective approach is a four-pass prompt chain (content structure → technical on-page → schema → competitive gap) that goes deep on one layer at a time. If you only have time for one, use Prompt 2 (heading hierarchy and content depth) — it catches the issues most directly tied to ranking.

Do I need to paste HTML or can I just give ChatGPT a URL?

Paste the HTML. When you give ChatGPT a URL (even with browsing enabled), it fetches a rendered snapshot that may differ from what Googlebot sees. View-source HTML gives you the raw document — including meta tags in the head, schema in script blocks, and canonical tags that might not be visible in rendered previews. The accuracy difference is significant.

Can these prompts replace a paid SEO audit tool?

They replace the content-layer portion of a manual review — meta tags, headings, schema, anchor text, image optimization. They cannot replace crawl-based tools for infrastructure issues (speed, redirects, broken links, cross-page duplicates). For a full picture of what AI-powered audit tools cover beyond prompts, see our guide to AI SEO audits.

How often should I re-run these prompts on my pages?

After any content update, after publishing new pages that change your internal link structure, and quarterly as a maintenance check. The prompts are fast enough (4 minutes for a full chain) that there is no reason to skip them. The limitation is that they have no memory — they cannot alert you when something breaks between checks.

Do these prompts work with GPT-4o, GPT-4, or GPT-3.5?

GPT-4o and GPT-4 produce accurate results with these prompts. GPT-3.5 struggles with longer HTML inputs and frequently hallucinates schema properties that do not exist. If you are using GPT-3.5, split the HTML into smaller sections (head only, body only) and run separate passes. The GPT-4o model handles full-page HTML (up to ~60,000 characters) without truncation in most cases.

Want to skip the prompt engineering and get both content-layer and infrastructure findings in a single automated audit? Join the waitlist — MendMySEO runs 54 technical checks, generates fix code for every finding, and verifies your fixes after deployment.