How to Build an AI SEO Audit Workflow

A real SEO audit takes 6-8 hours of clicking through tabs in Screaming Frog, exporting CSVs, eyeballing meta tags, and writing recommendations into a doc nobody reads. An AI SEO audit workflow does the same thing in 10 minutes, returns a prioritized fix list, and runs again automatically every week.

Why Automate the SEO Audit

A manual audit is the wrong shape of work for a human in 2026. The tasks inside it are 90% data extraction (deterministic, mechanical) and 10% judgment (interpretation, prioritization). The deterministic part should run automatically. The judgment part is exactly what an LLM is good at.

The numbers back this up. 86% of SEO professionals now use AI in their workflow, and the agencies that have moved audits onto automation are running 5-10× more client audits per week with the same headcount. The point isn't to replace the SEO. It's to free the SEO from spending half their week running audits when the audit itself is mechanical.

This guide shows you the exact architecture I use, in n8n, with Claude as the LLM. You can swap n8n for Make and Claude for GPT-4 or Gemini — the structure is the same.

The Architecture in One Diagram

The workflow is six stages, each one a small group of n8n nodes:

1. Input — accept a target URL or sitemap
2. Crawl — fetch HTML for every page (or a representative sample)
3. Extract — pull on-page signals: titles, descriptions, H1s, internal links, status codes, image alt text, schema, etc.
4. Analyze — feed extracted data into Claude or GPT and ask it to interpret
5. Score — apply a rubric (severity × traffic potential) to rank issues
6. Deliver — output a Markdown or HTML report, send via email or post to Slack

The discipline here matters: deterministic code does the crawling and extraction, the LLM does only the interpretation. Skipping that split is the most common mistake — people try to make GPT crawl a site, and it hallucinates page content it never actually fetched. Bad data, confidently presented.

Step 1: Set Up the Input Trigger

Start with two trigger options:

• Manual or webhook trigger — for one-off client audits. Drop in a target domain, hit run.
• Schedule trigger — for ongoing site monitoring. Run weekly on your own site or rotate through a client list.

In n8n, use a Webhook node for on-demand audits and a Cron node for scheduled runs. The body of the trigger should contain at minimum the target domain and optionally a depth parameter (how many pages to crawl).

Example webhook payload:

{
  "domain": "https://example.com",
  "max_pages": 50,
  "report_to": "you@email.com"
}

Keep max_pages low (25-100) on v1. Crawling a 5,000-page site is a different engineering problem with rate limits, queuing, and storage. Solve the small case first.

Step 2: Crawl the Site

You have three options for crawling, in order of effort and reliability:

For most use cases, fetch the sitemap.xml first, parse it for URLs, then fetch each URL with an HTTP Request node. This is free and works for 80% of sites.

The minimum viable crawl flow in n8n:

1. HTTP Request — fetch [domain]/sitemap.xml
2. XML node — parse the sitemap, output an array of URLs
3. Split In Batches — process URLs in groups of 5-10 to avoid rate limits
4. HTTP Request (loop) — fetch each URL's HTML
5. Set node — store URL + HTML body

Add a 1-2 second delay between requests if you're hitting external sites. Respect robots.txt as a courtesy.

Step 3: Extract On-Page SEO Signals

This is the part most people skip and regret. Extract structured data deterministically before sending anything to the LLM. The extraction is the same set of checks every SEO has been running for 15 years — automate it once and reuse.

For each fetched page, extract:

• Title tag — content and character length
• Meta description — content and character length (target: 130-155 chars)
• H1 — count (should be 1) and content
• H2/H3 hierarchy — headers in order
• Canonical tag — value and whether it points to self
• Robots meta tag — index/noindex, follow/nofollow
• Schema/structured data — JSON-LD blocks
• Internal links — count and target anchor text
• External links — count
• Images — total count and how many lack alt text
• Word count — total visible text
• Status code — 200, 301, 404, etc.

In n8n, a Code node with a simple Cheerio (or regex) parser does this in 30 lines of JavaScript. Output a flat object per URL with every signal as a field.

Add the AI-readiness layer too. Check robots.txt for explicit GPTBot, ClaudeBot, OAI-SearchBot, and PerplexityBot rules. In 2026, 30.6% of web traffic is bots, and the AI crawler subset is growing fast. If your client's robots.txt blocks AI crawlers without realizing it, that's a top-line finding.

Step 4: Send Data to Claude or GPT for Analysis

Here's where the LLM earns its keep. Pass the extracted data — not raw HTML — into the model with a structured prompt.

The prompt should:

1. State the role explicitly ("You are an SEO auditor")
2. Provide the rubric (what counts as critical, major, minor)
3. Pass the structured page data as JSON
4. Ask for output in a specific JSON shape

Example prompt skeleton:

You are an experienced SEO auditor. Review the following site data and produce a JSON report with:

- critical_issues (high traffic impact, fix immediately)
- major_issues (meaningful impact, fix this sprint)
- minor_issues (nice-to-have improvements)

Each issue should include: page_url, issue_type, current_state, recommended_fix, estimated_impact (high/medium/low).

Site data: [paste extracted JSON here]

Return only valid JSON.

Use Claude Sonnet 4 or GPT-4-class models for the analysis step. Cheaper models miss nuance on prioritization. Cost per audit at typical site size is $0.10-$0.50 — trivial compared to the value.

Set the model temperature to 0 or 0.2 for consistency across runs. SEO audits are not a place for creativity.

Step 5: Score and Prioritize the Findings

The LLM gives you issues. The scoring layer turns issues into a prioritized fix list.

A simple working rubric:

priority_score = traffic_potential × severity × ease_of_fix

Where:

• traffic_potential = estimated monthly impressions of the page (use Google Search Console data if available; otherwise rough proxy by URL depth)
• severity = 3 for critical (blocking issue), 2 for major, 1 for minor
• ease_of_fix = 3 for trivial (1-line change), 2 for moderate, 1 for hard

Run this calculation on every issue, sort descending, and you have a prioritized backlog. The top 5 items are usually 80% of the achievable lift.

This is the step that makes the audit actionable. Without it, you hand the client a 200-issue report and they freeze. With it, they have five things to do this week.

Step 6: Deliver the Report

The output format depends on who's reading it.

For internal use or technical clients, generate a Markdown report and email it. For agency clients, generate an HTML report with a branded template. For internal stakeholders, post a summary to Slack with the top 3 fixes.

In n8n:

• Markdown email: use a Code node to assemble the report body, then a Send Email node
• HTML report: use a Code node + a templating library (or just template literals), then upload to S3 / Drive and email a link
• Slack summary: use the Slack node with a formatted message and the top 5 issues as a thread

I prefer Markdown for the technical report and a 5-bullet Slack summary for the executive. Two channels, two audiences, one workflow.

Tools You'll Need

A working v1 costs roughly $20/month for n8n Cloud (or free if self-hosted) plus per-audit LLM costs. At $0.30 per audit on average, even running 100 audits a month keeps the entire stack under $50.

Common Mistakes to Avoid

Three patterns kill these workflows in production.

Asking the LLM to crawl the site. Already covered above. The LLM hallucinates content. Always crawl deterministically and pass extracted data.

Skipping the scoring step. Without prioritization, the report is a wall of issues that nobody reads. The scoring rubric is non-negotiable.

Building for 5,000 pages on day one. Crawling at scale is a separate engineering problem — rate limits, queuing, retries, deduplication. Build for 25-100 pages first, get value out of it, then scale up. Most sites don't need a 5,000-page audit anyway.

Extending the Workflow

Once v1 is running, the highest-value extensions are usually:

• Search Console integration — pull actual impressions and CTR per URL to weight the priority score with real traffic data
• PageSpeed Insights API — add Core Web Vitals to the audit (LCP, INP, CLS)
• Backlink check — pull data from Ahrefs or DataForSEO to factor authority into the priority score
• Diff mode — compare today's audit to last week's, surface only what changed (this is what makes the workflow valuable as a monitoring tool, not just an audit tool)
• Multi-site mode — accept a list of domains and run the workflow in batch with consolidated reporting

Each extension is roughly half a day of work in n8n. Add them as you find a real need, not preemptively.

What This Workflow Replaces

A working AI SEO audit workflow replaces:

• 6-8 hours of manual auditing per site
• The Screaming Frog → Excel → Google Doc handoff
• One-off client audit deliverables that go stale immediately
• The agency-side billable hour problem of "we should audit them again but who has time"

What it doesn't replace: the strategic work of deciding what to do with the findings. That's still the SEO's job. The audit is the input — the strategy is the output. Automation gets you to the input faster so you spend more time on the part that actually matters.