# SEO Audit & Site Health Checker: On-Page SEO Crawler (`f0rty7even/seo-auditor`) Actor

Crawl a website and get a per-page SEO audit: title/meta/H1/canonical/robots/Open Graph checks, image alt text, word count, and a prioritized list of issues with a health score.

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

## Pricing

from $5.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## SEO Audit & Site Health Checker — On-Page SEO Crawler

**Crawl any website and get a per-page SEO audit in minutes.** This **SEO audit** tool visits your pages (or a whole site), checks the on-page SEO signals that matter, and returns one structured report per page — with a **health score** and a **prioritized list of concrete issues to fix**. No account, no browser extension, no setup.

Point it at one URL or let it crawl the whole domain.

### What it checks

- **Title tag** — presence and length (aims for 30–60 chars).
- **Meta description** — presence and length (aims for 50–160 chars).
- **Headings** — missing or multiple `<h1>` tags.
- **Canonical link** — present or missing.
- **Indexability** — flags `noindex` pages that won't rank.
- **Open Graph** — `og:title` / `og:description` / `og:image` for social sharing.
- **Mobile & language** — viewport meta and `<html lang>`.
- **Image alt text** — counts images missing `alt`.
- **Content depth** — flags thin pages by word count.
- **Link profile** — internal vs. external link counts.
- **HTTP status** — flags 4xx/5xx and redirects.

Each page gets a **0–100 score** and an `issues` list you can sort and act on.

### Use cases

- **Site-wide SEO audits** — crawl a domain and export every page's issues to a spreadsheet.
- **Pre-launch / QA checks** — catch missing titles, noindex tags, and broken pages before they ship.
- **Content ops** — find thin content and missing meta descriptions across a blog.
- **Agency reporting** — generate structured, exportable SEO reports for clients.

### Input

| Field | Description |
|---|---|
| `startUrls` | Pages to audit (entry points when crawling). |
| `crawl` | Follow same-domain links and audit every page found. |
| `maxPages` | Hard cap on pages audited (main cost lever). |
| `maxDepth` | How many link-hops to follow when crawling. |
| `onlySameDomain` | Keep the crawl on the start URL's domain. |

### Output

Each page becomes one dataset item:

```json
{
  "url": "https://example.com/pricing",
  "statusCode": 200,
  "score": 82,
  "title": "Pricing — Example",
  "titleLength": 17,
  "metaDescription": null,
  "h1": "Simple, transparent pricing",
  "h1Count": 1,
  "canonical": "https://example.com/pricing",
  "indexable": true,
  "openGraph": { "title": "Pricing", "description": null, "image": "https://.../og.png" },
  "viewport": true,
  "lang": "en",
  "wordCount": 640,
  "imagesTotal": 8,
  "imagesMissingAlt": 2,
  "internalLinks": 34,
  "externalLinks": 5,
  "issues": [
    "Missing meta description",
    "Incomplete Open Graph tags (title/description/image)",
    "2 image(s) missing alt text"
  ],
  "issueCount": 3
}
```

### Pricing

Pay-per-result: you're charged **per page audited** — no monthly fee, and no charge for pages that can't be fetched.

### Notes

- Audits **server-rendered HTML** (the SEO signals crawlers like Google see first). Client-side-only content rendered by JavaScript is on the roadmap (browser-rendering toggle).
- Audits **public, logged-out pages** — it does not log in or bypass access controls.

### FAQ

**Does it crawl the whole site?** Yes — enable `crawl` and set `maxPages` / `maxDepth`.

**What's the score?** A 0–100 health score that starts at 100 and deducts points per issue by severity — a quick way to rank your worst pages first.

**What formats can I export?** JSON, JSONL, CSV, or Excel, or via the Apify API.

# Actor input Schema

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

Pages to audit. With crawling on, these are the entry points.

## `crawl` (type: `boolean`):

Follow same-domain links from the start URLs (up to the limits below) and audit every page found.

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

Hard cap on pages audited (also the main cost lever).

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

How many link-hops from a start URL to follow when crawling.

## `onlySameDomain` (type: `boolean`):

Only follow links on the same registered domain as the start URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://apify.com"
    }
  ],
  "crawl": true,
  "maxPages": 50,
  "maxDepth": 3,
  "onlySameDomain": true
}
```

# Actor output Schema

## `seoReports` (type: `string`):

One audit record per page — score, title/meta/H1/canonical/OG checks, and an issues list. Export as JSON, JSONL, CSV, or Excel.

# 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": [
        {
            "url": "https://apify.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("f0rty7even/seo-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": [{ "url": "https://apify.com" }] }

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8Wpv1zdBhPnRqZcxi/builds/MeezpqDBqYuCoj2a7/openapi.json
