# PageSpeed Insights Checker (`axiomworks/pagespeed-insights-checker`) Actor

PageSpeed Insights Checker audits URLs or pages found in a sitemap and returns Lighthouse scores, lab Core Web Vitals, failing audits, and CrUX field data when available. Run mobile or desktop reports, with no API key required by default; you can also use your own PageSpeed Insights API key.

- **URL**: https://apify.com/axiomworks/pagespeed-insights-checker.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** SEO tools, Developer tools, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.95 / 1,000 results

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

**Returns:** one row per audited page and device with `performanceScore`, `accessibilityScore`, `seoScore`, `largestContentfulPaintMs`, `cumulativeLayoutShift`, `fieldLcpP75Ms`, `failingAudits` and `sourceUrl`.
**Input:** `{"urls": ["https://www.wikipedia.org/", "example.org"], "strategies": ["mobile"], "maxItems": 50}`
**Best for:** bulk Core Web Vitals audits for SEO agencies, monitoring a site's PageSpeed scores over time, and finding the slowest pages in a sitemap.

```json
{
    "url": "https://www.wikipedia.org/",
    "strategy": "mobile",
    "performanceScore": 100,
    "seoScore": 100,
    "largestContentfulPaintMs": 1389,
    "cumulativeLayoutShift": 0.0009547550044766787,
    "fieldLcpP75Ms": 1279,
    "fieldInpP75Ms": 99
}
```

### What does PageSpeed Insights Checker do?

PageSpeed Insights Checker runs Google PageSpeed Insights (Lighthouse) on a list of URLs, or on every page of a sitemap, and returns one clean row per page and device. Each row has the four Lighthouse category scores (performance, accessibility, best practices, SEO), the lab Core Web Vitals (LCP, CLS, TBT, FCP, Speed Index), real-user Chrome UX Report (CrUX) p75 values when Google has them, and a ranked list of the audits that fail.

You don't need a Google account, a login or an API key. By default the Actor asks the same backend the pagespeed.web.dev website uses, so you get the same reports you would see there, without pasting URLs into the website one at a time. If you already have your own free PageSpeed Insights API key, you can add it and the Actor uses the official PageSpeed Insights API instead.

It is built for jobs where one report at a time is too slow: an agency checking fifty client home pages every Monday, a web team auditing every blog post in a sitemap after a redesign, or an AI agent that needs Core Web Vitals for a handful of URLs as structured JSON.

### What data can you get from PageSpeed Insights?

| Field | Description | Example |
|---|---|---|
| `url` | The page URL that was audited (Lighthouse requestedUrl) | `https://www.wikipedia.org/` |
| `finalUrl` | The URL Lighthouse ended on after redirects | `https://www.wikipedia.org/` |
| `strategy` | Device profile of the report: `mobile` or `desktop` | `mobile` |
| `fetchTime` | When Google ran the audit, ISO 8601 UTC | `2026-10-19T00:20:48.892Z` |
| `lighthouseVersion` | Lighthouse version used | `13.5.0` |
| `performanceScore` | Performance score, 0-100 | `100` |
| `accessibilityScore` | Accessibility score, 0-100 | `94` |
| `bestPracticesScore` | Best-practices score, 0-100 | `100` |
| `seoScore` | SEO score, 0-100 | `100` |
| `firstContentfulPaintMs` | Lab First Contentful Paint, ms | `1113` |
| `largestContentfulPaintMs` | Lab Largest Contentful Paint, ms | `1389` |
| `totalBlockingTimeMs` | Lab Total Blocking Time, ms | `0` |
| `cumulativeLayoutShift` | Lab Cumulative Layout Shift | `0.00095` |
| `speedIndexMs` | Lab Speed Index, ms | `2178.06` |
| `serverResponseTimeMs` | Main document server response time, ms | `110` |
| `totalByteWeight` | Total bytes downloaded by the page | `101094` |
| `largestContentfulPaintDisplay` | LCP as Lighthouse shows it | `1.4 s` |
| `fieldDataScope` | Source of the real-user data: `url`, `origin` or null | `url` |
| `fieldLcpP75Ms` | Real-user LCP, 75th percentile, ms | `1279` |
| `fieldInpP75Ms` | Real-user Interaction to Next Paint, p75, ms | `99` |
| `fieldClsP75` | Real-user CLS, p75 | `0` |
| `fieldFcpP75Ms` | Real-user First Contentful Paint, p75, ms | `1156` |
| `fieldTtfbP75Ms` | Real-user Time to First Byte, p75, ms | `535` |
| `failingAudits` | Audits scoring below 0.9, biggest savings first | see Output |
| `runWarnings` | Warnings Lighthouse raised during the run | `[]` |
| `id` | Stable id: strategy plus requested URL | `mobile:https://www.wikipedia.org/` |
| `sourceUrl` | Link to the report on pagespeed.web.dev | `https://pagespeed.web.dev/analysis/https-www-wikipedia-org/w9n8erjr94?form_factor=mobile` |

Each entry in `failingAudits` has `id`, `title`, `category`, `score`, `displayValue`, `savingsMs` and `savingsBytes`, so you can sort pages by what to fix first.

### How to use PageSpeed Insights Checker

1. Open the Actor in the Apify Console and go to the Input tab.
2. Paste your pages into **Page URLs**, one per line. Full URLs and bare domains such as `example.org` both work. Or put a `sitemap.xml` URL into **Sitemap URLs** to audit the pages it lists.
3. Choose **Strategies**: `mobile`, `desktop` or both. Each page gives one result per strategy.
4. Set **Maximum results** to cap how many reports you get (and pay for).
5. Click **Start**. Each analysis takes 10 to 100 seconds on Google's side; up to 3 run at the same time by default.
6. When the run finishes, open the Output tab, or export the dataset as JSON, CSV, Excel, XML or HTML.

A few things to know. `maxItems` counts reports, not pages. Ten pages with both strategies make up to 20 results. A page Google can't reach (a dead domain, a page that isn't HTML) is logged and skipped. It produces no result and no charge.

Real-user (CrUX) data exists only for pages and sites with enough Chrome traffic. Small sites often get null field metrics; the lab metrics and scores are still there. Lighthouse scores move a few points between runs because of network and CPU noise. For trends, schedule the Actor and compare over several runs.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `urls` | array of strings | Yes, unless `sitemapUrls` is given | Pages to audit. Full URLs or bare domains (https:// is added). |
| `sitemapUrls` | array of strings | No | sitemap.xml or sitemap-index URLs; their pages are added to the list. Indexes are followed up to 2 levels deep. |
| `strategies` | array of `mobile` / `desktop` | No | Device profiles to run. Default `["mobile"]`. |
| `maxItems` | integer | No | Maximum number of reports, 1-10000, default 50. |
| `maxFailingAudits` | integer | No | Failing audits kept per report, 0-50, default 10. |
| `includeFieldData` | boolean | No | Add real-user CrUX p75 metrics when Google has them. Default true. |
| `maxConcurrency` | integer | No | Analyses running at the same time, 1-5, default 3. |
| `apiKey` | string (secret) | No | Your own PageSpeed Insights API key; switches to the official API. |
| `proxyConfiguration` | object | No | Proxy settings. Default: Apify Proxy (datacenter). |

```json
{
    "urls": ["https://www.wikipedia.org/", "https://www.w3.org/", "example.org"],
    "sitemapUrls": ["https://blog.apify.com/sitemap.xml"],
    "strategies": ["mobile", "desktop"],
    "maxItems": 20,
    "maxFailingAudits": 10,
    "includeFieldData": true,
    "maxConcurrency": 3,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output

Real items from a local run (some `failingAudits` entries trimmed for length):

```json
[
    {
        "url": "https://example.org/",
        "finalUrl": "https://example.org/",
        "strategy": "mobile",
        "fetchTime": "2026-10-19T00:20:49.213Z",
        "lighthouseVersion": "13.5.0",
        "performanceScore": 100,
        "accessibilityScore": 96,
        "bestPracticesScore": 100,
        "seoScore": 80,
        "firstContentfulPaintMs": 756,
        "largestContentfulPaintMs": 812.5,
        "totalBlockingTimeMs": 3.5,
        "cumulativeLayoutShift": 0,
        "speedIndexMs": 756,
        "serverResponseTimeMs": 1,
        "totalByteWeight": 2383,
        "largestContentfulPaintDisplay": "0.8 s",
        "fieldDataScope": "url",
        "fieldLcpP75Ms": 854,
        "fieldInpP75Ms": 71,
        "fieldClsP75": 0,
        "fieldFcpP75Ms": 755,
        "fieldTtfbP75Ms": 523,
        "failingAudits": [
            {
                "id": "landmark-one-main",
                "title": "Document does not have a main landmark.",
                "category": "accessibility",
                "score": 0,
                "displayValue": null,
                "savingsMs": null,
                "savingsBytes": null
            },
            {
                "id": "link-text",
                "title": "Links do not have descriptive text",
                "category": "seo",
                "score": 0,
                "displayValue": "1 link found",
                "savingsMs": null,
                "savingsBytes": null
            }
        ],
        "runWarnings": [],
        "id": "mobile:https://example.org/",
        "sourceUrl": "https://pagespeed.web.dev/analysis/https-example-org/75gzwciw0m?form_factor=mobile"
    },
    {
        "url": "https://www.wikipedia.org/",
        "finalUrl": "https://www.wikipedia.org/",
        "strategy": "mobile",
        "fetchTime": "2026-10-19T00:20:48.892Z",
        "lighthouseVersion": "13.5.0",
        "performanceScore": 100,
        "accessibilityScore": 94,
        "bestPracticesScore": 100,
        "seoScore": 100,
        "firstContentfulPaintMs": 1113,
        "largestContentfulPaintMs": 1389,
        "totalBlockingTimeMs": 0,
        "cumulativeLayoutShift": 0.0009547550044766787,
        "speedIndexMs": 2178.0568614394815,
        "serverResponseTimeMs": 110,
        "totalByteWeight": 101094,
        "largestContentfulPaintDisplay": "1.4 s",
        "fieldDataScope": "url",
        "fieldLcpP75Ms": 1279,
        "fieldInpP75Ms": 99,
        "fieldClsP75": 0,
        "fieldFcpP75Ms": 1156,
        "fieldTtfbP75Ms": 535,
        "failingAudits": [
            {
                "id": "cache-insight",
                "title": "Use efficient cache lifetimes",
                "category": "performance",
                "score": 0,
                "displayValue": "Est savings of 27 KiB",
                "savingsMs": 250,
                "savingsBytes": null
            },
            {
                "id": "image-delivery-insight",
                "title": "Improve image delivery",
                "category": "performance",
                "score": 0,
                "displayValue": "Est savings of 35 KiB",
                "savingsMs": 100,
                "savingsBytes": null
            }
        ],
        "runWarnings": [],
        "id": "mobile:https://www.wikipedia.org/",
        "sourceUrl": "https://pagespeed.web.dev/analysis/https-www-wikipedia-org/w9n8erjr94?form_factor=mobile"
    }
]
```

The overview table in the Console shows the URL, strategy, the four scores, LCP, TBT, CLS, field LCP and INP, and the report link. Open `sourceUrl` to see the same report on pagespeed.web.dev with screenshots and full details.

### How much does it cost to check PageSpeed Insights?

PageSpeed Insights Checker is charged per result, and one result is one report (one page on one strategy). You pay only for reports returned: pages Google can't analyse cost nothing, and `maxItems` caps the total. See the Pricing tab for the current price.

Apify platform usage (compute and proxy) is included. If you set a maximum cost per run, the Actor stops cleanly when it is reached and tells you so in the status message.

### Use with AI agents (MCP)

Connect PageSpeed Insights Checker to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/pagespeed-insights-checker"
        }
    }
}
```

Example prompts:

1. "Check the mobile PageSpeed score and Core Web Vitals for https://www.python.org/ and https://www.w3.org/ and tell me which one has the worse LCP."
2. "Audit the first 20 pages of https://blog.apify.com/sitemap.xml on mobile and list the five slowest by largestContentfulPaintMs, with the top failing audit for each."
3. "Compare mobile and desktop performance scores for example.org and explain the gap using the failing audits."

Agents get structured JSON back, so they can sort, compare and summarise without reading report pages.

### Integrations and API

Run PageSpeed Insights Checker from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/pagespeed-insights-checker").call(run_input={
    "urls": ["https://www.wikipedia.org/", "https://www.w3.org/"],
    "strategies": ["mobile", "desktop"],
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["url"], item["strategy"], item["performanceScore"], item["largestContentfulPaintMs"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/pagespeed-insights-checker').call({
    urls: ['https://www.wikipedia.org/', 'https://www.w3.org/'],
    strategies: ['mobile'],
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~pagespeed-insights-checker/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://www.wikipedia.org/"], "strategies": ["mobile"], "maxItems": 10}'
```

On the Integrations tab you can connect runs to Make, Zapier, n8n, Google Sheets, Slack or a webhook, for example to post a weekly table of scores to a sheet. Use Schedules to run the same audit every day or week and track Core Web Vitals over time.

### FAQ

**Do I need a Google API key?**
No. By default the Actor uses the backend of the public pagespeed.web.dev website, which needs no key. Google's keyless API shares one daily quota across everyone and is often exhausted, which is why the Actor doesn't rely on it. If you have your own key, put it in `apiKey` and the Actor calls the official API with it; if Google rejects the key, the run falls back to the default source.

**Why are the field metrics null for some pages?**
Field data comes from the Chrome UX Report, which only covers pages and sites with enough real Chrome visitors. When Google has data for the exact page, `fieldDataScope` is `url`; when it only has data for the whole site, it is `origin`; when it has none, the field metrics are null.

**Why do my scores differ a little from the last run?**
Lighthouse runs a real browser with simulated throttling, so network and CPU noise move scores by a few points. Field (CrUX) values are a 28-day rolling window and change slowly.

**How long does a run take?**
Each analysis takes 10 to 100 seconds on Google's side. With the default 3 parallel analyses, 50 pages usually take a few minutes. You can raise `maxConcurrency` to 5.

**Why did a URL return nothing?**
Google could not load it: the domain doesn't resolve, the page isn't HTML (an image or PDF), or the site blocked Lighthouse. The log names each skipped URL and the reason. Skipped URLs are not charged.

**Can I audit a whole site?**
Yes. Put its sitemap URL into `sitemapUrls`. Sitemap indexes are followed up to two levels deep, and collecting stops once there are `maxItems` pages. Gzipped sitemaps (`.xml.gz`) are not supported; use the uncompressed one.

**What does `savingsMs` mean in `failingAudits`?**
It is Lighthouse's estimate of how many milliseconds fixing that audit would save on LCP, FCP or TBT (the largest of the three). `savingsBytes` is the estimated bytes saved. Audits without an estimate, such as most accessibility checks, have null savings and come after the ones with savings.

### Is it legal to check PageSpeed Insights?

The Actor requests public PageSpeed Insights reports, the same ones anyone can open on the pagespeed.web.dev website without logging in. It does not visit or crawl the audited pages itself, apart from reading the sitemaps you give it. You are responsible for how you use the results and for having the right to audit the URLs you submit.

PageSpeed Insights Checker is an independent tool. It is not affiliated with, endorsed by or sponsored by Google or PageSpeed Insights.

### Related Actors

| Actor | What it does |
|---|---|
| [Sitemap URL Extractor](https://apify.com/axiomworks/sitemap-url-extractor) | Lists every page URL in a sitemap, to pick which pages to audit. |
| [Link Status Checker](https://apify.com/axiomworks/broken-link-checker) | Checks which links on a site are broken. |
| [Semrush SEO Metrics Scraper](https://apify.com/axiomworks/semrush-domain-overview-scraper) | SEO traffic and keyword metrics for a domain. |
| [Google Search SERP Scraper](https://apify.com/axiomworks/google-search-results-scraper) | Google search results for keywords, to see who ranks. |

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

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

Pages to audit, one per line: full URLs (https://www.example.org/pricing) or bare domains (example.org, https:// is added). Needed unless sitemapUrls is given. A page Google can't reach is logged and skipped with no result and no charge.

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

Optional sitemap.xml or sitemap-index URLs, e.g. https://example.org/sitemap.xml. Their <loc> pages are added to the audit list; sitemap indexes are followed up to 2 levels deep, and collecting stops once there are maxItems pages.

## `strategies` (type: `array`):

Which Lighthouse device profiles to run: "mobile" (throttled phone) and/or "desktop". Default \["mobile"]. Each page gives one result per strategy, so both strategies double the results counted against maxItems.

## `maxItems` (type: `integer`):

Maximum number of reports (one page x one strategy) to return across all URLs and sitemaps, 1-10000, default 50. The run stops once this many are saved, and you are charged only for reports returned.

## `maxFailingAudits` (type: `integer`):

How many failing Lighthouse audits (score below 90) to list in failingAudits for each report, biggest estimated savings first. 0-50, default 10; 0 leaves the list empty.

## `includeFieldData` (type: `boolean`):

Add Chrome UX Report p75 values (LCP, INP, CLS, FCP, TTFB) from real users, for the exact URL when Google has them, else for the whole origin. Default true. Small sites often have none; the field metrics are then null.

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

How many pages are analysed at the same time, 1-5, default 3. Each analysis takes 10-100 seconds on Google's side.

## `apiKey` (type: `string`):

Optional. Your own free PageSpeed Insights API key from Google Cloud. When set, reports come from the official googleapis.com API (one call per page per strategy); if Google rejects the key, the run falls back to the default source. Leave empty to use the default source.

## `proxyConfiguration` (type: `object`):

Proxy for requests to PageSpeed Insights and your sitemaps, default Apify Proxy (datacenter). Switch to residential proxies only if runs get rate-limited.

## Actor input object example

```json
{
  "urls": [
    "https://www.wikipedia.org/",
    "https://www.w3.org/"
  ],
  "sitemapUrls": [],
  "strategies": [
    "mobile"
  ],
  "maxItems": 2,
  "maxFailingAudits": 10,
  "includeFieldData": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per report: Lighthouse scores, lab metrics, real-user field data and failing audits.

# 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://www.wikipedia.org/",
        "https://www.w3.org/"
    ],
    "strategies": [
        "mobile"
    ],
    "maxItems": 2,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/pagespeed-insights-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 = {
    "urls": [
        "https://www.wikipedia.org/",
        "https://www.w3.org/",
    ],
    "strategies": ["mobile"],
    "maxItems": 2,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/pagespeed-insights-checker").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://www.wikipedia.org/",
    "https://www.w3.org/"
  ],
  "strategies": [
    "mobile"
  ],
  "maxItems": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/pagespeed-insights-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/pagespeed-insights-checker"
        }
    }
}
```

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/Vf536mbqpx1JEb15E/builds/rDO6PATze58jo5X4o/openapi.json