# Lighthouse Audit – PageSpeed & Core Web Vitals, No API Key (`gazidev/lighthouse-audit`) Actor

Run Google Lighthouse on any list of URLs without a PageSpeed Insights API key. Performance, accessibility, best practices and SEO scores, Core Web Vitals (LCP, CLS, TBT, FCP), top opportunities, mobile and desktop, optional HTML reports. $35 per 1,000 audits.

- **URL**: https://apify.com/gazidev/lighthouse-audit.md
- **Developed by:** [Cemal Atakli](https://apify.com/gazidev) (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 $20.00 / 1,000 page auditeds

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 Audit – Bulk PageSpeed & Core Web Vitals, No API Key

Run **Google Lighthouse** on any list of URLs and get **performance, accessibility, best practices and SEO scores**, **Core Web Vitals** (LCP, CLS, TBT, FCP, Speed Index, TTI) and the **top fixes** for every page, on **mobile and desktop**. It runs the open-source Lighthouse 13 engine in a real headless Chrome inside the Actor, so you **don't need a PageSpeed Insights API key** and Google's API quota doesn't apply. Paste URLs, click Start, and get one clean row per page. You can also save the full Lighthouse HTML report.

### What it does

- **Bulk Lighthouse audits:** one URL or thousands. Each audit runs in its own fresh Chrome (like the Lighthouse CLI), with a hard timeout and automatic retry when Chrome crashes.
- **No API key, no quota:** Lighthouse runs locally, so nothing goes through the PageSpeed Insights API.
- **Mobile, desktop or both:** mobile is a Moto G Power with slow 4G (what PageSpeed Insights shows first). Desktop is 1350×940 on a fast connection. `both` gives two rows per URL.
- **Scores 0–100** for performance, accessibility, best practices and SEO. Pick only the categories you need.
- **Core Web Vitals and lab metrics:** LCP, FCP, CLS, TBT, Speed Index and TTI, as numbers in ms.
- **Top 5 opportunities** from Lighthouse's insights and diagnostics, sorted by estimated savings: ms of LCP/FCP, ms of TBT, and bytes. Examples: "Reduce unused JavaScript – 908 KiB", "Render-blocking requests – 1,350 ms".
- **Failed audits:** a count per category, plus the titles of failing accessibility, best-practice and SEO checks (for example "Document does not have a meta description").
- **Full reports (optional):** the interactive Lighthouse **HTML report** and/or the complete **JSON** result, saved with a public link.
- **Throttling:** `simulated` (default, the same method PageSpeed Insights and the Lighthouse CLI use), `devtools` (applied throttling) or `none`.
- **Errors are free:** unresolvable domains, HTTP error pages, hung pages and timeouts become error rows that you are not charged for.

### Use cases

- **SEO and agency reporting:** audit all key pages of a client site every month and track the scores in a spreadsheet or dashboard.
- **Core Web Vitals monitoring:** schedule a daily run on your top landing pages and get alerted when LCP or CLS gets worse after a deploy.
- **Competitor benchmarking:** compare the performance, SEO and accessibility of 100 competitor homepages in one run.
- **Lead generation for web agencies:** find slow or inaccessible websites in a list of prospects and attach the HTML report to your pitch.
- **Accessibility checks:** get the failing axe-core checks (contrast, labels, alt text) for many pages at once.
- **CI / pre-release checks:** call the API after each staging deploy and fail the build when a score drops below your budget.

### Input example

```json
{
  "urls": ["https://apify.com", "https://example.com", "en.wikipedia.org/wiki/Web_performance"],
  "formFactor": "both",
  "categories": ["performance", "accessibility", "best-practices", "seo"],
  "throttling": "simulated",
  "saveHtmlReport": true,
  "saveJsonReport": false,
  "timeoutSecs": 120
}
```

Other options: `maxConcurrency` (1–3 parallel audits, default 1 for the most accurate scores), `maxRetries` (default 1, only for Chrome crashes and blank pages), and `maxUrls` (a cap for big lists). Bare domains get `https://` added, and duplicates are removed.

### Output example

```json
{
  "url": "https://github.com/",
  "finalUrl": "https://github.com/",
  "formFactor": "mobile",
  "scores": { "performance": 54, "accessibility": 100, "bestPractices": 96, "seo": 100 },
  "metrics": { "lcpMs": 11216, "fcpMs": 9866, "cls": 0.072, "tbtMs": 129, "speedIndexMs": 9866, "ttiMs": 16416 },
  "opportunities": [
    { "id": "unused-javascript", "title": "Reduce unused JavaScript", "displayValue": "Est savings of 908 KiB",
      "estimatedSavingsMs": 2400, "estimatedSavingsBytes": 930198, "tbtSavingsMs": 0, "score": 0 },
    { "id": "render-blocking-insight", "title": "Render-blocking requests", "displayValue": "Est savings of 1,350 ms",
      "estimatedSavingsMs": 1350, "estimatedSavingsBytes": 0, "tbtSavingsMs": 0, "score": 0 }
  ],
  "failedAudits": { "performance": 10, "accessibility": 0, "bestPractices": 1, "seo": 0 },
  "failedAccessibilityAudits": [],
  "failedBestPracticesAudits": ["Issues were logged in the `Issues` panel in Chrome Devtools"],
  "failedSeoAudits": [],
  "throttling": "simulated",
  "lighthouseVersion": "13.5.0",
  "chromeVersion": "154.0.0.0",
  "benchmarkIndex": 3856,
  "runWarnings": [],
  "fetchedAt": "2026-10-11T11:51:26.010Z",
  "reportUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/00004-github-com-mobile.html",
  "jsonReportUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/00004-github-com-mobile.json",
  "durationMs": 17536,
  "status": "ok",
  "error": null
}
```

The Output tab has three views: **Scores & Core Web Vitals** (one table row per URL and device), **Opportunities & failed audits**, and **Errors**. `OUTPUT` in the key-value store holds a run summary. See [SAMPLE_OUTPUT.json](SAMPLE_OUTPUT.json) for full rows, including error rows.

### Pricing

Pay per event: **$0.02 per completed audit** (one URL on one device), plus $0.00005 per run start. That is **$20 per 1,000 audits**. The price is the same whether you run 1 or 4 categories, and with or without the HTML/JSON reports. Failed audits, invalid URLs and retries are **free**. The Actor respects your *Maximum cost per run*: it never starts an audit it could not pay for, and it stops cleanly when the limit is reached.

| Actor | Price | How it works |
|---|---|---|
| **Lighthouse Audit (this)** | **$0.02 / audit**, $0.00005 / start | Lighthouse 13 in local Chrome, no API key. Mobile + desktop, 4 categories, CWV metrics, top-5 opportunities, failed-audit lists, HTML + JSON reports, errors free |
| dev00/Google-PageSpeed-Insights-api | $0.002 / query | Uses the PageSpeed Insights API |
| constant_quadr/lighthouse-auditor | Free Actor, you pay platform usage | |
| perryay/website-performance-auditor | $0.025 / audit | |
| nexgendata/page-speed-analyzer | $0.10 / audit | |
| alizarin_refri/google-lighthouse-checker | $0.08 / audit | |

*Competitor prices from the Apify Store, October 2026. Check their pages for current terms.*

### FAQ

**Why are my scores different from PageSpeed Insights?** PageSpeed Insights runs the same Lighthouse engine, but on Google's machines and from Google's network location. Lab scores always vary a few points between runs and machines, especially for performance. This Actor uses the same simulated throttling and device settings as PSI, so the results are directly comparable to each other. For trend tracking, always use the same settings and memory. PSI's "field data" (CrUX, real users) isn't included, because that comes from Google's API.

**Which memory should I use?** The default 4096 MB gives Lighthouse one full CPU core, which gives the most stable performance scores. 2048 MB works and is a bit cheaper on compute, but audits are slower and performance scores are noisier. Use 8192 MB with `maxConcurrency: 2` to audit big lists faster.

**How long does one audit take?** About 8–15 seconds for a typical page and 20–35 seconds for very heavy news or e-commerce homepages. A list of 100 URLs on mobile takes about 20–30 minutes at concurrency 1.

**Some sites return an error or a 403 page.** A few sites block headless browsers or datacenter IPs. If Chrome only gets an error page, you get a free error row (for example `CHROME_INTERSTITIAL_ERROR` or `ERRORED_DOCUMENT_REQUEST`). If the site serves a bot-check page with status 200, Lighthouse audits that page.

**Can I audit pages behind a login or on localhost?** No. Only publicly reachable URLs are supported.

**Where are the HTML reports and how long are they kept?** In the run's default key-value store. Every row has a direct `reportUrl` that opens the full interactive Lighthouse report in the browser. Retention follows your Apify plan's storage settings. Turn on `saveJsonReport` if you need every audit's raw details (for example to load them into the Lighthouse Viewer).

**Is it legal?** Lighthouse loads a page once, like a single browser visit. Only audit sites you are allowed to test, and keep the list reasonable for small sites.

### Use with AI agents / Apify MCP

- **Apify MCP server:** add the Actor to Claude Desktop, Cursor or VS Code with `https://mcp.apify.com?actors=gazidev/lighthouse-audit`. An agent can call it with `{"urls":["https://mysite.com"],"formFactor":"both"}` and get back scores, Core Web Vitals and the top fixes as compact JSON, which is small enough to reason over, unlike the raw Lighthouse report.
- **API (synchronous):** `POST https://api.apify.com/v2/acts/gazidev~lighthouse-audit/run-sync-get-dataset-items?token=...` with the input JSON returns the rows in one call (about 10–20 s per URL).
- **Scheduled monitoring:** save your URLs as a Task, schedule it daily or weekly, and send the dataset to Google Sheets, Slack or a webhook with Apify integrations.

### More from the website toolkit

- [SEO Audit Crawler](https://apify.com/gazidev/seo-audit-crawler): broken links, meta tags, redirects and on-page SEO issues across a whole site.
- [Website Screenshot API](https://apify.com/gazidev/website-screenshot): bulk full-page screenshots and PDFs.
- [Tech Stack Detector](https://apify.com/gazidev/tech-stack-detector): find out which CMS, frameworks and tools a website uses.

Lighthouse is an open-source project by Google (Apache-2.0). This Actor isn't affiliated with or endorsed by Google.

# Actor input Schema

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

Pages to run Google Lighthouse on. Full URLs or bare domains (https:// is added). Duplicates are removed. Each URL × device is one audit.

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

Mobile = Moto G Power emulation with slow 4G throttling (what PageSpeed Insights shows first). Desktop = 1350×940 desktop with fast connection. Both = two audits per URL.

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

Lighthouse categories to run. Fewer categories = slightly faster audits. The price per audit is the same.

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

Simulated (default, same method as PageSpeed Insights and Lighthouse CLI): the page loads at full speed and slow network/CPU is simulated - fastest and most stable. DevTools: real network/CPU throttling applied in Chrome (slower, more variable). None: no throttling, raw speed of the server.

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

Save the full interactive Lighthouse HTML report of every audit to the key-value store and add its public link as reportUrl.

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

Save the complete Lighthouse JSON result (LHR, all audits and details, 0.5–3 MB) to the key-value store and add its link as jsonReportUrl.

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

Hard limit for one audit, including page load and analysis. Pages that do not finish become a free error row.

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

Audits that run at the same time. Lighthouse is CPU-heavy: 1 gives the most accurate performance scores. Use 2–3 only with 8192 MB+ memory for speed on big lists.

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

Extra tries when Chrome crashes or the page paints nothing (NO_FCP, protocol timeout). DNS errors, HTTP errors and timeouts are not retried.

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

Audit only the first N URLs (0 = no limit). Useful to cap costs on big lists.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://example.com"
  ],
  "formFactor": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "throttling": "simulated",
  "saveHtmlReport": false,
  "saveJsonReport": false,
  "timeoutSecs": 120,
  "maxConcurrency": 1,
  "maxRetries": 1,
  "maxUrls": 0
}
```

# Actor output Schema

## `scores` (type: `string`):

No description

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

No description

## `errors` (type: `string`):

No description

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

No description

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

No description

## `results` (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://apify.com",
        "https://example.com"
    ],
    "formFactor": "mobile",
    "categories": [
        "performance",
        "accessibility",
        "best-practices",
        "seo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gazidev/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://example.com",
    ],
    "formFactor": "mobile",
    "categories": [
        "performance",
        "accessibility",
        "best-practices",
        "seo",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("gazidev/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://example.com"
  ],
  "formFactor": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ]
}' |
apify call gazidev/lighthouse-audit --silent --output-dataset

```

## MCP server setup

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