# AEO & GEO Audit: AI Search Readiness + llms.txt Checker (`cygnix_labs/aeo-readiness-checker`) Actor

AEO audit / GEO audit for a list of URLs: score each page 0-100 for ChatGPT, Perplexity, Claude and Google AI Overviews. Checks llms.txt, GPTBot/ClaudeBot/PerplexityBot robots.txt access, schema, FAQ, answer-first content. Fix list per page. First 5 free, then $0.008/page.

- **URL**: https://apify.com/cygnix_labs/aeo-readiness-checker.md
- **Developed by:** [Umair Saleem Mohammad Saleem](https://apify.com/cygnix_labs) (community)
- **Categories:** SEO tools, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00 / 1,000 page auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AEO & GEO Audit: AI Search Readiness + llms.txt Checker

**Answer first:** this actor runs an **AEO audit / GEO audit on a list of URLs** and tells you whether each page can be found, read and quoted by **ChatGPT search, Perplexity, Claude and Google AI Overviews / AI Mode**. Every page gets an **AEO score from 0 to 100**, an A-F grade and a ranked fix list. Every domain gets an **llms.txt check** and a **robots.txt check for GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot, Google-Extended and CCBot**. **The first 5 pages of every run are free, then $0.008 per page.**

| Quick facts | |
|---|---|
| Best for | AEO audit, GEO audit, AI search readiness check, llms.txt checker, "does robots.txt block GPTBot / ClaudeBot?", pre-publish checks |
| Input | A list of page URLs (up to 5,000) |
| Output | One row per URL: `aeoScore`, `grade`, `topFixes`, `aiBotsBlocked`, `hasLlmsTxt`, schema types, answer-first and heading signals |
| Price | First 5 pages free every run, then $0.008 per page. No start fee. Pages that fail to load are free |
| Needs | No API keys, no LLM calls, no proxies |
| Not included | Full-site crawl (use [site-seo-aeo-audit](https://apify.com/cygnix_labs/site-seo-aeo-audit)), live ChatGPT/Perplexity citation tracking, backlinks |

### What it checks

- **AI crawler access (robots.txt):** GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot, Google-Extended and CCBot
- **llms.txt checker:** is `/llms.txt` published on the domain (HTML soft-404 pages don't count)
- **Structured data:** JSON-LD and microdata types (FAQPage, HowTo, QAPage, Article, Product, Organization…)
- **Answer-first content:** the first real paragraph is a 15–70 word direct answer
- **Question-style H2/H3 headings** ("How…", "What…", "…?") and FAQ blocks
- Quotable lists and tables, exactly one H1, meta description length, word count
- **Freshness and E-E-A-T:** published/modified dates and author signals

### Score breakdown (100 points)

| Signal | Points |
|---|---|
| AI crawlers allowed in robots.txt | 20 |
| JSON-LD / microdata schema present | 12 |
| Answer-first opening paragraph (15–70 words) | 12 |
| FAQ / HowTo / QAPage schema or 3+ question headings | 10 |
| 2+ question-style H2/H3 headings | 10 |
| 300+ words of content | 8 |
| Quotable list or table | 7 |
| Meta description 70–170 characters | 6 |
| Exactly one H1 | 5 |
| Published / modified date | 4 |
| Author signal | 3 |
| /llms.txt published | 3 |

Grades: A 85+, B 70+, C 55+, D 40+, F below 40. Every missed signal becomes a plain-English fix in `allFixes`, and the first five go in `topFixes`.

### Pricing (pay per event)

- **First 5 successfully audited pages in every run are free**
- Then **$0.008 per `page-audited` event** ($8 per 1,000 pages)
- **No actor-start fee.** Pages that fail to load (HTTP errors, timeouts) are listed with an `error` field and **not charged**
- Duplicate URLs are removed before the run, so you never pay twice for the same URL
- Set a **max charge per run** and the actor stops cleanly at your limit

| Pages audited | You pay\* |
|---|---|
| 5 | $0.00 |
| 25 | $0.16 (5 free + 20 × $0.008) |
| 100 | $0.76 |
| 500 | $3.96 |
| 1,000 | $7.96 |

\*This assumes every page loads. Failed pages are free.

### Output (per page)

`url, aeoScore, grade, topFixes, allFixes, schemaTypes, aiBotsBlocked, hasLlmsTxt, answerFirst, firstParagraphWords, questionHeadings, h1Count, wordCount, metaDescriptionLength, title`. The `SUMMARY` record in the key-value store holds `pagesAudited` and `averageAeoScore`.

### Example result

```json
{"url":"https://apify.com","aeoScore":66,"grade":"C","topFixes":["Add an FAQ block with FAQPage schema","Phrase 2+ H2/H3 headings as the questions users ask"],"aiBotsBlocked":[],"hasLlmsTxt":true}
```

### Input example

```json
{
  "urls": [
    "https://example.com/blog/what-is-aeo",
    "https://example.com/pricing",
    "https://example.com/faq"
  ],
  "maxConcurrency": 5
}
```

Paste up to 5,000 http(s) URLs. `maxConcurrency` runs 1–20 parallel fetches (default 5).

### Who it's for

SEO and AEO/GEO agencies auditing clients, content teams checking pages before publishing, site owners who want to know if **robots.txt blocks GPTBot or ClaudeBot**, and AI agents running audits through the Apify MCP server.

### Use cases

- AEO/GEO audits and client reports
- Pre-publish checks for ChatGPT and AI Overviews citations
- Finding robots.txt rules that block GPTBot, ClaudeBot or PerplexityBot
- Checking whether a domain has an llms.txt file
- Ranking which pages to restructure first
- Batch checks from Claude or Cursor via MCP

### How it compares (live Apify Store prices, verified 18 Oct 2026)

List prices on the Apify Free plan, read from the Apify Store API on 18 October 2026. Some actors charge less on higher plans.

| Actor | Price | Extra fees | Cost for 100 pages | Focus |
|---|---|---|---|---|
| **cygnix_labs/aeo-readiness-checker** (this) | **$0.008 / page, first 5 free every run** | none | **$0.76** | Content-level AEO score (answer-first, question headings, FAQ/schema) + 7 AI bots + llms.txt, fix list |
| jtpalms/seo-ai-readiness-audit | $0.002 / page | $0.003 / site | ~$0.20 | SEO basics + AI-bot / llms.txt flags |
| siteverdict/siteverdict-ai-search-readiness | $0.004 / page | $0.03 / site, add-ons extra | ~$0.43 | Site-level AI-bot matrix, render checks |
| fayoussef/seo-geo-aeo-audit | $0.0045 / result | none | ~$0.45 | Combined SEO + GEO + AEO scores, HTML report |
| dltik/geo-site-audit | $0.01 / page | tiny start fee | ~$1.00 | AI crawler access, llms.txt, schema |
| crawlwise/seo-audit-ai-search | $0.01 / page | tiny start fee | ~$1.00 | SEO basics + AI bot access + llms.txt |
| alizarin_refrigerator-owner/llms-txt-checker | $0.01 / URL | $0.10 start, $0.02 recommendations | ~$1.10+ | llms.txt presence and quality |
| wheaten_steelpan/geo-site-auditor | $0.02 / page | $0.02 start | ~$2.02 | GEO/AEO crawl + fix list |
| lofomachines/geo-technical-audit | $0.035 / result | $0.02 start | ~$3.52 | GEO schema, semantic HTML, E-E-A-T |
| foxlabs/geo-auditor | $0.04 / page | tiny start fee | ~$4.00 | GEO technical audit, citability |

**Honest take.** jtpalms, siteverdict and fayoussef are cheaper per page; they mostly grade SEO basics plus bot flags. This actor weights **content-level answer-engine signals** (answer-first opening, question headings, FAQ/HowTo schema, quotable lists) into one 0-100 score with a fix per missed signal, and spot checks of up to 5 pages cost $0. Among dedicated GEO/AEO page auditors (dltik, crawlwise, wheaten_steelpan, lofomachines, foxlabs at $0.01-0.04) it is the lowest list price.

### For AI agents / MCP

**When an agent should call this actor:** the user gives specific URLs and asks for an AEO or GEO audit, whether pages are ready for ChatGPT / Perplexity / AI Overviews, whether robots.txt blocks GPTBot or ClaudeBot, or whether a site has llms.txt. For a whole website from one URL, call cygnix_labs/site-seo-aeo-audit instead.

Connect the Apify MCP server with only this actor enabled (works in Claude, ChatGPT, Cursor, VS Code, Codex and any MCP client):

```
https://mcp.apify.com?tools=cygnix_labs/aeo-readiness-checker
```

Or search for it with the default server: `search-actors` keywords such as `AEO audit`, `GEO audit`, `llms.txt`, `AI search readiness`.

Example `call-actor` input:

```json
{
  "urls": [
    "https://example.com/",
    "https://example.com/pricing",
    "https://example.com/blog/what-is-aeo"
  ],
  "maxConcurrency": 5
}
```

**What to read from the result:** each dataset row has `url`, `aeoScore` (0-100), `grade`, `topFixes` (up to 5, plain English), `allFixes`, `aiBotsBlocked` (list of blocked bots), `hasLlmsTxt`, `schemaTypes`, `answerFirst` and `questionHeadings`. Rows with an `error` field failed to load and were not charged. The `SUMMARY` key-value record has `pagesAudited` and `averageAeoScore`.

**Cost control for agents:** Send 5 URLs or fewer for a free check; 100 URLs cost $0.76. Pass `maxTotalChargeUsd` in `callOptions` to hard-cap spend. This actor is pay-per-event, so it also works with Apify agentic payments (no Apify account needed for the agent).

Example prompt: *"Run an AEO audit on these 10 URLs, tell me which pages block GPTBot or have no llms.txt, and list the top 3 fixes per page."*

### FAQ

**Does it query ChatGPT or Perplexity?** No. It audits the on-page and crawl signals those engines rely on, so it is fast and cheap. To measure actual citations, pair it with an AI-visibility tracker.

**How is this different from a full SEO audit actor?** Full SEO crawlers map the whole site: status codes, redirects, internal links, sometimes Core Web Vitals. This actor scores **AI search readiness** only: bot access, llms.txt, schema/FAQ, answer-first content and citation structure. Use both if you need technical SEO *and* AEO.

**Which AI bots does it check?** GPTBot, OAI-SearchBot, ChatGPT-User, ClaudeBot, PerplexityBot, Google-Extended and CCBot. A bot counts as blocked when its own robots.txt group disallows `/`, or when it has no group and the `*` group does, unless there is an `Allow: /`. Path-level rules (e.g. `Disallow: /blog/`) are not counted as a full block.

**Does it check the whole site?** It audits the URLs you give it. robots.txt and /llms.txt are fetched once per domain and reused for every page on that domain.

**JavaScript-heavy sites?** It reads server-rendered HTML, the same way most AI crawlers do. Client-only SPAs may score low until their content is SSR/prerendered.

**What if a page is down or blocks the request?** It is still listed, with an `error` field and a score of 0, and you are not charged for it.

**Can I cap my spend?** Yes. Set a maximum charge per run in the run options, and the actor stops cleanly when it hits the limit.

**Is there a free allowance?** Yes. The first 5 successfully audited pages in every run are free, and only pages after that are charged.

**What is the difference between AEO and GEO?** AEO (answer engine optimization) is about pages being picked as the direct answer; GEO (generative engine optimization) is about being cited by generative AI search such as ChatGPT, Perplexity and AI Overviews. The checks overlap almost entirely: crawler access, extractable answers, structure and trust signals. This actor scores both with one 0-100 AEO score.

**Is llms.txt worth it?** It is cheap to publish and coding agents read it, but studies in 2026 show AI search crawlers rarely request it. That is why it carries only 3 of 100 points here, while AI crawler access in robots.txt carries 20.

### Integrations

Run it via the Apify API, schedule weekly runs, or send results to Google Sheets, Make, Zapier, n8n, Slack or webhooks.

### Changelog

- **0.1.8** (2026-10-18): README and Store text rewritten answer-first: AEO audit / GEO audit / llms.txt terms, quick facts, comparison re-verified against 10 named actors on 18 Oct 2026, "For AI agents / MCP" section with example input, AEO vs GEO and llms.txt FAQ. Price unchanged ($0.008/page, first 5 free).
- **0.1.7** (2026-10-16): Named Store comparison, bot-blocking rule explained, default memory 1 GB.
- **0.1.6** (2026-10-16): Cost table, score breakdown, FAQ, MCP link. Price $0.008 per `page-audited`, first 5 pages free.

### More SEO and AEO tools by Cygnix Labs

- [Website SEO Audit + AEO/GEO Checker (full-site crawl)](https://apify.com/cygnix_labs/site-seo-aeo-audit)
- [Internal Link Audit & Orphan Page Finder](https://apify.com/cygnix_labs/internal-link-audit)
- [Content Decay Audit (Search Console)](https://apify.com/cygnix_labs/content-decay-audit)
- [Keyword Cannibalization Checker (Search Console)](https://apify.com/cygnix_labs/keyword-cannibalization-finder)
- [Keyword Clustering + Content Briefs](https://apify.com/cygnix_labs/keyword-clusterer-brief)
- [Search Intent Classifier](https://apify.com/cygnix_labs/serp-intent-mapper)
- Free local SEO MCP server: [cygnix-seo-mcp](https://github.com/cygnixlabs-cmd/cygnix-seo-mcp) (`npx -y cygnix-seo-mcp`)

Questions or a feature request? Open an issue on this actor's Issues tab. We answer within 24 hours.

# Actor input Schema

## `urls` (type: `array`):

Pages to audit (blog posts, product, service pages). Up to 5,000.

## `maxConcurrency` (type: `integer`):

Parallel page fetches.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://docs.apify.com/platform/actors"
  ],
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com",
        "https://docs.apify.com/platform/actors"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("cygnix_labs/aeo-readiness-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": [
        "https://apify.com",
        "https://docs.apify.com/platform/actors",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("cygnix_labs/aeo-readiness-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://apify.com",
    "https://docs.apify.com/platform/actors"
  ]
}' |
apify call cygnix_labs/aeo-readiness-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cygnix_labs/aeo-readiness-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uh7eSR9pBDrAKspjU/builds/9D5iwATEeljutriKc/openapi.json