# Website SEO Audit (`lergassy/website-seo-audit`) Actor

\[from $30/1K pages] Website SEO audit for page URLs or a whole domain: on-page score 0-100, SEO issues in plain English with priority, title, meta description, H1, canonical, noindex, broken links, images without alt, duplicate titles, schema, load time. Run via API or with AI agents.

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

## Pricing

from $22.40 / 1,000 page analyzeds

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

### What is Website SEO Audit?

**Website SEO Audit** is an **on-page SEO checker** and **technical SEO audit tool** for any list of page URLs or a whole website. Paste page URLs (or type one domain to crawl) and get **one row per page** with the **HTTP status code**, an **on-page SEO score from 0 to 100**, every **SEO issue in plain English with a priority** (high, medium, low), the **title and meta description with their lengths**, **H1 headings**, **canonical tag**, **meta robots / noindex**, **page size**, **load time**, **word count**, **internal and external links**, **broken links**, **images without alt text**, **duplicate titles and descriptions** and the **schema.org structured data** found on the page.

One row is one page. No browser extension, no login, no API key: the pages are fetched and analysed by an on-page audit engine through a licensed data provider, and broken links are checked by the Actor itself.

- 💰 **From $0.03 per audited page** on paid plans ($0.04 on the Apify Free plan) — no start fee, no subscription. Free plan: same as the market leader; paid plans ~25% cheaper
- 🆓 **Free rows for pages that do not answer 200** (404, 5xx) and for invalid URLs — you only pay for fully audited pages
- 🔗 **Broken links checker included** at no extra cost — every link on the page is requested, broken ones are listed with their status
- 🗂️ **Bulk**: up to 1,000 URLs per run, or crawl a domain and audit every page found
- ⚙️ **JavaScript rendering ($)** for React, Vue and Angular sites, **mobile or desktop** user agent
- 🤖 Works from the **Apify API**, the **MCP server** (Claude, ChatGPT, Cursor), n8n, Make and Zapier

### What data can Website SEO Audit extract?

Values below are from a real run on `https://apify.com` and on a public page with broken links (`catb.org/~esr/faqs/hacker-howto.html`).

| Field | Example | What it means |
|---|---|---|
| 🔗 `url` | `https://apify.com/` | Final URL of the page after redirects |
| `statusCode` | `200` | HTTP status code; only 200 pages are charged |
| 💯 `onpageScore` | `100` / `83.38` | On-page SEO score 0–100 (100 = no on-page problems found) |
| ⚠️ `issues` | `["[high] Missing H1 heading", "[high] 16 broken link(s) on the page", "[medium] Missing meta description"]` | Every problem in plain English, highest priority first |
| `issueCodes` | `["no_h1_tag", "broken_links", "no_description"]` | The same issues as stable machine-readable codes |
| `issuesCount`, `highIssues`, `mediumIssues`, `lowIssues` | `16`, `3`, `3`, `10` | Issue counts by priority |
| 📰 `title`, `titleLength` | `Apify: Marketplace of ready-to-run tools for AI`, `47` | Title tag and its length |
| 📝 `metaDescription`, `descriptionLength` | `Thousands of tools to automate your business…`, `143` | Meta description and its length |
| `h1`, `h1Count`, `h1All`, `h2Count` | `78,661 tools for your AI`, `1` | First H1, number of H1s, all H1 texts, number of H2s |
| `canonical`, `canonicalStatus` | `https://apify.com/`, `self` | Canonical URL; `self`, `other` or `missing` |
| 🤖 `metaRobots`, `noindex`, `nofollow` | `index,follow`, `false`, `false` | Meta robots tag and whether it blocks indexing or following |
| `redirected`, `redirectTo` | `true` | The requested URL redirected (e.g. http → https) |
| `isHttps` | `true` | Served over HTTPS |
| ⏱️ `loadTimeMs` | `111` | Time to load the page (HTML download; full render with JavaScript rendering on) |
| `pageSizeKb` | `481.3` | Size of the HTML document |
| `wordCount`, `readabilityScore` | `403`, `56.6` | Words of visible text; Flesch-Kincaid reading ease |
| `internalLinks`, `externalLinks` | `49`, `42` | Link counts |
| 🔗 `linksChecked`, `brokenLinks`, `brokenLinkUrls` | `72`, `16`, `["http://www.olemichaelsen.dk/hacker-howto.html (404)", …]` | Broken links checker results (up to 25 URLs listed per page) |
| 🖼️ `images`, `imagesWithoutAlt` | `10`, `10` | Images and images missing alt text |
| `duplicateTitle`, `duplicateDescription` | `false` | Another audited page in the same run has the same title / description |
| 🧩 `schemaTypes`, `hasStructuredData` | `["Organization", "WebSite", "SoftwareApplication"]` | schema.org types from JSON-LD and microdata |
| `hasOpenGraph`, `language`, `hreflangCount` | `true`, `en`, `0` | Social preview tags, html lang attribute, hreflang links |
| `clickDepth` | `1` | Clicks from the start page (domain crawl only) |
| `device`, `javascriptRendered` | `desktop`, `false` | How the page was requested |

The **issues list** combines about 45 checks from the audit engine (status codes, title and description length, missing H1, slow load, thin content, render-blocking resources, HTTP links on HTTPS pages, redirect chains and more) with checks the Actor computes itself: **noindex**, **canonical pointing elsewhere**, **missing canonical**, **multiple H1**, **broken links**, **duplicate title and description across your pages**, **missing structured data**, **missing Open Graph tags**, **missing viewport tag** and **missing lang attribute**.

### How much does it cost to run an SEO audit?

Website SEO Audit uses **pay-per-event** pricing. You pay for audited pages, not for compute time or proxies.

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) | When it is charged |
|---|---|---|---|---|---|
| 💰 **Audited page** | $0.04 | **$0.03** | $0.02625 | $0.0225 | A page that answered HTTP 200 and got the full audit |
| ⚙️ **Add-on: JavaScript rendering** | $0.01 | **$0.009** | $0.008 | $0.007 | Only when *Render JavaScript* is on, per audited page |

- **No start fee** and no monthly subscription.
- **Free**: pages that answer 404, 5xx or another non-200 status (they still appear in the table so you can fix them), invalid URLs, unknown domains, pages that time out, and the optional site summary row.
- **The broken links check is free**: it does not change the price of a page.
- Platinum and Diamond plans pay the Business price.

**Examples on the Starter plan:** 100 pages cost **$3.00**; with JavaScript rendering **$3.90**. With $1 you can audit **33 pages**. On the Free plan 100 pages cost $4.00 ($5.00 with JavaScript rendering), and the $5 of monthly free credit covers about **125 pages**. The market leader for full SEO audits on Apify charges $0.04 per page on the Free and Starter plans, $0.035 on Scale and $0.03 on Business (Store prices on 2 October 2026). Free plan: same as the leader; paid plans ~25% cheaper.

### How to run an SEO audit with Website SEO Audit

1. Click **Try for free** and sign in to Apify (a free account is enough).
2. In **🔗 Page URLs**, paste the pages you want to check, one per line — or type a domain in **🌐 Domain to crawl** to audit the whole site.
3. Set **💯 Max pages** (default 100).
4. Leave **Check broken links** on, and switch on **Render JavaScript ($)** only if your site is built with React, Vue or Angular.
5. Click **Start**. Two pages take about 10 seconds.
6. Open the **SEO audit** tab, sort by `onpageScore` or `highIssues`, and export to **CSV, Excel, JSON** or Google Sheets.

### ⬇️ Input

#### Audit a list of page URLs

```json
{
  "urls": ["https://apify.com", "https://apify.com/store"]
}
```

URLs without `https://` are accepted (`example.com/page`). Duplicates are removed. Up to 1,000 URLs per run, audited in parallel batches.

#### Crawl a domain and audit every page

```json
{
  "domain": "crawlee.dev",
  "maxPages": 50,
  "includeSiteSummary": true
}
```

The crawler starts at the domain's home page (or at the start URL you give, e.g. `https://example.com/blog`) and follows internal links until it has found **Max pages**. When **Domain to crawl** is filled in, the URL list is ignored. A crawl of 5 pages took 39 seconds in our test; hundreds of pages take several minutes.

#### All options

| Field | Default | What it does |
|---|---|---|
| 🔗 `urls` | 2 demo pages | Page URLs to audit |
| 🌐 `domain` | empty | Domain or start URL to crawl instead of a list |
| 💯 `maxPages` | `100` | Most pages per run (1–1,000) |
| `checkBrokenLinks` | `true` | Request every link on the page and list broken ones |
| `renderJavaScript` ($) | `false` | Load pages in a browser with all resources before the audit |
| `device` | `desktop` | `desktop` or `mobile` (smartphone user agent) |
| `maxLinksPerPage` | `100` | Links checked per page (1–500); a link shared by many pages is checked once |
| `includeSiteSummary` | `false` | Add one free `summary` row at the end |

### ⬆️ Output

#### Page row

```json
{
  "type": "page",
  "url": "http://www.catb.org/~esr/faqs/hacker-howto.html",
  "statusCode": 200,
  "onpageScore": 83.38,
  "issuesCount": 16,
  "highIssues": 3,
  "issues": [
    "[high] Page is not served over HTTPS",
    "[high] Missing H1 heading",
    "[high] 16 broken link(s) on the page",
    "[medium] Missing meta description",
    "[medium] Images without alt text",
    "[medium] No viewport meta tag (not mobile-friendly)",
    "[low] Title is shorter than 30 characters"
  ],
  "title": "How To Become A Hacker",
  "titleLength": 22,
  "metaDescription": null,
  "h1Count": 0,
  "canonicalStatus": "missing",
  "noindex": false,
  "loadTimeMs": 397,
  "wordCount": 9562,
  "internalLinks": 7,
  "externalLinks": 67,
  "linksChecked": 72,
  "brokenLinks": 16,
  "brokenLinkUrls": [
    "http://scientificachievements.com/jak-se-stat-hackerem/ (ENOTFOUND)",
    "http://www.olemichaelsen.dk/hacker-howto.html (404)"
  ],
  "images": 10,
  "imagesWithoutAlt": 10,
  "schemaTypes": [],
  "scrapedAt": "2026-10-01T14:28:14.236Z"
}
```

(Shortened — every row carries all the fields from the table above.)

The dataset has three table views: **SEO audit** (score, issues, title, description, H1, broken links), **Meta tags & headings** and **Links & performance**.

#### Site summary row (optional)

With **Add a site summary row** on, one free row of type `summary` closes the table: pages audited, average on-page score, pages with high-priority issues, total broken links, duplicate title and description pages, noindex pages and a count of pages per issue code. In domain crawl mode it also carries site checks: **sitemap found**, **robots.txt found**, **valid SSL certificate** and its expiry date, **HTTP/2**, **HTTP → HTTPS redirect** and the detected CMS. It is off by default so the table holds only page rows.

#### Error rows

Input that cannot be audited becomes a free row: `{"type": "error", "url": "…", "error": "Domain not found (no DNS record) — check the spelling of the URL. Not charged."}`. Pages that answer 404 or 5xx are kept as normal `page` rows with `statusCode` and the issue `[high] Page not found or blocked (4xx status code)`, also free.

### Use cases for an on-page SEO checker

#### SEO agencies and freelancers

Audit a client's key pages before a pitch and hand over a prioritised list: high-priority issues first, each named in plain words. Re-run monthly on a schedule to show progress.

#### Content and marketing teams

Check every new blog post for a missing meta description, a title that Google will cut off, a missing H1 or images without alt text — before it is indexed.

#### Web developers and QA

Run it after each deploy on your key URLs: catch accidental `noindex`, canonical tags pointing at staging, redirects, broken links and 404 pages.

#### Site migrations

Paste the list of old URLs and confirm each one redirects (`redirected`, `url`) and the new pages keep their titles, descriptions and canonicals.

#### AI agents and LLM apps

An agent can call the Actor with a URL and get a flat JSON row it can reason about — `issues` is already written as sentences, `issueCodes` is stable for code.

### Integrations

#### Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/lergassy~website-seo-audit/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com", "https://example.com/pricing"]}'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("lergassy/website-seo-audit").call(run_input={"urls": ["https://example.com"]})
for page in client.dataset(run["default_dataset_id"]).iterate_items():
    print(page["url"], page.get("onpageScore"), page.get("issues"))
```

#### JavaScript

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('lergassy/website-seo-audit').call({ domain: 'example.com', maxPages: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### No-code and scheduling

Connect the Actor to **n8n, Make, Zapier, Google Sheets, Slack** or a **webhook** from the Integrations tab of the run. Use **Schedules** to audit your site every week and get the new issues in a sheet.

### 🤖 For AI Agents & LLM Apps

Compact reference for agents calling `lergassy/website-seo-audit` through the Apify MCP server or the API.

**Purpose:** one row per web page with its on-page SEO problems in plain English, an on-page score 0–100 and the raw facts (title, description, H1, canonical, robots, links, broken links, images, schema).

**Minimal input:** `{"urls": ["https://example.com/page"]}` or `{"domain": "example.com", "maxPages": 20}`.

**Output fields:** `type`, `url`, `requestedUrl`, `statusCode`, `redirected`, `onpageScore`, `issuesCount`, `highIssues`, `mediumIssues`, `lowIssues`, `issues`, `issueCodes`, `title`, `titleLength`, `metaDescription`, `descriptionLength`, `h1Count`, `h1`, `h1All`, `h2Count`, `canonical`, `canonicalStatus`, `metaRobots`, `noindex`, `nofollow`, `redirectTo`, `isHttps`, `pageSizeKb`, `loadTimeMs`, `wordCount`, `readabilityScore`, `internalLinks`, `externalLinks`, `linksChecked`, `brokenLinks`, `brokenLinkUrls`, `images`, `imagesWithoutAlt`, `duplicateTitle`, `duplicateDescription`, `schemaTypes`, `hasStructuredData`, `hasOpenGraph`, `language`, `hreflangCount`, `clickDepth`, `device`, `javascriptRendered`, `scrapedAt`.

**Behaviors an agent should know:**

- `domain` overrides `urls`; `maxPages` caps both (default 100).
- `issues` is sorted high → low priority; `issueCodes` is in the same order.
- `duplicateTitle` / `duplicateDescription` compare pages within the same run only.
- `brokenLinks` is `null` when the check is off; links answering 401, 403 or 429 are not counted as broken (often bot protection).
- Only pages with `statusCode` 200 are billed ($0.03 on Starter, $0.04 on the Free plan, plus $0.009 / $0.01 with `renderJavaScript`); error rows and non-200 pages are free.

### ❓ FAQ

#### Is it legal to audit websites with this tool?

The Actor reads public web pages the same way a search engine crawler does and does not log in or bypass access controls. Auditing your own sites and your clients' sites is standard SEO practice. For other websites, respect their terms of use; if in doubt, consult a lawyer.

#### How is the on-page score calculated?

`onpageScore` is computed by the audit engine from its on-page checks on a 100-point scale: 100 means it found no on-page problems, and the score drops as problems are found. Use it to rank pages; use `issues` to see what to fix.

#### Does it check broken links?

Yes. Every link on the page (up to **Max links checked per page**, default 100) is requested. Links that answer 4xx or 5xx, point to a domain that does not exist or fail SSL are listed in `brokenLinkUrls` with their status. Links answering 401, 403 or 429 are not counted, because sites often return those to automated requests.

#### Can it audit JavaScript websites?

Yes, switch on **Render JavaScript ($)**. Pages are then loaded in a browser with all resources before the audit, which costs an extra $0.01 per page.

#### Can I use Website SEO Audit with the Apify API?

Yes — every run can be started from the API, the Python and JavaScript clients, or the `run-sync-get-dataset-items` endpoint that returns the rows in one call.

#### Can I use it through an MCP server?

Yes. Add the Apify MCP server (`https://mcp.apify.com`) to Claude, ChatGPT, Cursor or your own agent and ask it to audit a URL; the agent calls `lergassy/website-seo-audit` and reads the rows.

#### Can I integrate it with other apps?

Yes: Google Sheets, n8n, Make, Zapier, Slack and webhooks are available from the run's Integrations tab.

#### How much does an SEO audit of 1,000 pages cost?

On the Starter plan $30 at $0.03 per audited page, or $39 with JavaScript rendering. On the Free plan $40, or $50 with JavaScript rendering. Pages that do not answer 200 are free.

#### Do I get one row per page?

Yes. The default table holds only `page` rows. The optional `summary` row is off unless you switch it on, and error rows appear only for input that could not be audited.

#### Why does a page show 403 or 404 here but opens in my browser?

Some sites block automated audit tools or serve them a different page (bot protection, geo-blocking). The row then shows the status code and HTML the audit engine actually received. Such rows are free when the status is not 200. Switching on **Render JavaScript ($)** or **Device: Mobile** sometimes helps.

#### Why is a page I asked for marked as redirected?

`redirected: true` means the URL you entered sent the browser elsewhere (for example `http://` → `https://`). The row describes the final page in `url`; your original URL stays in `requestedUrl`.

### Your feedback

Found an issue the audit missed, or a check that fires wrongly on your site? Open an issue on the **Issues** tab with the URL — we read every one. If the Actor saved you time, a review on the Store page helps other SEO teams find it.

### You might also like

| Actor | What it does |
|---|---|
| [Bulk Domain Authority Checker](https://apify.com/lergassy/bulk-domain-authority-checker) | Domain rank, backlinks and referring domains for a list of domains |
| [Keyword Search Volume Checker](https://apify.com/lergassy/keyword-search-volume-checker) | Search volume, CPC, keyword difficulty and intent for bulk keywords |
| [Website Tech Gap Scanner](https://apify.com/lergassy/website-tech-gap-scanner) | Find websites missing analytics, chat, SEO or marketing tools |
| [Wappalyzer Scraper](https://apify.com/lergassy/wappalyzer-scraper) | Detect the technology stack (CMS, frameworks, analytics) of any website |
| [Website Contacts API](https://apify.com/lergassy/website-contacts-api) | Emails, phones and social profiles from any website |

# Changelog

This Actor's version history is a separate document: https://apify.com/lergassy/website-seo-audit/changelog.md

# Actor input Schema

## `urls` (type: `array`):

Enter one page URL per line (up to 1,000 per run). Each page gets its own row with the full on-page audit. Bulk lists are audited in parallel batches. Ignored when <b>Domain to crawl</b> is filled in.

## `domain` (type: `string`):

Optional: enter a domain (example.com) or a start URL (https://example.com/blog) to crawl the site and audit every page found, up to <b>Max pages</b>. A crawl takes from about 30 seconds for a few pages to several minutes for hundreds. When filled in, the URL list above is ignored.

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

Set the most pages to audit in one run (1-1,000): the first N URLs of the list, or the first N pages the crawler finds on the domain.

## `checkBrokenLinks` (type: `boolean`):

Switch off to skip the broken-link check. When on (default), every link on each page is requested and links that answer 4xx/5xx, point to an unknown domain or fail SSL are listed as broken. Free — it only adds a few seconds per page.

## `renderJavaScript` (type: `boolean`):

Switch on for sites built with React, Vue, Angular or other JavaScript frameworks whose content is not in the raw HTML. Pages are loaded in a browser with all resources before the audit; load time then reflects the full render. Costs an extra add-on per page (see Pricing).

## `device` (type: `string`):

Choose the user agent the pages are requested with. Pick Mobile for sites that serve a different page to phones.

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

Set how many links per page the broken-link check requests (1-500). A link that appears on many pages is checked only once per run.

## `includeSiteSummary` (type: `boolean`):

Switch on to add one free row of type summary at the end: average on-page score, pages with high-priority issues, total broken links, duplicate titles and descriptions, noindex pages, issue counts and (domain crawl) sitemap, robots.txt and SSL checks. Off by default so the table holds only page rows.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://apify.com/store"
  ],
  "maxPages": 100,
  "checkBrokenLinks": true,
  "renderJavaScript": false,
  "device": "desktop",
  "maxLinksPerPage": 100,
  "includeSiteSummary": false
}
```

# Actor output Schema

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

One row per audited page: status code, on-page score, SEO issues in plain English with priority, title, meta description, H1, canonical, noindex, broken links, images without alt, word count and load time.

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lergassy/website-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/HQ4GLP4y25eAjbHne/builds/3U21Dpnmy4ITCp112/openapi.json