DEV Community: Aaron VanSledright

Catching SEO Regressions in Vercel Preview Deploys

Aaron VanSledright — Mon, 07 Sep 2026 14:00:05 +0000

Vercel preview deploys are the most underused SEO QA surface in modern frontend teams. Every PR gets a unique, real URL that loads in a real browser. That's exactly the environment an SEO audit needs — and it's a few minutes of YAML away from being a hard PR check.

This post is the production setup for catching SEO regressions on Vercel previews using SEO Score API. It's a sibling of Wiring an SEO analyzer API into a Next.js build but focused on the Vercel-specific gotchas.

The shape of the workflow

Three steps:

Wait for the Vercel preview to be live (it takes 30s–3min after PR push).
Audit the preview URL with SEO Score API.
Fail the PR check if the score is below the threshold.

The first step is where most teams get it wrong on the first try. The Vercel preview URL is available in the PR comment within seconds, but the deploy isn't ready for several minutes. Audit too early and you'll audit a 404 or an in-progress build.

The workflow

.github/workflows/seo-preview.yml:

name: SEO Preview Check
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - name: Wait for Vercel preview to be ready
        uses: patrickedqvist/wait-for-vercel-preview@v1.3.1
        id: preview
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          max_timeout: 600  # 10 min — Next.js builds can be slow

      - name: Audit preview
        id: audit
        env:
          KEY: ${{ secrets.SEO_KEY }}
        run: |
          URL="${{ steps.preview.outputs.url }}"
          RESP=$(curl -s -H "X-API-Key: $KEY" \
            "https://seoscoreapi.com/audit?url=$URL")
          SCORE=$(echo "$RESP" | jq '.score // 0')
          echo "score=$SCORE" >> $GITHUB_OUTPUT
          echo "## SEO Score: $SCORE" >> $GITHUB_STEP_SUMMARY
          echo "$RESP" | jq -r '.priorities[] | "- \(.issue)"' >> $GITHUB_STEP_SUMMARY

      - name: Threshold check
        run: |
          [ "${{ steps.audit.outputs.score }}" -ge 85 ] || exit 1

The wait-for-vercel-preview action listens for the Vercel deployment status webhook on the PR. It returns the URL only once the preview is actually serving traffic — that's the part you can't skip.

What we learned the hard way

A few things that bit us in production on the first version:

1. Don't audit immediately. Even after Vercel reports the preview is live, the CDN propagation takes another 5–10 seconds for global routes. Insert a sleep 15 after wait-for-vercel-preview if you see intermittent 502s from the audit.

2. Branch URLs change on rebase. The Vercel preview URL incorporates the branch name and commit SHA. After a force-push, the URL changes. wait-for-vercel-preview handles this if you call it fresh in every workflow run.

3. Auth-gated previews are invisible to us. If your Vercel preview deploys are behind Vercel Authentication (paid plans default to on), SEO Score API sees the auth wall, not your app. Turn off Vercel Authentication for previews, or use Vercel's protection-bypass-for-automation token and pass it as a header — we accept a ?bypass_token query parameter.

4. The first audit cold-starts the page. Next.js with on-demand rendering means the first request to a route compiles it. The audit will include that cold-start time. If your performance score is consistently 8–10 points lower than production, this is why. Run a warmup curl $URL step before the audit step and the numbers settle.

5. Set the threshold against main, not against the score you wish you had. A gate that fails every PR teaches developers to bypass it. See Pre-Deploy SEO Gates for how to pick the right threshold.

Multi-page auditing

The example above audits one URL. Most teams want to audit a small list of routes — the ones that matter for SEO, like /, /pricing, /signup, and the top 3–5 product pages.

URLS=("$URL/" "$URL/pricing" "$URL/signup" "$URL/docs")
FAIL=0
for u in "${URLS[@]}"; do
  S=$(curl -s -H "X-API-Key: $KEY" "https://seoscoreapi.com/audit?url=$u" | jq '.score // 0')
  echo "  $u → $S"
  [ "$S" -lt 85 ] && FAIL=1
done
exit $FAIL

Four URLs × ~10 PRs/day × 22 working days = ~880 audits/month. That fits in the Basic plan ($15/mo, 1,000 audits) with margin.

Posting the report back to the PR

GitHub's STEP_SUMMARY works, but a sticky PR comment is better — same content, doesn't get buried. The marocchino/sticky-pull-request-comment action handles the dedup:

- uses: marocchino/sticky-pull-request-comment@v2
  with:
    header: seo-score
    message: |
      ### SEO Preview Score: ${{ steps.audit.outputs.score }}
      Top issues:
      ${{ steps.audit.outputs.priorities }}

That comment updates in place on every push to the PR, so the latest score is always at the top of the conversation thread. Developers actually read those.

When to skip the gate

A seo-skip PR label that makes the workflow exit 0 is a one-line addition and it dramatically improves adoption. There are legitimate cases — intentional title changes, A/B test pages, copy experiments — where the gate should be silenced for one PR. Make that explicit and the rest of the team will stop disabling the workflow file when they're under deadline pressure.

What this gives you

Three months in, the win isn't the headline number going up — it's the absence of regressions. The gate catches the accidentally-deleted <title> tag, the broken canonical, the meta description someone overwrote in a CMS migration. Those don't show up in the metrics dashboard until traffic drops weeks later. The gate catches them before the PR merges.

That's the whole case for the Vercel preview audit.

Wiring an SEO Analyzer API into a Next.js Build

Aaron VanSledright — Mon, 31 Aug 2026 14:00:04 +0000

The most useful place to run an SEO analyzer API against a Next.js app isn't production — it's the preview deploy. By the time a regression hits production, you've already shipped it. By the time you find it in production, three more PRs have landed on top.

This post is the end-to-end setup for running SEO Score API against every Vercel preview deploy of a Next.js app, with a GitHub Action that fails the PR check if the score drops below a threshold. ~30 lines of YAML and one secret.

Why preview URLs and not production

Three reasons preview-deploy auditing beats production-deploy auditing:

You can block bad changes. A failed check on a preview is a PR you don't merge. A failed check on production is an incident.
Each PR is a clean diff. The score on main is a moving target; the score delta between main and feature/new-pricing is a number you can argue about in a PR review.
JS-rendered pages need a real URL. SEO Score API renders pages in headless Chrome, which means the preview deploy needs to actually be live. Vercel previews are. Local builds usually aren't.

The Vercel side

Vercel comments the preview URL on every PR. The format is stable enough to parse:

This pull request is being deployed to Vercel.
✅ Preview: https://your-app-git-feature-branch-team.vercel.app

We're going to grab that URL via the Vercel API instead of parsing the comment — same data, more reliable.

The GitHub Actions workflow

Save this as .github/workflows/seo-check.yml:

name: SEO Check
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - name: Wait for Vercel preview
        id: wait
        uses: patrickedqvist/wait-for-vercel-preview@v1.3.1
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          max_timeout: 300

      - name: Audit preview URL
        env:
          KEY: ${{ secrets.SEO_KEY }}
          URL: ${{ steps.wait.outputs.url }}
        run: |
          RESP=$(curl -s -H "X-API-Key: $KEY" \
            "https://seoscoreapi.com/audit?url=$URL")
          SCORE=$(echo "$RESP" | jq '.score')
          GRADE=$(echo "$RESP" | jq -r '.grade')
          echo "Score: $SCORE ($GRADE) on $URL"
          if [ "$SCORE" -lt 85 ]; then
            echo "::error::SEO score $SCORE is below threshold (85)"
            echo "$RESP" | jq '.priorities'
            exit 1
          fi

That's it. The action waits for the Vercel preview to be live (up to 5 minutes), audits it, and fails the check if the score is below 85. The failing case dumps the priorities array into the log so the PR author can see what to fix.

Setting the threshold

85 is the default we recommend, but it depends on your baseline. The right way to pick a threshold:

Run the audit against main to get your current baseline.
Set the threshold 2 points below that baseline.

If your main scores 92, threshold at 90. That way the gate fails on real regressions but tolerates the ±1 noise from network conditions and external API variance.

For sites that haven't been optimized yet (main scores 65), threshold at 65. Hold the line, then ratchet up as you improve. The pre-deploy SEO gates post has more on threshold strategy.

Auditing more than the homepage

The example above audits one URL — the preview root. Most apps have at least pricing, signup, and a handful of feature pages that matter just as much. The fix is a small bash loop:

URLS=(
  "$URL/"
  "$URL/pricing"
  "$URL/signup"
  "$URL/docs"
)
FAIL=0
for u in "${URLS[@]}"; do
  S=$(curl -s -H "X-API-Key: $KEY" "https://seoscoreapi.com/audit?url=$u" | jq '.score')
  echo "  $u → $S"
  [ "$S" -lt 85 ] && FAIL=1
done
exit $FAIL

That'll burn one audit per URL per PR. On the Basic plan ($15/mo, 1,000 audits), that comfortably covers a team shipping ~10 PRs/day audited against 3 URLs each.

What this catches that Lighthouse doesn't

Lighthouse runs in your CI by default if you use Vercel — but Lighthouse is Web Vitals first, SEO second. SEO Score API runs 83 checks specifically about SEO: title structure, meta description presence, canonical tags, schema validity, OpenGraph completeness, internal linking, AI-readability signals, robot directives.

You can run both. They overlap maybe 10% — there's no good reason not to gate on both.

What to do when a developer's PR fails the gate

Two things help adoption:

Print the priorities array in the failure log. The default response includes a sorted list of top remediation suggestions. Show them in the GitHub check output and you've turned the gate from "no, your PR is bad" into "yes, and here's what to fix."
Allow override via PR label. Add a seo-skip label that makes the workflow exit 0. There are legitimate cases (intentional title changes, A/B test pages) where the gate should be silenced. Don't make it impossible — just make it explicit.

Both of those keep the gate from becoming the kind of CI check that everyone learns to ignore.

How to Automate SEO Audits with n8n and SEO Score API

Aaron VanSledright — Mon, 24 Aug 2026 14:00:03 +0000

n8n is an open-source workflow automation platform — think Zapier but self-hosted and developer-friendly. Combined with the SEO Score API, you can build powerful SEO automation workflows without writing backend code. Schedule audits, route results to Slack or Google Sheets, and trigger alerts entirely through a visual editor.

What is n8n and how does it relate to SEO automation?

n8n is a self-hostable, node-based workflow automation tool that connects APIs, databases, and services without custom glue code. For SEO automation, it means you can schedule audits, route results to Slack or Google Sheets, and trigger alerts — all through a visual editor, with no backend server to maintain. Unlike hosted tools like Zapier, n8n runs on your own infrastructure, which means no per-task pricing and no data leaving your environment.

How does the SEO Score API n8n node work?

The SEO Score API n8n node is a purpose-built community node that wraps the /audit and /audit/batch endpoints. You configure your API key once in the node credentials, then connect it into any workflow. It handles authentication, passes your URL, and returns the full audit JSON — score, grade, and issue list — as node output data for downstream nodes to consume. Every field in the response is addressable using n8n's expression syntax.

Where do you install n8n-nodes-seoscoreapi?

Install the official community node directly from the n8n UI under Settings > Community Nodes > Install, entering n8n-nodes-seoscoreapi. On a self-hosted instance, you can also run npm install n8n-nodes-seoscoreapi and restart the n8n process. Once installed, the SEO Score API node appears in your node palette alongside other integrations. You only need to enter your API key once — n8n stores it in the node credentials and reuses it across every workflow that calls the node.

How do you set up an automated SEO audit workflow in n8n?

The three most common SEO automation workflows are weekly reports, bulk client audits, and competitive monitoring. Each follows the same pattern: a trigger node fires on a schedule, the SEO Score API node runs the audit, and downstream nodes route the results.

Weekly SEO Audit Report — audit your site every Monday and send results to Slack. Add a Cron node set to run at 9am on Mondays, connect a SEO Score API node with your target URL, add an IF node to check whether the score is below your threshold (for example, 80), then add a Slack node to post results to your channel.

Bulk Client Audits — import client URLs from a Google Sheet, audit each one, and write results back. Use a Google Sheets node to read URLs from column A, loop through them with a SEO Score API node, and write score and grade back to columns B and C. This workflow replaces hours of manual auditing with a single scheduled run.

Competitive Monitoring — track competitor SEO scores over time and alert on significant changes. Set a Cron node to run daily at midnight, audit competitor URLs with the SEO Score API node, use an IF node to check for score changes greater than 5 points, and send an email alert when something shifts.

What does the SEO Score API n8n node output?

The node returns the full audit JSON object as its output data, including score (0–100), grade (A+ to F), priorities (an array of issues with severity and description), and all 28 individual check results. Downstream nodes can reference any field using n8n's expression syntax — for example, {{ $json.score }} to branch on score or {{ $json.grade }} to include in a notification message. The structured output makes it easy to filter issues by severity, extract specific checks, or aggregate results across multiple URLs in the same workflow run.

Using the HTTP Request Node as an alternative

If you prefer not to install a community node, the built-in HTTP Request node works directly with the SEO Score API. Set the method to GET, enter https://seoscoreapi.com/audit as the URL, and add your target URL as a query parameter. Include your API key in the X-API-Key request header. The response is identical to the community node output — you get the same score, grade, and check data, and can reference it downstream using the same n8n expression syntax. The community node is slightly more convenient for credentials management, but the HTTP Request approach works on any n8n instance without additional packages.

Get Started

The free plan gives you 2 audits per day — enough to build and test your first workflow. Create a free account at seoscoreapi.com, install the n8n community node or configure the HTTP Request node, and connect your first workflow in under 5 minutes. For agencies auditing 10 or more client sites, the Pro plan at $39 per month includes batch auditing across multiple URLs in a single workflow step, along with monitoring and historical score tracking.

Frequently Asked Questions

Here are the most common questions about automating SEO audits with n8n and SEO Score API.

What is n8n and how does it relate to SEO automation?

n8n is an open-source, self-hostable workflow automation platform that connects APIs and services through a visual node editor. For SEO, it lets you schedule audits, route results to Slack or Sheets, and trigger alerts — without writing or maintaining custom backend code. Because n8n is self-hosted, there are no per-task fees and your audit data stays in your own environment.

How does the SEO Score API n8n node work?

The n8n-nodes-seoscoreapi community node wraps the SEO Score API endpoints. You enter your API key in the node credentials once, point it at a URL, and it returns the full audit JSON — score, grade, priorities, and all 28 check results — as structured output for subsequent workflow nodes. Credentials are stored securely and reused across every workflow that includes the node.

How do you set up an automated SEO audit workflow in n8n?

Add a Cron trigger node set to your desired schedule, connect a SEO Score API node with your target URL, then branch with an IF node on score thresholds. Connect a Slack, email, or Google Sheets node to deliver results. The whole workflow takes under five minutes to configure and runs automatically on every scheduled trigger without manual intervention.

What does the SEO Score API n8n node output?

The node outputs the full audit JSON including score, grade, priorities (issues with severity labels), and all individual check results. You can reference any field downstream using n8n expressions like {{ $json.score }} to power conditional logic or notification messages. The priorities array includes severity labels — critical, warning, and info — so you can filter alerts to only the most important issues.

Where do you install n8n-nodes-seoscoreapi?

Install via the n8n UI at Settings > Community Nodes > Install, entering n8n-nodes-seoscoreapi. Alternatively, install via npm with npm install n8n-nodes-seoscoreapi on a self-hosted instance. The node then appears in your node palette under the SEO Score API category. No restart is required on cloud-hosted n8n instances after installation.

Claude Code SEO Skill: Audits in Your Terminal

Aaron VanSledright — Mon, 17 Aug 2026 14:00:03 +0000

The Claude Code SEO Skill is a custom slash-command integration that runs SEO Score API audits directly in your terminal — no browser tabs, no copy-pasting URLs, no context switching. It supports single-URL audits, batch checks, site comparisons, and specific signal inspections.

Built as a wrapper around SEO Score API, the skill translates natural-language requests into API calls and formats results as readable terminal output. Type /seo-score, describe what you want, and get structured scores and priorities in seconds.

What Is the Claude Code SEO Skill?

The Claude Code SEO skill is a custom slash-command integration that lets you run SEO audits directly inside Claude Code sessions. The skill is a wrapper around the SEO Score API — it translates natural language requests into API calls and formats the results as readable terminal output, without requiring you to leave your coding environment.

The skill supports auditing individual URLs, batch-checking multiple pages, comparing two sites side by side, and inspecting specific SEO signals like meta tags, heading structure, and canonical configuration. It's designed for developers who want SEO data inline with their workflow, not as a separate tool to manage.

How Do You Install the SEO Score Skill in Claude Code?

Installing the skill takes under two minutes. Clone or download the skill files into your Claude Code skills directory:

mkdir -p ~/.claude/skills/seo-score/scripts
curl -sL https://seoscoreapi.com/skills/seo-score/SKILL.md \
  -o ~/.claude/skills/seo-score/SKILL.md
curl -sL https://seoscoreapi.com/skills/seo-score/seo_audit.py \
  -o ~/.claude/skills/seo-score/scripts/seo_audit.py
chmod +x ~/.claude/skills/seo-score/scripts/seo_audit.py

Then set your API key as an environment variable:

export SEO_SCORE_API_KEY="your_key_here"

The API key is optional for single URL audits — the skill uses the demo endpoint if no key is present, which allows a few free audits without signup. For batch audits, comparisons, and higher volume use, you'll need a key. Get one free at seoscoreapi.com.

Once installed, restart Claude Code and the /seo-score command becomes available in any session.

What Commands Does the SEO Score Skill Support?

The skill responds to natural language, so you don't need to memorize a command syntax. These phrasings all work:

Audit a URL:

"Audit https://example.com"
"Check the SEO score for my homepage"
"What's the SEO score for this URL?"

Batch check multiple pages:

"Audit these five URLs: [list]"
"Check SEO for all pages in my sitemap"
"Run a batch audit on these pages"

Compare two sites:

"Compare https://mysite.com vs https://competitor.com"
"Which site scores better for SEO?"
"Show me the SEO difference between these two domains"

Inspect specific signals:

"What meta tags does example.com use?"
"Check if this page has a canonical tag"
"Show me the heading structure for this URL"

The skill formats output as structured terminal text — score, grade, top issues, and a list of passing and failing checks. For batch runs, it displays a summary table so you can spot weak pages at a glance.

How Does the Skill Connect to the SEO Score API?

The skill calls the SEO Score API over HTTPS. When you make a request, Claude Code invokes the seo_audit.py script in the background, which sends a GET request to the /audit endpoint (or /audit/batch for multi-URL requests) with your API key in the X-API-Key header.

The API response — a JSON object containing score, grade, up to 82 individual check results, and fix recommendations — is passed back to Claude, which formats and summarizes it for you. On Starter plan and above, the response also includes SXO (Search Experience), AEO (Answer Engine), and AIO (AI Optimization) scores, each with their own grade and check breakdown. No data is stored locally; the skill is a thin client that calls the API and displays the results.

Request flow:
Claude Code → seo_audit.py → SEO Score API → JSON response → Claude formats output

The skill respects the rate limits of your plan. If you hit a limit mid-session, it will tell you and suggest when to retry. For high-volume use cases like auditing a full site during a build, the Pro or Ultra plan is recommended.

Which SEO Score API Plan Works with the Claude Code Skill?

All plans work with the skill, including the free tier:

Plan	Audits	Best For
Free	2/day	Quick checks during development
Starter	200/month	Regular audits on personal or small client projects
Basic	1,000/month	Teams running audits across multiple projects
Pro	5,000/month	Agencies or CI/CD pipelines with high audit volume
Ultra	25,000/month	Enterprise use or large-scale automated workflows

For individual developers, the Starter plan at $5/month covers most use cases — 200 audits is enough for daily checks across several projects with headroom to spare. If you're using the skill in a CI/CD pipeline or running audits automatically on each deploy, Pro gives you the rate limits to handle that without throttling.

Why Use the Skill Instead of the API Directly?

The skill adds value in specific developer scenarios:

During active development — check SEO signals on a staging URL without switching context to a browser or API client
When reviewing PRs — ask Claude to audit a preview deployment URL as part of your code review
While writing content — confirm a page's meta tags and heading structure are correct before publishing
For quick comparisons — benchmark your score against a competitor while you're already in a session working on something else

If you prefer scripting directly against the API — for example, in a CI pipeline, a Python script, or an n8n workflow — the skill is not the right tool for that. Use the API or one of the official SDKs (Python, Node.js) instead. The skill is optimized for interactive, in-session use inside Claude Code.

What Does the Skill Output Look Like?

After running an audit, you'll see output structured like this:

SEO Audit: https://example.com
Score: 78/100 (B)

Top Issues:
  - [CRITICAL] Missing Open Graph image tag
  - [HIGH] H1 tag not found
  - [MEDIUM] Page load time exceeds 3s threshold

SXO: 81/100 (A-)  AEO: 52/100 (C+)  AIO: 68/100 (B)

Report: https://seoscoreapi.com/report/example.com

The SXO, AEO, and AIO scores appear automatically on Starter plan and above — no extra flags needed. The full report link is shareable and can be pasted into a PR comment, Slack message, or client email without any additional setup.

Build an AI SEO Agent: Automated Website Auditing with Python

Aaron VanSledright — Mon, 10 Aug 2026 14:00:03 +0000

AI agents are transforming SEO workflows. Instead of manually running audits, an AI agent can crawl your site, identify issues, prioritize fixes, and generate recommendations — all autonomously.

What is an AI SEO Agent?

An AI SEO agent is an automated program that combines structured audit data with language model reasoning to identify, prioritize, and explain SEO issues without human intervention. Rather than generating a static report, the agent interprets results and produces actionable recommendations on demand. The key distinction from a traditional script is the LLM layer: instead of hard-coded logic, the agent reasons about what the data means and what to do next.

What does the seoscoreapi Python SDK do?

The seoscoreapi Python SDK wraps the SEO Score API REST endpoints into simple function calls. It handles authentication, request formatting, and response parsing — so you call audit("https://example.com", api_key=key) and get back a structured dict with score, grade, and prioritized issue list. The SDK also exposes batch_audit() for auditing multiple URLs in a single call, and signup() for programmatically creating a free API key without visiting the dashboard.

The Architecture

An AI SEO agent uses three components: the SEO Score API to provide raw audit data (82 checks per URL on paid plans), a Python orchestration layer that loops through pages and collects results, and an LLM to interpret those results and generate human-readable recommendations. These three layers are loosely coupled — you can swap the LLM (GPT-4, Claude, Gemini) or extend the orchestration without touching the audit layer.

Manual Auditing vs. AI Agent: What Changes?

Capability	Manual workflow	AI SEO agent
Audit frequency	Weekly or monthly	Continuous or scheduled
URLs covered	5-20 by hand	500+ via batch API
Issue interpretation	Human reads raw data	LLM generates plain-English recommendations
Reporting	Manual copy-paste	Automated structured output
Alert on regressions	Check manually	Automated diff + notification
Cost per audit	Engineer time	$0-0.02 per URL via API

How do you build an AI SEO agent with Python?

Building the agent takes three steps. First, install the dependencies with pip install seoscoreapi openai. Then create the audit function: call signup("agent@yourdomain.com") to get a free API key, then pass that key and your target URL to audit(). The response includes a numeric score, letter grade, and a priorities list where each item has a severity label (critical, warning, or info) and a description of the issue. The third step is LLM analysis: pass the structured result into a prompt asking for recommendations, then call your LLM of choice to interpret the data and generate plain-English fixes.

from seoscoreapi import audit, signup
import openai

api_key = signup("agent@yourdomain.com")
result = audit("https://example.com", api_key=api_key)

prompt = f"""Analyze this SEO audit and provide 3 actionable recommendations:
Score: {result['score']}/100 ({result['grade']})
Issues: {result['priorities']}"""

response = openai.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": prompt}]
)
print(response.choices[0].message.content)

How do you automate weekly SEO audits?

To run audits on a schedule, use batch_audit() to audit an entire site in a single call, then wrap the script in a cron job or workflow tool like n8n. Pass a list of URLs — homepage, about, pricing, blog — and get back a list of structured results you can loop through. Combine with an email or Slack notification step to receive weekly score summaries and issue alerts automatically. For CI/CD pipelines, add the audit to your deploy script and fail the build if any URL drops below your target score threshold.

from seoscoreapi import batch_audit

urls = [
    "https://example.com",
    "https://example.com/about",
    "https://example.com/pricing",
    "https://example.com/blog",
]
results = batch_audit(urls, api_key=api_key)

What does the agent output after an audit?

After running an audit, the agent returns a structured response containing a numeric score (0–100), a letter grade (A+ to F), and a prioritized list of issues with severity labels (critical, warning, info). Each issue includes the check name, description, and recommended fix, making it ready to pipe directly into an LLM prompt or a downstream reporting tool.

Use Cases

Agency automation: Build an agent that audits all client sites weekly and sends reports
Content QA: Audit every new blog post before publishing to catch missing meta tags or heading issues
Competitive intelligence: Monitor competitor SEO scores daily and alert on changes
CrewAI / LangChain: Add SEO auditing as a callable tool in your AI agent framework
CI/CD quality gate: Run the agent on every deploy and fail the build if score drops below threshold
Bulk site migrations: Audit all pages before and after a migration to detect regressions
Client onboarding: Auto-generate a first-audit report for new agency clients on signup
Content freshness monitoring: Alert when a high-ranking page's SEO score drops significantly

Get Started

The free tier gives you 2 audits per day to build and test your agent. For production workloads, paid plans start at $5 per month and include batch auditing, monitoring, and up to 25,000 audits per month on the Ultra plan. No credit card is required to start — sign up with your email address and get your API key immediately.

Frequently Asked Questions

What is an AI SEO agent?

An AI SEO agent is an automated program that runs structured website audits and uses a language model to interpret results, prioritize issues, and generate actionable recommendations — removing the need for manual review at every step. The LLM layer transforms raw check data into plain-English fixes that developers and content teams can act on immediately.

What does the seoscoreapi Python SDK do?

The seoscoreapi SDK wraps the SEO Score API into simple Python function calls like audit() and batch_audit(). It handles authentication and response parsing, returning structured data with scores, grades, and issue priorities ready for downstream processing or LLM input. A signup() helper lets you programmatically create a free API key without a browser.

How do you build an AI SEO agent with Python?

Install seoscoreapi and openai via pip, call audit() with your target URL and API key, then pass the structured result — score, grade, and priorities — into an LLM prompt. The LLM interprets the data and generates specific, actionable recommendations based on detected issues. The entire setup takes under 20 lines of Python and runs from any script or scheduler.

How do you automate weekly SEO audits?

Use batch_audit() to audit multiple URLs in one call, then wrap the script in a cron job or n8n workflow to run on a schedule. Pair with a Slack or email notification step to receive weekly score summaries and issue alerts without any manual trigger. For CI/CD use, add a score threshold check to fail the pipeline when quality drops below your target.

What does the agent output after an audit?

The audit response includes a numeric score (0–100), a letter grade, and a prioritized issues list with severity labels (critical, warning, info). Each entry contains the check name, a description of the problem, and the recommended fix — structured for direct use in reports or LLM prompts. The consistent response format means the same prompt template works across every URL you audit.

Add SEO Checks to Your CI/CD Pipeline

Aaron VanSledright — Mon, 03 Aug 2026 14:00:03 +0000

Add SEO Checks to Your CI/CD Pipeline

Every deployment is a chance to accidentally break SEO. A developer removes a canonical tag, a build step strips meta descriptions, a config change adds noindex to production — and you don't find out until rankings drop weeks later. The fix is treating SEO like any other quality gate: run checks on every deployment and fail the build if something critical breaks.

Why Do SEO Checks Belong in CI/CD?

SEO regressions are invisible at deploy time. Unlike a broken API endpoint or a failing unit test, a missing <title> tag or an accidental noindex directive has no immediate error signal — it silently degrades over days or weeks as search engines recrawl and update their indexes. By the time rankings drop, the causal commit is buried under dozens of subsequent changes.

CI/CD SEO checks create the same feedback loop you have for code quality: if a deployment introduces an SEO regression, the pipeline fails, the developer sees the issue immediately, and it never reaches production.

Which Checks Matter Most in a Pipeline?

Not all 54 audit checks are equally critical at deploy time. These are the high-priority checks that justify a build failure:

Check	Why it matters	Failure threshold
Meta title	Missing or empty title tanks click-through rate	Must be present
Meta description	Direct impact on SERP snippet quality	Must be present
Canonical tag	Duplicate content and indexation issues	Must be present
Noindex directive	Accidentally blocking pages from Google	Must not be set on key pages
HTTPS	Required for ranking; marks page as insecure	Must pass
Overall score	Composite health indicator	Define your own threshold (e.g., ≥ 70)

GitHub Actions Workflow

Add this workflow to .github/workflows/seo-check.yml:

name: SEO Quality Gate

on:
  deployment_status:
  push:
    branches: [main]

jobs:
  seo-audit:
    runs-on: ubuntu-latest
    if: github.event.deployment_status.state == 'success' || github.event_name == 'push'

    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Install SEO Score API SDK
        run: pip install seoscoreapi

      - name: Run SEO audit
        env:
          SEO_API_KEY: ${{ secrets.SEO_API_KEY }}
          AUDIT_URL: "https://your-production-site.com"
          SCORE_THRESHOLD: "70"
        run: |
          python - <<'EOF'
          import os, sys
          from seoscoreapi import audit

          result = audit(os.environ["AUDIT_URL"], api_key=os.environ["SEO_API_KEY"])
          score = result["score"]
          grade = result["grade"]
          threshold = int(os.environ["SCORE_THRESHOLD"])

          print(f"SEO Score: {score}/100 ({grade})")

          failures = []
          checks = result.get("audit", {})

          if checks.get("meta", {}).get("title") == "fail":
              failures.append("CRITICAL: Missing meta title")
          if checks.get("meta", {}).get("description") == "fail":
              failures.append("CRITICAL: Missing meta description")
          if checks.get("meta", {}).get("canonical") == "fail":
              failures.append("CRITICAL: Missing canonical tag")
          if score < threshold:
              failures.append(f"Score {score} is below threshold {threshold}")

          if failures:
              print("\nSEO Quality Gate FAILED:")
              for f in failures:
                  print(f"  - {f}")
              sys.exit(1)
          else:
              print("SEO Quality Gate PASSED")
          EOF

Store your API key as a GitHub Actions secret: Settings > Secrets and variables > Actions > New repository secret named SEO_API_KEY.

How to Fail a Build If Score Drops Below a Threshold

The pattern above uses sys.exit(1) to signal failure to the CI runner. Choose your threshold based on your baseline:

70 — reasonable starting point for most sites
80 — appropriate for established sites where any regression is significant
Custom — run an initial audit, note your current score, then set the threshold 5–10 points below it

To track score over time, write the result to a GitHub Actions output or post it as a PR comment using the GitHub API:

import os, json, urllib.request

score = result["score"]
comment = f"SEO Score: **{score}/100** ({result['grade']})"

pr_number = os.environ.get("PR_NUMBER")
if pr_number:
    data = json.dumps({"body": comment}).encode()
    req = urllib.request.Request(
        f"https://api.github.com/repos/{os.environ['GITHUB_REPOSITORY']}/issues/{pr_number}/comments",
        data=data,
        headers={"Authorization": f"token {os.environ['GITHUB_TOKEN']}", "Content-Type": "application/json"}
    )
    urllib.request.urlopen(req)

GitLab CI Example

Add to .gitlab-ci.yml:

seo-audit:
  stage: test
  image: python:3.11-slim
  script:
    - pip install seoscoreapi
    - |
      python - <<'EOF'
      import os, sys
      from seoscoreapi import audit

      result = audit("https://your-site.com", api_key=os.environ["SEO_API_KEY"])
      print(f"Score: {result['score']}/100 ({result['grade']})")

      if result["score"] < 70:
          print(f"FAIL: Score {result['score']} is below threshold 70")
          sys.exit(1)
      print("PASS: SEO quality gate cleared")
      EOF
  variables:
    SEO_API_KEY: $SEO_API_KEY
  only:
    - main
    - merge_requests

Set SEO_API_KEY in Settings > CI/CD > Variables in your GitLab project.

Python Script for Custom Pipelines

For non-GitHub/GitLab pipelines (Jenkins, CircleCI, Bitbucket Pipelines, or a local pre-deploy hook):

#!/usr/bin/env python3
"""seo_gate.py — run before any deployment to catch SEO regressions."""

import sys
import os
from seoscoreapi import audit

AUDIT_URL = os.environ.get("AUDIT_URL", "https://your-site.com")
API_KEY = os.environ["SEO_API_KEY"]
THRESHOLD = int(os.environ.get("SCORE_THRESHOLD", "70"))

result = audit(AUDIT_URL, api_key=API_KEY)
score = result["score"]
grade = result["grade"]
priorities = result.get("priorities", [])

print(f"\nSEO Audit: {AUDIT_URL}")
print(f"Score: {score}/100 ({grade})")

critical_issues = [p for p in priorities if p["severity"] == "critical"]

if critical_issues:
    print(f"\n{len(critical_issues)} critical issue(s) found:")
    for issue in critical_issues:
        print(f"  - {issue['issue']}")

if score < THRESHOLD or critical_issues:
    print(f"\nSEO Quality Gate: FAILED")
    sys.exit(1)

print(f"\nSEO Quality Gate: PASSED")
sys.exit(0)

Run it as a pipeline step: SEO_API_KEY=your_key python seo_gate.py

Get Started

Get a free API key — 2 audits/day, no credit card required
Add the workflow YAML to your repo
Set SEO_API_KEY as a pipeline secret
Push to main and watch the quality gate run

For teams running audits on every PR across multiple environments, the Basic plan ($15/mo) gives you 1,000 audits/month at 30 RPM.

Frequently Asked Questions

Why should SEO checks run in CI/CD rather than on a schedule?

Scheduled audits tell you that something broke — CI/CD checks tell you which deployment broke it. Running checks at deploy time means you catch regressions in the same pull request that introduced them, before they ever reach production and before any search engine recrawls the affected pages.

Which SEO checks are most important to fail a build on?

Fail the build on missing meta title, missing meta description, missing canonical tag, and any noindex directive on pages that should be indexed. These are high-impact, unambiguous regressions. Use a score threshold (e.g., ≥ 70) as a secondary gate to catch broader degradation across multiple minor issues.

How do you set up the SEO audit GitHub Action?

Add a workflow file to .github/workflows/seo-check.yml with a Python step that installs seoscoreapi, runs audit() against your production URL, checks for critical failures, and calls sys.exit(1) if any are found. Store your API key as a GitHub Actions secret named SEO_API_KEY.

Does the SEO audit check a staging URL or the live site?

You can audit either. For catching regressions before they go live, point the audit at your staging or preview URL after deployment but before promoting to production. For production monitoring, audit the live URL as a post-deploy verification step.

How many API calls does a CI/CD pipeline use?

Each audit call counts as one request against your monthly quota. A team pushing to main once a day uses about 30 audits/month — well within the free tier. If you audit on every PR (e.g., 10 PRs/day), the Starter plan at $5/mo (200 audits/month) covers most teams comfortably.

SEO Quality Gates with GitHub Actions

Aaron VanSledright — Mon, 27 Jul 2026 14:00:03 +0000

A broken meta tag in one pull request can silently tank your search rankings for weeks. By the time you spot the traffic drop in Google Search Console, the damage is done. The fix is simple: treat SEO like a test suite and run it automatically on every PR.

This guide walks through a real, production-ready GitHub Actions workflow using the SEO Audit Action. By the end, you'll have a workflow that audits your deployed site, posts a score report as a PR comment, and fails the build if the score drops below your threshold.

What Does the GitHub Actions SEO Audit Do?

Here's what the workflow does on every pull request:

Waits for your preview deployment (Vercel, Netlify, Cloudflare Pages, etc.)
Runs a 28-check SEO audit against the preview URL
Posts the score, grade, and top issues as a PR comment
Blocks the merge if the score is below 80

The full audit covers meta tags, technical SEO, Open Graph, performance, and accessibility — the same checks you'd get from running curl https://seoscoreapi.com/audit?url=yoursite.com.

What Are the Prerequisites?

You need two things:

A free SEO Score API key — sign up here (takes 10 seconds, no credit card)
A preview deployment in your pipeline — any system that gives you a URL for the PR branch (Vercel, Netlify, Render, etc.)

Add your API key as a repository secret:

Settings > Secrets and variables > Actions > New repository secret

Name: SEO_SCORE_API_KEY
Value: your API key

How Do You Add It to a Workflow?

Start with the simplest version. Create .github/workflows/seo-audit.yml:

name: SEO Audit

on:
  pull_request:
    branches: [main]

jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - name: SEO Audit
        id: seo
        uses: SeoScoreAPI/seo-audit-action@v1
        with:
          url: "https://your-site.com"
          api-key: ${{ secrets.SEO_SCORE_API_KEY }}
          threshold: 80

That's a working quality gate in 15 lines. If the SEO score is below 80, the workflow fails and the PR can't merge (assuming you have branch protection rules enabled).

The action produces a markdown summary in the GitHub Actions UI automatically — you'll see the score, grade, issue count, and top 5 issues right in the workflow run.

How Do You Get PR Comments on Audit Results?

The summary in the Actions tab is useful, but most reviewers look at the PR conversation, not the workflow logs. Let's post the results as a PR comment:

name: SEO Audit

on:
  pull_request:
    branches: [main]

jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - name: SEO Audit
        id: seo
        uses: SeoScoreAPI/seo-audit-action@v1
        with:
          url: "https://your-site.com"
          api-key: ${{ secrets.SEO_SCORE_API_KEY }}
          threshold: 80

      - name: Comment on PR
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const score = '${{ steps.seo.outputs.score }}';
            const grade = '${{ steps.seo.outputs.grade }}';
            const issues = '${{ steps.seo.outputs.issues }}';
            const reportUrl = '${{ steps.seo.outputs.report-url }}';
            const passed = parseInt(score) >= 80;

            const body = [
              `## SEO Audit Results`,
              ``,
              `| Metric | Value |`,
              `|--------|-------|`,
              `| Score | **${score}/100** |`,
              `| Grade | **${grade}** |`,
              `| Issues | ${issues} |`,
              `| Threshold | 80 |`,
              `| Status | ${passed ? 'Passed' : 'Failed'} |`,
              ``,
              `[View Full Report](${reportUrl})`,
            ].join('\n');

            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body
            });

The if: always() is important — it ensures the comment is posted even when the audit step fails due to a low score. Without it, a failing score would skip the comment step and you'd have to dig into the logs to find out what went wrong.

Real-World Example: Vercel Preview Deployments

Most teams don't audit a static production URL — they audit the preview deployment that Vercel (or Netlify, etc.) creates for each PR. Here's how to wire that up:

name: SEO Audit on Preview

on:
  pull_request:
    branches: [main]
    paths:
      - '**.html'
      - '**.jsx'
      - '**.tsx'
      - '**.vue'
      - '**.svelte'
      - 'content/**'
      - 'public/**'

jobs:
  seo:
    runs-on: ubuntu-latest
    steps:
      - name: Wait for Vercel Preview
        uses: patrickedqvist/wait-for-vercel-preview@v1.3.2
        id: preview
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          max_timeout: 300

      - name: SEO Audit
        id: seo
        uses: SeoScoreAPI/seo-audit-action@v1
        with:
          url: ${{ steps.preview.outputs.url }}
          api-key: ${{ secrets.SEO_SCORE_API_KEY }}
          threshold: 80

      - name: Comment on PR
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const score = '${{ steps.seo.outputs.score }}';
            const grade = '${{ steps.seo.outputs.grade }}';
            const issues = '${{ steps.seo.outputs.issues }}';
            const reportUrl = '${{ steps.seo.outputs.report-url }}';
            const previewUrl = '${{ steps.preview.outputs.url }}';
            const passed = parseInt(score) >= 80;

            const emoji = passed ? '✅' : '❌';

            const body = [
              `## ${emoji} SEO Audit`,
              ``,
              `Audited: ${previewUrl}`,
              ``,
              `| Metric | Value |`,
              `|--------|-------|`,
              `| Score | **${score}/100** |`,
              `| Grade | **${grade}** |`,
              `| Issues | ${issues} |`,
              `| Threshold | 80 |`,
              ``,
              `[Full Report](${reportUrl})`,
            ].join('\n');

            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body
            });

Three things worth noting about this version:

Path filters — the paths block ensures the audit only runs when files that affect SEO are changed. Backend-only PRs (API routes, database migrations, config changes) skip the audit entirely. This is important because audits cost API calls, and you don't want to burn them on changes that can't affect your SEO score.

Preview URL — instead of hardcoding a URL, we pull it from the Vercel preview deployment. Every PR gets its own preview URL, so you're auditing the actual changes in that PR, not the current production site.

Timeout — max_timeout: 300 gives Vercel 5 minutes to deploy. Adjust this based on your build times.

Netlify Variant

If you're on Netlify instead of Vercel, swap the preview step:

      - name: Wait for Netlify Preview
        uses: jakepartusch/wait-for-netlify-action@v1.4
        id: preview
        with:
          site_name: "your-netlify-site"
          max_timeout: 300

The rest of the workflow stays identical — just reference ${{ steps.preview.outputs.url }}.

Multi-Page Audits

For sites where SEO matters on more than one page, use a matrix strategy to audit multiple routes:

jobs:
  seo:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        path: ['/', '/pricing', '/blog', '/docs']
    steps:
      - name: SEO Audit - ${{ matrix.path }}
        id: seo
        uses: SeoScoreAPI/seo-audit-action@v1
        with:
          url: "https://your-site.com${{ matrix.path }}"
          api-key: ${{ secrets.SEO_SCORE_API_KEY }}
          threshold: 80

This runs 4 parallel audits — one per page. If any page drops below 80, that specific job fails. You can see exactly which page regressed in the Actions UI.

For larger sites (10+ pages), use the batch audit endpoint with a script step instead of the matrix approach to use fewer API calls.

How Do You Set Up Branch Protection?

The workflow only blocks merges if you configure branch protection:

Go to Settings > Branches > Branch protection rules
Add a rule for main
Check Require status checks to pass before merging
Search for and add the SEO Audit check

Now any PR where the SEO score drops below your threshold literally cannot be merged until the issues are fixed.

Choosing Your Threshold

Threshold	Best For
90	Marketing sites, landing pages where SEO directly drives revenue
80	Most production sites — catches real issues without false positives
70	Apps with some public-facing pages where SEO is secondary
60	Internal tools with minimal SEO requirements

Start at 70 if your site has existing issues, then ratchet up to 80 once the team has fixed the backlog. Don't start at 90 — you'll frustrate developers with failures on day one and they'll disable the check.

Which Plans Support CI/CD Use?

The free tier gives you 2 audits/day, which works for solo projects with a couple PRs per week. For teams:

Plan	Audits/mo	Price	Good For
Starter	200	$5/mo	Small team, 1-2 PRs/day
Basic	1,000	$15/mo	Active team, multi-page audits
Pro	5,000	$39/mo	Multiple repos, matrix audits

All paid plans support CI/CD use. The free tier is sufficient for personal projects; Starter or above is recommended for active teams. Sign up free and upgrade when your PR volume outgrows the free tier.

The Complete Workflow

Here's the full production-ready workflow with all the pieces — preview deployment, PR comments, path filtering, and the quality gate:

name: SEO Quality Gate

on:
  pull_request:
    branches: [main]
    paths:
      - '**.html'
      - '**.jsx'
      - '**.tsx'
      - '**.vue'
      - '**.svelte'
      - 'content/**'
      - 'public/**'

jobs:
  seo-audit:
    runs-on: ubuntu-latest
    steps:
      - name: Wait for Preview Deploy
        uses: patrickedqvist/wait-for-vercel-preview@v1.3.2
        id: preview
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
          max_timeout: 300

      - name: Run SEO Audit
        id: seo
        uses: SeoScoreAPI/seo-audit-action@v1
        with:
          url: ${{ steps.preview.outputs.url }}
          api-key: ${{ secrets.SEO_SCORE_API_KEY }}
          threshold: 80

      - name: Post Results to PR
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const score = '${{ steps.seo.outputs.score }}';
            const grade = '${{ steps.seo.outputs.grade }}';
            const issues = '${{ steps.seo.outputs.issues }}';
            const reportUrl = '${{ steps.seo.outputs.report-url }}';
            const previewUrl = '${{ steps.preview.outputs.url }}';
            const passed = parseInt(score) >= 80;

            const emoji = passed ? '✅' : '❌';
            const status = passed ? 'Passed' : 'Failed — fix issues before merging';

            const body = [
              `## ${emoji} SEO Audit`,
              ``,
              `**${status}**`,
              ``,
              `| Metric | Value |`,
              `|--------|-------|`,
              `| Preview | ${previewUrl} |`,
              `| Score | **${score}/100** |`,
              `| Grade | **${grade}** |`,
              `| Issues | ${issues} |`,
              `| Threshold | 80 |`,
              ``,
              `[View Full Report →](${reportUrl})`,
            ].join('\n');

            github.rest.issues.createComment({
              owner: context.repo.owner,
              repo: context.repo.repo,
              issue_number: context.issue.number,
              body
            });

Copy that into .github/workflows/seo-audit.yml, add your SEO_SCORE_API_KEY secret, enable branch protection, and you have an automated SEO quality gate protecting your site from regressions on every pull request.

Frequently Asked Questions

What does the GitHub Actions SEO Audit action do?

The SEO Audit Action runs a 28-check SEO audit against your site on every pull request. It checks meta tags, technical SEO, Open Graph, performance, and accessibility, then posts a score and grade as a PR comment and fails the build if the score drops below your configured threshold.

How do you add the SEO audit to a GitHub Actions workflow?

Create .github/workflows/seo-audit.yml, add the SeoScoreAPI/seo-audit-action@v1 step with your url, api-key (stored as a repository secret), and a threshold value. The action installs automatically — no additional dependencies or setup scripts required.

What score threshold triggers a build failure?

The threshold is configurable via the threshold input parameter. The default recommendation is 80 for most production sites. Scores below your threshold fail the workflow step, which blocks the PR from merging when branch protection is enabled. Start at 70 for sites with existing issues, then raise it over time.

How do PR comments with audit results work?

Add a second step using actions/github-script@v7 with if: always(). It reads the score, grade, issues, and report-url outputs from the audit step and posts them as a formatted comment on the pull request. The if: always() ensures the comment appears even when the audit fails.

Which plans support CI/CD use with GitHub Actions?

All plans, including the free tier (2 audits/day), support CI/CD use. The free tier works for solo projects with a few PRs per week. For active teams, the Starter plan ($5/mo, 200 audits/month) or Basic plan ($15/mo, 1,000 audits/month) is recommended depending on PR volume and multi-page audit needs.

Node SDK 1.3: Run SEO Audits, Track Trends, and Get Slack Alerts from Any Node Project

Aaron VanSledright — Mon, 20 Jul 2026 14:00:05 +0000

The Node.js client for SEO Score API is at 1.3.0 on npm. It mirrors the Python release we shipped at the same time: a new compare() function for side-by-side URL diffs, full history() and historyDomains() timeseries access, and webhook alerts on the monitor system (Slack-formatted automatically when you point it at an incoming webhook).

Install or upgrade with:

npm install seoscoreapi@latest

Or with pnpm/yarn — same name, no native dependencies, runs anywhere Node 18+ has fetch available.

What's new in 1.3

Function	Endpoint	Tier
`compare(urls, apiKey)`	`POST /compare`	Basic+
`history(url, apiKey, opts)`	`GET /history`	Starter+
`historyDomains(apiKey)`	`GET /history/domains`	Starter+
`addMonitor(url, apiKey, { webhookUrl, alertThreshold })`	`POST /monitors`	Paid

addMonitor is backwards compatible — the legacy addMonitor(url, apiKey, "weekly") form still works, but if you want webhooks you'll pass an options object instead.

1. Compare your page against 2–4 competitors in one call

compare() accepts 2–5 URLs and returns each one's score plus a diff block telling you who is ahead, per category, per pair:

const { compare } = require("seoscoreapi");

const result = await compare(
  [
    "https://acme.com/pricing",
    "https://competitor-a.com/pricing",
    "https://competitor-b.com/pricing",
  ],
  process.env.SEOSCORE_API_KEY,
);

for (const url of result.urls) {
  console.log(`${url.url}: ${url.score} (${url.grade})`);
}

for (const gap of result.diff.category_gaps) {
  console.log(`${gap.category}: leader ${gap.leader} (+${gap.gap.toFixed(1)})`);
}

This one's Basic plan ($15/mo) and up. It's the call we use to power the agency-style "where do we stand?" dashboards customers have been building on top of the API.

2. Pull historical scores for any URL

If your account has been running audits on a paid plan, every audit's full score breakdown is already in our database. history() returns the full timeseries plus a summary block:

const { history } = require("seoscoreapi");

const data = await history(
  "https://acme.com",
  process.env.SEOSCORE_API_KEY,
  { limit: 90 },
);

console.log(`${data.count} audits tracked`);
console.log(`First: ${data.summary.first_score}`);
console.log(`Latest: ${data.summary.latest_score}`);
console.log(`Total delta: ${data.summary.total_delta.toFixed(1)}`);

Retention windows are tied to your tier — Starter sees 30 days, Basic 90, Pro a year, Ultra unlimited. The deeper write-up on what's in the history block is in the historical comparison post.

3. One-shot view of every domain you've audited

historyDomains() returns one row per domain on your key, with the latest score and a 30-day trend:

const { historyDomains } = require("seoscoreapi");

const domains = await historyDomains(process.env.SEOSCORE_API_KEY);
domains.sort((a, b) => (a.trend_30d ?? 0) - (b.trend_30d ?? 0));

console.log("Worst trends this month:");
for (const d of domains.slice(0, 10)) {
  const arrow = (d.trend_30d ?? 0) < 0 ? "↓" : "↑";
  console.log(`  ${d.domain.padEnd(40)} ${d.latest_score} ${arrow}${Math.abs(d.trend_30d ?? 0).toFixed(1)}`);
}

Single API call, one row per domain. Use it for a Slack digest, an agency dashboard, or to feed an LLM that's writing a quarterly recap.

4. Get Slack alerts on score drops

addMonitor() now takes a webhookUrl and alertThreshold:

const { addMonitor } = require("seoscoreapi");

await addMonitor(
  "https://acme.com",
  process.env.SEOSCORE_API_KEY,
  {
    frequency: "daily",
    webhookUrl: "https://hooks.slack.com/services/T0/B0/xxxx",
    alertThreshold: 5, // alert when the score drops 5+ points
  },
);

If the webhook URL points at hooks.slack.com, the payload is auto-formatted as Block Kit so it renders cleanly. Any other https endpoint gets the raw event JSON — wire it into PagerDuty, Discord, n8n, or your own service.

Three places to drop this into a Node project

Express middleware that runs an SEO audit on demand

const express = require("express");
const { audit } = require("seoscoreapi");

const app = express();

app.get("/seo-check", async (req, res) => {
  const result = await audit(req.query.url, process.env.SEOSCORE_API_KEY);
  res.json({
    score: result.score,
    grade: result.grade,
    delta: result.history?.delta,
    top_issues: (result.priorities || []).slice(0, 3),
  });
});

app.listen(3000);

The result.history.delta field is what makes this useful in production: every audit response on a paid plan tells you whether the score moved since last time and by how much.

Next.js API route for an internal dashboard

// app/api/seo-snapshot/route.js
import { historyDomains } from "seoscoreapi";

export async function GET() {
  const domains = await historyDomains(process.env.SEOSCORE_API_KEY);
  return Response.json({
    domains: domains.map((d) => ({
      domain: d.domain,
      score: d.latest_score,
      grade: d.latest_grade,
      trend_30d: d.trend_30d,
    })),
  });
}

That's the entire backend for an internal "all our brands at a glance" page.

Stand-alone weekly CLI you run from cron

#!/usr/bin/env node
const { historyDomains } = require("seoscoreapi");

const domains = await historyDomains(process.env.SEOSCORE_API_KEY);
const dropped = domains.filter((d) => (d.trend_30d ?? 0) <= -2.0);

if (dropped.length === 0) {
  console.log("All domains stable.");
  process.exit(0);
}

console.log(`${dropped.length} domains down 2+ points:`);
for (const d of dropped) {
  console.log(`  ${d.domain}: ${d.latest_score} (${d.trend_30d.toFixed(1)} 30d)`);
}
process.exit(1);

Pipe the output to email or wire it to a Slack incoming webhook, schedule it weekly with cron or a CI pipeline, and you've got an automated Monday-morning report.

Upgrading from 1.2

Strict additive update. addMonitor() accepts the new options object form or the legacy (url, apiKey, "daily") string form, so existing code keeps working. The new functions are pure additions.

npm install seoscoreapi@latest

The full reference is in the README and at /docs. If you don't have a key yet, grab a free one or start on Starter for $5/mo.

Python SDK 1.3: Historical Trends, URL Comparisons, and Slack Alerts in Three Lines Each

Aaron VanSledright — Mon, 13 Jul 2026 14:00:03 +0000

The Python client for SEO Score API hit 1.3.0 today. It picks up everything we shipped through the latest sprint: side-by-side URL comparison, the /history and /history/domains endpoints, and webhook alerts (Slack-formatted by default) on the monitor system.

If you already have seoscoreapi installed, upgrade with:

pip install --upgrade seoscoreapi

Then the rest of this post is a tour of what the new functions actually do.

What's in 1.3

Function	Endpoint	Tier
`compare(urls, api_key)`	`POST /compare`	Basic+
`history(url, api_key, limit=100, since=None)`	`GET /history`	Starter+
`history_domains(api_key)`	`GET /history/domains`	Starter+
`add_monitor(..., webhook_url, alert_threshold)`	`POST /monitors`	Paid

competitive_audit() and report_url() were already in 1.2 — they're listed here for completeness because they pair well with the new history functions.

1. Compare your page against competitors in one call

Before 1.3, doing a head-to-head comparison meant calling /audit for each URL and computing diffs yourself. Now compare() does it server-side and returns a structured diff block:

import os
from seoscoreapi import compare

result = compare(
    [
        "https://acme.com/pricing",
        "https://competitor-a.com/pricing",
        "https://competitor-b.com/pricing",
    ],
    api_key=os.environ["SEOSCORE_API_KEY"],
)

for url_data in result["urls"]:
    print(f"{url_data['url']}: {url_data['score']} ({url_data['grade']})")

print("\nGap analysis:")
for entry in result["diff"]["category_gaps"]:
    print(f"  {entry['category']}: leader is {entry['leader']} (+{entry['gap']:.1f})")

compare() accepts 2–5 URLs in a single request and returns each URL's full audit, plus the diff object that tells you who is ahead in every category. It's Basic plan ($15/mo) and up.

This is the hook agency people have been asking for — drop it into a Streamlit or Slack-bot and you've got a "where do we stand against the top 3 competitors?" tool in 30 lines.

2. Pull the full audit history for any URL

If you've been auditing a URL on a paid plan, every audit's score breakdown is already in our database. history() returns the full timeseries plus a summary block:

from seoscoreapi import history

data = history("https://acme.com", api_key=os.environ["SEOSCORE_API_KEY"])

print(f"Tracked: {data['count']} audits")
print(f"  First: {data['summary']['first_score']}")
print(f"  Latest: {data['summary']['latest_score']}")
print(f"  Total delta: {data['summary']['total_delta']:+.1f}")
print(f"  Min/Max: {data['summary']['min_score']}/{data['summary']['max_score']}")

# Plot it
import matplotlib.pyplot as plt
ts = [p["timestamp"] for p in data["history"]]
scores = [p["score"] for p in data["history"]]
plt.plot(ts, scores)
plt.savefig("acme-trend.png")

history() accepts limit and since parameters if you want to scope the response. The retention windows are tied to your tier:

Plan	Retention
Starter ($5/mo)	30 days
Basic ($15/mo)	90 days
Pro ($39/mo)	1 year
Ultra ($99/mo)	Unlimited

For a deeper write-up on what's in the history block, see the historical comparison post.

3. Get a one-shot view of every domain you track

history_domains() is the "all your stuff at a glance" call:

from seoscoreapi import history_domains

domains = history_domains(api_key=os.environ["SEOSCORE_API_KEY"])

# Sort by 30-day trend, worst first
domains.sort(key=lambda d: d.get("trend_30d", 0))

for d in domains[:10]:
    arrow = "↓" if d.get("trend_30d", 0) < 0 else "↑"
    print(f"{d['domain']:40} {d['latest_score']:>3} {arrow}{abs(d.get('trend_30d', 0)):.1f}")

One call, one row per domain you've ever audited. Use it for an agency-wide "who needs attention this week?" dashboard or a Slack digest.

4. Get alerted in Slack when a score drops

add_monitor() now takes webhook_url and alert_threshold. If the webhook URL is a Slack incoming-webhook, the payload is auto-formatted as Block Kit:

from seoscoreapi import add_monitor

add_monitor(
    "https://acme.com",
    api_key=os.environ["SEOSCORE_API_KEY"],
    frequency="daily",
    webhook_url="https://hooks.slack.com/services/T0/B0/xxxx",
    alert_threshold=5,  # alert when the score drops 5+ points
)

A 5-point drop on Acme's homepage now pings your #seo-alerts channel within minutes of the next scheduled audit run. Other https endpoints get the raw event JSON, so you can route alerts into PagerDuty, Discord, your own SIEM — anything that takes a webhook.

The alert_threshold is in score points, not percent. Five points is a reasonable starting value: small enough to catch real regressions, large enough to ignore the kind of noise that comes from a slow Core Web Vitals reading on a single audit.

A complete worked example: the 30-line agency monitor

Putting it together, here's the entire script we run for a small in-house team. It uses every new function in 1.3:

import os
from seoscoreapi import history_domains, history, compare

API_KEY = os.environ["SEOSCORE_API_KEY"]

# 1. Find URLs that dropped 2+ points this month
domains = history_domains(API_KEY)
dropped = [d for d in domains if d.get("trend_30d", 0) <= -2.0]
dropped.sort(key=lambda d: d["trend_30d"])

print(f"## {len(dropped)} URLs to investigate\n")

# 2. For each, pull the timeseries to see when the drop happened
for d in dropped[:5]:
    h = history(f"https://{d['domain']}", API_KEY, limit=20)
    points = h["history"][-5:]
    print(f"### {d['domain']}")
    for p in points:
        print(f"  {int(p['timestamp'])}: {p['score']}")

# 3. Compare your worst one against two competitors
worst = dropped[0]
result = compare(
    [
        f"https://{worst['domain']}",
        "https://competitor-a.com",
        "https://competitor-b.com",
    ],
    API_KEY,
)
for u in result["urls"]:
    print(f"\n{u['url']}: {u['score']} ({u['grade']})")

That's a daily report that used to take a half-day in spreadsheets, in 30 lines, billable as a fixed-price retainer add-on. The full SDK reference is in the README and the auto-generated API docs.

Upgrading from 1.2

Nothing breaks. add_monitor() gets two new optional kwargs, but every existing call works as-is. The new functions (compare, history, history_domains) were either new in this release or added in 1.2 — if you've been on 1.2 already, this is a strict additive update.

pip install --upgrade seoscoreapi

If you don't have a key yet, grab a free one or start on Starter for $5/mo to get historical tracking on day one.

SEO Audit API for Developers: Complete Guide

Aaron VanSledright — Mon, 06 Jul 2026 14:00:04 +0000

SEO Audit API for Developers: Complete Guide

The SEO Score API is a REST API that runs a full technical SEO audit on any URL and returns a structured JSON response with a score, grade, and prioritized list of issues — covering meta tags, performance, accessibility, structured data, and AI readiness in a single call. For the endpoint overview, response shape, and full check list, see the SEO audit API reference; this guide walks through integrating it as a developer.

What is the SEO Score API?

The SEO Score API performs instant, headless-browser-backed audits across 54 checks and returns structured results in under 5 seconds. There's no scraping to manage, no Playwright setup required on your end, and no rate-limit gymnastics — just a single GET request per URL. It's designed for developers who want to add SEO intelligence to their applications, dashboards, or CI/CD pipelines without building the audit engine themselves.

How does authentication work?

Every request must include your API key in the X-API-Key header:

curl "https://seoscoreapi.com/audit?url=https://example.com" \
  -H "X-API-Key: YOUR_KEY_HERE"

You can get a free key (2 audits/day) at seoscoreapi.com/#signup — no credit card required. Paid plans start at $5/mo for 200 audits/month.

The /audit Endpoint

GET /audit?url={url}

Response example

{
  "url": "https://example.com",
  "score": 74,
  "grade": "B",
  "priorities": [
    {
      "severity": "critical",
      "issue": "Missing meta description",
      "recommendation": "Add a 120–165 character meta description tag."
    },
    {
      "severity": "warning",
      "issue": "Page load time 2.8s",
      "recommendation": "Optimize images and enable compression to get below 2s."
    }
  ],
  "audit": {
    "meta": { "title": "pass", "description": "fail", "canonical": "pass" },
    "performance": { "load_time_ms": 2800, "compression": "pass" },
    "accessibility": { "lang": "pass", "alt_tags": "warning" },
    "structured_data": { "json_ld": "pass", "og_tags": "pass" },
    "ai_readiness": { "robots_ai": "fail", "llms_txt": "fail" }
  }
}

Python SDK Example

Install the SDK:

pip install seoscoreapi

Run an audit in 5 lines:

from seoscoreapi import audit, signup

api_key = signup("you@example.com")  # one-time free key creation
result = audit("https://example.com", api_key=api_key)
print(f"Score: {result['score']}/100 ({result['grade']})")

Iterate over issues:

for issue in result["priorities"]:
    print(f"[{issue['severity'].upper()}] {issue['issue']}")
    print(f"  Fix: {issue['recommendation']}")

JavaScript / curl Examples

Node.js (fetch):

const response = await fetch(
  "https://seoscoreapi.com/audit?url=https://example.com",
  { headers: { "X-API-Key": "YOUR_KEY_HERE" } }
);
const data = await response.json();
console.log(`Score: ${data.score}/100 (${data.grade})`);

curl with jq:

curl -s "https://seoscoreapi.com/audit?url=https://example.com" \
  -H "X-API-Key: YOUR_KEY" | jq '{score, grade, issues: .priorities | length}'

The 5 Audit Categories

Category	What it covers	Example checks
Meta	On-page SEO fundamentals	Title tag, meta description, canonical, robots meta
Performance	Speed and delivery signals	Load time, compression, render-blocking scripts
Accessibility	Usability and standards	`lang` attribute, image alt text, heading structure
Structured Data	Rich result eligibility	JSON-LD presence, Open Graph tags, schema types
AI Readiness	LLM discoverability	AI bot access in robots.txt, llms.txt, SSR, fact density

On paid plans (Starter and above), three additional scoring dimensions are returned: SXO (search experience), AEO (answer engine eligibility), and AIO (AI optimization) — each with their own score, grade, and check breakdown.

Error Handling

Status	Meaning	Action
`401 Unauthorized`	Missing or invalid API key	Check the `X-API-Key` header value
`422 Unprocessable Entity`	Invalid or missing URL parameter	Ensure `url` is a valid, fully-qualified URL
`429 Too Many Requests`	Rate limit or daily quota exceeded	Back off and retry, or upgrade your plan

All error responses include a JSON body with a detail field explaining the specific problem.

Get Started

Free key — Sign up here for 2 audits/day, no credit card
Python SDK — pip install seoscoreapi
npm SDK — npm install seoscoreapi
Paid plans — start at $5/mo for 200 audits/month at seoscoreapi.com/#pricing

Frequently Asked Questions

What is the SEO Score API?

The SEO Score API is a REST API that runs instant technical SEO audits on any URL using a headless browser. It returns a structured JSON response with a 0–100 score, letter grade, and prioritized issue list covering 54 checks across meta, performance, accessibility, structured data, and AI readiness.

How do you authenticate with the SEO Score API?

Authentication uses an X-API-Key header on every request. Get a free key at seoscoreapi.com — it gives you 2 audits per day with no credit card required. Paid plans starting at $5/mo increase limits to 200–25,000 audits per month.

What does the /audit endpoint return?

The /audit endpoint returns a JSON object with score (0–100), grade (A+ to F), priorities (an array of issues with severity and recommended fix), and a full audit object broken into five categories. Paid plans also include sxo, aeo, and aio scoring objects.

How do you handle 429 rate limit errors?

A 429 response means you've hit either your per-minute rate limit (RPM) or your daily/monthly quota. Implement exponential backoff and retry after the interval suggested in the response. For sustained high-volume needs, upgrade to a higher plan — Pro allows 60 RPM and 5,000 audits/month.

Is there a Python or JavaScript SDK?

Yes. Install the Python SDK with pip install seoscoreapi and the JavaScript SDK with npm install seoscoreapi. Both wrap the REST API with typed function calls, handle authentication, and return parsed response objects — no raw HTTP requests needed for common operations.

SEO audits in Claude + Cursor: our new MCP server

Aaron VanSledright — Mon, 29 Jun 2026 14:00:03 +0000

SEO audits in Claude + Cursor: our new MCP server

We just shipped an official Model Context Protocol server. Install it once and Claude Desktop, Claude Code, Cursor, Windsurf, and any MCP-aware AI tool gets direct access to:

Full SEO audits (audit, batch_audit)
Your monitoring (add_monitor, list_monitors)
Audit-score history (history, history_domains)
Public report URLs (report_url)
Plan and usage (usage)
Observed backlinks (backlinks, Basic plan and up)

That's nine tools your AI can reach for the moment you ask "audit this URL" or "what backlinks point at my-startup.com?"

Why MCP matters for SEO

Most AI tools today guess at SEO. The model has a fuzzy idea of what a good page looks like, an even fuzzier idea of how Google ranks anything in 2026, and zero idea what your specific page actually scores. So you get advice like "make sure your meta description is between 150 and 160 characters" — true, generic, and unverifiable.

MCP changes the shape of that conversation. The AI doesn't need to guess; it can call our scoring engine directly. The same 82-check audit your CI pipeline runs is now one tool call away from any prompt.

The difference in practice:

Before MCP

"Hey Claude, can you audit my site?"
"I can't access URLs directly, but here are some general tips: make sure your title tags are 50-60 characters, write descriptive meta descriptions..."

After MCP

"Hey Claude, can you audit my site?"
(Claude calls the audit tool against https://seoscoreapi.com.)
"Your site scores 97.9 / A+. The only category with a flag is meta — your homepage description is 154 chars, well within range. AI readability scores 96/A+. The top priority would be... actually you have zero priorities right now. You're clean."

That's not a parlor trick. That's grounded answer-engine output, and it's exactly the kind of answer LLMs are starting to be measured on.

Install in 30 seconds

npx -y seoscoreapi-mcp

Or, in your AI client's config:

{
  "mcpServers": {
    "seoscoreapi": {
      "command": "npx",
      "args": ["-y", "seoscoreapi-mcp"],
      "env": { "SEO_SCORE_API_KEY": "ssa_your_key_here" }
    }
  }
}

Get a free API key. The free tier covers 2 audits per day with no card required — enough to wire up the MCP server and run your first batch.

Full setup instructions for Claude Desktop, Claude Code, Cursor, and Windsurf are in the README.

What you can ask once it's installed

Real prompts that route through the MCP tools without you specifying which one:

"Audit https://stripe.com and tell me the top 3 things to fix."

"Compare the AI readability scores of stripe.com, square.com, and adyen.com."

"What backlinks have we observed pointing at my-startup.com?"

"Show me the score history for our marketing site over the last 30 days."

"Are any of my monitored URLs trending down?"

The AI picks the right tool. You don't.

The `backlinks` tool deserves its own paragraph

This is unique to SEO Score API. Every audit our customers run contributes to a growing backlink graph: external links observed on each audited page get persisted into a public dataset. The backlinks tool surfaces that dataset for any domain, with an explicit data_caveat in every response.

It is not a comprehensive backlink index — Ahrefs crawls 8 billion pages a day and we don't, and we say so. It is honest, audit-fed, and grows with usage. For "show me referring pages we have actually seen," it works exactly the way you'd want.

> What backlinks does SEO Score API see pointing to stripe.com?

(via `backlinks` tool)

stripe.com:
  total observations: 142
  referring domains: 38
  top referring: docs.stripe.com (24), github.com (18), ...
  data_caveat: Backlinks observed during SEO Score API audits.
  Not exhaustive — coverage grows over time.

No competitor with our pricing offers anything like this, because no competitor has the audit volume we do feeding the graph.

Why we're shipping this now

Two reasons.

One: every developer audience we care about is moving into MCP-aware tools. Claude Desktop has it, Claude Code has it, Cursor has it, Windsurf has it, the OpenAI agents framework has it. If our API isn't reachable from the place customers actually do their work in 2026, we're invisible — even when we're the right answer.

Two: MCP is the cleanest possible packaging of the API. There's no SDK to learn, no auth dance to script, no batching to build. The user types a question, the AI picks the tool, the API answers. Friction approaches zero. That's the kind of leverage we want.

We have official Python and Node SDKs. We have a GitHub Action for CI. We have an n8n community node. The MCP server is the same idea — meet developers where they already are — pointed at AI clients instead of CI runners.

Source + license

seoscoreapi-mcp is MIT-licensed and open source. The whole server is one file you can read in five minutes:

https://github.com/avansledright/seoscoreapi.com/tree/main/sdks/mcp

If you build something on top of it, send us the link. We'll feature interesting integrations on the blog.

Try it

Get a free API key — 30 seconds, no card.
Add the MCP config to your AI client of choice.
Restart the client.
Ask: "Audit https://example.com."

That is the entire onboarding.

What We're Seeing After 8,000 SEO Audits

Aaron VanSledright — Thu, 25 Jun 2026 19:00:13 +0000

When you operate an SEO audit API, you end up with a strange vantage point. You don't see the full web — you see whatever sites people are bothering to check. That sample is biased: agencies running their client roster, developers wiring up CI checks, builders auditing their own pages. It is not a random crawl of the internet.

But it is a fairly honest cross-section of the sites that someone, somewhere, cared enough about to audit. And after running roughly 8,000 audits, the patterns are remarkably consistent.

Here's what we're seeing.

Most sites land in the same narrow band

The single most surprising finding wasn't about a specific issue. It was about how little spread there is in scores.

Average score: ~73 / 100
Median: ~73
~90% of all audits land between 70 and 79

Roughly 8% score 80 or higher. Almost nothing scores below 60. The web isn't bimodal between "great" and "terrible" sites — it's a giant middle. Most sites are doing the basics, missing the same handful of intermediate things, and getting a soft B as a result.

That tight clustering matters strategically: if you're operating in this range, the work to move from a 73 to an 85 is mostly the same five fixes applied to almost every site we see.

The five issues that show up almost everywhere

When we tally the top-five priority issues flagged on each audit, five items dominate — each appearing on roughly 9 out of 10 audits we've run:

Issue	Share of audits flagging it
No structured data (schema.org)	~94%
No sitemap.xml	~93%
Missing meta description	~92%
No canonical tag	~92%
Thin content on the audited page	~88%

These aren't exotic problems. They're not algorithm-update edge cases. They're the items every SEO checklist has had on it for a decade. And yet they're nearly universal.

A few notes on what's going on under each:

Structured data isn't optional anymore. Google's AI Overviews, ChatGPT search citations, and Perplexity's source picker all lean on schema to disambiguate what a page is about. A site without Article, Organization, or Product schema is asking AI search to guess.
Sitemap.xml is the cheapest crawl-budget signal you can give a search engine, and most sites still don't have one, or have one that isn't referenced from robots.txt.
Meta description isn't a ranking factor — but it's a click-through factor, which is a downstream ranking factor. Letting Google auto-generate it from page content is leaving CTR on the table.
Canonical tags are the single most reliable way to prevent self-inflicted duplicate-content problems. Most sites still don't set them.
Thin content here usually means the audited URL itself was light on text — landing pages, footer-linked utility pages, "about" stubs. Worth deciding whether those pages should be indexed at all.

Performance is not where most sites are losing

This one cut against my expectations. The performance category — request timing, response size, a basic look at render readiness — averages around 97 / 100 across all audits.

The "your site is slow" narrative is mostly outdated for the modern web. Cloudflare, Vercel, Netlify, and standard CDN setups have made fast-by-default the norm. The sites failing on performance are now the exception, not the rule.

Where they still exist, the failure mode is almost always the same: a heavy WordPress install with a page-builder theme stacking 30+ render-blocking scripts. The fix isn't tuning — it's a different stack.

The social / AI surface area is broken almost everywhere

Inversely, the social score average sits at around 41 / 100. This is the metadata that controls how a page renders when shared in Slack, LinkedIn, iMessage, X, Facebook — and increasingly, how AI search engines build their preview cards.

The pattern: sites have some OpenGraph tags (often whatever the CMS auto-generates), but they're missing og:image, twitter:card, structured author data, and consistent canonical URLs. The result is that when a link gets shared — which is increasingly the dominant traffic source for content sites — the unfurl looks like a 2012 Reddit post.

This is the highest ROI fix in the whole list, because it's the one your traffic source actually sees first.

What the numbers don't tell you

A few honest caveats, because the data has limits:

The sample skews toward sites being audited. Sites run through an audit API are disproportionately professional/SaaS/agency clients. Genuinely abandoned or amateur sites are underrepresented.
Repeated audits of the same page count separately. If a developer wires up an audit into CI, that one URL gets audited dozens of times. The aggregate is "audits run," not "unique sites."
Top-5 priorities is a per-audit ranking. An issue showing up in 92% of audits' top 5 doesn't mean 92% of sites have it — it means it's almost always severe enough to be flagged in the top 5 when present.

So treat the numbers as directional rather than demographic. They tell you what shows up over and over when professionals look at the sites they care about. That's still useful.

The actionable read

If you're prioritizing SEO work in 2026, the data suggests a clear order:

Ship structured data first. This is your AI search insurance policy.
Fix social/OG metadata. Highest visibility per hour of effort.
Audit canonical and sitemap setup. Cheapest "crawl hygiene" wins available.
Stop worrying about base performance unless you're on WordPress with a heavy theme. You probably already pass.
Decide which thin pages should be indexed and noindex the rest, rather than trying to bulk them up.

None of these are new. The takeaway from 8,000 audits isn't what to do — it's how few sites have done it.

If you want to see where your site sits in this distribution, run an audit — it takes about 12 seconds.