# Lighthouse Bulk Speed Auditor - PageSpeed & Core Web Vitals (`jeanswiegers/lighthouse-bulk-speed-auditor`) Actor

Run open-source Lighthouse on hundreds of URLs at once. Get performance, SEO, accessibility & best-practices scores, Core Web Vitals (LCP, CLS, TBT), top fixes with savings and full HTML reports. Mobile & desktop. No API key needed.

- **URL**: https://apify.com/jeanswiegers/lighthouse-bulk-speed-auditor.md
- **Developed by:** [Jean Swiegers](https://apify.com/jeanswiegers) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$30.00 / 1,000 audit completeds

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 Lighthouse Audit – PageSpeed, Core Web Vitals & SEO Scores for Many URLs

**Run Google's open-source Lighthouse on a whole list of URLs and get one clean row per page:** Performance, Accessibility, Best Practices and SEO scores (0–100), Core Web Vitals lab metrics (LCP, CLS, TBT, plus FCP, Speed Index and TTI), the top page speed fixes ranked by estimated savings, and optional full Lighthouse HTML reports you can share. Mobile, desktop or both. **No API key, no PageSpeed Insights quota, no start fee – $0.03 per successful audit.** Export to JSON, CSV or Excel, or pull results into your own dashboards via the Apify API.

Lighthouse (Apache-2.0) runs inside the Actor in headless Chrome, using the same simulated throttling as the lab section of PageSpeed Insights. This is an independent tool, not affiliated with or endorsed by Google.

### What you get

One dataset row per URL per device:

| Field | What it contains |
|---|---|
| `url`, `finalUrl` | The URL you gave and the URL Lighthouse ended on after redirects |
| `device` | `mobile` or `desktop` |
| `status` | `succeeded` or `failed` |
| `scores` | `performance`, `accessibility`, `best-practices`, `seo` (0–100, for the categories you selected) |
| `metrics` | `lcpMs`, `fcpMs`, `cls`, `tbtMs`, `siMs` (Speed Index), `ttiMs` (Time to Interactive) |
| `opportunities` | Top fixes sorted by estimated savings: `id`, `title`, `displayValue`, `savingsMs`, `savingsKb` |
| `diagnostics` | `failedAuditCount`, `failedAudits` (first 15 IDs), `totalByteWeightKb`, `numRequests`, `numScripts`, `domSize`, `serverResponseTimeMs`, `mainThreadWorkMs`, `bootupTimeMs` |
| `warnings` | Lighthouse run warnings, if any |
| `lighthouseVersion`, `throttling`, `fetchTime`, `durationMs` | How and when the audit ran |
| `reportJsonUrl`, `reportHtmlUrl` | Links to the full Lighthouse JSON and shareable HTML report (when `saveFullReport` is on, otherwise `null`) |
| `error` | `null` on success, otherwise `{ code, message }` |

Ready-made dataset views in Apify Console: **Scores & Core Web Vitals**, **Top opportunities** and **Errors**. A `RUN_SUMMARY` record in the key-value store holds the succeeded/failed totals.

### How much does it cost?

**$0.03 per successful audit** (one URL on one device). You only pay for successful results: failed audits and invalid URLs are free, there is no start fee, and there are no extra platform usage charges. `"device": "both"` counts as 2 audits per URL.

| Audits | Price |
|---|---|
| 100 URLs, mobile | $3.00 |
| 100 URLs, mobile + desktop | $6.00 |
| 1,000 URLs, mobile | $30.00 |

Set a maximum cost per run in Apify Console and the Actor stops starting new audits once it is reached.

### Use cases

- 📈 **Core Web Vitals & SEO monitoring** – schedule weekly audits of your key landing pages and spot regressions early.
- 🏁 **Competitor benchmarking** – compare page speed and SEO scores against competitors' home and product pages.
- 🧾 **Agency reports & lead generation** – audit a list of prospect websites and show each one what to fix, with a shareable HTML report.
- 🚀 **Pre/post-release QA** – audit production URLs after each deploy by calling the Actor from CI via the Apify API.
- ♿ **Accessibility sweeps** – find pages with failing accessibility audits across a site.

### How to run a bulk Lighthouse audit

1. Paste your URLs (or upload a text file of URLs) into **URLs to audit**. URLs without `https://` get it added, and duplicates are removed.
2. Pick the device (mobile, desktop or both) and the categories you need. Fewer categories make audits faster.
3. Click **Start**, then download the results as JSON, CSV or Excel, or fetch them via the API.

#### Example input

```json
{
  "urls": [{ "url": "https://example.com" }, { "url": "https://apify.com" }],
  "device": "both",
  "categories": ["performance", "accessibility", "best-practices", "seo"],
  "throttling": "simulate",
  "saveFullReport": true,
  "maxOpportunities": 5,
  "maxConcurrency": 1
}
```

All input options:

| Field | Default | What it does |
|---|---|---|
| `urls` | example.com, apify.com | Pages to audit (one audit per URL per device) |
| `device` | `mobile` | `mobile` (Moto G Power, slow 4G), `desktop` or `both` |
| `categories` | all four | `performance`, `accessibility`, `best-practices`, `seo` |
| `throttling` | `simulate` | `simulate` (Lighthouse default), `devtools` (applied throttling) or `none` |
| `saveFullReport` | `false` | Save full Lighthouse JSON + HTML reports and link them from each row |
| `maxOpportunities` | `5` | How many top fixes to list per URL (0–30) |
| `maxConcurrency` | `1` | Parallel audits (1–4). Use 1 per ~4 GB memory for stable scores |
| `timeoutSecs` | `120` | Per-audit timeout (20–300 s) |
| `maxRetries` | `1` | Retries per failed audit (0–3). Retries are never charged |

#### Example output

A real mobile audit of apify.com from a test run (opportunities and failed audits shortened):

```json
{
  "url": "https://apify.com/",
  "finalUrl": "https://apify.com/",
  "device": "mobile",
  "status": "succeeded",
  "scores": { "performance": 31, "accessibility": 100, "best-practices": 75, "seo": 85 },
  "metrics": { "lcpMs": 13371, "fcpMs": 2830, "cls": 0, "tbtMs": 28423, "siMs": 11305, "ttiMs": 42340 },
  "opportunities": [
    { "id": "unused-javascript", "title": "Reduce unused JavaScript", "displayValue": "Est savings of 1,362 KiB", "savingsMs": 1970, "savingsKb": 1361.6 },
    { "id": "duplicated-javascript", "title": "Remove duplicate modules in JavaScript bundles", "displayValue": "Est savings of 93 KiB", "savingsMs": 0, "savingsKb": 92.7 }
  ],
  "diagnostics": {
    "failedAuditCount": 25,
    "failedAudits": ["largest-contentful-paint", "speed-index", "total-blocking-time"],
    "totalByteWeightKb": 4857.2,
    "numRequests": 250,
    "numScripts": 111,
    "domSize": 1641,
    "serverResponseTimeMs": 82,
    "mainThreadWorkMs": 41286,
    "bootupTimeMs": 27303
  },
  "warnings": [],
  "lighthouseVersion": "12.8.2",
  "throttling": "simulate",
  "fetchTime": "2026-10-18T07:16:55.450Z",
  "durationMs": 43072,
  "reportJsonUrl": null,
  "reportHtmlUrl": null,
  "error": null
}
```

Failed URLs get `"status": "failed"` and an `error` object with a `code` (`INVALID_URL`, `NAVIGATION_FAILED`, `TIMEOUT`, …) and a `message`.

### Tips

- Lighthouse is CPU-sensitive. Keep `maxConcurrency` at 1 per ~4 GB of memory (Apify gives 1 CPU core per 4 GB). Less memory makes pages look slower (higher TBT).
- In our test runs one audit took about 10 seconds for a light page (example.com) and about 45 seconds for a heavy JavaScript page (apify.com). Raise the run timeout for long URL lists.
- Scores vary a few points between runs (in PageSpeed Insights too). Track trends, not single values.
- Use **Schedules** in Apify Console for daily or weekly monitoring, and **Integrations** (Slack, Google Sheets, webhooks) to get the results where you work.

### FAQ

**Is this the same as Google PageSpeed Insights?** It uses the same open-source Lighthouse engine and the same simulated throttling as PageSpeed Insights' lab data, but runs on Apify's servers, so absolute numbers can differ slightly. It does not include CrUX field data from real users.

**Do I need a Google API key?** No. Lighthouse runs inside the Actor, so there is no key and no PageSpeed Insights API quota.

**What am I charged for?** Only successful audits, at $0.03 each. Failed audits, invalid URLs and retries are free, and there is no start fee.

**Can I audit pages behind a login?** Not currently – only publicly reachable URLs.

**Can I get the full Lighthouse report?** Yes. Turn on `saveFullReport` and each row links to the full JSON and the shareable HTML report in the run's key-value store.

**Is it legal?** You audit public pages the way any browser loads them. Only audit sites you own or have a legitimate reason to test, and respect their terms. No personal data is collected.

**Something broke?** Open an issue on the Actor's Issues tab with the run ID.

# Changelog

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

# Actor input Schema

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

Pages to audit. One Lighthouse run per URL per device. URLs without a scheme get https:// added. Duplicates are removed.

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

Emulated form factor. 'both' runs (and bills) two audits per URL.

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

Lighthouse categories to score. Fewer categories = faster audits.

## `throttling` (type: `string`):

'simulate' (Lighthouse default, same as PageSpeed lab data, fast and stable), 'devtools' (applied throttling, slower, closer to real devices) or 'none' (raw cloud network speed).

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

Parallel audits. Lighthouse is CPU-heavy: use 1 per ~4 GB memory (4 GB = 1 CPU core) for stable scores.

## `saveFullReport` (type: `boolean`):

Store the complete Lighthouse JSON and the shareable HTML report in the key-value store and add links to each dataset row.

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

How many improvement opportunities (sorted by estimated savings) to include.

## `timeoutSecs` (type: `integer`):

Abort an audit that runs longer than this.

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

Retry a failed audit this many times. You are only charged for successful audits.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://example.com"
    },
    {
      "url": "https://apify.com"
    }
  ],
  "device": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "throttling": "simulate",
  "maxConcurrency": 1,
  "saveFullReport": false,
  "maxOpportunities": 5,
  "timeoutSecs": 120,
  "maxRetries": 1
}
```

# Actor output Schema

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

One item per URL and device: Lighthouse category scores, LCP/CLS/TBT/FCP/SI/TTI, top opportunities, diagnostics and error details.

## `opportunities` (type: `string`):

Improvement opportunities with estimated savings, one row per opportunity.

## `reports` (type: `string`):

Full Lighthouse JSON and shareable HTML reports (only when saveFullReport is enabled).

## `runSummary` (type: `string`):

Totals of succeeded and failed 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": [
        {
            "url": "https://example.com"
        },
        {
            "url": "https://apify.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jeanswiegers/lighthouse-bulk-speed-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": [
        { "url": "https://example.com" },
        { "url": "https://apify.com" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jeanswiegers/lighthouse-bulk-speed-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": [
    {
      "url": "https://example.com"
    },
    {
      "url": "https://apify.com"
    }
  ]
}' |
apify call jeanswiegers/lighthouse-bulk-speed-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jeanswiegers/lighthouse-bulk-speed-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/sFq9c0XvtkiDkM3WZ/builds/z80Bb9QbPBD06Ki1m/openapi.json