# Bulk Lighthouse Audit: Core Web Vitals & SEO (`hpbt/bulk-lighthouse-audit`) Actor

Run Lighthouse on any list of URLs, mobile and desktop: performance, Core Web Vitals, accessibility, best practices, SEO and the new Agentic Browsing score, with a shareable HTML report per page. No API key needed. Failed URLs are free.

- **URL**: https://apify.com/hpbt/bulk-lighthouse-audit.md
- **Developed by:** [Tran Nam](https://apify.com/hpbt) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 lighthouse 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 Lighthouse Audit: Core Web Vitals & SEO

Run **Lighthouse** on hundreds of URLs at once, on **mobile and desktop**. For every page you get the Performance, Accessibility, Best Practices, SEO and new **Agentic Browsing** scores, the **Core Web Vitals** lab metrics, the list of checks the page fails and a **shareable HTML report**. No API key needed, and **failed URLs are free**.

### What it does

- 🚦 **Five scores from 0 to 100**: Performance, Accessibility, Best Practices, SEO and Agentic Browsing.
- ⏱️ **Core Web Vitals lab metrics**: Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), Total Blocking Time (TBT), First Contentful Paint (FCP), Speed Index and server response time. Each one is rated good, needs improvement or poor, with the same colors as the Lighthouse report.
- 🧾 **A to-do list per page**: the SEO, accessibility, best-practice and AI-agent checks the page fails, and the top performance opportunities with their estimated time savings.
- 📄 **The full HTML report** of every page, the same report as in Chrome DevTools, ready to send to a client. You also get a screenshot, and the raw JSON report if you want it.
- 🤖 **Agentic Browsing**: the category added in Lighthouse 13. It checks how well AI agents can read and use the page: the accessibility tree, llms.txt and WebMCP.
- 📱 **Mobile and desktop** in one run.
- 🎯 **Steady scores**:
  - Every audit runs in a fresh Chrome with two CPU cores of its own, so the scores come out close to those of Lighthouse on a normal computer.
  - Set **Runs per page** to 3 or 5 to keep the median run, as Lighthouse CI does.
- 🌍 **Reports in 44 languages**, from English and Spanish to Japanese and Vietnamese.
- 🧪 **Block third parties**, such as analytics, ads or chat, to see how fast the page is without them.
- ✅ **Plain-English errors, for free**: a page can fail because it does not load, answers with an error, shows a bot check or stays blank. You get one-line reasons such as `"The server answered with HTTP 404."`, and such pages cost nothing.

### How to use it

1. Paste your URLs (one per line; `example.com` works too).
2. Choose **Mobile**, **Desktop** or both.
3. Click **Start**. Each page shows up in the **Output** tab with its scores. `reportUrl` opens its Lighthouse report.

### Pricing

**$20 per 1,000 audits** ($0.02 per page and device), with pay-per-event pricing.

- One audit is one Lighthouse run of one URL on one device. For example, 100 pages on mobile and desktop are 200 audits and cost $4.
- With **Runs per page** set to 3, each page and device counts as 3 audits.
- You pay only for pages that were audited. A failed URL costs nothing.
- A tiny start fee is charged per run, about $0.0004 with the default 8 GB of memory.
- Set a **maximum cost per run** in the run options, and the Actor stops when it reaches it.

### Input example

```json
{
    "urls": ["https://apify.com", "example.com/pricing"],
    "devices": ["mobile", "desktop"],
    "categories": ["performance", "accessibility", "best-practices", "seo", "agentic-browsing"],
    "runsPerUrl": 1,
    "reportLanguage": "en-US"
}
```

All other settings are optional. See the **Input** tab for the full list.

### Output example

One dataset row per URL and device (shortened):

```json
{
    "url": "https://apify.com/",
    "finalUrl": "https://apify.com/",
    "device": "mobile",
    "status": "success",
    "performance": 59,
    "accessibility": 100,
    "bestPractices": 73,
    "seo": 85,
    "agenticBrowsing": 98,
    "fcpMs": 2320,
    "fcpRating": "needs-improvement",
    "lcpMs": 3033,
    "lcpRating": "needs-improvement",
    "tbtMs": 3459,
    "tbtRating": "poor",
    "cls": 0.001,
    "clsRating": "good",
    "speedIndexMs": 4895,
    "speedIndexRating": "needs-improvement",
    "ttfbMs": 89,
    "reportUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/apify-com-mobile-1a2b3c4d-report.html",
    "screenshotUrl": "https://api.apify.com/v2/key-value-stores/STORE_ID/records/apify-com-mobile-1a2b3c4d-screenshot.jpg",
    "jsonReportUrl": null,
    "opportunities": [
        { "id": "bootup-time", "title": "Reduce JavaScript execution time", "displayValue": "7.6 s", "savingsMs": 3800 }
    ],
    "failedAudits": [
        { "category": "best-practices", "id": "third-party-cookies", "title": "Uses third-party cookies" }
    ],
    "runs": 1,
    "warnings": [],
    "lighthouseVersion": "13.5.0",
    "benchmarkIndex": 2605,
    "durationSecs": 22.2,
    "auditedAt": "2026-10-28T03:13:48.486Z",
    "error": null
}
```

A failed URL has `"status": "failed"`, empty scores and a reason in `error`, such as `"The page did not show any content."` The Output tab has two views: **Scores** and **Core Web Vitals**.

### Why are my scores different from PageSpeed Insights?

- **Lab scores depend on the machine and network that run the test.** PageSpeed Insights runs Lighthouse on Google's own servers. This Actor runs Lighthouse with its default settings, on two dedicated CPU cores per audit. Expect a few points of difference, and more on heavy pages full of JavaScript.
- **Scores vary from run to run**, wherever Lighthouse runs. For steadier numbers, set **Runs per page** to 3 and the Actor keeps the median run.
- **PageSpeed Insights also shows field data**, the speed real Chrome users saw over 28 days. This Actor measures lab data only.

`benchmarkIndex` in the output tells how fast the CPU was during the audit.

### Use it from your code or an AI agent

Run the Actor and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/Hpbt~bulk-lighthouse-audit/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com"], "devices": ["mobile"]}'
```

- **JavaScript or Python**: use the Apify client (see the **API** tab for ready-made code).
- **AI agents**: the Actor works through the Apify MCP server.
- **No-code**: connect it to Zapier, Make, n8n, Google Sheets or Slack through Apify integrations.

### Tips

- **Monitor your sites:** schedule a weekly run in Apify and send the dataset to Google Sheets or Slack to see when a score drops.
- **Client reports:** send `reportUrl`. The report opens in any browser and needs no Apify account.
- **What do third parties cost?** Run the page twice, the second time with **Block these requests** set to `*google-analytics.com*`, `*googletagmanager.com*` or `*doubleclick.net*`, and compare.
- **More pages at once:** the default 8 GB of memory audits one page at a time. 16 GB audits 2 pages at once, and 32 GB audits 4.

### Limitations

- No logging in, no CAPTCHA solving and no bot-protection bypass. Pages that answer with a bot check are reported as failed, and they are free.
- Local and private network addresses (localhost, 10.x, 192.168.x…) are blocked.
- Lab data only. There is no field data from real users (Chrome UX Report).
- Proxies are not used, because a proxy would make every page look slower than it is.

### FAQ

**Which Lighthouse version does it use?**
Lighthouse 13.5 with the Chrome in Apify's image. `lighthouseVersion` in every row tells the version.

**Is this an official Google tool?**
No. Lighthouse is Google Chrome's open-source auditing tool (Apache 2.0 license). This Actor runs it for you at scale and is not affiliated with Google.

**How long are the reports kept?**
As long as your Apify plan keeps run storage. Download them or send them on with an integration if you need them longer.

**Something looks wrong?**
Open an issue in the **Issues** tab with the URL and the input you used.

# Changelog

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

# Actor input Schema

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

Pages to audit, one per line. "example.com" works too, https:// is added for you.

## `devices` (type: `array`):

Each URL is audited once per device. Mobile emulates a mid-range phone on a slow 4G connection, as Lighthouse does by default.

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

What Lighthouse checks. Agentic Browsing tells how well AI agents can read and use the page (accessibility tree, llms.txt, WebMCP).

## `runsPerUrl` (type: `integer`):

Performance scores vary a little from run to run. With 3 or 5 runs, the Actor keeps the median run, as Lighthouse CI does. Each run counts as one audit.

## `reportLanguage` (type: `string`):

Language of the HTML report and of the check titles in the results.

## `saveHtmlReport` (type: `boolean`):

The full Lighthouse report of every page, as in Chrome DevTools, ready to send to a client. reportUrl in the results opens it.

## `saveJsonReport` (type: `boolean`):

The complete Lighthouse result of every page (1–3 MB each), for your own processing.

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

Simulated is fast and matches the default of Lighthouse and PageSpeed Insights. Applied really slows the connection down: slower, but closer to a real slow phone. None measures the page at full speed.

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

How long a page may take to load. A slower page is measured as far as it got; a server that does not answer in this time is reported as failed, for free.

## `blockedUrlPatterns` (type: `array`):

URL patterns the page may not load, to see how fast it is without them. \* matches anything, for example *google-analytics.com* or *.doubleclick.net/*

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://www.wikipedia.org"
  ],
  "devices": [
    "mobile"
  ],
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo",
    "agentic-browsing"
  ],
  "runsPerUrl": 1,
  "reportLanguage": "en-US",
  "saveHtmlReport": true,
  "saveJsonReport": false,
  "throttling": "simulate",
  "timeoutSecs": 30
}
```

# Actor output Schema

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

Results table. status is success or failed (failed URLs are free). reportUrl opens the HTML report of each page.

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

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

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

```

## MCP server setup

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