GEO Auditor — AI Search Readiness & Citability Audit

    

Is your website ready to be found, read and cited by AI search — ChatGPT, Perplexity, Gemini and Claude? AI answer engines don't rank ten blue links: they crawl a few pages, pull the most extractable facts, and cite a handful of sources. If a crawler can't reach your pages, can't parse your content, or can't trust your structure, you never appear in the answer. This Actor crawls your site exactly the way an AI crawler sees it (raw HTML, no JavaScript rendering), scores its AI-readiness 0–100, and hands you a prioritized, evidence-backed fix list — fully deterministic, no LLM guesswork, no proxy required.

• 🤖 AI-crawler access — audits robots.txt for 8 AI-search/citation crawlers (OAI-SearchBot, PerplexityBot, ChatGPT-User, Claude-SearchBot, Googlebot…) and reports training-bot blocks separately
• 📊 0–100 GEO score across 5 weighted dimensions — for every page and a whole-site scorecard
• 🔍 Sees your site like an AI bot — raw HTML, no JS rendering, so a JS-only page that's invisible to crawlers scores like one
• 🛠️ Prioritized, evidence-backed fixes — impact-ranked ("you're blocking PerplexityBot → unblock it"), not a pass/fail checklist

Quick start (API)

Audit a site's first 10 pages in one call — returns the per-page rows and the site scorecard:

curl -X POST "https://api.apify.com/v2/acts/foxlabs~geo-auditor/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "websiteUrl": "https://www.notion.so", "maxPages": 10 }'

Prefer no code? Open the Input tab, paste your website URL, set max pages, and click Start — then download the results. No API key, no proxy, no setup.

What you get

Two kinds of rows land in one dataset: one page row per audited page, plus a single summary row (also saved to the key-value store as SUMMARY).

How the GEO score works (5 weighted dimensions)

Each page is scored on five dimensions; the weighted blend is the page's geoScore, and the site scorecard averages them:

Dimension	Weight	What it measures
Content extractability	30%	Heading structure, content depth, text-to-HTML ratio, lists/tables, and a JS-render check (if content only appears after JavaScript, AI crawlers see an empty page)
Structured data	25%	JSON-LD presence & useful schema types (Organization, WebSite, Article, Product, FAQPage, HowTo, BreadcrumbList)
AI-crawler access	20%	Whether robots.txt lets the crawlers that power AI answers in (site-level; same for every page)
Trust & freshness	15%	Published/modified date signals, author/Organization schema, canonical tag
Speed	10%	Time-to-first-byte and page weight — fast, light pages are more likely to be cited

A page's band is strong (≥70), mid-tier (≥40) or gap (<40).

Per-page fields (type: "page")

Field	Type	Description
type	string	Row type — always "page"
url	string	The audited page URL
geoScore	integer	Overall GEO readiness for this page (0–100)
band	string	strong (≥70), mid-tier (≥40) or gap (<40)
title	string	The page <title> (trimmed to 200 chars)
wordCount	integer	Extractable body words after stripping scripts/styles
hasJsonLd	boolean	Whether the page ships any JSON-LD structured data
structuredDataText	string	Comma-joined JSON-LD @types found (e.g. "Organization, WebSite")
headingOutlineText	string	First ~12 headings as an H1/H2/H3 outline, |-joined
jsRenderedRisk	boolean	true if content looks client-side rendered (little text + many scripts)
hasCanonical	boolean	Whether a <link rel="canonical"> is present
hasDates	boolean	Whether published/modified date signals were found
accessScore	integer	AI-crawler access dimension, 0–100 (site-level)
structuredScore	integer	Structured-data dimension, 0–100
extractabilityScore	integer	Content-extractability dimension, 0–100
speedScore	integer	Speed dimension, 0–100
trustScore	integer	Trust/freshness dimension, 0–100
topIssuesText	string	Up to 5 top issues for this page, ; -joined

Site scorecard fields (type: "summary")

Field	Type	Description
type	string	Row type — always "summary"
domain	string	Audited domain (www. stripped)
startUrl	string	The URL the crawl started from (after any www↔non-www fallback)
pagesAudited	integer	Number of pages actually scored
overallGeoScore	integer	Site-wide GEO Readiness Index (0–100)
band	string	Overall band (strong / mid-tier / gap)
dimensionScores	object	{ access, structured, extractability, speed, trust } — each 0–100
weakestDimensionsText	string	Dimensions scoring under 60, weakest first (surfaced even when the headline band is "strong")
aiAccessText	string	Human-readable AI-search crawler access (e.g. "7/8 AI-search crawlers allowed")
blockedAiBotsText	string	AI-search crawlers blocked in robots.txt, or "none"
blockedTrainingBotsText	string	Training/grounding crawlers blocked (reported, not penalized)
hasLlmsTxt	boolean	Whether /llms.txt exists (informational only)
robotsTxtFound	boolean	Whether robots.txt was found
prioritizedFixes	array	Impact-ordered fix strings
prioritizedFixesText	string	The same fixes as one numbered string
generatedAtIso	string	ISO 8601 timestamp of the audit

Sample output (illustrative)

A page row and the site summary row from one run:

{
  "type": "page",
  "url": "https://www.example.com/",
  "geoScore": 86,
  "band": "strong",
  "title": "Example — the all-in-one workspace for docs & projects",
  "wordCount": 420,
  "hasJsonLd": true,
  "structuredDataText": "Organization, WebSite",
  "headingOutlineText": "H1: One workspace for your team | H2: Docs | H2: Projects | H3: Templates",
  "jsRenderedRisk": false,
  "hasCanonical": true,
  "hasDates": false,
  "accessScore": 88,
  "structuredScore": 85,
  "extractabilityScore": 92,
  "speedScore": 96,
  "trustScore": 65,
  "topIssuesText": "No published/modified date signals"
}

{
  "type": "summary",
  "domain": "example.com",
  "startUrl": "https://www.example.com/",
  "pagesAudited": 10,
  "overallGeoScore": 61,
  "band": "mid-tier",
  "dimensionScores": { "access": 88, "structured": 42, "extractability": 55, "speed": 96, "trust": 44 },
  "weakestDimensionsText": "structured (42), trust (44), extractability (55)",
  "aiAccessText": "7/8 AI-search crawlers allowed",
  "blockedAiBotsText": "PerplexityBot",
  "blockedTrainingBotsText": "GPTBot, CCBot",
  "hasLlmsTxt": false,
  "robotsTxtFound": true,
  "prioritizedFixes": [
    "CRITICAL: robots.txt blocks AI-search crawlers (PerplexityBot) — you cannot appear in their answers. Allow them.",
    "Add JSON-LD structured data (Organization, Article/Product, FAQPage, BreadcrumbList) — AI engines rely on it to understand and cite you.",
    "Improve content extractability: one H1, clear H2 sections, answer-first self-contained paragraphs, lists/tables — RAG retrieval favors this.",
    "Add trust/freshness signals: published & modified dates, author/Organization schema, canonical tags."
  ],
  "generatedAtIso": "2026-07-05T09:12:44.081Z"
}

Input & filters

• Website URL (websiteUrl) — the page to start from. The Actor crawls this page and, up to your page limit, internal same-origin pages linked from it. If the host fails, it automatically retries the www ↔ non-www variant.
• Max pages (maxPages, 1–50) — how many pages to crawl & score. 1 = audit just that page; more pages = a fuller site picture at slightly higher cost.
• Proxy (proxyConfiguration, optional) — leave off for fast, free audits (most sites work directly). Turn on Apify Proxy with the RESIDENTIAL group only if a site is behind Cloudflare/WAF bot-protection that blocks direct requests.

Example inputs (copy & paste)

// 1) Fast single-page check — just the homepage
{ "websiteUrl": "https://www.yoursite.com", "maxPages": 1 }

// 2) Full-site audit — crawl up to 50 internal pages
{ "websiteUrl": "https://www.yoursite.com", "maxPages": 50 }

// 3) WAF-protected site — route through residential proxy
{
  "websiteUrl": "https://www.yoursite.com",
  "maxPages": 10,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}

// 4) Focus one section — start at a subpath, crawl its internal pages
{ "websiteUrl": "https://www.yoursite.com/blog", "maxPages": 15 }

// 5) Competitive benchmark — point it at a rival's domain
{ "websiteUrl": "https://www.competitor.com", "maxPages": 20 }

// 6) QA a single key landing page in isolation
{ "websiteUrl": "https://www.yoursite.com/product", "maxPages": 1 }

Use cases

• SEO / GEO agencies. Ship clients a technical AI-readiness audit plus an impact-ranked fix roadmap — a repeatable, recurring deliverable. Run it on a schedule and show the overallGeoScore climbing.
• In-house SEO / web teams. You're not showing up in AI answers and don't know why. The audit pinpoints the cause — a blocked crawler, JS-rendered content, missing schema — and the exact fix, per page.
• Founders & marketers. A two-minute check on whether AI search can even see your site, with no setup and no code.
• Migration & launch QA. Before/after a redesign or platform move, confirm AI-search crawlers are still allowed and key content is still server-rendered (jsRenderedRisk: false).
• Competitive benchmarking. Point it at competitors' domains to see who's structurally ready for AI search and where the gaps are.
• Pairs with AI Brand Monitor. That Actor tells you whether AI engines mention your brand; this one tells you why — and exactly what to fix on the site.

Performance & throughput

The Actor fetches raw HTML sequentially and does no JavaScript rendering, so pages load fast and there's zero LLM or proxy cost by default. Each request has a 30-second timeout ceiling, and a bad page is skipped rather than failing the run. A 1–10 page audit typically finishes in well under a minute; a full 50-page crawl takes a few minutes — bounded mainly by how fast the target site responds. Enabling the residential proxy adds latency but gets you past WAF/Cloudflare blocks.

Integrations

JavaScript (apify-client):

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('foxlabs/geo-auditor').call({
  websiteUrl: 'https://www.notion.so', maxPages: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const summary = items.find((i) => i.type === 'summary');
console.log(summary.overallGeoScore, summary.prioritizedFixesText);

Python (apify-client):

from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("foxlabs/geo-auditor").call(run_input={
    "websiteUrl": "https://www.notion.so", "maxPages": 10,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "summary":
        print(item["overallGeoScore"], item["weakestDimensionsText"])

Also works with Make / n8n / Zapier (Apify app → run this Actor, map websiteUrl + maxPages), scheduled runs and webhooks. And it's an MCP tool for AI agents:

• Hosted: https://mcp.apify.com?tools=foxlabs/geo-auditor
• Self-hosted (Claude Desktop, Cursor, Cline): npx @apify/actors-mcp-server --tools foxlabs/geo-auditor

Data quality — deterministic & evidence-backed

Every score traces to an observable signal on the page: a robots.txt rule, a JSON-LD @type, a heading count, a byte size, a date marker. There is no LLM in the loop, so the audit is fully deterministic — the same page yields the same score, which makes results reproducible and comparable over time. Nothing is fabricated: a signal is either present or it isn't, and each recommended fix names the specific issue behind it. Because the crawl reads raw HTML (no JS execution), it deliberately reflects what AI crawlers actually retrieve — not what a full browser would render.

Pricing

Pay per event — you're billed per page audited (the Actor charges a page-audit event as each page is scored). No LLM API calls and no proxy by default means no hidden third-party costs; the residential proxy is optional and only used if you enable it. There's an Apify free tier to try the full audit before you scale.

FAQ

What exactly is the "GEO score"? A 0–100 index blending five weighted dimensions — content extractability (30%), structured data (25%), AI-crawler access (20%), trust/freshness (15%) and speed (10%) — reported per page and as a site-wide average.

Does it render JavaScript? No — by design. Most AI crawlers fetch raw HTML and don't execute JavaScript, so a page whose content only appears after JS genuinely is invisible to them. The audit reflects that reality (jsRenderedRisk).

Which AI crawlers does it check? The eight search/citation crawlers that power live AI answers — OAI-SearchBot, ChatGPT-User, PerplexityBot, Perplexity-User, Claude-SearchBot, Claude-Web, Googlebot and Bingbot. Training/grounding crawlers (GPTBot, ClaudeBot, Google-Extended, CCBot…) are reported separately but not penalized.

Why didn't blocking GPTBot lower my score? Blocking training crawlers is a legitimate privacy choice, so it's reported (blockedTrainingBotsText) without hurting your score. Only blocking the search/citation crawlers costs you access points, because that's what keeps you out of AI answers.

Do I need an API key, login or proxy? No. It runs on public pages plus robots.txt/llms.txt. The residential proxy is optional, for WAF-protected sites only.

Can I audit a competitor's site? Yes — any public URL. It only reads publicly served pages.

How many pages can I audit in one run? Up to 50 (maxPages), crawled same-origin from your start URL.

Does it check llms.txt? It reports whether /llms.txt exists (hasLlmsTxt), but doesn't score it or recommend adding one — as of 2026 AI-search crawlers don't fetch it and it doesn't measurably improve citation.

What export formats are available? JSON, CSV, Excel, or via the Apify API/integrations. The site scorecard is also stored in the key-value store as SUMMARY.

Is the score stable over time? Yes — it's deterministic, so re-running on an unchanged page returns the same score. That makes it a reliable before/after metric for tracking fixes.

Troubleshooting

• "Could not fetch any page" / 0 pages audited → the site is blocking direct requests (WAF/Cloudflare). Enable Apify Proxy → RESIDENTIAL and re-run. The Actor already auto-retries the www ↔ non-www host variant for you.
• A JS-heavy site scores low on extractability → its content is client-side rendered, so AI crawlers see little/no text (jsRenderedRisk: true). Serve key content as server-rendered HTML (SSR/SSG). This is a real finding, not a false negative.
• Only 1 page was audited though maxPages is higher → the start page had few same-origin internal links, or the links point off-origin or to non-HTML files (PDF/images are skipped). Start from a hub/nav page.
• The run is slow → a page is hitting the 30-second fetch timeout, or the residential proxy is adding latency. Lower maxPages, or turn the proxy off if the site doesn't need it.

Notes, limits & legal (honest)

• Technical/structural audit — not a citation guarantee. It scores the on-site signals that make you eligible to be found and cited by AI search. Whether a given engine actually cites you depends on many off-site factors it can't measure.
• Raw HTML, no JavaScript rendering — deliberate, to mirror what AI crawlers retrieve. A perfectly good page that renders only client-side will (correctly) flag as a risk.
• Same-origin crawl, capped at your maxPages. It reads public pages plus robots.txt/llms.txt — no logins, no personal data.
• Crawler names are trademarks of their owners (OpenAI, Perplexity, Google, Anthropic, Microsoft), used only to identify user-agents in robots.txt.
• Not affiliated with OpenAI, Perplexity, Google, Anthropic, Microsoft or Apify. Always respect the target site's terms of use.

Support

Questions, a signal you'd like added, or a custom build? Open the Issues tab on this Actor, or email info@foxlabs.com.tr. We reply fast.

If this Actor saves you time, a ⭐ review really helps.

Changelog

0.2 — 2026-07-05

• Reworked docs: API quick-start, full per-page + site-scorecard field tables, sample output, integration snippets (JS / Python / Make / MCP), FAQ & troubleshooting.

0.1.1 — 2026-07-05

• Hardened output handling so an edge-case value can never trip dataset-schema validation.

0.1.7 — 2026-06-27

• Rebalanced the scoring weights so the score discriminates on what you can actually fix: AI-crawler access + speed hit the ceiling on most sites, so their combined weight drops from 40% to 30%, and structured data + trust/freshness gain the difference.
• Added weakestDimensionsText to the summary — surfaces the lowest-scoring dimensions (below 60) even when the overall band is "strong", so a high headline score never hides what still needs work.
• Declared the undici dependency explicitly (previously resolved transitively) for reproducible builds.

0.1.5 — 2026-06-04

• Structured-data detection now catches nested JSON-LD @types (e.g. SearchAction inside potentialAction).
• Removed the "add llms.txt" suggestion from the fix list: as of 2026, AI-search crawlers don't fetch /llms.txt and it doesn't measurably improve citation, so recommending it as a fix would be misleading. The presence of llms.txt is still reported as an informational field.

0.1.2 — 2026-06-01

• Reachability: automatic www↔non-www fallback; optional residential proxy for WAF-protected sites; browser User-Agent; graceful per-page skip so one bad page never fails the run.

0.1.0 — 2026-06-01

• Initial release: deterministic GEO / AI-search readiness audit — 0–100 score across 5 weighted dimensions (AI-crawler access, structured data, content extractability, speed, trust) with a prioritized, evidence-backed fix list.

---

Part of the foXLabs data platform — public-data company, contact, procurement, financial and AI-search visibility intelligence Actors. Browse the full suite and free how-to guides at data.foxlabs.com.tr.