# Seobility SEO Checker (`maximedupre/seobility-seo-checker`) Actor

Run Seobility SEO checks for public websites and page URLs. Get score, issue count, category scores, hints, factor checks, wiki links, and message evidence for exports, API workflows, and scheduled audits.

- **URL**: https://apify.com/maximedupre/seobility-seo-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Marketing, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 checked 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/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

### 🔎 Seobility SEO checker for website audits

Seobility SEO Checker runs public [Seobility](https://www.seobility.net/en/seocheck/) checks for the websites, domains, and page URLs you submit. Add targets like `example.com` or `https://apify.com`, and the Actor saves one clean SEO audit result per successful target with the overall score, issue count, category scores, hints, factor checks, message labels, and Seobility wiki links.

Use this Seobility SEO checker when you need quick on-page SEO evidence for client audits, prospect lists, content QA, migrations, reporting dashboards, or recurring checks. The output is ready for Apify dataset exports, API workflows, schedules, webhooks, and integrations.

No Seobility login, cookies, user token, source API key, or paid Seobility account is required from you. For a small first run, keep the prefilled targets and inspect the dataset shape before adding a larger list.

### ✅ What this Actor does

- Accepts public domains such as `example.com`, full website URLs such as `https://apify.com`, and page URLs.
- Normalizes each accepted target before checking it with Seobility.
- Saves one dataset item per successful Seobility SEO check.
- Returns the overall SEO score, issue count, and highest issue severity.
- Returns category scores for meta, page quality, structure, links, server, and external signals.
- Returns high-level Seobility hints and detailed factor checks with source labels, severities, parameters, score percentages, and wiki links.
- Skips invalid or failed targets and continues with the rest of the batch.

This Actor is focused on Seobility's public single-page SEO check. It does not crawl a whole website, run rank tracking, check backlinks from a private account, generate AI-written SEO advice, create PDF reports, or access logged-in Seobility dashboards.

### 📊 Data you can extract

Each dataset item is one successful website SEO checker result. Rows include:

- `target` - the website, domain, or page URL you entered.
- `analyzedUrl` - the final URL Seobility checked after normalization or redirects.
- `overallScore` - Seobility's 0-100 SEO score.
- `issueCount` - number of SEO issues reported by Seobility.
- `topIssueSeverity` - highest source severity when Seobility reports one.
- `categories` - score summaries for meta, page quality, structure, links, server, and external signals.
- `hints` - high-level Seobility hints with code, importance, and source section anchor.
- `checks` - factor-level checks with category, factor key, factor name, importance, score percentage, wiki URL, and source messages.

The dataset keeps Seobility's source labels and message parameters instead of inventing new advice. That makes the output easier to audit, join to reports, and compare across repeat runs.

### 🚀 How to run it

1. Add one or more public websites, domains, or page URLs in **Websites or URLs**.
2. Start with a small list if you are checking unfamiliar sites.
3. Run the Actor.
4. Open the dataset, export it as JSON, CSV, Excel, XML, RSS, or HTML, or read the same results through the Apify API.

The Actor pushes each accepted audit row as soon as it is ready, so you can watch results appear while the run continues.

### 🧾 Input

The input has one required field:

```json
{
  "targets": [
    "example.com",
    "https://apify.com"
  ]
}
````

Add one target per line in Apify Console. Each successful target can emit one result row.

### 📦 Output example

```json
{
  "target": "example.com",
  "analyzedUrl": "https://example.com/",
  "overallScore": 57,
  "issueCount": 3,
  "topIssueSeverity": "error",
  "categories": {
    "meta": {
      "points": 342,
      "pointsMax": 515,
      "scorePercent": 66
    },
    "pageQuality": {
      "points": 175,
      "pointsMax": 360,
      "scorePercent": 48
    },
    "structure": {
      "points": 164,
      "pointsMax": 170,
      "scorePercent": 96
    },
    "links": {
      "points": 20,
      "pointsMax": 80,
      "scorePercent": 25
    },
    "server": {
      "points": -40,
      "pointsMax": 110,
      "scorePercent": 0
    },
    "external": {
      "points": 100,
      "pointsMax": 100,
      "scorePercent": 100
    }
  },
  "hints": [
    {
      "code": "hint_description_adddescription",
      "importance": 3,
      "anchor": "factor_description"
    }
  ],
  "checks": [
    {
      "category": "meta",
      "factor": "title",
      "factorName": "factor_title_content",
      "importance": 3,
      "scorePercent": 52,
      "wikiUrl": "https://www.seobility.net/en/wiki/Meta_Title",
      "messages": [
        {
          "severity": "warning",
          "label": "title_short",
          "text": null,
          "params": {
            "size": 152,
            "maxlen": 580
          }
        }
      ]
    }
  ]
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successful checked page saved to the dataset. Targets that fail, are invalid, or do not produce a usable Seobility SEO check are skipped and are not charged as checked pages.

### ⚠️ Limits and caveats

- Seobility checks the submitted page or normalized website URL. This Actor does not crawl every page on a site.
- Some public websites block or fail source checks. Those targets are skipped so the rest of the run can continue.
- Missing category values are saved as `null` when Seobility does not return them.
- Category point totals come from Seobility and can be negative.
- The Actor returns source-backed labels and evidence. It does not rewrite findings into AI recommendations.

### ❓ FAQ

#### 🔐 Does this need a Seobility account?

No. The Actor uses Seobility's public website SEO checker and does not ask for your Seobility account, cookies, or API key.

#### 📚 Can I use it for bulk SEO audits?

Yes. Add multiple public websites, domains, or page URLs. The Actor checks independent targets and emits one row for each successful target.

#### 🕸️ Does it crawl the whole website?

No. It checks the submitted target as a single Seobility SEO check. Use a crawler when you need a full site URL inventory.

#### 🗓️ Can I schedule repeat checks?

Yes. After the Actor is published, you can run it from Apify Console, API, schedules, webhooks, or integrations like other Apify Actors.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~seobility-seo-checker/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Ahrefs Free Website Stats Scraper ↗](https://apify.com/maximedupre/ahrefs-free-website-stats-scraper) - Extract public Ahrefs domain metrics for SEO research and audits.
- [SEMrush Free Website Stats Scraper ↗](https://apify.com/maximedupre/semrush-free-website-stats-scraper) - Export public SEMrush overview metrics for domains and URLs.
- [Moz Scraper ↗](https://apify.com/maximedupre/moz-scraper) - Scrape public Moz domain authority and SEO metrics.
- [Sitemap Sniffer ↗](https://apify.com/maximedupre/sitemap-sniffer) - Find public sitemap files and URL inventory for SEO audits.
- [Website URL Crawler ↗](https://apify.com/maximedupre/website-url-crawler) - Crawl rendered public pages and export a link map.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `targets` (type: `array`):

Enter one public website, domain, or page URL per line, such as example.com or https://apify.com.

## Actor input object example

```json
{
  "targets": [
    "example.com",
    "https://apify.com",
    "openai.com",
    "github.com",
    "wikipedia.org"
  ]
}
```

# Actor output Schema

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

One successful Seobility SEO check per accepted website, domain, or page URL.

# 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 = {
    "targets": [
        "example.com",
        "https://apify.com",
        "openai.com",
        "github.com",
        "wikipedia.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/seobility-seo-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 = { "targets": [
        "example.com",
        "https://apify.com",
        "openai.com",
        "github.com",
        "wikipedia.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/seobility-seo-checker").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 '{
  "targets": [
    "example.com",
    "https://apify.com",
    "openai.com",
    "github.com",
    "wikipedia.org"
  ]
}' |
apify call maximedupre/seobility-seo-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seobility SEO Checker",
        "description": "Run Seobility SEO checks for public websites and page URLs. Get score, issue count, category scores, hints, factor checks, wiki links, and message evidence for exports, API workflows, and scheduled audits.",
        "version": "0.1",
        "x-build-id": "VqPYwIGmA1TVvEwi5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~seobility-seo-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-seobility-seo-checker",
                "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/maximedupre~seobility-seo-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-seobility-seo-checker",
                "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/maximedupre~seobility-seo-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-seobility-seo-checker",
                "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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Websites or URLs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Enter one public website, domain, or page URL per line, such as example.com or https://apify.com.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```