Claude Code for SEO Audits: Crawl, Analyze, and Report in One Session

A full-site SEO audit used to cost $3,000 and three weeks. A Claude Code session delivers a better version in an afternoon. Not a simplified checklist — a real crawl of every URL, extracted metadata at scale, broken links flagged, schema validated, and a redirect map generated. That's not a hypothetical; it's a reproducible workflow that any team can run today.

Most SEO audits fail not because of bad analysis but because the data collection is manual. Pulling H1s across 800 URLs in a spreadsheet is a full day's work. Claude Code collapses that to a single prompt. The result is more coverage, fewer human errors, and a report that's ready the same day you start.

TL;DR: Claude Code for SEO makes full-site audits dramatically faster by combining site crawl scripts, metadata extraction, broken link detection, schema validation, and Core Web Vitals pulls into a single session. What used to take days now fits in an afternoon, with output precise enough to hand directly to a developer.

Why traditional SEO audits break down at scale

Auditing 50 pages is manageable. Auditing 2,000 isn't — at least not with manual tools. Most SEO teams hit the same three failure modes:

1. Data fragmentation. Screaming Frog exports a CSV, Google Search Console exports another, PageSpeed sits in a separate tab. Reconciling these takes longer than the audit itself.
2. Sampling bias. Under time pressure, auditors check the homepage and a few category pages, then extrapolate. The real issues — duplicate meta descriptions on pagination, missing schema on product pages, redirect chains on old URLs — live in the long tail.
3. Report latency. By the time the audit is written up, the site has changed. The data is already stale.

Claude Code solves all three. It writes the crawl script, runs it, parses the output, and surfaces findings in a single session. The data is live, complete, and in one place.

Setting up a site crawl with Claude Code for SEO

The first step is giving Claude Code a crawl script to work with. You don't need an existing tool installed — Claude Code will write one from scratch in Python using requests and BeautifulSoup, or spin up a scrapy spider if the site is large.

A useful opening prompt:

Write a Python crawler that:
1. Starts at https://example.com/sitemap.xml and extracts all URLs
2. For each URL, fetches the page and extracts: title tag, meta description,
   H1, H2s (all), canonical URL, robots meta tag, and HTTP status code
3. Follows and records all redirects, noting the final destination URL
4. Outputs a CSV with one row per URL
5. Respects a 1-second crawl delay and sets a descriptive User-Agent

Claude Code generates this script, runs it in your terminal, and returns the CSV. For a 1,000-URL site, this typically completes in 20–30 minutes. For larger sites, you can parallelise with a --workers flag Claude will add on request.

Once the CSV is ready, the real work begins: analysis. This is where Claude's long context pays off. Paste the entire CSV (or save it to disk and reference it) and ask for patterns. Claude can hold thousands of rows in context and surface findings that a manual review would miss.

Extracting H1, H2, and meta coverage at scale

With the crawl CSV in hand, the next prompt drives the first major deliverable:

Analyze this CSV. Report:
- Pages missing H1 tags
- Pages with duplicate H1s (list the duplicates)
- Pages missing meta descriptions or with descriptions over 155 characters
- Pages where the H1 doesn't contain the primary keyword from the URL slug
- Pages with no H2 tags
Format findings as a prioritized issue list with URL, issue type, and current value.

Claude returns a structured report within seconds. A real session on a 900-URL e-commerce site surfaced 47 pages with missing meta descriptions, 12 duplicate H1s on paginated category pages, and 31 product pages where the H1 was the product SKU rather than a keyword-bearing name. None of those were visible in the Screaming Frog summary view.

This is the core value of using Claude Code for SEO: it doesn't just collect data, it reasons about it. You can ask follow-up questions like "which of these missing-meta pages get the most organic traffic?" — and if you've pasted a Search Console export alongside the crawl data, Claude will cross-reference them.

For content teams thinking about how this fits into the broader writing workflow, see how Claude approaches SEO content writing for the upstream half of this process.

Broken link detection and redirect mapping

Broken internal links are one of the most common audit findings and one of the most tedious to fix manually. Claude Code handles both detection and the redirect map generation in sequence.

From the crawl CSV, find all internal links that returned 404 or 410 status codes.
Then check the redirect log and identify any redirect chains longer than 2 hops.
Generate a redirect map table: Source URL | Current Destination | Recommended Fix.
For 404s, suggest the most relevant live page based on URL slug similarity.

The recommended fix column is the part that saves real time. Instead of handing developers a list of broken URLs, you hand them a ready-to-implement .htaccess or Nginx config block — which Claude will generate on the next prompt.

On a mid-size SaaS site audit, this process identified 23 broken internal links, 8 redirect chains of 3+ hops, and 4 URLs canonicaling to pages that had since been deleted. Total time from prompt to actionable output: under 10 minutes.

Schema audit: finding structured data gaps

Automation shines here because schema errors are invisible to humans scanning pages but highly consequential for rich results in search. Claude Code can pull structured data from every page in the crawl and validate it.

For each URL in the crawl CSV, extract all JSON-LD blocks.
Report:
- Pages with no structured data
- Pages using Article schema without required fields (headline, datePublished, author)
- Pages using Product schema without offers.price
- Pages where the schema @type doesn't match the page content type

This is particularly valuable for e-commerce and blog-heavy sites. A content site with 400 posts might have structured data on only the first 50 articles written after a schema initiative — and the other 350 are silently missing out on rich results eligibility.

For the mechanics of how structured data interacts with AI-powered search, see the analysis in optimizing content for AI search and LLM visibility.

Content duplication and thin content detection

Duplicate content and thin pages are audit staples, but finding them across a large site typically requires a dedicated tool. Claude Code can approximate both with the crawl data you already have.

For exact duplicate detection:

Compare the meta descriptions and H1s across all URLs. Flag any exact duplicates.
Then compare title tag + H1 combinations — flag cases where the same combination
appears on more than 2 URLs, noting the URLs.

For thin content:

The crawl CSV includes a word count column. Flag all pages with fewer than 300 words
that are not tagged as noindex. Group by section (blog, product, category, landing-page)
and report the percentage of thin pages in each section.

These prompts won't catch all forms of duplicate content — you still need a tool like Copyscape for near-duplicate detection across body text — but they catch the structural issues that a developer can fix programmatically: pagination without canonical tags, faceted navigation generating duplicate URLs, A/B test variants that were never noindexed.

Core Web Vitals and page speed audit

The PageSpeed Insights API is publicly accessible, and Claude Code can call it for every URL in your crawl.

Write a Python script that:
1. Takes the URL list from crawl.csv
2. Calls the PageSpeed Insights API (key: YOUR_KEY) for each URL, both mobile and desktop
3. Extracts: LCP, FID/INP, CLS, overall Performance score
4. Writes results to pagespeed.csv
5. Rate-limits to 1 request per second

Once pagespeed.csv is ready, the follow-up analysis prompt:

Identify the 20 worst-performing pages by LCP on mobile. For each, note whether
it's a product page, category page, blog post, or other. Group by page type and
report average LCP per type. Flag pages with CLS above 0.1.

The web.dev Core Web Vitals documentation defines thresholds clearly: LCP under 2.5s is "good," 2.5–4s needs improvement, over 4s is poor. Claude Code can apply these categories automatically and generate a prioritized fix list sorted by impact.

This Core Web Vitals workflow pairs with the broader technical picture covered in how to start a blog with proper technical foundations — the same principles apply when auditing an established site.

What Claude Code doesn't replace in an SEO audit

This is worth naming directly. Claude Code for SEO is a force multiplier, not a full replacement for SEO judgment.

It won't tell you why a page isn't ranking for a target keyword. That requires understanding search intent, SERP composition, and backlink authority — analysis that needs human context.

It won't do link prospecting or outreach. It can compile a broken backlink report if you feed it an Ahrefs export, but it can't assess link quality or send emails.

It can't evaluate content quality. It can flag thin word counts, but a 2,000-word page can be thin in value and a 400-word page can be definitive. That call still belongs to a human editor.

And it's only as good as the crawl. JavaScript-rendered content won't appear in a basic requests crawl. For SPAs or heavy React sites, you need a headless browser approach — which Claude Code can set up with Playwright, but it takes more setup time.

The honest framing: Claude Code handles the data layer of an SEO audit with near-zero marginal cost. The interpretation layer — prioritization, strategy, competitive context — still requires a practitioner.

For teams building out that competitive intelligence layer, see how agentic workflows connect to the AdLibrary API for the broader automation picture.

Pulling it into a final audit report

The last prompt in a Claude Code SEO session is the one that turns raw findings into a document you can actually send.

Summarize all findings from this session into an SEO audit report with:
1. Executive summary (3-5 bullets, most critical findings)
2. Technical issues table: Issue | Pages Affected | Priority | Recommended Fix
3. Content issues table: Issue | Pages Affected | Priority | Recommended Fix
4. Core Web Vitals summary: worst pages, average scores by page type
5. Schema coverage summary: types present, types missing, critical gaps
6. Quick wins section: issues fixable in under 1 hour of dev time

Claude returns a structured Markdown report you can paste into Notion, convert to PDF, or hand directly to a client. The full session — from first crawl prompt to final report — typically runs 3–4 hours for a 1,000-URL site.

Compare that to the traditional audit timeline of 2–3 weeks for a similar scope. The difference isn't just speed; it's that you can run this audit monthly instead of once a year, which changes how you use the data entirely.

If your content pipeline sits on top of AdLibrary's API access layer, the same agentic approach applies — scheduled audits that fire whenever content is published, flagging SEO issues before they accumulate.

For a broader view of how analyzing competitor content for SEO signals fits into this workflow, the patterns transfer directly: same scripted extraction, same Claude analysis loop, different data source.

To put the speed advantage in concrete terms, an ad budget planner built on the same data layer shows how much faster decisions get when the underlying data collection is already automated.

Frequently Asked Questions

Can Claude Code run a full SEO audit without any additional tools?

Yes, for most technical audit components. Claude Code can write crawl scripts from scratch using Python libraries that are standard in most environments (requests, BeautifulSoup, csv). It can call the PageSpeed Insights API directly. For JavaScript-heavy sites, it can set up a Playwright-based crawl, though that requires Node.js. The one external dependency you'll actually want is access to a Search Console export for traffic data — that's not something Claude Code can pull directly.

How large a site can Claude Code audit in one session?

Practically, sites up to about 5,000 URLs work well within a single session. For larger sites, the crawl itself runs fine (Claude Code can write a resumable script), but you'll want to break the analysis into sections — technical issues, content issues, schema audit — and run them as separate prompts rather than one massive one. Claude's context window handles several thousand rows of CSV data without issue.

Is the output good enough to send to a client without editing?

The structured data tables are client-ready with light formatting. The narrative executive summary usually needs one pass to adjust tone and add site-specific context. The redirect map and issue tables are precise enough to hand directly to developers. Treat the Claude Code output as a first draft that's 80–90% complete rather than a finished deliverable.

Does Claude Code work for auditing meta-ads landing pages?

Yes, and it's particularly useful for landing page audits at scale. If you're running traffic to 50+ landing page variants, Claude Code can crawl all of them, compare title tags and H1s across variants, flag missing schema, and check load times — all in one session. The same prompts from the site crawl section above apply directly.

What's the difference between using Claude Code vs. Screaming Frog for an SEO audit?

Screaming Frog is better for data collection on large sites — it's faster, handles JavaScript rendering well, and has mature export options. Claude Code is better for analysis: it reasons about the data, surfaces patterns, generates the redirect map, and writes the final report. The optimal workflow uses both: Screaming Frog for the crawl, Claude Code for the analysis layer. If you don't have Screaming Frog, Claude Code can do the crawl too — it's just slower at scale.

The mechanics of automation here are worth understanding: Claude Code doesn't wrap an existing SEO tool. It writes the code, runs it, reads the output, and reasons over it — all in the same session. That's the difference between a workflow tool and an agent.

The Anthropic documentation on Claude's agentic capabilities describes the interface that makes this possible. Claude Code takes that further by operating directly in your terminal, which means the crawl script, the PageSpeed API calls, and the final Markdown report all happen in one continuous context.

The compounding effect is real. After three or four monthly audits with Claude Code, you start to see directional trends: which page types are accumulating thin content, where schema coverage is slipping, which sections consistently fail Core Web Vitals. That longitudinal view is what turns an audit from a one-time deliverable into an operational signal.

Run the first session. The results will make the workflow obvious.