# Lighthouse & Core Web Vitals Bulk Auditor – PageSpeed Scores (`ausbizstack/lighthouse-core-web-vitals-bulk-auditor`) Actor

Bulk Google Lighthouse audit for domains or URLs: performance, accessibility, best-practices and SEO scores, Core Web Vitals (LCP, CLS, TBT), ranked fixes, page weight, mobile + desktop, score monitoring. Failed pages free.

- **URL**: https://apify.com/ausbizstack/lighthouse-core-web-vitals-bulk-auditor.md
- **Developed by:** [AusBizStack Intelligence](https://apify.com/ausbizstack) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 page audited with lighthouses

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Lighthouse & Core Web Vitals Bulk Auditor

Run **real Google Lighthouse 13 audits** on a list of domains or page URLs and get one clean row per page and device:

- **Performance, accessibility, best-practices and SEO scores** (0-100) plus an overall score and A-F performance grade
- **Core Web Vitals (lab)**: LCP, CLS, TBT (the lab stand-in for INP), FCP, Speed Index, TTI and TTFB, each rated *good / needs-improvement / poor* against Google's thresholds, with a pass/fail
- **Ranked fixes**: performance opportunities sorted by estimated time saved (ms / KiB), then failing accessibility, SEO and best-practice checks, each with a plain-English **how to fix** and the official docs link
- **Page weight**: total KiB, requests, KiB by type, **third-party share** and the heaviest third parties (chat widgets, pixels, tag managers)
- **LCP element**: which element is the Largest Contentful Paint and where its time goes (TTFB, load delay, render delay)
- **Mobile, desktop or both** in one run
- **Multi-page sampling**: add key pages from the sitemap (or homepage links), one per section
- **Free full HTML Lighthouse reports** (the same report Chrome DevTools shows), one link per row
- **Score monitoring**: schedule it with a monitor name and every row shows the change since last run and a regression flag
- **Optional real-user data**: add your own free PageSpeed Insights API key to get Chrome UX Report field data (LCP, INP, CLS at p75 and the official Core Web Vitals pass/fail)
- Run-level **summary, HTML report and CSV** in the key-value store

No API key needed. Failed pages are never charged.

### Who it is for

- **SEO and web agencies**: audit every client site or a prospect list in one run and attach the HTML report to a proposal
- **Site owners and developers**: find out which templates are slow and what to fix first
- **Lead generation**: find businesses with slow, failing sites (sort by performance score) and pitch the fix
- **Monitoring**: schedule weekly runs and get a regression flag when a deploy slows a page down

### Input

| Field | What it does |
|---|---|
| `urls` | Domains (audit the homepage) or full page URLs. Duplicates and invalid lines get a free row. |
| `strategy` | `mobile` (default, what PageSpeed Insights shows first), `desktop` or `both` |
| `maxPagesPerDomain` | 1-10. Above 1 adds pages from the sitemap / homepage links |
| `saveHtmlReports` | Store the full Lighthouse HTML report per page (free) |
| `monitorName` | Compare with the previous run under the same name |
| `alertOnScoreDrop` | Points drop that counts as a regression (default 5) |
| `pageSpeedApiKey` | Optional. Your own Google API key: runs via PageSpeed Insights and adds real-user field data |

```json
{ "urls": ["example.com", "https://www.example.org/pricing"], "strategy": "both", "maxPagesPerDomain": 3, "saveHtmlReports": true }
```

### Output (one row per page and device)

```json
{
  "url": "https://example.com/", "strategy": "mobile", "status": "ok", "charged": true,
  "performance": 100, "accessibility": 96, "bestPractices": 100, "seo": 80, "overallScore": 94, "performanceGrade": "A",
  "coreWebVitals": { "lcpMs": 835, "cls": 0, "tbtMs": 6, "fcpMs": 835, "speedIndexMs": 835, "ttfbMs": 13,
    "ratings": { "lcp": "good", "cls": "good", "tbt": "good", "fcp": "good" }, "passesLab": true },
  "topFixes": [ { "rank": 1, "priority": "medium", "category": "accessibility", "title": "Document does not have a main landmark.", "howToFix": "...", "docsUrl": "..." } ],
  "pageWeight": { "totalKiB": 2, "requests": 2, "thirdPartyShare": 0 },
  "lcpElement": { "selector": "body > p", "breakdown": [ { "phase": "Time to first byte", "ms": 38 } ] },
  "lighthouseVersion": "13.6.0"
}
```

Views: **Scores and Core Web Vitals** and **Ranked fixes**. Key-value store: `OUTPUT` (summary), `REPORT_HTML`, `REPORT_CSV`, and `report-*` full Lighthouse reports.

### Pricing

Pay per event, no subscription:

- **$0.012 per page audit** (one page on one device) with Lighthouse in Chrome on Apify. Bronze $0.011, Silver $0.010, Gold $0.009.
- **$0.002 per page audit** when you bring your own PageSpeed Insights API key.
- HTML reports, monitoring, summary and CSV are included.
- Invalid, duplicate, unreachable, blocked, timed-out and error pages are **free**.

100 pages on mobile + desktop = 200 audits = $2.40 (or $0.40 with your own API key).

### Accuracy notes

- Mobile uses Lighthouse's default Moto G Power emulation with simulated throttling, the same method PageSpeed Insights uses. Scores move a few points between runs on any machine; use `alertOnScoreDrop` of 5+ for monitoring.
- Parallel audits on one machine skew scores, so the Actor runs one audit per 4 GB of memory (1 CPU, max 4). Give it more memory to go faster.
- Lab data is not field data. For real-user Core Web Vitals, add a PageSpeed API key.

### Safety

The audited page runs in a sandboxed headless Chrome whose **every request goes through a filtering proxy**: private, loopback, link-local, cloud-metadata and internal addresses are refused at DNS and connect time (DNS-rebinding safe), only ports 80/443 are allowed, and each page has a download cap. Each row reports how many requests were blocked.

### FAQ

**Is this the real Lighthouse?** Yes. The official `lighthouse` npm package (v13) in Google Chrome, the same engine as PageSpeed Insights and Chrome DevTools.

**Do I need an API key?** No. The key is optional and only adds real-user field data.

**Can I use it from Make, Zapier, n8n or an AI agent?** Yes, like any Apify Actor (API, integrations, MCP).

Built by AusBizStack.

# Actor input Schema

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

One per line. A bare domain (acme.com) audits the homepage; a full URL (https://acme.com/pricing) audits that page. Case, www and trailing slashes are normalised and duplicates removed. Public websites only (ports 80/443): IP addresses, localhost and internal names are refused. Invalid and duplicate lines get a free row.

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

Mobile uses Lighthouse's default Moto G Power emulation with simulated slow 4G (what PageSpeed Insights shows first). Desktop uses Lighthouse's desktop preset. 'Both' gives one row per device (each row is one audit).

## `maxPagesPerDomain` (type: `integer`):

1 = only the page you entered. 2-10 adds key pages from the site's sitemap (or homepage links when there is no sitemap), one per section, so you see template-level problems. Applies to bare domains / homepages only.

## `saveHtmlReports` (type: `boolean`):

Stores the complete interactive Lighthouse report (the same one Chrome DevTools shows) in the run's key-value store and adds its link to the row. Free. Up to 100 reports per run.

## `maxFixes` (type: `integer`):

How many ranked fixes to return per page (performance opportunities by estimated time saved, then failing accessibility, SEO and best-practice checks).

## `monitorName` (type: `string`):

Give a name (e.g. client-sites) and schedule the Actor. Each run compares every page with its previous run under the same name and adds score / LCP / CLS / TBT changes plus a regression flag. Previous scores are kept in a key-value store named 'lighthouse-monitor' on your own account.

## `alertOnScoreDrop` (type: `integer`):

Points (0-100 scale). Lighthouse scores naturally move a few points between runs, so 5+ is recommended.

## `pageSpeedApiKey` (type: `string`):

Paste your own free Google API key to run the audits through the PageSpeed Insights API instead. Adds real-user Chrome UX Report field data (LCP, INP, CLS, FCP, TTFB at the 75th percentile and the official Core Web Vitals pass/fail) and is billed at the lower API rate. Leave empty to run Lighthouse in Chrome on Apify.

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

Lighthouse is CPU-heavy, so parallel audits on the same machine skew scores. By default the Actor runs one audit per 4 GB of memory (Apify gives 1 CPU per 4 GB, max 4 audits). With an API key up to 8 run in parallel.

## `auditTimeoutSecs` (type: `integer`):

Pages that take longer are stopped and get a free timeout row. Default 75 s (120 s on runs under 4 GB).

## `reportTitle` (type: `string`):

Heading of the HTML report (e.g. your agency or client name).

## Actor input object example

```json
{
  "urls": [
    "example.com"
  ],
  "strategy": "mobile",
  "maxPagesPerDomain": 1,
  "saveHtmlReports": false,
  "maxFixes": 8,
  "alertOnScoreDrop": 5
}
```

# Actor output Schema

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

No description

## `fixes` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `reportHtml` (type: `string`):

No description

## `reportCsv` (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": [
        "example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ausbizstack/lighthouse-core-web-vitals-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": ["example.com"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ausbizstack/lighthouse-core-web-vitals-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/uQ6glFNabXeheYyPk/builds/FDpfjp4cPSk2OaGqw/openapi.json
