How to Automate Technical SEO Audits with Claude Code

I run technical SEO audits for clients every week. For years, that meant spending 4–6 hours per site clicking through Screaming Frog exports, cross-referencing spreadsheets, and manually documenting every missing meta tag and broken schema markup. The work was important but painfully repetitive.

Now I use Claude Code to automate technical SEO audit workflows, and I've cut that time down to about 45 minutes per site. The tool does the crawling, extraction, and initial flagging. I review the output, add context where needed, and deliver a prioritized report to the client. Same quality, a fraction of the time.

Here's exactly how I built this system and how you can replicate it for your own SEO workflow.

What a Technical SEO Audit Actually Checks

Before automating anything, you need to know what you're auditing. A good technical SEO audit covers on-page elements that search engines use to understand and rank your content. The checklist I use includes:

• Title tags — present, under 60 characters, includes primary keyword, no duplicates across the site
• Meta descriptions — present, 120–155 characters, contains a call to action, unique per page
• Heading structure — exactly one H1 per page, logical H2/H3 hierarchy, no skipped levels
• Canonical tags — present, self-referencing or correctly pointing to the primary version of the page
• Schema markup — valid JSON-LD for relevant page types (Article, Product, LocalBusiness, etc.)
• Open Graph and Twitter Cards — og:title, og:description, og:image present for social sharing
• Image alt attributes — descriptive alt text on all images, especially those above the fold

There are deeper technical checks — Core Web Vitals, server response codes, JavaScript rendering issues — but those require different tools. Claude Code excels at the on-page HTML layer, which is where most quick wins live.

Building the Audit Script: Step-by-Step

The workflow I use has three stages: crawl the site, extract the relevant HTML elements, and score each page against the audit criteria. Let me walk you through each one.

Stage 1: Fetch the Sitemap and Page List

Most sites have an XML sitemap at /sitemap.xml. I start by feeding that URL to Claude Code and asking it to parse the list of URLs. If the sitemap is paginated or nested (common on large sites), I tell Claude Code to follow the <sitemap> references recursively until it has the full list.

For smaller sites without a sitemap, I provide a manual list of URLs or ask Claude Code to scrape the navigation structure. Either way, the output is a plain text list of every page that needs to be audited.

Stage 2: Extract On-Page Elements from Each URL

Once I have the URL list, I ask Claude Code to fetch the HTML for each page and extract the key SEO elements. The prompt looks like this:

For each URL in this list, fetch the raw HTML and extract:
- Title tag (content between <title> tags)
- Meta description (content attribute of <meta name="description">)
- H1 (text content of the first <h1> tag)
- Canonical URL (href attribute of <link rel="canonical">)
- All H2 and H3 tags (as an array of text content)
- JSON-LD schema (content of <script type="application/ld+json">)
- Open Graph tags (og:title, og:description, og:image)
- Image alt attributes (alt text for all <img> tags)

Return the results as a JSON array, one object per URL.

Claude Code processes this in batches. For a 200-page site, it takes about 10–15 minutes to complete the extraction. The output is a structured JSON file that I can review or pass to the next stage.

Stage 3: Score and Flag Issues

This is where the audit becomes useful. I run a second Claude Code session that takes the extracted data and scores each page against my audit criteria. The scoring prompt defines what counts as a pass, warning, or critical issue:

You are a technical SEO auditor. For each page object in this JSON array, evaluate:

1. Title tag: 
   - CRITICAL if missing or empty
   - WARNING if over 60 characters or under 30 characters
   - WARNING if it duplicates another page's title
   - INFO if it doesn't contain the primary keyword (you'll infer this from the URL or H1)

2. Meta description:
   - CRITICAL if missing
   - WARNING if under 120 or over 155 characters
   - INFO if it doesn't end with a question or CTA

3. H1:
   - CRITICAL if missing or if there are multiple H1s
   - WARNING if it's identical to the title tag
   - INFO if it's under 20 or over 70 characters

4. Canonical:
   - CRITICAL if missing
   - WARNING if it points to a different domain
   - INFO if it's present and self-referencing

5. Schema:
   - WARNING if missing on a blog post, product, or service page
   - INFO if present but not validated (you can't validate, just note)

6. Open Graph:
   - WARNING if og:title or og:description is missing
   - INFO if og:image is missing

For each page, return an "issues" array with objects like:
{ "severity": "critical" | "warning" | "info", "field": "title", "message": "Title tag exceeds 60 characters (current: 72)" }

The output is a prioritized list of every issue on the site. Critical issues go at the top — things like missing title tags or multiple H1s. Warnings are next, and informational notes are at the bottom.

How This Workflow Saves Time in Practice

Here's the before-and-after for a typical client audit. Before automation, I would:

1. Run a Screaming Frog crawl (20 minutes)
2. Export the data to CSV and open it in Excel (5 minutes)
3. Manually check each row for missing or malformed tags (2–3 hours)
4. Cross-reference duplicate content and title tags (30 minutes)
5. Write up findings in a Google Doc with screenshots (1 hour)

Total: 4–5 hours, and that's if nothing unexpected comes up.

With Claude Code, the process is:

1. Feed the sitemap URL to Claude Code (2 minutes)
2. Run the extraction script (10–15 minutes, unattended)
3. Run the scoring script (5 minutes)
4. Review the flagged issues and add client-specific notes (20–30 minutes)
5. Export the report to PDF (5 minutes)

Total: 45 minutes of actual work.

The time savings compound when you're running audits for multiple clients. I now do in a week what used to take me a month.

Where Claude Code Outperforms Traditional Tools

Screaming Frog is still the gold standard for crawling large sites with complex JavaScript rendering. But for static or server-rendered sites — which is most small business websites — Claude Code has some clear advantages:

• Custom scoring logic — I can define audit rules that match my client's brand guidelines (e.g., all title tags must include the city name for local SEO)
• Context-aware flagging — Claude Code can infer whether a missing schema tag actually matters based on the page type
• Natural language reports — instead of exporting raw CSV data, I get a human-readable summary I can send directly to clients

The biggest win is flexibility. If a client asks me to add a new check — like verifying that all blog posts have an author byline — I just update the prompt. No need to learn new software or reconfigure a third-party tool.

Common Issues Claude Code Catches Automatically

Here are the top five issues the audit script flags on almost every site I review:

• Duplicate title tags — especially on e-commerce category pages where developers reuse templates without customization
• Missing or generic meta descriptions — pages that still have the default "Welcome to our site" placeholder
• Multiple H1 tags — common on sites that use the logo image as an H1 in the header, then add another H1 in the page content
• Broken or missing canonical tags — often caused by URL parameters or pagination that wasn't handled correctly
• Schema markup errors — usually valid JSON syntax but missing required fields like datePublished on blog posts

Each of these is a quick fix once identified, but they're easy to miss in a manual review. Automation catches them every time.

How to Build This for Your Own Workflow

If you want to replicate this system, here's the path I'd recommend:

1. Start with a single-page test — give Claude Code the HTML of one page and ask it to extract title, meta description, and H1. Make sure the output format is what you need.
2. Scale to a small batch — pick 10 URLs from a test site and run the full extraction workflow. Check for errors or edge cases.
3. Define your scoring rules — write out the exact criteria for what counts as a critical, warning, or info-level issue. The more specific, the better.
4. Automate the full audit — run the workflow on a real client site and compare the results to a manual review. Iterate until the false positive rate is under 10%.

The upfront work takes about 3–4 hours if you already know what to check for. After that, each audit is just minutes of setup and review time.

When to Use This vs. Traditional SEO Tools

Claude Code works best for on-page HTML audits on static or server-rendered sites. It's faster and more customizable than most paid tools for that use case.

But it's not a replacement for everything. Here's where I still use traditional tools:

• JavaScript-heavy sites — if the content is rendered client-side, Screaming Frog or a headless browser tool is more reliable
• Crawl budget and indexation analysis — tracking what Google actually indexes requires Search Console data, not just HTML scraping
• Backlink analysis — that's a job for Ahrefs or Semrush

The winning approach is to use Claude Code for the high-volume, repeatable checks and save the specialized tools for the areas where they add unique value.

Takeaways

Technical SEO audits don't have to be a multi-hour manual grind. With Claude Code, you can automate the crawl, extraction, and scoring stages, then focus your time on interpretation and client-specific strategy.

The system I've outlined here is what I use every week for client work. It's saved me hundreds of hours over the past year, and the audit quality has stayed consistent or improved because the checks are now systematic instead of ad hoc.

If you're an SEO consultant or agency owner looking to scale your operations without hiring more people, this is one of the highest-ROI automations you can build. Start with one client site, refine the workflow, and then roll it out across your entire book of business.

For more on how I use Claude Code in my consulting practice, check out my SEO automation workflow post, the guide on programmatic SEO with Claude Code, and the overview of getting started with Claude Code. And if you have questions about whether this fits your specific client needs, the FAQ page covers most of the common scenarios.