# SEO, GEO & AEO Audit — AI Search Readiness Checker (`fayoussef/seo-geo-aeo-audit`) Actor

Audit any website for Google SEO and AI search visibility in one run. Get 0–100 SEO, GEO & AEO scores per page, AI-crawler & llms.txt checks, schema validation, and a prioritized fix list with a shareable HTML report. No API keys needed — just enter a URL.

- **URL**: https://apify.com/fayoussef/seo-geo-aeo-audit.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** SEO tools, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does SEO, GEO & AEO Audit do?

**SEO, GEO & AEO Audit** lets you **audit any website for Google SEO and AI search visibility** in a single run — no API keys, no setup, just paste a URL. It crawls your homepage and key pages, runs **45+ deterministic checks**, and returns **0–100 scores per page for SEO (Google search), GEO (Generative Engine Optimization for ChatGPT, Perplexity, Gemini and Google AI Overviews) and AEO (Answer Engine Optimization for featured snippets and voice search)** — plus a prioritized fix list and a polished, shareable **HTML report**. Run it on demand, **schedule weekly audits, call it via API, or plug it into AI agents through the Apify MCP server**, and export every result as JSON, CSV, Excel or HTML.

Unlike AI-visibility trackers that bill you $0.25–0.50 per prompt to query chatbots, this Actor analyzes **your website itself** — the thing you can actually fix — for a fraction of the price.

### Why audit your website for AI search (GEO/AEO)?

Search is splitting in two: classic Google rankings still drive traffic, but a fast-growing share of buyers now asks **ChatGPT, Perplexity and Gemini** for recommendations. If AI crawlers are blocked in your robots.txt, your content is JavaScript-only, or your pages lack structured data, **AI engines simply cannot cite you** — and you're invisible in the answers your customers read.

Typical uses:

- **Agencies & freelancers** — generate branded audit reports for clients and prospects (the HTML report is client-ready).
- **SEO & content teams** — track SEO/GEO/AEO scores weekly and catch regressions before rankings drop.
- **Founders & marketers** — check whether ChatGPT, Perplexity and Claude can even see your site, and get the exact fix list.
- **Lead generation** — audit prospect websites in bulk via API and open conversations with concrete findings.
- **Developers & AI agents** — call the Actor from workflows or **via the Apify MCP server** so your AI agent can audit sites autonomously.

### How to audit a website for SEO, GEO and AEO

1. Click **Try for free** — you'll need a free Apify account.
2. Paste your **website URL** (e.g. `https://yourdomain.com`).
3. Optionally set **Pages to audit** (default 10).
4. Click **Start** and wait a few seconds to a couple of minutes.
5. Open the **Output** tab for per-page scores, the **REPORT** record in the key-value store for the shareable HTML report, and export anything as JSON, CSV or Excel.

### What does the audit check?

- **SEO (Google search)** — title & meta description quality, single H1 and heading hierarchy, canonical, noindex traps, viewport/mobile readiness, image alt text, internal linking, Open Graph & Twitter cards, content depth, language declaration, HTTPS, sitemap.xml, clean URLs.
- **GEO (AI search engines)** — **AI-crawler access in robots.txt** (GPTBot, ClaudeBot, PerplexityBot, Google-Extended and 10+ more), **llms.txt / llms-full.txt** presence, JSON-LD structured data, Organization/Person entity schema with sameAs, author & E-E-A-T signals, contact/trust signals, factual density, server-side rendering (JS-shell detection), semantic HTML, freshness signals.
- **AEO (answer engines & voice)** — FAQPage & HowTo schema, question-phrased headings, 40–60 word direct-answer paragraphs, list & table snippet eligibility, definition sentences, BreadcrumbList, Speakable markup, local NAP signals.

### Input

Only one field is required — the website URL. Everything else has sensible defaults (see the **Input** tab for details).

```json
{
    "websiteUrl": "https://yourdomain.com",
    "maxPages": 10
}
````

### Output

One dataset item per audited page, plus a **site summary JSON** (`SUMMARY`) and a **shareable HTML report** (`REPORT`) in the key-value store. Download results as **JSON, CSV, Excel or HTML**.

```json
{
    "url": "https://yourdomain.com/",
    "pageTitle": "Your Domain — Home",
    "grade": "B",
    "overallScore": 74,
    "seoScore": 82,
    "geoScore": 68,
    "aeoScore": 61,
    "issuesFound": 9,
    "criticalCount": 1,
    "topIssues": [
        "robots.txt blocks AI crawlers: GPTBot, PerplexityBot — the site cannot be cited by those AI engines.",
        "No FAQPage schema — missing eligibility for FAQ rich results and AI answer extraction."
    ],
    "schemaTypes": ["Organization", "WebSite"],
    "wordCount": 640
}
```

### Data fields

| Field | Description |
|---|---|
| `url`, `pageTitle`, `pageType` | The audited page and its title |
| `grade` | Letter grade A–F |
| `overallScore` | Weighted 0–100 score (40% SEO, 35% GEO, 25% AEO) |
| `seoScore` / `geoScore` / `aeoScore` | Per-pillar 0–100 scores |
| `issues` | Every failed check with severity, message and a concrete fix |
| `passedChecks` | Everything the page already does right |
| `schemaTypes` | schema.org types detected in JSON-LD |
| `wordCount`, `internalLinks`, `imagesMissingAlt`, `questionHeadings` | Page statistics |

### How much does it cost to audit a website?

Pricing is **pay-per-result: you only pay for pages actually audited** (one result = one page). A 10-page audit costs about **$0.20**, a full 200-page site about $4. No subscription, no API keys, no hidden LLM costs. **Free-plan users can audit up to 5 pages per run**; subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock up to 200 pages, scheduling and higher limits.

### Tips for the best results

- Start with 10 pages — the homepage plus key pages usually reveal 90% of site-wide issues.
- **Schedule a weekly run** and diff the scores to catch regressions the day they ship.
- The HTML report (`REPORT` key in the key-value store) is self-contained — download and send it to clients as-is.
- Lower **Concurrency** if the target site rate-limits aggressively.
- Fix **critical** issues first: noindex traps, blocked AI crawlers and JS-only content each make whole channels invisible.

### Is it legal to audit a website?

Yes. The Actor only reads publicly accessible pages and public files like robots.txt, sitemap.xml and llms.txt — the same things every search engine reads. It sends a modest number of polite requests and does not bypass any access controls. You are responsible for auditing only sites you own or are authorized to analyze.

### FAQ

**What is GEO (Generative Engine Optimization)?**
GEO is the practice of optimizing a website so AI search engines like ChatGPT, Perplexity and Gemini can crawl, understand and cite it in their answers.

**What is AEO (Answer Engine Optimization)?**
AEO optimizes content to be extracted as direct answers — Google featured snippets, People Also Ask boxes and voice assistant responses.

**How do I know if ChatGPT can see my website?**
Run this audit: it parses your robots.txt and reports exactly which AI crawlers (GPTBot, ClaudeBot, PerplexityBot and 10+ more) are allowed or blocked, and detects JavaScript-only pages AI crawlers can't read.

**What is llms.txt?**
llms.txt is an emerging standard file (like robots.txt for AI) that gives language models a curated markdown guide to your site. The audit checks whether you have one.

**Does this Actor use AI or need API keys?**
No. Every check is deterministic and reproducible — no LLM calls, no API keys, no hallucinated findings, and much lower cost.

**Can I run this from an AI agent or via API?**
Yes. Call it through the Apify API, integrations (Make, Zapier, n8n, Google Sheets) or from AI agents via the **Apify MCP server** — the output schema is fully typed for agent consumption.

**Can it audit my competitors?**
Yes — audit any publicly accessible website and compare scores side by side.

### Support & custom solutions

Found a bug or need a new check? Open an issue in the **Issues** tab — it's actively maintained.

💼 Need a **custom scraper, audit pipeline or automation**? Reach out at **youssefarhan24@gmail.com**
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)
⚡ [Subscribe to an Apify plan](https://apify.com/pricing?fpr=youssef) to unlock full limits, scheduling and API access.

# Actor input Schema

## `websiteUrl` (type: `string`):

The website you want to audit — just paste the homepage URL. The Actor discovers and audits the most important pages automatically.

⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `maxPages` (type: `integer`):

Maximum number of pages to audit (homepage + automatically discovered key pages). Free plan is capped at 5 pages; paid plans can audit up to 200.

## `includeHtmlReport` (type: `boolean`):

Stores a polished, self-contained HTML audit report in the key-value store (key: REPORT).

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

How many pages are fetched in parallel. Lower this if the target site rate-limits.

## Actor input object example

```json
{
  "websiteUrl": "https://books.toscrape.com",
  "maxPages": 10,
  "includeHtmlReport": true,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `pageAudits` (type: `string`):

One item per audited page with SEO/GEO/AEO scores, grade, issues and recommendations.

## `htmlReport` (type: `string`):

Polished, self-contained HTML audit report — open it in a browser or share it with a client.

## `siteSummary` (type: `string`):

Site-wide scores, grade, AI-crawler access map and top issues as machine-readable JSON.

# 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 = {
    "websiteUrl": "https://books.toscrape.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/seo-geo-aeo-audit").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 = { "websiteUrl": "https://books.toscrape.com" }

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/seo-geo-aeo-audit").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "websiteUrl": "https://books.toscrape.com"
}' |
apify call fayoussef/seo-geo-aeo-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/seo-geo-aeo-audit",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEO, GEO & AEO Audit — AI Search Readiness Checker",
        "description": "Audit any website for Google SEO and AI search visibility in one run. Get 0–100 SEO, GEO & AEO scores per page, AI-crawler & llms.txt checks, schema validation, and a prioritized fix list with a shareable HTML report. No API keys needed — just enter a URL.",
        "version": "1.0",
        "x-build-id": "ZKVmVwuVYRmHzrDo2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~seo-geo-aeo-audit/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-seo-geo-aeo-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fayoussef~seo-geo-aeo-audit/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-seo-geo-aeo-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fayoussef~seo-geo-aeo-audit/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-seo-geo-aeo-audit",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "websiteUrl"
                ],
                "properties": {
                    "websiteUrl": {
                        "title": "🌐 Website URL",
                        "pattern": "^(https?://)?[\\w.-]+\\.[a-zA-Z]{2,}.*$",
                        "type": "string",
                        "description": "The website you want to audit — just paste the homepage URL. The Actor discovers and audits the most important pages automatically.\n\n⚡ Unlock full pages and higher limits by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)"
                    },
                    "maxPages": {
                        "title": "📄 Pages to audit",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of pages to audit (homepage + automatically discovered key pages). Free plan is capped at 5 pages; paid plans can audit up to 200.",
                        "default": 10
                    },
                    "includeHtmlReport": {
                        "title": "Generate shareable HTML report",
                        "type": "boolean",
                        "description": "Stores a polished, self-contained HTML audit report in the key-value store (key: REPORT).",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many pages are fetched in parallel. Lower this if the target site rate-limits.",
                        "default": 10
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```