# Bulk PageSpeed Insights Test: Lighthouse & Core Web Vitals (`hillcountrybots/bulk-pagespeed-checker`) Actor

Bulk PageSpeed Insights test for many URLs via Google's official API: Lighthouse 13 scores, Core Web Vitals (LCP, INP, CLS), real-user CrUX data and top fixes. Mobile and desktop. No API key needed. $3 per 1,000 audits, failures free.

- **URL**: https://apify.com/hillcountrybots/bulk-pagespeed-checker.md
- **Developed by:** [Hill Country Bots](https://apify.com/hillcountrybots) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 successful 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 Test: Lighthouse & Core Web Vitals

Run a **bulk PageSpeed Insights test** on a whole list of URLs in one click. This is a website speed test that returns **Lighthouse scores**, lab speed metrics, **real-user Core Web Vitals** (LCP, INP, CLS) and the top fixes. Results are ready for an SEO audit, a CSV export, or an AI agent. It uses **Google's official PageSpeed Insights API**, for mobile, desktop or both. **$3.00 per 1,000 successful audits. Failed audits are free.**

### What does this bulk PageSpeed Insights checker do?

You give it URLs. For each URL and device, Google runs Lighthouse 13 on its own servers, and you get one clean row with:

- **Lighthouse scores (0-100):** Performance, Accessibility, Best Practices, SEO
- **Lab metrics:** LCP, CLS, TBT, FCP, Speed Index, server response time (TTFB)
- **Real-user Core Web Vitals** from the Chrome UX Report (CrUX): p75 LCP, INP, CLS, FCP and TTFB, each rated FAST/AVERAGE/SLOW, for the page and for the whole origin, when Google has enough traffic data
- **Top 5 opportunities**, sorted by estimated time savings
- A clear `status` and `errorCode` for any URL that could not be tested

### Who is it for?

- **SEO agencies and consultants:** a bulk Core Web Vitals check across every client page, exported to CSV, Excel or Google Sheets
- **Developers:** compare Lighthouse performance before and after a release, or schedule a daily run
- **AI agents and automations:** stable JSON through the Apify API, MCP server, Make, Zapier or n8n, with a predictable price per result

### Quick start

1. Paste your URLs. A domain without `https://` is fine. The form comes prefilled, so **Start** works right away.
2. Choose **Device** (mobile, desktop, or both) and the Lighthouse categories you want. The price is the same whether you pick one category or all four.
3. Click **Start**, then download the results as JSON, CSV or Excel, or read them through the API.

To audit a whole site, first extract URLs with the [Sitemap URL Extractor](https://apify.com/hillcountrybots/sitemap-url-extractor), then paste the `url` column here. Each audit takes Google about **15 seconds (median)**. Slow pages can take up to 2 minutes. Six audits run in parallel by default.

#### Sample output

This table is from a real run on **November 10, 2026, at 9:35 PM CT** (America/Chicago), using the prefilled Wikipedia and web.dev URLs on mobile. You pay about **$3 per 1,000** successful audits. Failed audits are free.

![Sample output from a real Bulk PageSpeed Insights Test run](https://api.apify.com/v2/key-value-stores/2kusIBSeqRffwM3Q9/records/pagespeed-sample-output.png?signature=pu9hvO0iZMvSEKOpwGyA)

| URL | Perf | A11y | BP | SEO | Lab LCP | Lab CLS | CrUX |
|---|---:|---:|---:|---:|---:|---:|---|
| wikipedia.org | 100 | 94 | 100 | 100 | 1.23 s | 0.001 | FAST |
| web.dev | 65 | 90 | 96 | 92 | 2.55 s | 0.112 | SLOW |

If a URL cannot be tested, the run writes a row with `status: "error"`, `errorCode` and `errorMessage` instead of finishing as a silent success with empty data. Those rows are not charged.

#### Example inputs

Mobile Core Web Vitals and Lighthouse scores for a short URL list:

```json
{
  "urls": ["https://www.wikipedia.org/", "https://web.dev/"],
  "strategy": "mobile",
  "categories": ["performance", "accessibility", "best-practices", "seo"]
}
```

Compare a page speed test on mobile and desktop (two rows, two charges per URL):

```json
{
  "urls": ["https://www.wikipedia.org/"],
  "strategy": "both",
  "categories": ["performance", "accessibility", "best-practices", "seo"]
}
```

Performance-only bulk audit (same $0.003 price per successful audit):

```json
{
  "urls": ["https://www.wikipedia.org/", "https://web.dev/", "https://www.example.com/"],
  "strategy": "mobile",
  "categories": ["performance"]
}
```

Desktop SEO and accessibility audit:

```json
{
  "urls": ["https://www.wikipedia.org/", "https://web.dev/"],
  "strategy": "desktop",
  "categories": ["accessibility", "seo"]
}
```

Ready-to-run example tasks (pre-filled inputs on this Actor's Store page):

- [Mobile Core Web Vitals for a short URL list](https://apify.com/hillcountrybots/bulk-pagespeed-checker/examples/pagespeed-mobile-core-web-vitals)
- [Mobile vs desktop PageSpeed Insights test](https://apify.com/hillcountrybots/bulk-pagespeed-checker/examples/pagespeed-mobile-vs-desktop)

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `urls` | array of strings | (required) | Public http(s) pages. Private, local and internal addresses are refused and not charged. |
| `strategy` | `mobile` / `desktop` / `both` | `mobile` | `both` gives two rows and two charges per URL. |
| `categories` | array | `["performance"]` | Any of `performance`, `accessibility`, `best-practices`, `seo`. |
| `googleApiKey` | secret string | (none) | Optional. Your own free Google PageSpeed Insights API key, used **instead of** the built-in key. Stored encrypted, sent only to Google, never logged. |
| `maxConcurrency` | integer 1-10 | 6 | Audits in parallel. |
| `maxResults` | integer | 1000 | Most audits per run. Spend is capped at `maxResults` × $0.003. |
| `requestTimeoutSecs` | integer 30-180 | 120 | Seconds to wait on one audit. A timed-out audit is retried once, then marked `TIMEOUT` (free). |

### Output example

Here is a real row from a test run on Nov 10, 2026, shortened to the first opportunity and the first field metric:

```json
{
  "url": "https://www.wikipedia.org/",
  "strategy": "mobile",
  "finalUrl": "https://www.wikipedia.org/",
  "lighthouseVersion": "13.6.0",
  "scores": {
    "performance": 100,
    "accessibility": 94,
    "bestPractices": 100,
    "seo": 100
  },
  "lab": {
    "lcpMs": 1221,
    "cls": 0.0005,
    "tbtMs": 0,
    "fcpMs": 1150,
    "speedIndexMs": 2521.7069,
    "ttfbMs": 5
  },
  "opportunities": [
    {
      "id": "cache-insight",
      "title": "Use efficient cache lifetimes",
      "estimatedSavingsMs": 250,
      "metricSavings": {
        "LCP": 250,
        "FCP": 0
      },
      "displayValue": "Est savings of 28 KiB"
    }
  ],
  "fieldData": {
    "overallCategory": "FAST",
    "lcpMs": {
      "p75": 1302,
      "category": "FAST"
    }
  },
  "status": "ok",
  "errorCode": null,
  "errorMessage": null,
  "durationMs": 15548,
  "attempts": 1,
  "fetchedAt": "2026-11-10T20:44:34.016Z"
}
```

A failed audit is **not charged** and looks like this:

```json
{"url": "https://httpbin.org/status/404", "strategy": "mobile", "status": "error", "errorCode": "LIGHTHOUSE_FAILED", "errorMessage": "Lighthouse returned error: NO_FCP. The page did not paint any content. Please ensure you k…"}
```

The key-value store also gets a `RUN_SUMMARY` record with totals (`audited`, `failed`, `skipped`, `durationSecs`).

#### Output fields (for AI agents and integrations)

- `status`: `ok` means audited and charged. `error` means not audited and not charged.
- `errorCode` is one of:
  - `INVALID_URL` or `PRIVATE_URL`: bad or internal address
  - `LIGHTHOUSE_FAILED`: Google could not load or render the page, e.g. a 404 page or a block
  - `TIMEOUT`, `NETWORK_ERROR` or `HTTP_<code>`: the request to Google failed
  - `INVALID_API_KEY` or `QUOTA_EXCEEDED_DAILY`: the run stops cleanly
- `scores.performance|accessibility|bestPractices|seo`: 0-100
- `lab.lcpMs, cls, tbtMs, fcpMs, speedIndexMs, ttfbMs`: lab measurements
- `fieldData` / `originFieldData`: real-user p75 values plus a category. Null when Google has no CrUX data.
- `opportunities[]`: `id`, `title`, `estimatedSavingsMs`, `metricSavings`, `displayValue`

### Use it from the API, MCP or an AI agent

- **Actor ID:** `hillcountrybots/bulk-pagespeed-checker`
- **One API call** runs the audit and returns the rows. It waits up to 5 minutes, so use the async run endpoints for big batches:

```bash
curl -X POST "https://api.apify.com/v2/acts/hillcountrybots~bulk-pagespeed-checker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://www.wikipedia.org/"],"strategy":"mobile"}'
```

- **MCP (Claude, Cursor, ChatGPT and other MCP clients):** add `https://mcp.apify.com?tools=hillcountrybots/bulk-pagespeed-checker` as an MCP server. The tool takes the same input as above.
- **For agents:** branch on `status` (`ok` or `error`). `scores.performance` is 0-100. Every row costs $0.003 when `status` is `ok` and nothing otherwise.

### Use with n8n, Make, Zapier or on a schedule

You can run this Actor from the tools you already use. No extra plugin is required. Apify's official integrations start a run with **your own Apify token** and pass the results to the next step.

- **On a schedule:** in [Apify Console](https://console.apify.com), open this Actor, go to **Schedules**, and run it weekly (for example every Monday) on the same URL list or website. See [Schedules](https://docs.apify.com/platform/schedules).
- **Make:** use the official [Apify Make integration](https://docs.apify.com/integrations/make) to start a run and send the dataset to Sheets, Slack or email.
- **Zapier:** use the official [Apify Zapier integration](https://docs.apify.com/integrations/zapier).
- **n8n:** use the official [Apify n8n integration](https://docs.apify.com/integrations/n8n) to add this Actor to a workflow.

A typical setup is: schedule a weekly run → export the dataset to Google Sheets or Slack → review the new rows. The input is the same as on this page.

### How much does it cost?

**$3.00 per 1,000 successful audits**, which is $0.003 per `url-audited` event (one URL on one device). You pay nothing for:

- failed audits
- invalid or private URLs
- timeouts
- the run summary

The Actor's compute is included, so there's no separate platform usage charge. For example, 500 URLs on mobile and desktop is 1,000 audits, or $3.00. To cap spend, use `maxResults` or the run's maximum charge setting.

### Limits

- Google limits how many tests the built-in key can run per day. If that quota runs out, the run stops cleanly and the remaining URLs are not charged. For very large or daily jobs, add your own free key in `googleApiKey`.
- Lighthouse scores vary a few points between runs. That is normal for Lighthouse.
- Real-user Core Web Vitals appear only for pages and origins with enough Chrome traffic.
- The Actor cannot test pages behind a login, and it does not crawl. It audits exactly the URLs you give it.

### FAQ

**Do I need a Google API key?** No. A built-in key is included. Your own key only matters for very high volume.

**Is this legal?** Yes. It calls Google's public PageSpeed Insights API under Google's API terms, and it tests only the URLs you supply.

**Does it collect personal data?** No. It returns page performance metrics only.

**Are the scores the same as pagespeed.web.dev?** Yes. This uses the same Google PageSpeed Insights API, so the results match. Lighthouse lab scores still move a few points from one run to the next, on the website too.

**Can I test a whole website (a sitemap)?** Paste or upload the list of URLs. The Actor doesn't crawl, so you control exactly which pages get tested and charged.

**Why did one URL fail?** Check `errorCode` and `errorMessage`. `LIGHTHOUSE_FAILED` usually means the page returned an error, painted nothing, or blocked Google's tester.

### More tools from Hill Country Bots

- [Bulk Domain Availability Checker](https://apify.com/hillcountrybots/domain-availability-checker): Bulk available/taken checks from official registry RDAP, with registrar and expiry dates. $1 per 1,000 domains, invalid inputs and errors free.
- [Sitemap URL Extractor](https://apify.com/hillcountrybots/sitemap-url-extractor): Every URL from a site's XML sitemaps (robots.txt, indexes, gzip). $0.50 per 1,000 URLs, failures free.
- [Tech Stack Detector](https://apify.com/hillcountrybots/tech-stack-detector): CMS, ecommerce, analytics, CDN and frameworks for many websites. $0.50 per 1,000 sites, failures free.
- [SEO Audit Tool](https://apify.com/hillcountrybots/seo-audit): 0-100 SEO score per page, top 5 fixes and a client-ready HTML report. $2 per 1,000 pages, failures free.

### Support

Found a bug or need a field added? Open an issue on this Actor's **Issues** tab with the run ID and the URL. We reply within 2 business days (US Central time), and we fix confirmed bugs as fast as we can. Built and maintained by **Hill Country Bots**.

# Actor input Schema

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

Required. Public web pages to audit, one per line (https://example.com/). A domain without https:// is accepted. Private, local and internal addresses are refused (free).

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

Device to emulate: 'mobile', 'desktop', or 'both' (two rows and two charges per URL).

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

Lighthouse categories to score: performance, accessibility, best-practices, seo. Adding categories does not change the price.

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

Optional. Your own free Google PageSpeed Insights API key. If set, it is used instead of the Actor's built-in key (good for very large or daily jobs). Stored encrypted, sent only to Google, never logged or saved in results.

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

How many audits run in parallel (1-10). Google takes about 15 s per audit (median), slow pages up to 2 minutes.

## `maxResults` (type: `integer`):

Maximum number of URL x device audits in this run. Caps spend: at most maxResults x $0.003.

## `requestTimeoutSecs` (type: `integer`):

Seconds to wait for one audit before retrying once, then marking it TIMEOUT (free).

## Actor input object example

```json
{
  "urls": [
    "https://www.wikipedia.org/",
    "https://web.dev/"
  ],
  "strategy": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "maxConcurrency": 6,
  "maxResults": 1000,
  "requestTimeoutSecs": 120
}
```

# Actor output Schema

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

No description

## `summary` (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://www.wikipedia.org/",
        "https://web.dev/"
    ],
    "categories": [
        "performance",
        "accessibility",
        "best-practices",
        "seo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hillcountrybots/bulk-pagespeed-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://web.dev/",
    ],
    "categories": [
        "performance",
        "accessibility",
        "best-practices",
        "seo",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("hillcountrybots/bulk-pagespeed-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://web.dev/"
  ],
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ]
}' |
apify call hillcountrybots/bulk-pagespeed-checker --silent --output-dataset

```

## MCP server setup

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