# Bulk PageSpeed & SEO Audit (Lighthouse, Sitemap) (`scaleturn/pagespeed-seo-audit`) Actor

Audit every page of a sitemap or URL list: Lighthouse scores, Core Web Vitals and a technical SEO check (title, meta, H1, canonical, robots, structured data, broken links), with one score and ranked fixes per page. No API key. $25/1,000 pages audited; SEO-only $3/1,000.

- **URL**: https://apify.com/scaleturn/pagespeed-seo-audit.md
- **Developed by:** [Sanjaya Maharjan](https://apify.com/scaleturn) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 page auditeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

This page speed and SEO audit tool checks **every page of a website**, from its sitemap or from a list of URLs, and returns one row per page with:

- **Google Lighthouse scores** (performance, accessibility, best practices, SEO, 0 to 100) and the lab **Core Web Vitals** (LCP, CLS, TBT) with good / needs-improvement / poor ratings;
- a **technical SEO check** of the page with the actual values: title, meta description, H1 headings, canonical URL, robots directives and indexability, structured data (JSON-LD types and errors), language, viewport and images without alt text;
- the page's **broken links**;
- **one 0-100 score** and a **ranked list of fixes** in plain English, high severity first, with the estimated time or bytes saved where Lighthouse gives one.

Lighthouse runs in its own Chrome inside the Actor: **no API key, no PageSpeed Insights quota, no proxies**. Pages that cannot be audited (404, robots.txt refusal, timeout) come back as **free rows** that say why.

*Not affiliated with or endorsed by Google. Lighthouse is Google's open-source auditing tool; this Actor runs it unmodified. PageSpeed Insights and Core Web Vitals are named only for comparison.*

### How to audit a website's speed and SEO

1. Enter your **Sitemap URL** (for example `https://example.com/sitemap.xml`), or list **Page URLs**, or both.
2. Set **Max pages** (default 100), the **Device** (mobile by default, as Google ranks on mobile) and the **Checks to run**.
3. Click **Start**. Rows appear in the **Output** tab as pages finish: the **Overview**, **On-page SEO** and **Fixes** views, plus the full JSON. Export as JSON, CSV or Excel, or read them with the API.
4. Open the **Run summary** for the averages across the site, the most common issues and the slowest pages.

For a quick, cheap pass over a large site, choose only **On-page SEO** and **Broken links**: no Lighthouse, priced as a page check instead of a full audit.

### What it does

- **Whole sites from a sitemap.** Reads sitemaps and sitemap indexes (also `.xml.gz`), removes duplicates and audits up to 5,000 pages per run.
- **Lighthouse 13 in Chrome.** Performance, accessibility, best practices and SEO scores; LCP, CLS, TBT, FCP, Speed Index, server response time and page weight; the performance insights that failed, with their estimated savings.
- **Technical SEO with the values, not just pass/fail.** The title and meta description text and length, every H1, heading-level skips, the canonical URL and whether it points to the page itself or elsewhere (and whether the HTML tag and HTTP `Link` header disagree), `noindex` in the robots meta tag or `X-Robots-Tag` header, `lang`, viewport, hreflang count, Open Graph tags, images without `alt`, word count.
- **Structured data.** Every JSON-LD block is parsed: invalid JSON is reported, all schema.org types are listed (including `@graph`), and the properties Google requires are checked for Product, BreadcrumbList, FAQPage, Event, Recipe and JobPosting. Microdata and RDFa types are listed too.
- **Broken links.** The first 100 unique links of each page (you can change this) are checked once per run, internal and external. 404, 410, other client errors, server errors, DNS and TLS failures count as broken. Sites that refuse automated requests (401, 403, 429) are reported as **unverified**, never as broken.
- **One score, one fix list.** Each fix says what is wrong and what to do, ranked high, medium, low, then by estimated saving.
- **Charged only for real audits.** 404s, errors, robots.txt refusals, timeouts, non-HTML responses and pages Lighthouse could not score are free.

### Use cases

- **SEO and web agencies.** Audit each client's whole site every month from its sitemap; hand the developer the ranked fix list; track the scores over time with a schedule.
- **In-house SEO and marketing teams.** Find noindexed pages, missing or duplicate titles and descriptions, wrong canonicals, broken links and invalid structured data across the site in one run.
- **Developers before and after a release.** Run the same URL list before and after a change and compare performance, Core Web Vitals and SEO side by side.
- **AI agents.** "Audit this page" or "why is this page slow?" as one tool call through the Apify MCP server (see below).

### Input example

```json
{
    "sitemapUrl": "https://example.com/sitemap.xml",
    "urls": ["https://example.com/pricing"],
    "maxPages": 50,
    "device": "mobile",
    "checks": ["performance", "accessibility", "best-practices", "seo", "links"]
}
```

| Field | Default | What it does |
|---|---|---|
| `urls` | | Pages to audit. `https://` is added when missing. Duplicates are audited once. |
| `sitemapUrl` | | A sitemap or sitemap index (also `.xml.gz`). Its pages are audited after `urls`. |
| `maxPages` | 100 | Most pages per run (1 to 5,000), after removing duplicates. |
| `device` | `mobile` | `mobile` (a mid-range phone on slow 4G, Lighthouse's default) or `desktop`. |
| `checks` | all five | `performance`, `accessibility` and `best-practices` run Lighthouse; `seo` is the on-page check (plus Lighthouse's SEO score when Lighthouse runs); `links` is the broken-link check. |
| `maxLinksPerPage` | 100 | Links checked per page; 0 turns the link check off. |
| `checkExternalLinks` | `true` | Off: only links to the same site are checked. |
| `pageTimeoutSecs` | 45 | How long Lighthouse waits for the page to load (15 to 120). |
| `maxFixes` | 10 | Fixes listed per page (1 to 30). |

### Output

One dataset row per page. A real row for python.org from a test run on 18 November 2026 (fixes, links and details shortened):

```json
{
    "url": "https://www.python.org/",
    "finalUrl": "https://www.python.org/",
    "httpStatus": 200,
    "status": "audited",
    "device": "mobile",
    "score": 88,
    "performanceScore": 87,
    "accessibilityScore": 75,
    "bestPracticesScore": 100,
    "lighthouseSeoScore": 92,
    "onPageSeoScore": 84,
    "lcpMs": 3807,
    "cls": 0,
    "tbtMs": 80,
    "lcpRating": "needs-improvement",
    "clsRating": "good",
    "tbtRating": "good",
    "title": "Welcome to Python.org",
    "titleLength": 21,
    "metaDescription": "The official home of the Python Programming Language",
    "metaDescriptionLength": 52,
    "h1": ["Functions Defined", "All the Flow You’d Expect", "Compound Data Types", "Intuitive Interpretation", "Quick & Easy to Learn"],
    "canonical": null,
    "canonicalStatus": "missing",
    "indexable": true,
    "brokenLinkCount": 0,
    "fixes": [
        {
            "area": "accessibility",
            "severity": "high",
            "issue": "`[role]`s are not contained by their required parent element",
            "fix": "Some ARIA child roles must be contained by specific parent roles to properly perform their intended accessibility functions. Learn more about ARIA roles and required parent element: https://dequeuniversity.com/rules/axe/4.14/aria-required-parent.",
            "lighthouseAudit": "aria-required-parent"
        },
        {
            "area": "performance",
            "severity": "medium",
            "issue": "Render-blocking requests: Est savings of 960 ms",
            "fix": "Defer or inline the CSS and JavaScript that block the first paint.",
            "savingsMs": 950,
            "lighthouseAudit": "render-blocking-insight"
        },
        {
            "area": "seo",
            "severity": "medium",
            "issue": "The page names no canonical URL.",
            "fix": "Add <link rel=\"canonical\" href=\"https://www.python.org/\"> (the page's preferred absolute URL) to the <head>.",
            "check": "canonical-missing"
        }
    ],
    "links": { "found": 127, "internal": 64, "external": 63, "checked": 99, "broken": [], "unverified": [],
               "notChecked": { "robots": 1, "cap": 25, "login-walled-host": 2, "external-off": 0 } },
    "seo": { "headings": { "h1": 5, "h2": 9, "h3": 0, "h4": 0, "h5": 0, "h6": 0 },
             "structuredData": { "jsonLdBlocks": 1, "types": ["WebSite", "SearchAction"], "issues": [] }, "...": "..." },
    "lighthouse": { "version": "13.6.0", "benchmarkIndex": 2583, "...": "..." }
}
```

| Field | Notes |
|---|---|
| `url`, `finalUrl`, `httpStatus`, `redirectCount` | The page as given and where it ended after redirects. |
| `status` | `audited` (Lighthouse and checks), `checked` (checks only) or a free row: `not-found`, `http-error`, `blocked-by-robots`, `unreachable`, `timeout`, `not-html`, `lighthouse-failed`. `note` says why. |
| `score` | The mean of the category scores present (performance, accessibility, best practices, Lighthouse SEO, on-page SEO). |
| `performanceScore`, `accessibilityScore`, `bestPracticesScore`, `lighthouseSeoScore` | Lighthouse category scores, 0-100. |
| `onPageSeoScore` | 100 minus the penalties in the table below, never below 0. |
| `lcpMs`, `cls`, `tbtMs`, `fcpMs`, `speedIndexMs`, `serverResponseMs`, `totalBytes` | Lighthouse lab metrics. |
| `lcpRating`, `clsRating`, `tbtRating` | `good` / `needs-improvement` / `poor` (LCP 2.5 s / 4 s; CLS 0.1 / 0.25; TBT 200 ms / 600 ms). |
| `title`, `titleLength`, `metaDescription`, `metaDescriptionLength`, `h1` | As found in the page's HTML. |
| `canonical`, `canonicalStatus` | The canonical URL (resolved) and `self`, `other`, `missing`, `multiple` or `invalid`. |
| `indexable` | `false` when a `noindex` directive applies to Google. |
| `brokenLinkCount` | Broken links on the page; the list is in `links.broken`. |
| `fixes` | `severity`, `area` (`seo`, `links`, `performance`, `accessibility`, `best-practices`), `issue`, `fix`, and `savingsMs` / `savingsBytes` where Lighthouse estimates them. |
| `seo` | Headings per level, heading-order skips, robots meta, `X-Robots-Tag`, lang, viewport, hreflang count, Open Graph, images without alt, word count, structured data (`jsonLdBlocks`, `jsonLdErrors`, `types`, `microdataTypes`, `rdfaTypes`, `issues`). |
| `links` | `found`, `internal`, `external`, `checked`, `broken`, `unverified`, and `notChecked` by reason (`robots`, `cap`, `login-walled-host`, `external-off`). |
| `lighthouse` | Lighthouse version, the machine's CPU `benchmarkIndex`, Lighthouse's warnings, and the accessibility, best-practice and SEO audits that failed. |

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

| Check | Penalty |
|---|---|
| `noindex` in the robots meta tag or `X-Robots-Tag` header | 40 |
| No title (20); more than one (5); under 30 or over 60 characters (5) | as listed |
| No meta description (10); more than one (3); under 70 or over 160 characters (3) | as listed |
| No H1 (10); more than one (3); a heading level skipped (2) | as listed |
| No canonical (5); conflicting canonicals (10); invalid canonical URL (10) | as listed |
| Invalid JSON-LD block (10 each); a Google-required structured-data property missing (5 each, at most 15) | as listed |
| Broken links (5 each, at most 20) | as listed |
| No viewport meta tag (10); no `lang` on `<html>` (3); images without alt (1 each, at most 5) | as listed |

A canonical that points to another page, or a relative canonical URL, is listed as a fix but not penalised.

#### Run summary

Each run writes an `OUTPUT` record (the **Run summary** output): pages per status, events charged, mean scores, the ten issues found on the most pages, the ten slowest pages by LCP, the total of broken links, sitemap details and the run time.

### Pricing

The Actor is priced **per page**. Apify platform usage is included:

- **USD 25.00 per 1,000 pages audited** (USD 0.025 per page): Lighthouse plus the chosen SEO and link checks.
- **USD 3.00 per 1,000 pages checked** (USD 0.003 per page): on-page SEO and broken links only, no Lighthouse.
- Apify's Actor start fee of USD 0.00005 per GB of memory per run (USD 0.0004 per run at the default 8 GB).

Free rows: 404 and other HTTP errors, robots.txt refusals, unreachable pages, timeouts, non-HTML responses and pages Lighthouse could not score. There is no per-run fee of our own, so a single-page audit costs USD 0.025.

You can set a maximum total charge for a run. The Actor checks it before every Lighthouse audit and stops before starting a page it could not charge for, so no time is spent on pages you would not get.

### Use via API

Run the Actor and get its rows in one call (replace `YOUR_API_TOKEN`):

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

For a sitemap, start the run asynchronously and read the dataset when it finishes. Webhooks, schedules and integrations (Make, Zapier, n8n, Google Sheets, Slack) can send each run's results where you need them.

### Use from AI agents (MCP)

AI agents and assistants (Claude, Cursor, VS Code and other Model Context Protocol clients) can run this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

Load it as a tool by naming it in the server URL:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=actors,docs,scaleturn/pagespeed-seo-audit"
        }
    }
}
```

On first connection the client opens Apify's sign-in to approve access; or set the header `Authorization: Bearer <APIFY_TOKEN>`. Without naming it, an agent can still find the Actor with `search-actors` and run it with `call-actor`, then read the rows with `get-dataset-items`.

Prompts that work well:

- "Audit https://example.com/pricing on mobile and list the three fixes that would help most."
- "Check https://example.com/sitemap.xml for pages that are noindexed, missing a meta description or have broken links. Skip Lighthouse."
- "Why is LCP poor on https://example.com/? Show the Lighthouse insights with their savings."

Tips for agents: one page with Lighthouse takes about 25 seconds on Apify, within the 45 seconds `call-actor` can wait (`waitSecs`); for a sitemap, read the dataset when the run finishes. For a faster answer pass `"maxLinksPerPage": 20`, or `"checks": ["seo"]` for the on-page check alone (under a second per page plus the run's start). Every row has `status` and `note`, so a page that could not be audited explains itself, and `fixes` is already ranked.

### Speed

Measured on Apify on 18 November 2026 (default 8,192 MB, mobile, all checks):

- **One page:** 25 seconds for the whole run, start to finish.
- **10 pages from 8 sites:** 109 seconds (9 audited; Wikipedia refused Lighthouse's browser, a free row).
- **A heavy page:** a news home page (cnn.com, performance 33, LCP 9.2 s) took 23 seconds.

Measured on a desktop machine the same day, without Lighthouse: the on-page SEO check alone took under a second for 10 pages; with the broken-link check it took 64 seconds for the same 10 pages (7 to 50 seconds per page, depending on how many links a page has, at 2 requests at a time per site).

Pages are audited one at a time, as Lighthouse recommends, so raise the run timeout (default 1 hour) for large sitemaps; the run stops starting new pages shortly before the timeout.

### Limits

- **Lab data, not field data.** Scores and Core Web Vitals are Lighthouse lab measurements on a simulated device, like the "Diagnose performance issues" part of PageSpeed Insights. Real-user (Chrome UX Report) data is not included.
- **Scores move between runs and machines.** Lighthouse's performance score depends on the network and the CPU of the machine that runs it; the same page can move 10 points or more between runs. Third-party content such as ads and banners can differ by where and when the test runs, which changes layout shift (CLS) and timings. Best-practice scores can also differ from PageSpeed Insights on pages with third-party cookies, which this Actor's Chrome reports. Each row has Lighthouse's `benchmarkIndex` for the machine. Compare a page with itself over time rather than with another tool, and keep the default 8,192 MB of memory: Apify gives one CPU core per 4 GB, and with one core Lighthouse measured much longer blocking times (python.org scored 63 at 4,096 MB, 87 at 8,192 MB and 94 on PageSpeed Insights).
- **Some sites refuse test browsers from cloud servers.** Wikipedia served its HTML to the Actor but answered HTTP 429 to Lighthouse's browser on Apify; such a page comes back as a free `lighthouse-failed` row with the status code, and its on-page SEO and link results are still in the row.
- **On-page values come from the HTML the server sends**, as a crawler first sees it. Titles, descriptions or canonicals added later by JavaScript are not seen by these checks; Lighthouse's SEO score does read the rendered page.
- **robots.txt is respected** for the token `PagespeedSeoAudit` (or `*`) on audited pages, sitemaps and checked links. A page disallowed there is a free `blocked-by-robots` row.
- **No login, no CAPTCHA solving, no proxies.** Pages behind a sign-in or a bot check are not audited. Links to sites that require a login (LinkedIn, Indeed, Facebook, Instagram, X, TikTok, Threads) are not requested and are counted under `links.notChecked`.
- **One Lighthouse audit at a time**, as Lighthouse recommends, so large sites take time: raise the run timeout for long sitemaps. The run stops starting pages shortly before its timeout, so the pages done are delivered.
- **The link check** reads up to 500 links per page (100 by default), with at most 2 requests at a time to any one site.

### FAQ

**How is this different from PageSpeed Insights?** PageSpeed Insights tests one URL at a time in a browser tab. This runs the same Lighthouse audits for a whole sitemap or URL list in one run, adds an on-page SEO check with the actual values and a broken-link check, and returns everything as data you can export, schedule or compare.

**Why is my score different from PageSpeed Insights?** Lighthouse's performance score depends on the machine and the network at the moment of the test, on Google's servers too. Differences of 10 points or more between runs are normal; look at the rating band and at the fixes.

**Does it crawl my whole site?** It audits the pages in your sitemap or URL list (up to 5,000 per run). It does not follow links to discover new pages; it checks that the links on each audited page work.

**Is it allowed to audit sites I do not own?** The Actor reads public pages the way a browser does and respects robots.txt. Use it on sites you own or manage, or have permission to test; you are responsible for how you use it. This is not legal advice.

**Can I get the results into my own system?** Yes: through the API call above, a webhook when a run finishes, an integration, or the MCP server.

### How it is tested

- **27 automated tests** run on recorded real responses (a live page, its 404, robots.txt files, two sitemaps and the status of every link on the page) and recorded Lighthouse 13.6 results, with the Apify SDK's pay-per-event simulation: a good page, a page with SEO faults, a 404, a page slower than the time limit, a slow real page (LCP 16.4 s), a sitemap index with a gzip sitemap, a robots.txt refusal, a Lighthouse failure, the spending limit, the run timeout, a restarted run, and a check that no request is in flight while Lighthouse measures a page.
- **Checked by hand on 10 real pages** (18 November 2026): titles, meta descriptions, H1s, canonicals, robots tags, `lang` and structured-data types matched an independent parser on all 10 pages; every link reported broken was re-requested by hand; against PageSpeed Insights, Lighthouse SEO scores were identical on all 10 pages, accessibility within 4 points, and performance within 20 points on 8 of 10. On the other two, PageSpeed Insights measured a layout shift that never appeared in our runs (see "Limits").

### Politeness

The Actor sends at most 2 requests at a time to any one site and 8 in all, uses timeouts, reads each robots.txt once per run, and identifies itself as `Mozilla/5.0 (compatible; PagespeedSeoAudit/1.0; +https://apify.com/scaleturn/pagespeed-seo-audit)`. Lighthouse's Chrome sends Chrome's own user agent, as any browser visit does.

# Actor input Schema

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

Pages to audit, one per line. https:// is added when missing. Duplicates are audited once. You can give URLs, a sitemap, or both.

## `sitemapUrl` (type: `string`):

A sitemap or sitemap index, for example https://example.com/sitemap.xml (gzip-compressed .xml.gz works too). Its pages are audited after the URLs above, up to 'Max pages'.

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

Most pages audited in one run, after removing duplicates. Pages over the limit are not audited or charged.

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

Lighthouse's mobile setting (a mid-range phone on a slow 4G network, which Google ranks on) or its desktop setting.

## `checks` (type: `array`):

Performance, accessibility and best practices run Lighthouse in Chrome (charged as 'Page audited'). Without them a page gets only the on-page SEO and link checks (charged as 'Page checked', much cheaper and faster). 'seo' also adds Lighthouse's SEO score when Lighthouse runs.

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

The first N unique links of each page are checked for broken targets. 0 turns the link check off.

## `checkExternalLinks` (type: `boolean`):

Off: only links to the audited page's own site are checked.

## `pageTimeoutSecs` (type: `integer`):

How long Lighthouse waits for the page to load, and the time limit for downloading the page's HTML.

## `maxFixes` (type: `integer`):

The most important fixes listed for each page, high severity first.

## Actor input object example

```json
{
  "urls": [
    "https://scaleturn.com/"
  ],
  "maxPages": 100,
  "device": "mobile",
  "checks": [
    "performance",
    "accessibility",
    "best-practices",
    "seo",
    "links"
  ],
  "maxLinksPerPage": 100,
  "checkExternalLinks": true,
  "pageTimeoutSecs": 45,
  "maxFixes": 10
}
```

# Actor output Schema

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

One row per page: scores, Core Web Vitals, on-page SEO values, broken links and ranked fixes. Pages that could not be audited are free rows with a status that says why.

## `summary` (type: `string`):

Pages per status, events charged, mean scores, the most common issues across pages, the slowest pages and the run 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://scaleturn.com/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scaleturn/pagespeed-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://scaleturn.com/"] }

# Run the Actor and wait for it to finish
run = client.actor("scaleturn/pagespeed-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://scaleturn.com/"
  ]
}' |
apify call scaleturn/pagespeed-seo-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scaleturn/pagespeed-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/zMirZaLOV16Ea2d8x/builds/EIjE7I7RFw2d8AfhY/openapi.json
