# Bulk PageSpeed Insights & Core Web Vitals Checker + PDF Report (`jordydev/pagespeed-bulk-audit`) Actor

Bulk PageSpeed Insights and Lighthouse audit for hundreds of URLs on mobile and desktop. Get Core Web Vitals (LCP, CLS, INP), performance, SEO and accessibility scores, real-user CrUX data and the top fixes as JSON, CSV and a client-ready PDF report. $6 per 1,000 audits.

- **URL**: https://apify.com/jordydev/pagespeed-bulk-audit.md
- **Developed by:** [Jordy](https://apify.com/jordydev) (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 $6.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 with PDF Report

**Audit hundreds of URLs on mobile and desktop with Google PageSpeed Insights or Lighthouse, and get scores, Core Web Vitals and the top fixes as JSON, CSV and a client-ready PDF, for $6 per 1,000 audits.**

Paste a list of URLs and get, per page and device: the four Lighthouse scores (Performance, Accessibility, Best Practices, SEO), Core Web Vitals (LCP, CLS, INP, FCP, TBT, TTFB), real-user **CrUX field data** when Google has it, and the **top opportunities ranked by estimated savings**. Built for agencies, SEO consultants and developers who need to check many pages at once instead of pasting them into pagespeed.web.dev one by one.

### What can it do?

- ✅ **Bulk PageSpeed checks**: up to 500 URLs per run by default (`maxUrls`, up to 10,000). Duplicates removed, `example.com` becomes `https://example.com/`.
- ✅ **Mobile and/or desktop** with Lighthouse's official settings.
- ✅ **Two engines**: `psi` (Google's PageSpeed Insights API, with CrUX field data), `local` (Lighthouse 13 inside the Actor, no key or quota needed) and `auto` (PSI first, local Lighthouse when Google's daily quota runs out).
- ✅ **Core Web Vitals ratings**: each metric rated good / needs-improvement / poor.
- ✅ **Top fixes per page** (render-blocking requests, unused CSS, image sizes…) with estimated savings in ms and KB.
- ✅ **Reports**: dataset rows, `audit.csv`, a client-ready `audit-summary.pdf`, `RUN_SUMMARY`, and optionally the full Lighthouse JSON per page.
- ✅ **Reliable at volume**: retries on 429/5xx with back-off and `Retry-After`; quota errors are detected and never billed.

### Use cases

- **SEO and web agencies**: a monthly Core Web Vitals report for every client page, as a PDF you can send as-is.
- **Developers and QA**: check performance before and after a release, or across all templates of a site.
- **Site migrations**: compare old vs new URLs on the same engine.
- **Monitoring**: schedule it weekly and push results to Google Sheets, Slack or a webhook to spot regressions.
- **Prospecting**: audit a list of prospect websites and open the conversation with their scores.

### How to use it

1. Click **Try for free** and paste your URLs into **URLs**, one per line.
2. Pick **mobile**, **desktop** or both. Optional: add your free Google PageSpeed Insights API key for your own quota and CrUX field data.
3. Click **Start**. Each URL × device becomes one row in the **Output** tab; `audit.csv` and `audit-summary.pdf` are in the run's storage.
4. To track Core Web Vitals over time, save the input as a **task** and add a weekly **schedule**.

### Example input

```json
{
  "urls": ["https://example.com", "https://www.wikipedia.org", "https://www.python.org"],
  "strategies": ["mobile", "desktop"],
  "engine": "auto",
  "apiKey": "",
  "saveCsv": true,
  "savePdf": true
}
```

#### Call it from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/jordydev~pagespeed-bulk-audit/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://example.com","https://www.python.org"],"strategies":["mobile","desktop"]}'
```

### Example output

Real run on 27 Oct 2026 (local Lighthouse engine):

| URL | Device | Performance | Accessibility | Best practices | SEO | LCP | CLS | TBT |
|---|---|---|---|---|---|---|---|---|
| https://www.python.org/ | mobile | 84 | 75 | 100 | 92 | 3,942 ms | 0.003 | 0 ms |
| https://www.python.org/ | desktop | 93 | 79 | 100 | 92 | 982 ms | 0.138 | 0 ms |
| https://www.wikipedia.org/ | mobile | 69 | 94 | 100 | 100 | 2,368 ms | 0.001 | 2,088 ms |
| https://www.wikipedia.org/ | desktop | 79 | 99 | 100 | 100 | 312 ms | 0.001 | 482 ms |
| https://example.com/ | mobile | 100 | 96 | 100 | 80 | 825 ms | 0 | 15 ms |

One row as JSON (another run the same day, so timings differ slightly; shortened to 2 opportunities):

```json
{
  "tool": "pagespeed-bulk-audit",
  "target": "https://www.python.org/",
  "status": "ok",
  "strategy": "mobile",
  "lighthouseVersion": "13.5.0",
  "scores": { "performance": 84, "accessibility": 75, "bestPractices": 100, "seo": 92 },
  "performanceRating": "needs-improvement",
  "lab": { "lcpMs": 4025, "fcpMs": 2482, "cls": 0.003, "tbtMs": 5, "speedIndexMs": 2482, "ttfbMs": 52 },
  "labRatings": { "lcp": "poor", "cls": "good", "tbt": "good", "fcp": "needs-improvement" },
  "topOpportunities": [
    { "id": "render-blocking-insight", "title": "Render-blocking requests", "savingsMs": 1400 },
    { "id": "unused-css-rules", "title": "Reduce unused CSS", "savingsMs": 570, "savingsKb": 128.5 }
  ],
  "field": null,
  "engine": "lighthouse-local"
}
```

With the `psi` engine, `field` holds CrUX data when available, e.g. `{ "source": "url", "coreWebVitalsAssessment": "needs-improvement", "lcpMs": 2300, "inpMs": 240, "cls": 0.05 }` (`source: "origin"` when only site-wide data exists).

### How much does it cost?

Pay per event: you only pay per audit, not for Apify compute.

| Event | Price | When it's charged |
|---|---|---|
| Page audit | **$0.006** ($6 per 1,000 audits) | One URL audited on one device (mobile or desktop) |
| Actor start | $0.00005 | Apify's standard fee per run start (per GB of memory) |

Examples: 100 URLs on mobile ≈ **$0.60**; 100 URLs on mobile + desktop ≈ **$1.20**; 1,000 URLs on mobile ≈ **$6.00**.

**Free**: invalid URLs, blocked (private/internal) addresses and Google quota errors. Pages that fail on the target site itself (DNS error, page doesn't load) are charged, because the audit was run. You can set a maximum cost per run; the Actor stops cleanly at the cap.

### FAQ

**Do I need a Google API key?**
No, but it's recommended. Without a key Google's shared quota is often used up and the Actor falls back to local Lighthouse. A free key (Google Cloud → enable "PageSpeed Insights API" → create an API key) gives you your own quota and CrUX field data. The key is stored as a secret input.

**Is this the same as pagespeed.web.dev?**
With the `psi` engine it calls the same Google PageSpeed Insights API. With `local` it runs the same open-source Lighthouse engine on Apify's servers.

**Why are my scores different from pagespeed.web.dev?**
Lighthouse lab scores vary between runs, machines and locations. Compare trends with the same engine rather than single numbers.

**What is field data?**
Real-user measurements from the Chrome UX Report, only via the PSI engine and only for pages or sites with enough traffic.

**Can I audit any website?**
Each URL is loaded once, like a normal visitor (PSI requests come from Google). Private and internal addresses are refused. Only audit sites you are allowed to test; you are responsible for how you use the results.

**Can I get the full Lighthouse report?**
Turn on `saveRawLighthouseJson` (local engine) to store the complete JSON per page.

**Can I schedule it?**
Yes. Save your input as a task and add a schedule. Each run has its own CSV and PDF, so you can compare over time.

### Related Actors

More tools by the same developer, all pay-per-event with the same clean output style:

- [EU Jobs Search (Workday, Greenhouse, Lever & Teamtailor)](https://apify.com/jordydev/eu-job-search): search live jobs from 6,500+ European employers' career sites by keyword and country, no company list needed.
- [Greenhouse & Lever Jobs Scraper (ATS Job Feed)](https://apify.com/jordydev/ats-job-feed): every open job from your own list of companies on Greenhouse, Lever, Ashby, Workable, Recruitee and Personio.
- [Website Screenshot & HTML to PDF](https://apify.com/jordydev/screenshot-pdf): full-page PNG/JPEG screenshots and PDFs of any URL or raw HTML, cookie banners removed.
- [Broken Link Checker & SEO Site Audit (Site QA Crawler)](https://apify.com/jordydev/site-qa-crawler): broken links, redirects, SEO basics, WCAG accessibility and SSL expiry in one crawl, with a fix list and PDF.

***

Related searches: bulk PageSpeed Insights checker, PageSpeed Insights API, Lighthouse bulk audit, Core Web Vitals checker, LCP CLS INP report, website speed test API, page speed test bulk, performance report PDF for clients.

# Actor input Schema

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

Pages to audit. One URL per line; https:// is added when missing. Duplicates are removed.

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

Audit as mobile, desktop, or both. Each URL × device is one audit.

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

Which Lighthouse categories to score. Fewer categories run faster.

## `engine` (type: `string`):

auto: Google PageSpeed Insights API (adds real-user Core Web Vitals from CrUX), switching to local Lighthouse if the API quota is used up. psi: API only. local: Lighthouse in this run only (no field data).

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

Your own free Google API key raises the API quota (Google's documented default is 25,000 requests a day per Google Cloud project). Without a key, shared keyless quota is often exhausted and the run falls back to local Lighthouse.

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

How many PageSpeed Insights API calls run at once. Local Lighthouse always runs one page at a time for stable timings.

## `maxRetries` (type: `integer`):

Retries for rate limits (HTTP 429), timeouts and server errors, with exponential backoff.

## `topOpportunities` (type: `integer`):

How many top performance opportunities (biggest estimated savings first) to return per page.

## `saveCsv` (type: `boolean`):

Store a flat CSV (one row per URL × device) as audit.csv in the key-value store.

## `savePdf` (type: `boolean`):

Store a client-ready PDF summary as audit-summary.pdf in the key-value store.

## `saveRawLighthouseJson` (type: `boolean`):

Also store the complete Lighthouse report for each page (local engine only). Large.

## `maxUrls` (type: `integer`):

Safety cap on the number of URLs audited in one run.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://www.wikipedia.org"
  ],
  "strategies": [
    "mobile"
  ],
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "engine": "auto",
  "maxConcurrency": 3,
  "maxRetries": 4,
  "topOpportunities": 5,
  "saveCsv": true,
  "savePdf": true,
  "saveRawLighthouseJson": false,
  "maxUrls": 500
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

## `pdf` (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://example.com",
        "https://www.wikipedia.org"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jordydev/pagespeed-bulk-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://example.com",
        "https://www.wikipedia.org",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jordydev/pagespeed-bulk-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://example.com",
    "https://www.wikipedia.org"
  ]
}' |
apify call jordydev/pagespeed-bulk-audit --silent --output-dataset

```

## MCP server setup

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