# SEO Audit Tool: On-Page SEO Checker with PageSpeed (`tan-solutions/seo-audit`) Actor

On-page SEO audit for any list of pages: titles, meta descriptions, canonicals, robots and noindex, headings, structured data, images, links, sitemap, robots.txt and optional Core Web Vitals (your PageSpeed key). A score and fix hints per page; failed pages are free. Not affiliated with Google.

- **URL**: https://apify.com/tan-solutions/seo-audit.md
- **Developed by:** [Tan Solutions](https://apify.com/tan-solutions) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 audited pages

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

## SEO Audit Tool: On-Page SEO Checker with PageSpeed

On-page SEO audit for any list of pages, in one run: an SEO checker with optional PageSpeed (Core Web Vitals). For every page you get a score from 0 to 100, a list
of issues (each with how serious it is and how to fix it) and the facts behind them: title, meta description,
canonical, robots and `noindex`, headings, structured data, images without alt text, links, page speed basics and
more.

### Run it from the API or on a schedule

Get the audit back in one call (replace `<YOUR_API_TOKEN>` with your Apify API token from Console, **Settings**, **API & Integrations**):

```bash
curl -X POST "https://api.apify.com/v2/acts/tan-solutions~seo-audit/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.iana.org/help/example-domains"}],"checkLinks":true}'
```

Send `{}` (no input) to try it on one page.

Audit the same pages every Monday at 07:00 UTC with an Apify schedule (`bk5p8wKYXNqaaBJMg` is this Actor's ID):

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"name": "seo-audit-weekly", "cronExpression": "0 7 * * 1", "timezone": "UTC", "isEnabled": true, "isExclusive": true,
       "actions": [{"type": "RUN_ACTOR", "actorId": "bk5p8wKYXNqaaBJMg",
         "runInput": {"body": "{\"startUrls\":[{\"url\":\"https://www.iana.org/help/example-domains\"}],\"checkLinks\":true}", "contentType": "application/json"}}]}'
```

In Apify Console the same is: **Schedules**, **Create new**, cron `0 7 * * 1`, add this Actor with your input.

### What it does

- Opens each page you list and runs more than 40 on-page checks on it.
- Gives each page a score: 100 minus the weight of each issue found, so fixing an issue always raises the score.
- Tells you what to fix: every issue has a stable `code`, a plain message and a fix hint.
- Optional: checks robots.txt and the sitemap once per site (on by default), tests the links on each page for broken
  ones, renders JavaScript sites in a browser first, and adds Core Web Vitals from Google PageSpeed Insights with your
  own free API key.

| Area | What is checked |
| --- | --- |
| Title and description | missing, empty, too short or too long, more than one |
| Indexing | meta robots and `X-Robots-Tag` (`noindex`, `nofollow`), canonical (missing, points elsewhere, invalid, more than one) |
| International | `lang` attribute, hreflang codes, self reference, `x-default` |
| Content | one H1, skipped heading levels, word count, images without alt text |
| Social | Open Graph title, description, image and URL; Twitter card |
| Structured data | JSON-LD that does not parse, missing `@context` or `@type`, missing required properties (Article, Product, Organization and more); microdata and RDFa |
| Technical | HTTPS, mixed content, redirect chain, response time, HTML size, mobile viewport, zoom disabled |
| Site files (optional, on) | robots.txt present, `Sitemap:` lines, the sitemap itself (urlset, index or gzip) |
| Links (optional) | each link checked once: broken, redirect, restricted, bot wall |
| Performance (optional) | PageSpeed Insights score, lab LCP, FCP, TBT, CLS and Speed Index, field LCP, CLS and INP, top 5 opportunities |

### Who it is for

- Site owners and marketers who want a quick SEO check of their key pages before or after a launch.
- SEO agencies that audit client pages in bulk and track issues over time.
- Developers who want an SEO audit API in a build pipeline or on a schedule, to catch a lost canonical, a stray
  `noindex` or a broken link before search engines do.

### Quick start

1. Paste one or more page URLs into **Pages to audit**.
2. Click **Start**.
3. Open the **Output** tab: the overview shows each page's score and issue counts, the issues view lists every issue.
   Download as JSON, CSV or Excel, or read the dataset through the API.

### Input

| Field | What it does | Default |
| --- | --- | --- |
| `startUrls` (Pages to audit) | The pages to audit. Each URL is one page; there is no crawl, you choose the pages. Bare domains get `https://`. | `https://example.com` |
| `maxUrls` (Max pages) | Pages past this number are listed as not processed (free). Hard limit 1,000 per run. | 100 |
| `renderJs` (Render JavaScript) | Open each page in a browser first, for sites that build their content with JavaScript. Slower. | off |
| `checkSiteFiles` (Check robots.txt and sitemap) | Once per site: is there a robots.txt, and can the sitemap be found and read? | on |
| `checkLinks` (Check links for errors) | Test the links on each page for broken (4xx/5xx) and redirecting targets. | off |
| `maxLinksPerPage` | Links past this number are counted as not checked. Hard limit 100. | 50 |
| `pageSpeedApiKey` | Your own Google API key with the PageSpeed Insights API turned on. Stored as a secret; never shown in the output or the log. Without it, everything else still runs. | empty |
| `pageSpeedStrategy` (PageSpeed device) | `mobile` or `desktop`. | `mobile` |
| `timeoutSecs` (Page timeout) | Seconds per page, from request to full page. 5-120. | 30 |
| `maxConcurrency` (Max parallel pages) | Pages at once across all sites (1-10). Each site still gets at most 2 requests at once, 1 second apart. | 5 |

Example:

```json
{
  "startUrls": [{ "url": "https://www.python.org/" }, { "url": "https://example.com/" }],
  "checkSiteFiles": true,
  "checkLinks": false
}
```

### Output example

One dataset row per URL. A real row from a test run (www.python.org, 13 Nov 2026), shortened:

```json
{
  "url": "https://www.python.org/",
  "finalUrl": "https://www.python.org/",
  "status": "ok",
  "httpStatus": 200,
  "fetchedWith": "http",
  "score": 88,
  "issueCounts": { "error": 0, "warning": 1, "notice": 5 },
  "issues": [
    { "code": "CANONICAL_MISSING", "severity": "warning", "message": "No canonical link", "hint": "Add <link rel=\"canonical\" href=\"...\"> with the preferred absolute URL of this page." },
    { "code": "TITLE_TOO_SHORT", "severity": "notice", "message": "The title is shorter than 30 characters: 21 characters", "hint": "Use 30-60 characters: the topic plus a qualifier or the brand." },
    { "code": "H1_MULTIPLE", "severity": "notice", "message": "More than one H1 heading: 5 found", "hint": "Use one <h1> for the page topic and <h2>-<h6> for sections." }
  ],
  "page": {
    "title": { "text": "Welcome to Python.org", "length": 21, "count": 1 },
    "metaDescription": { "text": "The official home of the Python Programming Language", "length": 52, "count": 1 },
    "canonical": { "href": null, "count": 0, "selfReferencing": null },
    "headings": { "counts": { "h1": 5, "h2": 9, "h3": 0, "h4": 0, "h5": 0, "h6": 0 }, "skipped": [] },
    "structuredData": { "jsonLdBlocks": 1, "validBlocks": 1, "types": ["WebSite"], "problems": [] },
    "images": { "total": 1, "missingAlt": 0 },
    "links": { "total": 212, "internal": 134, "external": 78, "nofollow": 0 },
    "wordCount": 963,
    "viewport": { "responsive": true, "zoomDisabled": false },
    "https": true,
    "htmlBytes": 52202
  },
  "site": {
    "origin": "https://www.python.org",
    "robotsTxt": { "present": true, "httpStatus": 200, "sitemaps": [] },
    "sitemap": { "status": "missing", "url": "https://www.python.org/sitemap.xml", "httpStatus": 404 }
  },
  "linkCheck": null,
  "cwv": "no_api_key",
  "pageSpeed": null,
  "auditedAt": "2026-11-13T08:59:07.176Z",
  "error": null
}
```

`status` is `ok` (audited), `robots_disallowed` (the site's robots.txt does not allow the page; site facts are still
filled in), `blocked` (a bot wall answered) or `error` (with `error.code` and `error.message`).

### Pricing

You pay per audited page (the `page` event): a page that was fetched and audited. Failed, blocked and
robots-disallowed pages are free, and so are HTTP errors, non-HTML URLs, invalid URLs and pages past `maxUrls`. If
your spending limit is reached, the run stops cleanly and tells you so.

| Apify plan | Price per 1,000 audited pages |
| --- | --- |
| Free | $3.00 |
| Bronze | $2.50 |
| Silver | $2.25 |
| Gold | $2.00 |

Apify's standard Actor start event is charged when a run starts, at the platform's default price: one event per GB of
run memory (1 event at the default 1 GB). PageSpeed Insights calls use your own Google key and quota.

### Limits

- Only the pages you list; no site crawl. Up to 1,000 pages per run and 100 links checked per page.
- Always obeys robots.txt (user agent token `TanForgeBot`), with at most 2 requests per site at once, 1 second apart.
- No logins, cookies, custom headers or proxies. Pages behind a login or a bot wall are reported, not bypassed.
- Memory: 1,024 MB is the default and the minimum. A 1,000-page run peaks at about 870 MB.
- PageSpeed Insights takes 10-30 s per page and is limited by your key's quota (`quota_exceeded` when it runs out).

### FAQ

**Is this an SEO audit API?** Yes. Start the Actor through the Apify API with a list of URLs and read the dataset as
JSON, CSV or Excel. Every issue has a stable `code`, so you can track issues over time.

**Why is my page `robots_disallowed`?** The site's robots.txt does not allow automated access to that page. The tool
always respects it, and you are not charged for it.

**Why is `cwv` `no_api_key`?** Core Web Vitals come from Google PageSpeed Insights, which needs your own API key.
Create one in the Google Cloud console, turn on the PageSpeed Insights API and paste the key into `pageSpeedApiKey`.

**Does the score match tool X?** No two SEO tools score the same way. Here the score is 100 minus the weight of each
issue found, so fixing an issue always raises it.

**My site builds its pages with JavaScript. Will it work?** Turn on `renderJs`. Each page is then opened in a browser
before the audit. It is slower, so leave it off for normal sites.

### Related tools by Tan Solutions

- [URL to Markdown](https://apify.com/tan-solutions/url-to-markdown): web pages to clean Markdown for LLMs, RAG pipelines and AI agents.
- [Document to Markdown](https://apify.com/tan-solutions/document-to-markdown): PDF, Word and PowerPoint files to Markdown for LLMs and RAG.
- [Domain Intelligence](https://apify.com/tan-solutions/domain-intel): DNS, WHOIS/RDAP, SSL and tech stack for up to 1,000 domains.
- [US Company Filings & Financials](https://apify.com/tan-solutions/company-filings): 10-K, 10-Q, 8-K filings and XBRL facts by ticker.

### More from Tan Solutions

- [SEO audit tool page](https://www.tansolutions.org/tools/seo-audit/): details and examples for this Actor on our site.
- [All Tan Solutions data tools](https://www.tansolutions.org/tools/)

### Terms of use

By running this Actor you agree to the following:

- You are responsible for the URLs you audit: your own sites, or sites you are permitted to audit. You are also
  responsible for your own Google API key, its terms and its quota.
- The Actor obeys robots.txt, does not log in, and stops at CAPTCHAs and bot walls.
- No warranty: scores and checks are indicative. Liability is capped at the fees you paid for this Actor in the last
  12 months.
- Issues reported on the Actor page are answered within 14 days.

Not affiliated with, endorsed by or sponsored by Google. PageSpeed Insights is a trademark of Google LLC. Performance
data: Google PageSpeed Insights, used under the [Google APIs Terms of Service](https://developers.google.com/terms).

Made by Tan Solutions.

# Actor input Schema

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

Each URL is audited as one page. Bare domains get https://.

## `maxUrls` (type: `integer`):

Pages past this number are listed as not processed (free). Hard limit 1000 per run.

## `renderJs` (type: `boolean`):

Open each page in a browser before the audit, for sites that build their content with JavaScript. Slower.

## `checkSiteFiles` (type: `boolean`):

Once per site: is there a robots.txt, and can the sitemap be found and read?

## `checkLinks` (type: `boolean`):

Test the links on each page for broken (4xx/5xx) and redirecting targets. Pages on other sites get one light request each.

## `maxLinksPerPage` (type: `integer`):

Links past this number are counted as not checked. Hard limit 100.

## `pageSpeedApiKey` (type: `string`):

Your own free Google API key turns on Core Web Vitals and the performance score. Without it, everything else still runs. The key is never shown in the output or the log. Not affiliated with Google.

## `pageSpeedStrategy` (type: `string`):

Which device PageSpeed Insights tests as.

## `timeoutSecs` (type: `integer`):

Per page, from request to full body.

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

Across all sites. Each site still gets at most 2 requests at once, 1 second apart.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "maxUrls": 100,
  "renderJs": false,
  "checkSiteFiles": true,
  "checkLinks": false,
  "maxLinksPerPage": 50,
  "pageSpeedStrategy": "mobile",
  "timeoutSecs": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

One item per audited page with its score and issue counts.

## `issues` (type: `string`):

The problems found on each page, ready to fix.

# 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://example.com"
        }
    ]
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tan-solutions/seo-audit"
        }
    }
}
```

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/bk5p8wKYXNqaaBJMg/builds/rQpjUNtahiFBMwcGD/openapi.json
