# SEO Audit & Sitemap Checker - 404s, Redirects, Meta Tags (`syntrovia/sitemap-seo-check-http`) Actor

Audit a website you own or may audit: reads robots.txt and sitemaps, then checks each page for status code, redirects, title, meta description, H1, canonical and 35+ SEO issues, or lists every sitemap URL. Plain HTTP, no browser, honours robots.txt and Crawl-delay. From $1.50 per 1,000 pages.

- **URL**: https://apify.com/syntrovia/sitemap-seo-check-http.md
- **Developed by:** [Syntrovia Data](https://apify.com/syntrovia) (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 $1.50 / 1,000 pages

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/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 & Sitemap Checker - 404s, Redirects, Meta Tags

**Run a technical SEO audit of a website you own or are authorised to audit, and get one row per page with its issue codes.** The Actor reads robots.txt and the sitemaps, then checks each page for status code, redirect, title, meta description, H1, canonical, indexability, word count, links and images, and tags it with codes such as `not-found`, `redirect-chain` or `missing-meta-description`. Or list every URL of the sitemaps without requesting a single page. Plain HTTP (no headless browser), so runs are fast and cheap. It follows robots.txt and Crawl-delay, sends at most 2 requests at a time, never fills in forms, and stops as soon as the site refuses access.

**Try it now:** click **Try for free**, replace the example site with a site you own or may audit, and click **Start**. A 20-page audit costs $0.035 and a 1,000-page audit $1.505. Listing 5,000 sitemap URLs costs $1.505.

### Who uses it

- **SEO freelancers and agencies:** a fix-list for a client site you are authorised to audit, filtered by issue code and exported to a spreadsheet.
- **Developers before a launch or migration:** 404s, redirect chains, canonical problems and leftover `noindex` tags across the whole sitemap.
- **Content teams:** missing, duplicate, too short or too long titles and meta descriptions, page by page.
- **Weekly site health checks:** save the input as a Task, add a Schedule, and compare the `RUN_SUMMARY` issue totals from week to week.

### Sample audit rows

| URL | Status | Indexability | Title length | Issues |
|---|---|---|---|---|
| `https://www.example.com/pricing` | 200 | indexable | 17 | `title-too-short`, `missing-meta-description`, `images-missing-alt` |
| `https://www.example.com/old-pricing` | 301 | redirect | - | `redirect` |

Rows from the output example below. The run summary (`RUN_SUMMARY`) adds how many pages have each issue code.

### What can this Actor do?

- **SEO audit (default):** starts at your URL, reads `robots.txt`, reads the sitemaps (the `Sitemap:` lines of robots.txt, or `/sitemap.xml` and `/sitemap_index.xml`, or the ones you give), then checks the start page, the sitemap URLs and the links it finds on the checked pages, up to **Max pages**.
- **Sitemap URLs only:** reads robots.txt and the sitemaps and lists each URL with its `lastmod`, `changefreq` and `priority`, flags URLs that robots.txt disallows, URLs on another host, plain-http URLs on an https site and invalid fields. No page is requested, so it is very cheap.
- Understands **sitemap indexes** (up to 3 levels), **gzip** sitemaps (`.xml.gz`), **plain-text** sitemaps (one URL per line), and sitemaps up to the protocol limits (50,000 URLs, 50 MB each; up to 50 sitemap files per run).
- Reports **35+ issue codes** per page (missing or duplicate titles and meta descriptions, missing H1, canonical problems, noindex, redirects and redirect chains, 4xx and 5xx, thin content, pages that need JavaScript, images without alt text, slow answers, pages missing from the sitemap, and more; full list below).
- Writes a **run summary** (`RUN_SUMMARY`) with the robots.txt rules it applied, every sitemap file it read, how many rows have each issue, status code classes, skipped URLs by reason, where the site refused access if it did, and why the run stopped.
- **No browser, no proxies, no tricks:** one honest User-Agent, plain HTTP GET requests, nothing else.

### What data can you extract?

#### SEO audit: one row per requested URL

| Field | Example | Description |
|---|---|---|
| `url` | `https://www.example.com/pricing` | The URL that was requested |
| `statusCode` | `200` | HTTP status (one request per row; a redirect is not followed inside a row) |
| `redirectUrl` | `https://www.example.com/pricing/` | Where a 3xx answer points. A same-site target is checked as its own row |
| `foundIn`, `depth`, `inSitemap` | `link`, `1`, `false` | How the URL was found (start, sitemap, link, redirect), clicks from the start URL, and whether a sitemap lists it |
| `indexable`, `indexability` | `true`, `indexable` | `indexable`, `noindex`, `canonicalized`, `redirect`, `client-error`, `server-error` or `not-html` |
| `title`, `titleLength` | `Pricing - Example`, `17` | First `<title>` and its length |
| `metaDescription`, `metaDescriptionLength` | `Plans for teams of any size.`, `28` | Meta description and its length |
| `h1`, `h1Count`, `h2Count` | `Pricing`, `1`, `4` | First H1 and heading counts |
| `canonicalUrl`, `canonicalStatus` | `https://www.example.com/pricing`, `self` | `rel="canonical"` and `self`, `other`, `missing`, `multiple` or `invalid` |
| `metaRobots`, `xRobotsTag` | `noindex, follow`, `null` | Robots meta tag and X-Robots-Tag header |
| `lang`, `hreflangCount`, `hasViewport`, `hasOpenGraph` | `en`, `2`, `true`, `true` | Language, hreflang alternates, viewport tag, Open Graph tags |
| `structuredDataTypes` | `["Organization", "WebSite"]` | schema.org types found in JSON-LD |
| `wordCount` | `642` | Words of visible text |
| `internalLinks`, `externalLinks`, `nofollowLinks` | `58`, `12`, `0` | Link counts |
| `images`, `imagesWithoutAlt` | `14`, `3` | Image counts |
| `contentType`, `htmlBytes`, `responseTimeMs` | `text/html; charset=utf-8`, `77435`, `420` | Answer facts |
| `issues` | `["title-too-short", "missing-meta-description"]` | Issue codes (table below) |
| `checkedAt` | `2026-11-15T08:00:00.000Z` | When the page was checked |

The title, meta description and H1 are the site's own short texts. E-mail addresses and phone numbers in them are masked with pattern rules (replaced with `[contact removed]`), and you can switch the texts off (**Include title, meta description and H1 text**) to get only their lengths and counts. The Actor does not return the page body, link texts, `mailto:` or `tel:` links.

#### Sitemap mode: one row per listed URL

| Field | Example | Description |
|---|---|---|
| `url` | `https://www.example.com/blog/post-1` | URL listed in the sitemap |
| `sitemapUrl` | `https://www.example.com/sitemap-posts.xml` | Sitemap file that lists it |
| `lastmod`, `changefreq`, `priority` | `2026-11-02`, `weekly`, `0.6` | As published (`null` when missing or invalid) |
| `allowedByRobots` | `true` | Whether robots.txt lets crawlers fetch the URL (`null` for another host) |
| `issues` | `["blocked-by-robots"]` | `blocked-by-robots`, `other-host`, `insecure-http`, `invalid-lastmod`, `invalid-changefreq`, `invalid-priority` |
| `listedAt` | `2026-11-15T08:00:00.000Z` | When the run started |

Duplicate URLs across sitemap files are listed once.

#### Issue codes (audit)

| Code | Rule |
|---|---|
| `http-4xx`, `not-found` | 4xx answer; `not-found` for 404 and 410 |
| `http-5xx` | 5xx answer after 2 retries |
| `redirect`, `redirect-chain`, `redirect-loop`, `redirect-off-site` | 3xx answer; a redirect reached through another redirect; a redirect back to an earlier URL; a redirect to another host |
| `non-html` | 2xx answer that is not HTML (no on-page checks) |
| `missing-title`, `multiple-titles`, `title-too-short`, `title-too-long`, `duplicate-title` | No title; more than one; under 30 or over 60 characters; same title as an earlier indexable page of the run |
| `missing-meta-description`, `multiple-meta-descriptions`, `meta-description-too-short`, `meta-description-too-long`, `duplicate-meta-description` | Same rules with 70 and 160 characters |
| `missing-h1`, `multiple-h1` | No H1; more than one H1 |
| `missing-canonical`, `multiple-canonicals`, `invalid-canonical`, `canonical-points-elsewhere` | Canonical tag problems |
| `noindex`, `nofollow` | Robots meta tag or X-Robots-Tag with `noindex`/`nofollow` (or `none`) |
| `meta-refresh` | `<meta http-equiv="refresh">` |
| `thin-content` | Fewer than 200 words of visible text |
| `javascript-rendered` | Fewer than 50 words and scripts present: the content probably needs JavaScript, which this Actor does not run |
| `images-missing-alt` | At least one `<img>` without an `alt` attribute |
| `missing-lang`, `missing-viewport` | No `lang` on `<html>`; no viewport meta tag |
| `invalid-structured-data` | A JSON-LD block that is not valid JSON |
| `slow-response` | Complete answer took more than 3 seconds |
| `large-html`, `html-truncated` | HTML over 1 MB; over 5 MB (only the first 5 MB is checked) |
| `insecure-http` | Page served over plain http |
| `not-in-sitemap` | Indexable page found through links but missing from the sitemaps (only when every sitemap was read completely) |
| `has-login-form` | The page contains a password field that is not its main content (for example a login popup in the header or a sidebar login box) |
| `has-captcha` | The page contains a CAPTCHA widget that is not a bot check of the page itself (for example on a contact or newsletter form) |

### How to use it

1. Click **Try for free**. The form opens with Apify's public documentation site (docs.apify.com) as an example. Replace it with the **Website URL** you want to audit, and keep **I own this website or am authorised to audit it** ticked only if that is true for the site you enter. The prefilled run checks 20 pages.
2. Choose **SEO audit of the pages** or **List sitemap URLs only**, and set **Max pages**. Click **Start**.
3. Open the **SEO audit** view of the results (or **Status and redirects**, or **Sitemap URLs**), download them as JSON, CSV, Excel or HTML, or read them through the Apify API. The `RUN_SUMMARY` record in the run's key-value store has the totals per issue.

**Weekly site health check:** save your input as a Task and add a Schedule (for example every Monday at 07:00 in your time zone). Send the results onward with Apify integrations, for example Slack, e-mail, Google Sheets, Zapier or Make.

### How much does it cost?

This Actor uses pay-per-event pricing with exactly three events; nothing else is charged. Platform usage is included.

| Event | Price |
|---|---|
| Run start, charged once per run together with the first saved result | $0.005 |
| Page requested, checked and saved (audit mode) | $0.0015 ($1.50 per 1,000 pages) |
| Sitemap URL listed and saved (sitemap mode) | $0.0003 ($0.30 per 1,000 URLs) |

Examples:

- The prefilled audit of 20 pages: $0.005 + 20 × $0.0015 = **$0.035**.
- An audit of 1,000 pages: $0.005 + $1.50 = **$1.505**.
- Listing 5,000 sitemap URLs: $0.005 + $1.50 = **$1.505**.

Every requested URL that gets an HTTP answer is one page, including redirects, 404s and server errors (they are findings). You are **not charged** for URLs that robots.txt disallows or that the Actor skips, for requests that got no answer, for login or CAPTCHA pages, or when the input is invalid. **A run that saves no result costs nothing**, not even the run start. You can set a maximum cost per run; the Actor checks it before it requests each page and before every charge, and stops when the next result would go over it.

### Input example

```json
{
    "startUrl": "https://www.example.com/",
    "authorizedToAudit": true,
    "mode": "audit",
    "maxPages": 500,
    "discoverFrom": "sitemaps-and-links",
    "includePageText": true,
    "maxRequestsPerMinute": 60
}
```

Sitemap mode:

```json
{
    "startUrl": "https://www.example.com/",
    "authorizedToAudit": true,
    "mode": "sitemap",
    "maxSitemapUrls": 20000
}
```

### Output example

```json
[
    {
        "url": "https://www.example.com/pricing",
        "statusCode": 200,
        "redirectUrl": null,
        "foundIn": "sitemap",
        "inSitemap": true,
        "depth": null,
        "contentType": "text/html; charset=utf-8",
        "responseTimeMs": 412,
        "htmlBytes": 58246,
        "title": "Pricing - Example",
        "titleLength": 17,
        "metaDescription": null,
        "metaDescriptionLength": null,
        "h1": "Pricing",
        "h1Count": 1,
        "h2Count": 4,
        "canonicalUrl": "https://www.example.com/pricing",
        "canonicalStatus": "self",
        "metaRobots": null,
        "xRobotsTag": null,
        "indexable": true,
        "indexability": "indexable",
        "lang": "en",
        "hreflangCount": 0,
        "hasViewport": true,
        "hasOpenGraph": true,
        "structuredDataTypes": ["Organization"],
        "wordCount": 481,
        "internalLinks": 39,
        "externalLinks": 6,
        "nofollowLinks": 0,
        "images": 9,
        "imagesWithoutAlt": 2,
        "issues": ["title-too-short", "missing-meta-description", "images-missing-alt"],
        "checkedAt": "2026-11-15T08:00:12.000Z"
    },
    {
        "url": "https://www.example.com/old-pricing",
        "statusCode": 301,
        "redirectUrl": "https://www.example.com/pricing",
        "foundIn": "link",
        "inSitemap": false,
        "depth": 1,
        "indexable": false,
        "indexability": "redirect",
        "issues": ["redirect"],
        "checkedAt": "2026-11-15T08:00:13.000Z"
    }
]
```

(The redirect row has the same fields; the on-page fields are `null`.)

### Limits and responsible use

```text
Use this Actor only on websites you own or are authorised to audit, and only where
the site's terms allow automated access. The Actor follows robots.txt and
crawl-delay, sends at most 2 concurrent requests per host, skips individual login
pages and stops when the site sits behind a login wall, a CAPTCHA or bot challenge,
or answers HTTP 401/403/429, and never bypasses access controls.
It does not collect e-mail addresses or phone numbers. You are responsible for the
websites you choose to audit.
```

- **robots.txt (RFC 9309):** read again at the start of every run, for each origin the run touches. The Actor obeys the group for its own name (`SitemapSeoCheckHttp`) when there is one, otherwise the `*` group. A disallowed URL is never requested, even when you enter it yourself. If robots.txt answers with a server error or cannot be reached, nothing is crawled; if it does not exist (404), every path may be crawled. If robots.txt itself answers 401, 403, 407 or 429, the Actor treats the site as refusing bots and stops without crawling.
- **Speed:** at most 2 requests at the same time and at most 60 requests per minute by default (you can choose 10-120), per website: `www.example.com` and `example.com` share these limits. With a robots.txt `Crawl-delay`, one request at a time and at least that many seconds between requests. The audit supports a Crawl-delay of up to 10 seconds and sitemap mode up to 60 seconds; above that, the run stops before requesting anything and costs nothing.
- **Stops, never works around:** HTTP 401, 403, 407 or 429, or a CAPTCHA or bot-check page shown instead of the content (a challenge page, a near-empty page with a CAPTCHA, "Just a moment...", "Attention Required", "Access denied"), stops the run at once. Results saved before are kept. The Actor never submits forms, never sends or stores cookies, and uses no proxies and no browser.
- **Login pages are skipped, login walls stop the run:** a page whose main content is a password form is never filled in; it is skipped (not saved, not charged, its links not followed, counted as `login-page` in `RUN_SUMMARY.skipped`) and the crawl goes on. When 5 checked pages in a row, or more than half of the first 20 checked pages, are login pages, the site sits behind a login wall and the run stops (`stopReason: login-wall`, see `blockedAt`); pages saved before are kept. Skipped login pages count toward **Max pages**, so a login-only site never makes more requests than that. A login popup, a sidebar login box or a CAPTCHA on a contact or newsletter form that is only part of a page does not stop anything: the page is checked and gets the `has-login-form` or `has-captcha` issue. Network errors and server errors are retried twice (after 2 and 5 seconds); after 5 network failures or 10 server errors in a row the run stops so the site is left alone.
- **Scope:** only the host you enter, with and without `www.`, over http or https, on the default ports. Login, sign-up, account, cart and checkout pages (such as `/login`, `/signup`, `/register`, `/join`, `/users/sign_in`, `/my-account/`, `/cart`, `/checkout`, `/wp-admin`) and files (images, PDFs, archives, scripts) are not requested. Links with a query string are not followed unless you turn on **Follow links with a query string**. Links marked `nofollow` and links on pages marked `nofollow` are not followed.
- **Safety:** only public websites. Local names, private, link-local and reserved IP addresses (including cloud metadata addresses) are refused, also when a redirect or a DNS answer points to them.
- **JavaScript:** pages are read as HTML, without running JavaScript. Pages that build their content in the browser are flagged `javascript-rendered`.
- **Run timeout:** the Actor stops cleanly about 2 minutes before the run timeout and keeps what it saved (`stopReason: time-limit`). With the default 1-hour timeout and 60 requests per minute, an audit checks about 3,400 pages; raise the run timeout for more.
- **Size:** up to 5,000 pages per audit run and 100,000 URLs per sitemap run; 5 MB of HTML per page; 50 sitemap files per run; URLs up to 2,048 characters (the sitemap protocol limit). Memory is fixed at 256 MB.
- **Interrupted runs:** if Apify moves the run to another server or you abort it, the Actor finishes the batch it is saving, records it, and stops. A moved run is designed to continue where it left off without saving or charging any page twice.
- Using this Actor to overload a website or to get around its access controls also breaks the Apify Acceptable Use Policy.

#### For website owners

The Actor identifies itself as `SitemapSeoCheckHttp/0.1 (+https://apify.com/syntrovia/sitemap-seo-check-http)`. To keep it away from your site, add to your robots.txt:

```text
User-agent: SitemapSeoCheckHttp
Disallow: /
```

You can also slow it down with `Crawl-delay`. To report misuse, open an issue on this Actor's Issues tab.

### Data and privacy

- **What this Actor returns:** technical facts about the pages of the website you name (status codes, tags, counts, lengths, issue codes) and, if you keep it on, three short texts per page (title, meta description, first H1) with e-mail addresses and phone numbers masked. Fields are limited to an allow-list.
- **Page texts belong to the website owner:** titles, meta descriptions and H1 texts are the website owner's content and are returned only so you can audit that website. Do not republish them or use them for other purposes without the owner's permission.
- **What it does not return:** page body text, link texts, `mailto:` or `tel:` links, cookies or `Set-Cookie` headers. E-mail addresses and phone numbers in the returned texts are masked with pattern rules, and URLs that contain an e-mail address or phone number are not requested and not listed.
- **Your website, your responsibility:** you confirm that you may audit the website. If page titles of your website contain names of people (for example staff profile pages), they appear in the `title` field; switch **Include title, meta description and H1 text** off if you do not want that.
- **Removal requests:** open an issue on this Actor's Issues tab. We aim to review requests within 72 hours.
- Data is provided as is, without warranty. It is not legal or professional SEO advice.

### FAQ

**Why did my run stop early?**
Open the `RUN_SUMMARY` record and read `stopReason`: `max-pages`, `max-urls`, `charge-limit` (your maximum cost per run), `blocked` (see `blockedAt`: the site answered 401/403/407/429, or showed a CAPTCHA or bot-check page instead of the content), `login-wall` (most pages ask for a login), `robots-unreachable`, `crawl-delay-too-long`, `site-unavailable`, `server-errors`, `time-limit` (close to the run timeout), or `all-urls-checked`.

**Why were some pages not checked?**
`RUN_SUMMARY.skipped` counts them by reason: `robots` (disallowed by robots.txt), `login-page` (a login form page, skipped and not charged), `account-area`, `non-page-file`, `contact-in-url`, `query-link` (links, each time one is found), `url-too-long`, `queue-full`, `crawl-delay-too-long`, `unsafe-target` or `invalid-row`.

**My site needs JavaScript to show its content. Will this work?**
Only partly: the Actor reads the HTML your server sends. Titles, meta tags, canonicals and status codes are usually in that HTML; body text built by JavaScript is not. Such pages get the `javascript-rendered` issue.

**Is it legal to audit any website?**
Use it on your own websites and on websites you are authorised to audit, where automated access is allowed. The Actor follows robots.txt and stops when a site refuses access, but it cannot read each site's terms for you.

**How is the "not-in-sitemap" issue decided?**
Only when every sitemap was read to the end; an indexable page reached through links that no sitemap lists gets the issue.

### More data tools from Syntrovia Data

- [SAM.gov Federal Contract Opportunities (Unofficial)](https://apify.com/syntrovia/federal-opportunities-sam-gov-extract): U.S. federal bids and award notices from the public SAM.gov extract file.
- [Greenhouse & Lever Jobs API (Unofficial)](https://apify.com/syntrovia/ats-jobs-greenhouse-lever): open jobs from the Greenhouse and Lever boards you list, with only-new mode.
- [UK Companies House Data (Unofficial)](https://apify.com/syntrovia/uk-company-register-companies-house): UK company lists by SIC code, postcode or incorporation date.

### Support

Open an issue on the **Issues** tab with your run ID. We aim to review issues and requests within 72 hours.

# Changelog

This Actor's version history is a separate document: https://apify.com/syntrovia/sitemap-seo-check-http/changelog.md

# Actor input Schema

## `startUrl` (type: `string`):

Home page or any page of the website, e.g. https://www.example.com/. The Actor stays on this host (with and without "www."). Only public http/https sites on the default ports.

## `authorizedToAudit` (type: `boolean`):

Required. The Actor runs only when this is checked. You are responsible for the websites you choose to audit.

## `mode` (type: `string`):

"audit": request each page and report its on-page SEO facts and issues (one result per page). "sitemap": only read robots.txt and the sitemaps and list every URL they contain (one result per URL, no page is requested).

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

The audit stops after checking this many pages; skipped login pages count too. You pay only per saved page.

## `maxSitemapUrls` (type: `integer`):

Sitemap mode stops after listing this many URLs. You pay per listed URL.

## `discoverFrom` (type: `string`):

Audit mode: which pages to check after the start URL. Sitemap URLs come first, then links found on the checked pages.

## `sitemapUrls` (type: `array`):

Optional sitemap files on the same website. By default the Actor uses the Sitemap lines of robots.txt, then tries /sitemap.xml and /sitemap_index.xml.

## `includePageText` (type: `boolean`):

On: the result shows these three texts (e-mail addresses and phone numbers masked). Off: only their lengths and counts.

## `followQueryLinks` (type: `boolean`):

Off (default): links such as /list?page=2 are not followed, which avoids endless filter and calendar pages. Sitemap URLs are always checked.

## `maxRequestsPerMinute` (type: `integer`):

Speed limit for the website (10-120). robots.txt Crawl-delay is always honoured and may make the run slower. At most 2 requests run at the same time.

## Actor input object example

```json
{
  "startUrl": "https://docs.apify.com/",
  "authorizedToAudit": true,
  "mode": "audit",
  "maxPages": 20,
  "maxSitemapUrls": 5000,
  "discoverFrom": "sitemaps-and-links",
  "sitemapUrls": [],
  "includePageText": true,
  "followQueryLinks": false,
  "maxRequestsPerMinute": 60
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

# 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 = {
    "startUrl": "https://docs.apify.com/",
    "authorizedToAudit": true,
    "maxPages": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("syntrovia/sitemap-seo-check-http").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 = {
    "startUrl": "https://docs.apify.com/",
    "authorizedToAudit": True,
    "maxPages": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("syntrovia/sitemap-seo-check-http").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 '{
  "startUrl": "https://docs.apify.com/",
  "authorizedToAudit": true,
  "maxPages": 20
}' |
apify call syntrovia/sitemap-seo-check-http --silent --output-dataset

```

## MCP server setup

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

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/Jek6XXyOY3Fc33COr/builds/QeFqOKS23wRkKITrY/openapi.json