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

Run real Google Lighthouse audits (the PageSpeed Insights engine) on hundreds of URLs: performance, accessibility, best-practices and SEO scores, Core Web Vitals (LCP, CLS, TBT, FCP), top fixes and optional HTML reports. Mobile, desktop or both. No API key or quota.

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

## Pricing

from $8.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

## Lighthouse & PageSpeed Bulk Audit: Core Web Vitals, SEO & Accessibility Scores for Many URLs

Runs **real Google Lighthouse audits** (the engine behind PageSpeed Insights) on a list of URLs. You get every result in one table: scores, Core Web Vitals, the biggest fixes, and optionally the full interactive HTML report. You don't need a Google API key or a PageSpeed quota.

### What you can use it for

- **SEO and web agencies:** benchmark a client's whole site or their competitors in one run, then export to Sheets or Excel.
- **Monitoring:** schedule a weekly run and alert when performance drops (works with webhooks, Make, Zapier and n8n).
- **E-commerce:** audit every category and product template before and after a release.
- **Accessibility triage:** find the pages with the most failing accessibility audits.

### How to use it

1. Paste your URLs under **URLs** (whole sitemaps work fine).
2. Choose **mobile**, **desktop** or **both**, and the categories you need.
3. Optionally turn on **Save HTML report** for the full Lighthouse report per URL.
4. Click **Start** and sort the table by `scores.performance` or `metrics.lcpMs`.

### What you get for each URL

- **Scores (0–100):** performance, accessibility, best practices, SEO.
- **Lab metrics:** LCP, CLS, TBT, FCP, Speed Index, time to interactive, server response time (TTFB), total page weight, request count.
- **Top opportunities,** ranked by estimated savings, e.g. "Reduce unused JavaScript: 600 ms".
- **Failed audits** for accessibility, best practices and SEO, e.g. `image-alt`, `document-title`, `color-contrast`.
- **Optional full HTML report:** the same report Chrome DevTools produces, stored and linked from the results.
- **Device:** mobile (Lighthouse default throttling), desktop, or both.

### Input

```json
{ "urls": ["https://example.com", "https://example.com/pricing"], "formFactor": "both", "categories": ["performance", "seo"], "saveHtmlReport": true }
```

### Output (one item per URL and device; example values)

```json
{
  "input": "https://example.com/", "formFactor": "mobile", "finalUrl": "https://example.com/",
  "scores": {"performance": 100, "accessibility": 96, "best-practices": 100, "seo": 80},
  "metrics": {"fcpMs": 841, "lcpMs": 841, "tbtMs": 0, "cls": 0, "speedIndexMs": 841, "ttfbMs": 35, "totalBytes": 1250, "requests": 2},
  "opportunities": [{"id": "unused-javascript", "title": "Reduce unused JavaScript", "savingsMs": 600}],
  "failedAudits": {"seo": [{"id": "meta-description", "title": "Document does not have a meta description"}]},
  "htmlReportUrl": "https://api.apify.com/v2/key-value-stores/.../records/report-...",
  "lighthouseVersion": "12.8.2"
}
```

### Notes on accuracy

- These are **lab** measurements from a cloud machine, comparable to PageSpeed Insights lab data but not identical. Scores vary run to run, as with any Lighthouse run. Keep `maxConcurrency` at 1 for the most stable numbers.
- Real-user field data (CrUX) is not included.
- Only public pages are audited. Logins aren't supported, and requests to private or internal addresses are refused.

### Pricing

Pay per event, no monthly rent: **$0.008 per audit** (**$8.00 per 1,000**), plus $0.005 per run start.

| Example | Cost |
|---|---|
| 100 URLs on mobile | $0.805 |
| 1,000 URLs on mobile | $8.01 |
| 100 URLs on mobile + desktop (200 audits) | $1.60 |

Unreachable pages and invalid URLs are **not charged**.

You can set a **maximum cost per run** in the run options; the Actor stops cleanly when it is reached. New to Apify? The free plan includes $5 of platform credit every month, so you can try this Actor at no cost.

### API, integrations and AI agents (MCP)

Run it from your own code with the [Apify API](https://docs.apify.com/api/v2) and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/manageable_gully~lighthouse-bulk-audit/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" -d @input.json
```

```python
from apify_client import ApifyClient
run = ApifyClient("<YOUR_APIFY_TOKEN>").actor("manageable_gully/lighthouse-bulk-audit").call(run_input={...})
```

- **No-code:** use the Apify app in **n8n, Make or Zapier** ("Run Actor", then "Get dataset items"), or send results to Google Sheets, Slack or a webhook.
- **AI agents (MCP):** add `https://mcp.apify.com?tools=manageable_gully/lighthouse-bulk-audit` to Claude, Cursor, VS Code or any MCP client and the agent can call this Actor as a tool.
- **Schedules:** run it hourly, daily or weekly from Apify Console.

### FAQ

**Is this the same as PageSpeed Insights?** It runs the same Lighthouse engine that PageSpeed Insights uses for its lab data, without the PSI API quota. Field data from real Chrome users (CrUX) is not included.

**Do I need a Google API key?** No. Lighthouse runs inside the Actor in headless Chrome.

**Why do scores differ slightly between runs?** Lighthouse lab scores always vary a little. For the most stable numbers keep `maxConcurrency` at 1 and compare medians over a few runs.

**Can AI agents use it?** Yes. It is available as a tool through the Apify MCP server (`https://mcp.apify.com?tools=manageable_gully/lighthouse-bulk-audit`) and the Apify API, and it returns structured JSON that agents can read directly.

### More tools from WebIntel Tools

- [SEO Audit & Domain Checker](https://apify.com/manageable_gully/website-health-audit): SEO, DNS, SSL and security-header audit for lists of domains
- [Broken Link Checker](https://apify.com/manageable_gully/broken-link-checker): crawl a site and find every 404, broken image and bad redirect
- [Website Screenshot & URL to PDF](https://apify.com/manageable_gully/url-to-pdf-screenshot): full-page screenshots and PDFs of URLs or your own HTML
- [Website Tech Stack Detector](https://apify.com/manageable_gully/website-tech-detector): BuiltWith/Wappalyzer-style tech stack lookup in bulk

See [all WebIntel Tools Actors](https://apify.com/manageable_gully).

*Made by WebIntel Tools. This Actor was built and is maintained with AI assistance. Report issues on the Issues tab; they are monitored daily.*

# Actor input Schema

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

Pages to audit, one per line. Domains without a scheme get https://.

## `formFactor` (type: `string`):

'Both' runs and charges two audits per URL.

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

Fewer categories = faster runs.

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

Store the complete interactive Lighthouse report for each audit in the key-value store and link it from the results.

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

More instances = faster, but scores get noisier (CPU contention). Give the run about 2 GB of memory per instance.

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

Maximum time Lighthouse waits for a page to load before the audit fails.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://crawlee.dev"
  ],
  "formFactor": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "saveHtmlReport": false,
  "maxConcurrency": 1,
  "timeoutSecs": 90
}
```

# Actor output Schema

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

One item per URL and device: Lighthouse scores, LCP/CLS/TBT/FCP, top fixes and a link to the HTML report.

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

Full Lighthouse HTML reports (only when HTML reports are enabled).

# 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://crawlee.dev"
    ]
};

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

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

```

## MCP server setup

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