# Bulk PageSpeed Insights & Core Web Vitals Checker (`zrk1212/pagespeed-bulk-auditor`) Actor

Bulk PageSpeed Insights and Lighthouse audits for whole websites. Get performance, SEO and accessibility scores, real-user Core Web Vitals (LCP, INP, CLS) with pass/fail, top fixes, and regression alerts.

- **URL**: https://apify.com/zrk1212/pagespeed-bulk-auditor.md
- **Developed by:** [zachary klein](https://apify.com/zrk1212) (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 $5.00 / 1,000 page audits

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

## Bulk PageSpeed Insights & Core Web Vitals Checker

Audit a whole website or a list of URLs with Google PageSpeed Insights. Get Lighthouse scores, real-user Core Web Vitals, a plain pass/fail verdict and the top fixes in one row per page, plus a site summary and optional regression alerts between runs.

### What does it do?

- **Whole-site audits from a domain.** Enter `example.com` and the actor finds the sitemap (robots.txt, /sitemap.xml, sitemap indexes, .xml.gz), then audits up to your page limit, spread across the site's sections. The homepage always comes first.
- **Lab and field data in one row.** Lighthouse scores (performance, SEO, accessibility, best practices) and lab metrics (LCP, CLS, TBT, FCP, Speed Index), next to real-user Chrome UX Report p75 values for LCP, INP and CLS at page level and site (origin) level.
- **A plain Core Web Vitals verdict.** `cwvVerdict` is `pass`, `fail` or `no-data` using Google's thresholds, so anyone can filter the failing pages.
- **Top fixes ranked by impact.** The biggest Lighthouse opportunities per page, sorted by estimated time saved, plus the most common fixes across the whole site.
- **Monitoring with regression alerts.** Schedule it daily or weekly and it flags score drops, pass-to-fail flips and real-user metrics getting worse.
- **Fast, cheap field-only mode.** Check real-user Core Web Vitals for about 100 URLs per minute without running Lighthouse.

### Who is it for?

- **SEO agencies** producing monthly performance reports for client sites.
- **Developers and QA teams** checking a release for speed regressions with a scheduled monitor.
- **E-commerce teams** checking every product, category and landing page template.
- **Site migrations:** audit before and after a redesign or platform move and compare.
- **Lead generation agencies** finding slow websites to pitch (pair it with a list of websites).

### What data do you get?

One row per page and device (`rowType: "audit"`), one free summary row per site (`rowType: "summary"`), and free error rows (`rowType: "error"`).

| Field | Example | Meaning |
|---|---|---|
| `requestedUrl` | https://web.dev/ | Page you asked for, or found in the sitemap |
| `finalUrl` | https://web.dev/ | Page after redirects |
| `strategy` | mobile | `mobile` or `desktop` |
| `performanceScore` | 64 | Lighthouse performance, 0 to 100 |
| `seoScore`, `accessibilityScore`, `bestPracticesScore` | 92, 90, 96 | Other Lighthouse categories |
| `labLcpMs`, `labCls`, `labTbtMs`, `labFcpMs`, `labSpeedIndexMs` | 2553, 0.098, 1063, 2553, 5577 | Lab metrics from this audit |
| `serverResponseMs`, `pageWeightKb` | 6, 3635 | Server response time, total page weight |
| `fieldScope` | url | Real-user data is for this `url`, the whole `origin`, or `none` |
| `fieldLcpP75Ms`, `fieldInpP75Ms`, `fieldClsP75` | 3042, 228, 0.01 | Real users, 75th percentile (last 28 days) |
| `fieldLcpRating`, `fieldInpRating`, `fieldClsRating` | needs-improvement | `good`, `needs-improvement` or `poor` |
| `cwvVerdict` | fail | Core Web Vitals assessment: `pass`, `fail` or `no-data` |
| `originCwvVerdict` | fail | Same assessment for the whole site |
| `fieldPeriodStart`, `fieldPeriodEnd` | 2026-10-19, 2026-11-15 | Real-user data collection window |
| `opportunities` | \[{"title": "Render-blocking requests", "savingsMs": 1600}] | Top fixes, biggest first |
| `topOpportunity` | Render-blocking requests | The single biggest fix (handy in CSV) |
| `psiReportUrl` | https://pagespeed.web.dev/report?url=... | Open the same page in Google's report |
| `previousPerformanceScore`, `performanceDelta`, `regressions`, `isRegression` | 70, -6, \[], false | Monitor mode only |

Summary rows include `pagesAudited`, `avgPerformanceScore`, `medianPerformanceScore`, `cwvPassRatePct`, `worstPages` (5 slowest), `commonOpportunities` and `regressionsCount`.

The Output tab has ready-made table views: Overview, Lab metrics, Core Web Vitals (real users), Monitor, Site summary and Errors. Export to CSV, Excel or JSON.

### How much does it cost?

You pay per page audited. Errors (404 pages, unreachable sites, invalid URLs), site summaries, sitemap discovery and monitoring comparisons are free.

| What | Price | 100 | 1,000 | 10,000 |
|---|---|---|---|---|
| Audit (shared Google key) | $5 per 1,000 | $0.50 | $5.00 | $50.00 |
| Audit (your own Google key) | $2 per 1,000 | $0.20 | $2.00 | $20.00 |
| Field-only Core Web Vitals check | $1 per 1,000 | $0.10 | $1.00 | $10.00 |
| Errors, summaries, monitoring | Free | | | |

Plus the small Apify actor start fee. The monthly credit on the Apify free plan covers hundreds of audits, so you can try it at no cost. A field-only check is charged even when Google has no real-user data for the page (`no-data`), because the lookup answered the question.

### How to use it

1. Click **Try for free**.
2. Add pages in **Page URLs**, or a domain in **Whole websites (domains)** to audit a site from its sitemap.
3. Pick the device (mobile is what Google ranks on) and the maximum pages per site.
4. Optional: paste your own Google API key for the lower price and your own daily quota (guide below).
5. Click **Start**. Each audit takes 10 to 40 seconds and they run in parallel.

Example input:

```json
{
    "startDomains": ["example.com"],
    "maxPagesPerSite": 25,
    "strategy": "mobile",
    "includeFieldData": true,
    "includeSiteSummary": true
}
```

#### Get your own free Google API key (optional, cheaper)

1. Open https://console.cloud.google.com/ and create a project.
2. APIs & Services > Library: enable **PageSpeed Insights API** (and **Chrome UX Report API** for field-only mode).
3. APIs & Services > Credentials > Create credentials > API key.
4. Optional: restrict the key to those two APIs.
5. Paste it into **Your Google API key**. It is stored as a secret input and never written to the output or logs.

Your own key gives you Google's free quota (typically 25,000 audits per day), runs larger than 1,000 audits, up to 20 parallel audits (with 1024 MB memory), and the $2 per 1,000 price.

#### Monitoring for regressions

Turn on **Monitor mode**, give it a **Monitor ID** such as `client-acme-mobile`, and run it on an Apify Schedule (daily or weekly). Each run compares with the previous run of the same monitor and fills `regressions`:

- `performance-drop`: score fell by at least the threshold (default 10 points)
- `cwv-verdict-pass-to-fail`: the page started failing Core Web Vitals
- `field-lcp-worse`, `field-inp-worse`, `field-cls-worse`: real-user metrics got clearly worse and are no longer good
- `new-error`: the page worked last time and now errors

Lab scores naturally move 5 to 10 points between runs, so the default threshold keeps false alarms low. Add an email or Slack integration that filters on `isRegression = true` to get alerts.

### Example output

```json
[
    {
        "id": "audit:mobile:https://web.dev/",
        "rowType": "audit",
        "requestedUrl": "https://web.dev/",
        "finalUrl": "https://web.dev/",
        "strategy": "mobile",
        "performanceScore": 64,
        "accessibilityScore": 90,
        "bestPracticesScore": 96,
        "seoScore": 92,
        "labLcpMs": 2553,
        "labCls": 0.098,
        "labTbtMs": 1063,
        "fieldScope": "url",
        "fieldLcpP75Ms": 3042,
        "fieldInpP75Ms": 228,
        "fieldClsP75": 0.01,
        "cwvVerdict": "fail",
        "originCwvVerdict": "fail",
        "fieldPeriodStart": "2026-10-19",
        "fieldPeriodEnd": "2026-11-15",
        "opportunities": [
            { "id": "render-blocking-insight", "title": "Render-blocking requests", "savingsMs": 1600, "savingsKb": 0, "displayValue": "Est savings of 1,590 ms" },
            { "id": "mainthread-work-breakdown", "title": "Minimize main-thread work", "savingsMs": 1050, "savingsKb": 0, "displayValue": "3.5 s" }
        ],
        "topOpportunity": "Render-blocking requests",
        "psiReportUrl": "https://pagespeed.web.dev/report?url=https%3A%2F%2Fweb.dev%2F&form_factor=mobile",
        "auditedAt": "2026-11-18T02:01:38.250Z"
    },
    {
        "id": "summary:mobile:web.dev",
        "rowType": "summary",
        "host": "web.dev",
        "strategy": "mobile",
        "pagesAudited": 1,
        "avgPerformanceScore": 64,
        "cwvPassRatePct": 0,
        "worstPages": [{ "url": "https://web.dev/", "performanceScore": 64 }],
        "commonOpportunities": [{ "id": "render-blocking-insight", "title": "Render-blocking requests", "pages": 1 }]
    }
]
```

### Use it via API, MCP, n8n, Make, Zapier

Run it from any language with the Apify API, from AI agents through the Apify MCP server, or from n8n, Make and Zapier with the Apify integration.

```bash
curl -X POST "https://api.apify.com/v2/acts/zrk1212~pagespeed-bulk-auditor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://web.dev/"],"strategy":"mobile"}'
```

### FAQ

**Why do scores differ from the PageSpeed Insights website?**
Lab scores vary 5 to 10 points between runs because of network and server timing, even on Google's own site. Field data is a rolling 28-day window, so it changes slowly.

**What does "no-data" mean?**
Google only publishes real-user data for pages and sites with enough Chrome traffic. Small or new pages often have none. Lab scores are still returned for every audit.

**What is the difference between URL and origin field data?**
URL data is for that exact page. When a page has too little traffic, Google falls back to data for the whole site (origin), and `fieldScope` says `origin`.

**How long does an audit take?**
Usually 10 to 40 seconds per page, run in parallel. Very heavy pages can take up to 2 minutes. About 1,000 pages take 45 to 60 minutes, so raise the run timeout for big runs. If a run gets close to its timeout, it stops starting new pages and still writes the site summary.

**Is there a daily limit?**
Runs on the shared Google key are capped at 1,000 audits each, and the shared key has a daily Google quota. If it runs out, remaining pages are returned as free `QUOTA_EXCEEDED` rows and the run still succeeds. Add your own free key for guaranteed capacity.

**Why is a page an error row instead of a result?**
If a page returns 404 or 500, cannot be reached, or redirects to a different website, the scores would describe the wrong page, so you get a free error row with the reason instead.

**Is this legal?**
Yes. It audits public web pages using Google's official PageSpeed Insights API and Chrome UX Report data. No personal data is collected.

**Something broke?**
Open an Issue on the actor page. We respond within 24 hours.

Uses the Google PageSpeed Insights API and Chrome UX Report data (Chrome UX Report data is published by Google under the Creative Commons Attribution license). Not affiliated with or endorsed by Google.

### Related actors

- [Luma Event Scraper: Organizer Leads](https://apify.com/zrk1212/luma-organizer-leads)

# Changelog

This Actor's version history is a separate document: https://apify.com/zrk1212/pagespeed-bulk-auditor/changelog.md

# Actor input Schema

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

Pages to audit. Full URLs including https://. Each URL is audited once per strategy.

## `startDomains` (type: `array`):

Domains to audit as a whole site, for example example.com. The actor finds the sitemap automatically (robots.txt, /sitemap.xml, /sitemap_index.xml) and audits up to "Max pages per site" pages. If no sitemap is found, only the homepage is audited.

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

Direct sitemap URLs (XML, sitemap index, or .xml.gz). Pages are taken from the sitemap up to "Max pages per site" per sitemap.

## `maxPagesPerSite` (type: `integer`):

Maximum pages taken from each domain or sitemap. For domains, the homepage is always included first.

## `sitemapSampling` (type: `string`):

spread picks pages evenly across the sitemap so the audit covers different sections. first takes pages in sitemap order.

## `strategy` (type: `string`):

Device to emulate. Both produces two rows per URL and costs two audits. Google ranks on mobile, so mobile is the default.

## `categories` (type: `array`):

Lighthouse categories to score. Performance is always included.

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

Add real-user Core Web Vitals from the Chrome UX Report (URL level and origin level). Free of extra charge.

## `fieldDataOnly` (type: `boolean`):

Skip Lighthouse and only fetch real-user Chrome UX Report data. Much faster and cheaper (charged as a field check, not an audit). Pages without enough Chrome traffic return no-data.

## `maxOpportunities` (type: `integer`):

How many top Lighthouse fixes (opportunities) to include per page, sorted by estimated time savings.

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

Add one free summary row per site with averages, Core Web Vitals pass rate, worst pages and the most common fixes.

## `monitorMode` (type: `boolean`):

Compare with the previous run that used the same monitor ID and flag regressions. Use with an Apify Schedule for daily or weekly monitoring.

## `monitorId` (type: `string`):

Name of this monitor (letters, numbers, dashes). If empty while monitor mode is on, an ID is derived from the input URLs.

## `regressionThreshold` (type: `integer`):

Performance score drop (in points) that counts as a regression in monitor mode. Lab scores naturally vary 5 to 10 points between runs.

## `locale` (type: `string`):

Language for opportunity titles, for example en, de, fr.

## `googleApiKey` (type: `string`):

Optional. Your own Google Cloud API key with the PageSpeed Insights API (and optionally the Chrome UX Report API) enabled. Gives you your own daily Google quota (typically 25,000 audits per day), larger runs, and a lower price per audit.

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

Parallel audits. Without your own API key the actor uses at most 8. Values above 8 need your own key and 1024 MB memory.

## `maxAudits` (type: `integer`):

Hard cap on audits in this run (each URL plus device counts as one). Protects your budget. Runs on the shared key are capped at 1,000.

## Actor input object example

```json
{
  "urls": [
    "https://web.dev/"
  ],
  "maxPagesPerSite": 25,
  "sitemapSampling": "spread",
  "strategy": "mobile",
  "categories": [
    "performance",
    "seo",
    "accessibility",
    "best-practices"
  ],
  "includeFieldData": true,
  "fieldDataOnly": false,
  "maxOpportunities": 5,
  "includeSiteSummary": true,
  "monitorMode": false,
  "regressionThreshold": 10,
  "locale": "en",
  "maxConcurrency": 6,
  "maxAudits": 500
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `field` (type: `string`):

No description

## `results` (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 = {
    "urls": [
        "https://web.dev/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zrk1212/pagespeed-bulk-auditor").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://web.dev/"] }

# Run the Actor and wait for it to finish
run = client.actor("zrk1212/pagespeed-bulk-auditor").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://web.dev/"
  ]
}' |
apify call zrk1212/pagespeed-bulk-auditor --silent --output-dataset

```

## MCP server setup

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

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/VvErt6QjOZCCbCY4B/builds/DBQqCTWV6GaGcDw3o/openapi.json
