# AI SEO + AEO/GEO Site Auditor — Crawl & Auto-Fix (`fuze/ai-seo-site-auditor`) Actor

Crawl a whole site and get an AI-prioritized technical + content + AEO/GEO audit with ready-to-paste fixes: rewritten titles/metas, generated JSON-LD, FAQ blocks, content gaps, plus a sitewide report and generated llms.txt. Actively maintained. · More no-code data tools → datatools-hub.vercel.app

- **URL**: https://apify.com/fuze/ai-seo-site-auditor.md
- **Developed by:** [Fredrik Hansson](https://apify.com/fuze) (community)
- **Categories:** SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## AI SEO + AEO/GEO Site Auditor — Crawl & Auto-Fix

Crawl a whole site and get an **AI-prioritized technical + content + AEO/GEO audit with ready-to-paste fixes** — plus a sitewide report and a generated `llms.txt`.

Every SEO crawler hands you a list of problems. **This one hands you the fixes.**

![AI SEO + AEO/GEO Site Auditor — Crawl & Auto-Fix — input and sample output](https://datatools-hub.vercel.app/actor-shots/ai-seo-site-auditor.png)

### Quick start

1. **Fill in the input** — set the fields in the input tab (prefilled with a working example).
2. **Click Start** — the Actor runs and writes one record per item to the dataset.
3. **Get your data** — export to **JSON, CSV or Excel**, or pull it via the API.

### 👉 Make this continuous with Citely

This actor gives you a **one-time crawl and audit** — a snapshot you run on demand. [**Citely**](https://datatools-hub.vercel.app/citely) turns that snapshot into an **always-on SEO + AEO system that auto-applies the fixes**: a self-learning CTR title/meta optimizer that auto-applies to your pages, weekly AI-citation tracking with share-of-voice trends, Google Search Console insights with click-collapse alarms, and JSON-LD validation. Connect once, it runs daily.

→ <https://datatools-hub.vercel.app/citely>

### What it does

It crawls your site (same-site, up to your page/depth limits) and for **each page** produces:

- Scores across four dimensions — **technical, SEO, AEO, GEO** — and a prioritized issue list (deterministic, reproducible)
- Optional **AI-generated, ready-to-paste fixes**:
  - a rewritten `<title>` and meta description
  - a single strong H1
  - a complete **JSON-LD schema** block (the right `@type` chosen for the page)
  - a generated **FAQ block**
  - concrete **content-gap** additions

Then a **sitewide report** that only a full crawl can produce:

- duplicate titles / meta descriptions
- **orphan pages** (no inbound internal links, from the crawl graph)
- schema coverage %
- your **robots.txt AI-crawler policy** (GPTBot, ClaudeBot, Google-Extended, PerplexityBot, CCBot…)
- a **generated `llms.txt`** file, ready to publish (saved to the key-value store)

One run future-proofs you for Google **and** for ChatGPT, Perplexity and Gemini at once.

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Domain or start URLs. Required. |
| `maxPages` | integer | Max pages to crawl (default 25). |
| `maxDepth` | integer | Link-hops from the start (default 3). |
| `generateFixes` | boolean | Generate AI fixes per page (default true). |
| `targetKeywords` | array | Keywords to steer the fixes. |
| `includeGlobs` / `excludeGlobs` | array | URL patterns to include/skip. |
| `maxConcurrency` | integer | Pages in parallel (default 5). |

```json
{
  "startUrls": ["https://example.com"],
  "maxPages": 50,
  "maxDepth": 3,
  "generateFixes": true
}
```

### Output

One record per page (plus a `site-report` record):

```json
{
  "recordType": "page",
  "url": "https://example.com/pricing",
  "overallScore": 72,
  "scores": { "technical": 93, "seo": 55, "aeo": 70, "geo": 70 },
  "issues": [{ "category": "seo", "issue": "Title length 16 is outside the 30-65 char sweet spot.", "severity": "medium" }],
  "fixes": {
    "title": "Simple, Transparent Pricing — Example",
    "metaDescription": "Compare plans and pick the right one…",
    "jsonLd": "<script type=\"application/ld+json\">{…}</script>",
    "faqBlock": "### FAQ\n**Q: …**\nA: …",
    "contentGaps": ["Add a plan-comparison table", "…"]
  }
}
```

### Pricing (pay-per-event)

| Event | When | Price |
|---|---|---|
| `page-audited` | per crawled page (deterministic audit) | $0.10 |
| `page-fixes-generated` | per page (AI-written fixes) | $0.20 |
| `site-report-generated` | per run (sitewide rollup + llms.txt) | $0.50 |

### Who it's for

SEO agencies, in-house SEO teams, technical SEOs and content strategists — re-auditing clients monthly across hundreds of pages.

### Notes

- Requires an OpenAI API key (`OPENAI_API_KEY`) when `generateFixes` is on.
- `maxPages` is a soft cap (a crawl batch may slightly overshoot it).

### Related actors

- [YouTube Transcript Scraper](https://apify.com/fuze/youtube-transcript-scraper) — Fetch YouTube video transcripts — plain text plus timed segments, with title, channel
- [AI Share of Voice — Multi-Engine GEO Tracker](https://apify.com/fuze/ai-share-of-voice) — Track your brand's visibility and share of voice across AI answer engines, with
- [Google Maps Lead Enricher (AI)](https://apify.com/fuze/google-maps-lead-enricher) — Takes company lists from popular Google Maps scrapers and turns them into sales-ready

# Actor input Schema

## `startUrls` (type: `array`):

The site to audit — a domain or one or more start URLs. The crawler stays on the same site. Example: 'https://example.com'.

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

Upper bound on pages visited this run.

## `maxDepth` (type: `integer`):

How many link-hops from the start URL to follow.

## `generateFixes` (type: `boolean`):

If on, generate ready-to-paste fixes per page (rewritten title/meta, JSON-LD schema, FAQ block, content gaps). Requires an OpenAI key and adds a per-page charge.

## `targetKeywords` (type: `array`):

Optional keywords to steer the AI fixes toward.

## `includeGlobs` (type: `array`):

Optional glob patterns — only crawl URLs matching these (e.g. 'https://example.com/blog/\*').

## `excludeGlobs` (type: `array`):

Optional glob patterns to skip (e.g. 'https://example.com/tag/\*').

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

How many pages to fetch/audit in parallel.

## `model` (type: `string`):

OpenAI model for the fix generation. gpt-4o-mini is the cost-effective default.

## Actor input object example

```json
{
  "startUrls": [
    "https://apify.com"
  ],
  "maxPages": 25,
  "maxDepth": 3,
  "generateFixes": true,
  "targetKeywords": [],
  "includeGlobs": [],
  "excludeGlobs": [],
  "maxConcurrency": 5,
  "model": "gpt-4o-mini"
}
```

# Actor output Schema

## `audit` (type: `string`):

All page audits and the sitewide report in the default dataset.

## `llmsTxt` (type: `string`):

The generated llms.txt file.

# 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 = {
    "startUrls": [
        "https://apify.com"
    ],
    "targetKeywords": [],
    "includeGlobs": [],
    "excludeGlobs": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fuze/ai-seo-site-auditor").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 = {
    "startUrls": ["https://apify.com"],
    "targetKeywords": [],
    "includeGlobs": [],
    "excludeGlobs": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fuze/ai-seo-site-auditor").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 '{
  "startUrls": [
    "https://apify.com"
  ],
  "targetKeywords": [],
  "includeGlobs": [],
  "excludeGlobs": []
}' |
apify call fuze/ai-seo-site-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fuze/ai-seo-site-auditor"
        }
    }
}
```

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/fpnKK65Qie5h05Y0z/builds/WOvSOpiZSaTi0wzCv/openapi.json