How to Run an SEO Audit With AI: The ChatGPT and Claude Workflow I Actually Use

A year ago, an SEO audit meant me, a giant crawl export, and most of an afternoon squinting at spreadsheets. Now I do the same work in about an hour, and it's more thorough. The trick isn't a magic button — it's a workflow where AI reads, sorts, and drafts, and I decide and verify.

This is the exact way I run an SEO audit with AI in 2026, using ChatGPT and Claude on real audit data — with the copy-paste prompts, the responsibility split that keeps it safe, and the one setup step that lets your assistant pull the data itself instead of guessing from a URL. By the end you'll have a repeatable loop you can run monthly, not a one-off panic.

First, get the expectations right

Every "AI wrecked my SEO" story starts the same way: someone treated the model as an oracle instead of an analyst. AI is genuinely excellent at the high-volume, tedious parts of a technical audit, and genuinely bad at the parts that decide whether your work matters. Hold this split before you write a single prompt.

Rule of thumb: let AI do the reading, sorting, and drafting, then verify every output yourself. Modern AI-assisted audits surface far more than a manual sampling pass ever did — but they also surface noise, so the model hands you a shortlist and you confirm each item is real before anyone touches code.

The stack I actually use

You don't need a new platform for this. My whole setup is three things:

1. A real audit as the data source. Chat models don't crawl your site when you paste a URL — more on that below — so you need actual results: status codes, titles, meta, canonicals, schema, Core Web Vitals. DidYouSEO's free audit runs 30+ checks on any URL in under a minute, and its MCP server lets Claude, ChatGPT, or Cursor run that audit inside the chat and read the structured results directly.
2. A reasoning model — ChatGPT or Claude — for analysis, prioritization, and drafting. I use both and cross-check anything important.
3. Validators — Google's Rich Results Test, a redirect checker, and a robots.txt tester — because nothing the model writes ships unverified.

The one-time setup is connecting the MCP server to your assistant: paste https://didyouseo.com/mcp into its connector settings and sign in. After that, "run a DidYouSEO audit on example.com" pulls real data straight into the chat — no exports, no copy-paste. (New to this? Start with what an AI SEO agent is, or the mechanics of MCP for SEO under the hood.)

How to run an SEO audit with AI, step by step

Step 1: Start with real data, not a pasted URL

This trips people up constantly: pasting a URL into ChatGPT does not crawl your site. The model sees one page's rendered text at best, and often just guesses from what it already "knows" about the domain. So start with ground truth — a full audit — then let AI read it.

Once the audit is in the chat (or exported to a table), ask for a diagnosis before anything clever:

You are a senior technical SEO. I'm giving you the results of a site audit
(status codes, titles, meta, canonicals, indexability, schema, Core Web Vitals).

Summarize the site's technical health in plain English:
1. The 5 most serious issues, by how many URLs each affects.
2. Any patterns (a section of 404s, canonical mismatches, thin pages).
3. Anything that could deindex pages or waste crawl budget.

Cite example URLs. Do NOT suggest fixes yet — just diagnose.

Telling it not to jump to fixes matters. You want a clean diagnosis first, so a critical noindex doesn't get buried under twelve cosmetic alt-text nits.

Step 2: Make AI prioritize by impact and effort

This is where AI earns its keep. Finding issues was never the hard part — deciding which 20 of 500 to fix this sprint was. Make the model score them, then sanity-check it:

Using the same audit data, build a prioritized action plan.

For each distinct issue type, give me a table with:
- Issue
- # of URLs affected
- Impact on rankings/indexing (1–5, one-line reason)
- Effort (1–5)
- Quadrant: Quick Win / Major Project / Nice-to-have / Deprioritize

Sort highest-impact, lowest-effort first. Flag anything that could remove
pages from Google's index as CRITICAL, regardless of effort.

You work that output top-left to bottom-right: quick wins first (unblock crawlers, fix indexable noindex tags, add missing canonicals), major projects next (server-render content, rebuild internal links), and the bottom-right box — high effort, low impact, like chasing a perfect Lighthouse score — is where SEO time goes to die.

Step 3: Let AI draft the tedious fixes

Schema, robots.txt, redirect regex, hreflang clusters — finicky, error-prone, copy-paste work AI drafts brilliantly. The key is constraining the prompt so it can't invent things:

Generate valid schema.org JSON-LD for this page (content pasted below).
- Use the most appropriate type(s): Article, Product, FAQPage, BreadcrumbList.
- Only use facts from the content I give you. NEVER invent ratings, prices, or dates.
- Output one <script type="application/ld+json"> block, ready to paste.
- After it, list properties I should add manually and why.

The same pattern handles robots.txt rewrites and redirect rules. When you're done, check the drafts against the free tools that test exactly these things: the schema validator, the robots.txt tester, and the redirect checker.

Step 4: Validate everything (non-negotiable)

This is the step people skip, and the one that separates "AI saved me hours" from "AI deindexed my blog." Treat every output as a draft from a fast, confident intern who occasionally makes things up:

• Schema → paste into Google's Rich Results Test and a schema markup validator. If it doesn't validate, it doesn't go live.
• Redirects → run the example URLs through a checker; confirm single-hop 301s, no loops.
• robots.txt → test key URLs so you didn't just block a section you meant to keep.
• Any factual claim about your site → confirm it against the audit. Models will occasionally "remember" a problem that was never there.

Step 5: Make your site AI-crawler ready

In 2026 technical SEO isn't only for Googlebot — it's for the AI engines increasingly answering queries. And they behave differently in one way that wrecks a lot of sites: most of them don't render JavaScript. If your content, links, or schema only appear after JS runs, those crawlers see a blank page.

The takeaway: server-render anything you want cited, and make sure your robots.txt actually allows the AI user-agents you want quoting you. You can confirm the exact, current user-agent strings against a public database like Dark Visitors, and see the scale of AI-crawler traffic on your own infrastructure with tools like Cloudflare Radar. OpenAI also documents its own crawlers in the GPTBot docs.

The one place you see these bots by name is your server logs — Search Console doesn't break them out. If wiring up log parsing sounds like work, DidYouSEO's bot-traffic tracker does it for you: it identifies which AI crawlers actually hit your pages and what status codes they get, so you know whether GPTBot and ClaudeBot are reaching your content or bouncing off a redirect. (For a primer on why this matters, see do AI crawlers even visit your site.)

Step 6: Put it on a loop

A one-time audit is a snapshot; sites rot continuously. The real unlock is that re-running this loop is cheap, so schedule it instead of waiting for a quarterly panic. A fresh audit on a cadence, the same Step 1–2 prompts on the new data, and a quick "what changed since last time" diff catches regressions — a botched deploy that adds noindex, a new redirect chain, schema that broke in a template update — the week they happen.

The guardrails that keep this safe

If you take one thing from this, make it this list:

• Real data in, or garbage out. Feed AI an actual audit, GSC export, or logs — never let it guess from the URL.
• Diagnose, prioritize, and fix in separate prompts. Mixing them lets critical issues hide behind cosmetic ones.
• Validate every output. Schema, redirects, robots — test before deploy, every time.
• Constrain the prompt. "Only use data I gave you" and "never invent values" prevent most hallucinations.
• You make the final call. AI ranks and drafts; you decide what matters and own the result.

Run it yourself

Start with a real audit, then let AI do the reading. You can run a free DidYouSEO audit on any URL right now — no signup — and if you want the whole loop inside your assistant, connect the MCP server and just ask it to audit your site.

FAQ

Can AI do an SEO audit on its own? Not reliably. Chat models don't fully crawl your site from a URL, and they hallucinate issues and fixes. The workflow that works is: run a real audit for ground-truth data, then use AI to summarize it, prioritize by impact and effort, and draft fixes like schema and redirects — while you validate every output and make the final calls. AI removes the grunt work; it doesn't replace the SEO.

What tools do I need to run an SEO audit with AI? Three categories, not one tool: a real audit for data (DidYouSEO checks 30+ signals free, and exposes them to your assistant over MCP), a reasoning model for analysis and drafting (ChatGPT or Claude — cross-checking both is ideal), and validators (Google's Rich Results Test, a redirect checker, a robots.txt tester).

Is AI-generated schema markup safe to use? Yes, if you validate it. AI drafts JSON-LD quickly but can invent ratings, prices, or dates that aren't true, which can trigger structured-data problems. Constrain the prompt to "only use data I give you," then run the output through Google's Rich Results Test and a schema validator before it goes live.

Do AI crawlers like GPTBot render JavaScript? Mostly no. GPTBot, OAI-SearchBot, PerplexityBot, and ClaudeBot read raw server-rendered HTML and generally don't execute JavaScript. Google's crawler is the main exception. So if your content or schema only appears after JavaScript runs, most AI engines never see it — server-render anything you want cited.

How often should I run an SEO audit with AI? Treat it as a loop, not a one-off. Because re-running is cheap, schedule a fresh audit monthly, or after any significant deploy or migration, and re-run the summarize-and-prioritize prompts on the new data. A quick "what changed" diff catches regressions the week they happen instead of next quarter.