# Lighthouse Audit API (`conserving_celerytop/lighthouse-audit-api`) Actor

Run a Lighthouse audit on public URLs and get one JSON row per URL and device: performance, accessibility, best practices and SEO scores, Core Web Vitals (LCP, CLS, TBT), page weight and the top speed fixes. Mobile or desktop.

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

## Pricing

from $10.50 / 1,000 url audits

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

Use this lighthouse audit API to run Google Lighthouse on public web pages and get one clean JSON row per URL with performance, accessibility, best practices and SEO scores, Core Web Vitals and the top fixes, for $15.00 per 1,000 audits.

Paste a list of page addresses, choose mobile, desktop or both, and start the run. Each URL is opened in a real Chrome browser and tested with Lighthouse. You get flat rows you can sort in a table, send to a spreadsheet or compare from one run to the next. You need no Google API key and no login. The Actor runs Lighthouse itself, so there is no quota to hit.

### Sample output

One row per URL and device. This is a real row from a run on 4 October 2026. The page was a small test page served on the test machine, so your values will differ:

```json
{
  "inputUrl": "http://127.0.0.1:8780/",
  "url": "http://127.0.0.1:8780/",
  "strategy": "mobile",
  "status": "ok",
  "performanceScore": 73,
  "accessibilityScore": 80,
  "bestPracticesScore": 96,
  "seoScore": 82,
  "fcpMs": 1179,
  "lcpMs": 15185,
  "lcpRating": "poor",
  "cls": 0,
  "clsRating": "good",
  "tbtMs": 0,
  "tbtRating": "good",
  "speedIndexMs": 2231,
  "serverResponseTimeMs": 18,
  "totalByteWeight": 2883193,
  "requestCount": 5,
  "opportunities": [
    { "id": "image-delivery-insight", "title": "Improve image delivery", "savingsMs": 13950, "savingsBytes": null, "summary": "Est savings of 2,784 KiB" },
    { "id": "render-blocking-insight", "title": "Render-blocking requests", "savingsMs": 400, "savingsBytes": null, "summary": "Est savings of 420 ms" }
  ],
  "lighthouseVersion": "13.5.0",
  "auditedAt": "2026-10-04T18:15:02.218Z"
}
```

### How to run a lighthouse audit with this Actor

1. Click **Try for free**. No API key is needed.
2. In **URLs to audit**, enter one public page address per line. A missing https:// is added for you.
3. Choose **Device**: mobile (the default), desktop, or both.
4. Click **Start**, open the **Overview** view, and export as JSON, CSV or Excel.

Typical uses:

- SEO and web teams check the Core Web Vitals of the key pages of a site every week.
- Agencies audit a client's pages before and after a release and keep the rows for the report.
- Developers add a performance check to a pipeline and fail a build when a score drops.
- AI agents ask for the scores of a URL and get a flat answer instead of the full Lighthouse report, which runs to hundreds of kilobytes.

### What you get

| Group | Fields |
|---|---|
| Page | inputUrl, url (after redirects), strategy (mobile or desktop), status |
| Scores | performanceScore, accessibilityScore, bestPracticesScore, seoScore (0 to 100) |
| Core Web Vitals | lcpMs and lcpRating, cls and clsRating, tbtMs and tbtRating |
| Speed details | fcpMs, speedIndexMs, serverResponseTimeMs, totalByteWeight, requestCount |
| Top fixes | opportunities: up to 10 fixes ranked by estimated time saved, with title, savingsMs, savingsBytes and a short summary |
| Run details | lighthouseVersion, auditedAt, runWarnings, htmlReportUrl (only when you ask for the full report) |
| Errors | errorCode and errorMessage when a page could not be scored |

The ratings use the usual Web Vitals limits: LCP good up to 2.5 s and poor over 4 s, CLS good up to 0.1 and poor over 0.25, TBT good up to 200 ms and poor over 600 ms. Total Blocking Time stands in for responsiveness, because Lighthouse tests in a lab and cannot measure real user interaction.

### Pricing

You pay per scored audit, plus a start fee of $0.00005 for each run. One audit is one URL on one device that returned scores.

- Free plan: $0.015 per audit, which is $15.00 per 1,000.
- Bronze, Silver and Gold plans pay 10, 20 and 30 percent less per audit.
- You are charged only when Lighthouse produced scores. Every `error` row is free. This covers a malformed address, a private or local address, a host name that does not exist, a 404 or other error page, a file that is not HTML, a page that does not finish loading, a security warning, a redirect to a private address, and an audit that failed on our side after one retry.
- Set a maximum cost per run in the run options. The Actor stops when it is reached and keeps what it saved.

Worked example: 100 URLs on mobile and desktop are 200 audits. If all of them are scored, that costs 200 x $0.015 = $3.00, plus $0.00005 for the start. If 10 of the 200 return an error row, you pay for 190.

### Input example

```json
{
  "urls": ["https://example.com/", "https://example.com/pricing"],
  "strategy": "both",
  "maxOpportunities": 5,
  "saveHtmlReport": false
}
```

Settings you can change: **Top fixes per audit** (0 to 10), **Save full HTML report** (adds a link to the complete Lighthouse report in each row), **Parallel audits** (1 to 4, default 2) and **Page timeout** (20 to 180 seconds, default 60).

### Error row example

```json
{
  "inputUrl": "https://example.com/missing-page",
  "url": null,
  "strategy": "mobile",
  "status": "error",
  "errorCode": "ERRORED_DOCUMENT_REQUEST",
  "errorMessage": "The page answered with an error status (for example 404 or 500), so no score could be calculated.",
  "performanceScore": null,
  "opportunities": []
}
```

### FAQ

#### Is it legal to audit a page?

The Actor opens only the public addresses you list, once per audit, like a visitor with a browser. It does not log in, follow links or collect personal data, and it refuses private and local network addresses, including IPv6 forms of them, and drops a result if the page redirects to one. The address is checked before Chrome loads it and again after redirects, so a host that changes its DNS answer between the two steps is a residual risk. Lighthouse is open-source software under the Apache 2.0 license. Audit pages you own or have permission to test, and check that your use follows the rules of the sites you test.

#### Why did the same page score differently on two runs?

Lighthouse is a lab test. Network timing and machine load move the numbers a little. In our tests the same page scored 73 once and 75 another time. Compare scores from the same device and the same settings, and repeat an audit before you act on a small change.

#### How is this different from PageSpeed Insights?

PageSpeed Insights runs Lighthouse on Google servers and adds field data from real Chrome users. This Actor runs Lighthouse itself and returns lab data only. In return you need no API key, there is no quota, and the rows are flat.

#### Can it audit pages behind a login?

No. Only public pages are supported. A page that redirects to a sign-in form is scored as the sign-in form.

#### Are error rows charged?

No. A URL that cannot be scored returns an `error` row with a code and a plain message, and it costs nothing. The start fee of $0.00005 still applies to the run.

#### What does the device setting change?

Mobile uses the standard Lighthouse phone profile with a slow 4G connection and a slowed CPU. Desktop uses a wide screen and a fast connection. Mobile scores are usually lower.

#### How many URLs can I audit in one run?

Up to 500 URLs per run. With both devices that is up to 1,000 audits. Larger lists can be split over several runs.

#### How long does a run take?

Each audit loads the page in a real browser, so it takes tens of seconds, not milliseconds. Two audits run at the same time by default, and the Actor lowers that number when the run has less memory.

#### What if a run stops in the middle?

The Actor saves each row as soon as it is done. If the run is moved to another server it continues with the URLs that were not finished and does not charge twice.

### Related Actors

Other website and SEO tools by the same author are listed on the author's profile.

### About this Actor

I built this Actor as an independent developer. It is not affiliated with, endorsed by or approved by Google. Lighthouse is an open-source project under the Apache 2.0 license.

# Actor input Schema

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

Enter one public page address per line, for example https://example.com/pricing. A missing https:// is added. Each URL is audited once per device, so 10 URLs on both devices are 20 audits.

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

Choose the device to test. Mobile uses the standard Lighthouse phone profile with slow 4G throttling. Both returns two rows per URL.

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

Return up to this many of the largest speed fixes for each page, ranked by estimated time saved. Enter 0 to leave them out.

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

Save the full Lighthouse HTML report for each audit in the run storage and add its link to the row. Turn on to open the report in a browser.

## `concurrency` (type: `integer`):

Run this many audits at the same time. Each one uses about 1.5 GB of memory, so the Actor lowers this number when the run has less memory. Scores can differ a little when many audits share one machine.

## `pageTimeoutSeconds` (type: `integer`):

Wait up to this many seconds for a page to finish loading before the audit is stopped and an error row is returned.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://www.wikipedia.org"
  ],
  "strategy": "mobile",
  "maxOpportunities": 5,
  "saveHtmlReport": false,
  "concurrency": 2,
  "pageTimeoutSeconds": 60
}
```

# Actor output Schema

## `audits` (type: `string`):

No description

## `stats` (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://example.com",
        "https://www.wikipedia.org"
    ],
    "strategy": "mobile",
    "maxOpportunities": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("conserving_celerytop/lighthouse-audit-api").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://example.com",
        "https://www.wikipedia.org",
    ],
    "strategy": "mobile",
    "maxOpportunities": 5,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,conserving_celerytop/lighthouse-audit-api"
        }
    }
}
```

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/vhObZ5r6gT7mYdDc7/builds/wl9d1jjr4CPB34A2m/openapi.json