An SEO checker API is an SEO checker that returns its results as machine-readable JSON instead of a dashboard. Every check returns a structured pass/fail, a numeric score, and the value found — so the next thing in your pipeline can act on it without a human in the loop.

That distinction is the entire reason to use an API over a tool like Screaming Frog or a SaaS dashboard. The dashboard is for humans clicking through findings. The API is for code that already knows what to do once it has the answer.

What "pass/fail per check" actually means

When you hit GET /audit?url=https://example.com against SEO Score API, you get back a response that looks like this (trimmed):

{
  "score": 78,
  "grade": "B",
  "audit": {
    "meta_content": {
      "score": 92,
      "checks": [
        {"id": "title_present", "status": "pass", "value": "Example Domain"},
        {"id": "title_length", "status": "pass", "value": 14, "ideal": "30-60"},
        {"id": "meta_description_present", "status": "fail", "value": null}
      ]
    },
    "technical_seo": { "...": "..." }
  }
}

status is one of pass, warn, fail. That single field is the whole product surface for code-driven workflows: filter the array, count the failures, threshold on category sub-scores, write a diff against last week's run. None of that requires reading the dashboard.

Three workflows the pass/fail shape unlocks

1. CI gates. Pull the score in a GitHub Action and fail the build if it drops below 85. Twenty lines of YAML and a single API call. We publish a GitHub Action that does exactly this, but you can roll your own with curl.

- name: SEO checker
  run: |
    SCORE=$(curl -s -H "X-API-Key: ${{ secrets.SEO_KEY }}" \
      "https://seoscoreapi.com/audit?url=https://preview.example.com" \
      | jq '.score')
    if [ "$SCORE" -lt 85 ]; then exit 1; fi

2. Regression diffs. Store yesterday's audit JSON, run today's, diff the checks arrays. Any check that flipped pass → fail is a regression you can name. We do this in the historical tracking endpoint and it's also trivial to do client-side with two JSON blobs and a dict comparison.

3. Agent loops. An AI agent doesn't want a screenshot, it wants structured findings to act on. Hand the agent the checks array and let it decide which failures to fix in which order. See Build an AI SEO Agent for a worked example.

Why structured pass/fail beats a score-only API

A lot of "SEO score" APIs return a number and nothing else. That's not actually useful in code — you can't fix a problem you can't name. The minimum useful response for an SEO checker API is:

  • An overall 0–100 score (for thresholding)
  • A category breakdown (for routing fixes to teams)
  • Per-check results with stable IDs (for diffs and remediation)

SEO Score API returns all three. Every check has a stable string ID (title_length, canonical_present, og_image_dimensions) that you can match against across audits without parsing display text.

How it relates to dashboard tools

A dashboard tool — Ahrefs Site Audit, Screaming Frog, Sitebulb — is built to give a human the full picture of a site so they can prioritize. An SEO checker API is built for the moment after prioritization, when you already know what "good" looks like and want code to enforce it.

The two are complementary. Big agencies typically run a dashboard for human-driven discovery and an API for the production guardrails (CI gates, weekly client diffs, monitoring). How SEO Score API sits alongside Ahrefs and Moz goes into more detail on the split.

Getting started in five minutes

Sign up for the free tier (2 audits/day, no credit card), grab your key, and hit the endpoint:

curl -H "X-API-Key: YOUR_KEY" \
  "https://seoscoreapi.com/audit?url=https://your-site.com"

That's the full first interaction. You'll get back the same response shape your CI gates and monitoring will eventually consume — which means the prototype you write today is the production code you ship tomorrow.

If you're evaluating SEO checker APIs against each other, the questions worth asking are: does it render JavaScript pages (we do, via headless Chromium)? Does it return stable check IDs (yes)? Does it have SDKs in your language (Python, Node, n8n, and a GitHub Action ship today)? And does the free tier let you actually evaluate the response shape before committing? All four of those are table stakes for a checker that's going to live in your pipeline.