# Core Web Vitals Auditor · Bulk Lighthouse for many URLs (`siccscha/core-web-vitals-auditor`) Actor

Bulk Lighthouse for many URLs — no PageSpeed API key needed. Real Chrome runs measure LCP, CLS, TBT, performance/SEO/accessibility/best-practices scores and ranked fix opportunities, mobile and desktop. Optional real-user CrUX field data. URLs that fail to measure are free.

- **URL**: https://apify.com/siccscha/core-web-vitals-auditor.md
- **Developed by:** [Chris S](https://apify.com/siccscha) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$60.00 / 1,000 url measureds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Core Web Vitals Auditor — bulk Lighthouse for a whole list of URLs

Measure **Core Web Vitals and full Lighthouse scores for many URLs in one run**: LCP, CLS, TBT,
plus performance, accessibility, best-practices and SEO scores, plus the ranked list of fixes with
the milliseconds and kilobytes each one saves. Mobile, desktop, or both. Clean JSON per URL, ready
for a schedule, the API, Make, Zapier or an MCP client.

Google ranks on Core Web Vitals, and PageSpeed Insights checks **one URL at a time in a browser
tab**. This Actor is a bulk Lighthouse API for the job that isn't: 50, 500 or 5,000 URLs, on a
schedule, with the results in a dataset you can diff against last week — and it works **without a
PageSpeed API key**, because every measurement is a real Chrome run inside the Actor, not a call to
Google's rate-limited endpoint.

### What you get per URL

```json
{
  "url": "https://example.com/pricing",
  "strategy": "mobile",
  "mobile": {
    "scores": { "performance": 87, "accessibility": 96, "best-practices": 100, "seo": 92 },
    "metrics": {
      "largestContentfulPaint": { "value": 3117, "unit": "millisecond", "display": "3.1 s", "rating": "needs-improvement" },
      "cumulativeLayoutShift":  { "value": 0,    "unit": "unitless",    "display": "0",     "rating": "good" },
      "totalBlockingTime":      { "value": 0,    "unit": "millisecond", "display": "0 ms",  "rating": "good" },
      "firstContentfulPaint":   { "value": 3117, "display": "3.1 s" },
      "speedIndex":             { "value": 3117, "display": "3.1 s" },
      "timeToInteractive":      { "value": 3117, "display": "3.1 s" },
      "serverResponseTime":     { "value": 50,   "display": "Root document took 50 ms" }
    },
    "opportunities": [
      { "id": "unused-javascript", "title": "Reduce unused JavaScript", "savingsMs": 820, "savingsBytes": 152975 },
      { "id": "render-blocking-resources", "title": "Eliminate render-blocking resources", "savingsMs": 300 }
    ],
    "failedAudits": [{ "id": "color-contrast", "title": "Background and foreground colors do not have a sufficient contrast ratio" }],
    "lighthouseVersion": "12.8.2",
    "finalUrl": "https://example.com/pricing"
  }
}
```

`rating` follows Google's published thresholds — `good` / `needs-improvement` / `poor` — so you can
filter a dataset down to the pages that actually fail without knowing the cut-offs by heart.

### Real-user data, optional and on your own key

Lighthouse is a **lab** measurement: reproducible, synthetic, one simulated device. What Google
actually uses for ranking is **field** data from real Chrome users.

Put a free [Chrome UX Report API key](https://developer.chrome.com/docs/crux/api) into
`pageSpeedApiKey` and each item additionally carries `fieldData`: the p75 values real visitors
experienced for LCP, CLS, **INP** and TTFB, with the full histogram and the collection period.

Deliberately your key, not ours: quotas stay yours, and nothing about your run depends on somebody
else's rate limit. **Without a key nothing fails** — you get the complete lab measurement and the
`fieldData` section is simply absent. URLs with too little real traffic return
`{"available": false, "reason": "insufficient-real-user-data"}`, which is a normal answer, not an
error.

### Input

| Field | Meaning |
|---|---|
| `urls` | The exact pages to measure. No crawling — what you list is what runs. |
| `strategy` | `mobile` (what Google ranks on), `desktop`, or `both`. `both` measures twice and is **still charged once**. |
| `pageSpeedApiKey` | Optional CrUX key for real-user field data. Stored as a secret. |

#### Example input

```json
{
    "urls": [
        "https://example.com/",
        "https://example.com/pricing",
        "https://example.com/blog/launch"
    ],
    "strategy": "mobile"
}
```

Three URLs, measured on mobile (what Google ranks on), $0.18 total. Add `"pageSpeedApiKey"` to also
get real-user CrUX data per URL.

### Pricing

**$0.06 per URL measured.** A URL that cannot be measured at all is delivered with
`measurementFailed: true` and is **free** — you never pay for a failed run.

Each measurement is a genuine Chrome run, not an API lookup, which is why this costs more than a
plain HTML crawl and why a page takes ~15–20 seconds. Budget roughly 4 GB of memory.

### Honest limits

- **Lab numbers vary between runs.** Throttling is simulated; ±10 % on LCP between two runs of the
  same page is normal. For trend lines, schedule the Actor and compare over days, not single runs.
- **No crawling.** This Actor measures the URLs you give it. To *find* the URLs, and for broken
  links, canonicals, structured-data errors and duplicate titles, use the
  **SEO Health Auditor** — the two are built to be run side by side.
- **Contrast and screen-reader checks are Lighthouse's**, which catches a meaningful subset of
  accessibility problems, not a full WCAG audit.
- Pages behind a login, a hard bot wall or a CAPTCHA cannot be measured; you get the error, free.

### Typical uses

- **Weekly regression watch** over your 200 most important URLs — schedule it, diff the datasets,
  and see which release made LCP worse.
- **Client reporting for agencies**: one run per client site, scores and the top three fixes
  straight into a report.
- **Pre-launch gate** in CI: run the Actor via API against a staging list and fail the build if the
  performance score drops below your threshold.
- **AI-agent workflows**: an agent that maintains or reviews a site can measure it on demand —
  see below.

### Use with AI agents (MCP)

This Actor is available as a tool through the [Apify MCP server](https://mcp.apify.com), so agents
in Claude, ChatGPT or any MCP client can trigger measurements and read the results directly.
Prompts that map onto this Actor:

- *"Measure Core Web Vitals for these five URLs on mobile and tell me which ones fail Google's thresholds."*
- *"Which single fix would save the most milliseconds across my landing pages?"*
- *"Re-measure the pricing page and compare the performance score with the last run."*

Every metric carries its own `rating` against Google's published thresholds and a human-readable
`display` value, so an agent doesn't need to know that 2.5 s is the LCP cut-off.

### FAQ

**Do I need a Google PageSpeed API key?**
No. Lighthouse runs in a real Chrome inside the Actor — no external API, no shared quota, no 429s.
A key is only useful if you *additionally* want real-user CrUX field data.

**What is the difference between the lab scores and `fieldData`?**
Lab (Lighthouse) is a reproducible synthetic run on one simulated device — ideal for regression
testing. Field (CrUX) is what real Chrome users experienced over the last 28 days — it is what
Google actually ranks on. This Actor gives you lab always, field optionally on your key.

**Why do two runs of the same page differ slightly?**
Throttling is simulated; ±10 % on LCP between runs is normal. For decisions, look at trends across
scheduled runs, not at a single number.

**How is `strategy: "both"` charged?**
Once per URL, even though it measures twice (mobile + desktop). Mobile-only is the default because
mobile is what Google ranks on.

**What happens with a URL that can't be measured?**
It is delivered with `measurementFailed: true` and the error message — and it is **free**. You only
pay for URLs that produced a measurement.

**Can I use this in CI?**
Yes — call the Actor via the Apify API from your pipeline against a list of staging URLs and fail
the build if a score drops below your threshold. A run takes ~15–20 s per URL.

### More from this publisher

- **[SEO Audit + AI Visibility](https://apify.com/siccscha/seo-health-auditor)** — crawls your site,
  finds broken links, canonical contradictions and structured-data errors, and checks whether AI
  systems can cite you. Built to run alongside this Actor: audit there, measure here.
- **[TED Tender Scraper](https://apify.com/siccscha/ted-tender-scraper)** — search and monitor EU
  public procurement notices via the official TED API.
- **[E-Invoice Parser](https://apify.com/siccscha/e-invoice-parser)** — XRechnung, ZUGFeRD/Factur-X
  and UBL e-invoices to clean, validated JSON.

# Actor input Schema

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

One or more page URLs to measure. Each URL gets a real Chrome + Lighthouse run (no external API, no shared quota): Core Web Vitals (LCP, CLS, TBT), performance/accessibility/best-practices/SEO scores 0–100, and fix opportunities ranked by savings. No crawling — exactly the pages you list, ~15–20 s each.

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

Mobile is what Google ranks on. "Both" measures each URL twice and is charged once per URL.

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

Supply your own free Google API key to additionally receive REAL-USER field data (CrUX p75 for LCP, CLS, INP, TTFB). Without a key you still get the full Lighthouse lab measurement — nothing fails, the fieldData section is simply absent. Your key, your quota.

## Actor input object example

```json
{
  "urls": [
    {
      "url": "https://apify.com"
    }
  ],
  "strategy": "mobile"
}
```

# Actor output Schema

## `measurements` (type: `string`):

One item per URL: Lighthouse scores (performance, SEO, accessibility, best practices), LCP, CLS, TBT with their good/needs-improvement rating, ranked fix opportunities and failed audits, mobile and desktop.

## `vitalsTable` (type: `string`):

Reduced to the three field metrics and the performance score — the view to paste into a report.

## `runInConsole` (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": [
        {
            "url": "https://apify.com"
        }
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("siccscha/core-web-vitals-auditor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    {
      "url": "https://apify.com"
    }
  ]
}' |
apify call siccscha/core-web-vitals-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=siccscha/core-web-vitals-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/HyzmG7hiN52vUp4Rb/builds/GfbKq8YlMVwGq8f8c/openapi.json