# Lighthouse Bulk Audit — PageSpeed, Core Web Vitals & AI Agents (`saliga/lighthouse-bulk-audit`) Actor Bulk PageSpeed Insights for hundreds of URLs, mobile and desktop: Lighthouse scores for Performance, Accessibility, Best Practices, SEO and Agentic Browsing, Core Web Vitals with real-user data, failed audits and HTML reports. No API key needed. - **URL**: https://apify.com/saliga/lighthouse-bulk-audit.md - **Developed by:** [Salih Küçükkayış](https://apify.com/saliga) (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 $4.00 / 1,000 audit (pagespeed insights)s 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 Run Google Lighthouse on hundreds of URLs in one run, on mobile and desktop, and get every page's **Performance, Accessibility, Best Practices, SEO and Agentic Browsing (AI agent readiness)** scores, **Core Web Vitals** from the lab and from real Chrome users, the failed audits with their estimated savings, and the full Lighthouse HTML report. The same results as PageSpeed Insights (pagespeed.web.dev), in bulk, with no Google API key of your own. **$4 per 1,000 audits** (one audit = one URL on one device). Audits with *Run Lighthouse on Apify* are $25 per 1,000, because they run Chrome and Lighthouse on Apify. You pay only for audits that finish. Failed pages are free. HTML reports are included. No platform usage fees. ### Quick start Press **Start** with the example input. It audits two pages on mobile and desktop: ```json { "urls": ["https://www.bbc.com", "https://example.com"], "devices": ["mobile", "desktop"] } ``` You get one dataset row per URL and device (trimmed here): ```json { "url": "https://www.bbc.com", "device": "mobile", "source": "pagespeed-insights", "performance": 41, "accessibility": 93, "bestPractices": 54, "seo": 100, "agenticBrowsing": 50, "agenticBrowsingPassed": "1/2", "fcpMs": 2722, "lcpMs": 8847, "tbtMs": 1109, "cls": 0.004, "speedIndexMs": 7387, "ttfbMs": 11, "totalBytes": 4806258, "requests": 205, "issueCount": 21, "issues": [ { "category": "performance", "id": "bootup-time", "title": "Reduce JavaScript execution time", "score": 0, "displayValue": "3.4 s", "savingsMs": 1550, "savingsBytes": null, "items": 19 }, { "category": "performance", "id": "mainthread-work-breakdown", "title": "Minimize main-thread work", "score": 0, "displayValue": "5.3 s", "savingsMs": 1100, "savingsBytes": null, "items": 7 }, … ], "agentChecks": { "agent-accessibility-tree": "fail", "webmcp-form-coverage": "not applicable", "webmcp-registered-tools": "not applicable", "webmcp-schema-validity": "not applicable", "llms-txt": "not found", "ard-schema": "not found" }, "field": { "scope": "url", "assessment": "FAST", "lcpMs": 1159, "lcpRating": "FAST", "inpMs": 109, "inpRating": "FAST", "cls": 0.03, "clsRating": "FAST", "fcpMs": 662, "fcpRating": "FAST", "ttfbMs": 355, "ttfbRating": "FAST" }, "finalUrl": "https://www.bbc.com/", "lighthouseVersion": "13.5.0", "reportUrl": "https://api.apify.com/v2/key-value-stores/…/records/0004-www-bbc-com-mobile.html", "error": null } ``` The lab score (41) and the real-user assessment (FAST) often differ: the lab test loads the page on a slow phone and network, while real visitors mostly have faster devices. Both are what PageSpeed Insights shows. ### What you get - **Bulk PageSpeed Insights, mobile and desktop.** Every URL is audited on each device you pick by Google PageSpeed Insights, so the scores match what pagespeed.web.dev shows. Five audits run at the same time by default. - **All five Lighthouse categories,** scored 0-100: Performance, Accessibility, Best Practices, SEO and the new **Agentic Browsing** category. - **AI agent readiness.** Lighthouse 13's Agentic Browsing category checks whether AI agents can use the page: a well-formed accessibility tree, `llms.txt`, WebMCP tools and forms, and stable layout. You get the score as Lighthouse shows it ("1/2") and each check as `pass`, `fail` or `not found`. - **Core Web Vitals, lab and field.** Lab metrics from the audit (LCP, CLS, TBT, FCP, Speed Index, Time to Interactive, server response time, page weight, requests) and, when the page or site has enough traffic, real-user data from the Chrome UX Report: LCP, INP, CLS, FCP and TTFB at the 75th percentile, each rated FAST, AVERAGE or SLOW, and the overall Core Web Vitals assessment. - **What to fix.** The failed audits of every category, biggest savings first, with estimated time (ms) and bytes saved: render-blocking requests, image delivery, cache lifetimes, missing labels, contrast, meta descriptions and so on. - **The full HTML report** of every audit, the same one Chrome DevTools shows, saved and linked in each row. The full JSON result is optional. - **Or run Lighthouse on Apify.** Turn on *Run Lighthouse on Apify* to audit with this Actor's own Lighthouse 13.5 in Chrome, for example through a proxy from another country. ### Typical uses - **Audit a whole site** after a redesign or migration: feed it the URLs from your sitemap and sort by performance or by failed audits. - **Track Core Web Vitals over time:** schedule a daily or weekly run of your key pages and chart the dataset. - **Compare against competitors:** the same audit for your pages and theirs, side by side. - **SEO and accessibility checks for clients:** one row per page with scores and the list of issues, plus the HTML report to send. - **Check AI agent readiness:** which of your pages AI agents can read and use, and what is missing (llms.txt, WebMCP, accessibility tree). - **Give an AI agent a performance tool** through the Apify MCP server: "run Lighthouse on these URLs and tell me what slows them down". ### Input | Field | Default | Meaning | |---|---|---| | `urls` | | Pages to audit. `example.com` becomes `https://example.com`. | | `devices` | `["mobile"]` | `mobile`, `desktop` or both. Each device is one audit. | | `categories` | all five | Any of `performance`, `accessibility`, `best-practices`, `seo`, `agentic-browsing`. | | `saveHtmlReport` | `true` | Save and link the Lighthouse HTML report. | | `saveJsonReport` | `false` | Also save the full Lighthouse JSON result (about 0.5 MB per audit). | | `maxIssuesPerCategory` | `10` | Failed audits listed per category. | | `throttling` | `simulate` | With `localLighthouse`: `simulate` estimates load times on a slow network, `none` measures the page as it loads on Apify. | | `locale` | `en-US` | Language of audit titles and the HTML report (`de`, `fr`, `es`, `ja`, `pt-BR`, `tr`…). | | `concurrency` | `5` | Audits at the same time: up to 10 with PageSpeed Insights, up to 4 on Apify. | | `localLighthouse` | `false` | Run Lighthouse on Apify instead of through PageSpeed Insights (priced higher). | | `proxyConfiguration` | none | With `localLighthouse`: audit a page as seen from another country. | | `timeoutSecs` | `60` | How long to wait for a page to load. | | `maxRetries` | `1` | Tries again on failure. Failed audits are free. | ### Output One dataset row per URL and device: | Field | Meaning | |---|---| | `url`, `finalUrl`, `device` | Requested URL, URL after redirects, `mobile` or `desktop` | | `source` | `pagespeed-insights` or `local` (Lighthouse on Apify) | | `performance`, `accessibility`, `bestPractices`, `seo`, `agenticBrowsing` | Category scores, 0-100 (`null` if the category was not run) | | `agenticBrowsingPassed` | Agentic Browsing as Lighthouse shows it, for example `"1/2"` | | `lcpMs`, `cls`, `tbtMs`, `fcpMs`, `speedIndexMs`, `ttiMs`, `ttfbMs` | Core Web Vitals and other lab metrics | | `field` | Real-user data from the Chrome UX Report: `assessment`, `lcpMs`, `inpMs`, `cls`, `fcpMs`, `ttfbMs` with a rating each, and `scope` (`url`, or `origin` when the page alone has too little traffic). `null` when there is none | | `totalBytes`, `requests` | Page weight and number of requests | | `issueCount` | Number of failed audits in all categories | | `issues` | Failed audits, biggest savings first: `category`, `id`, `title`, `score`, `displayValue`, `savingsMs`, `savingsBytes`, `items` | | `agentChecks` | Each AI agent check: `pass`, `fail`, `not found` or details | | `reportUrl`, `jsonReportUrl` | Links to the HTML and JSON reports | | `lighthouseVersion`, `fetchTime`, `warnings` | Lighthouse version, when it ran, Lighthouse's warnings | | `benchmarkIndex`, `cpuSlowdownMultiplier` | Speed of the machine that ran the audit and the CPU slowdown used | | `tookMs`, `error` | Time taken and why it failed, if it did | ### What it costs | Run | Price | |---|---| | 100 pages, mobile and desktop (200 audits) | $0.80 | | 1,000 pages, mobile | $4.00 | | Weekly check of 50 key pages, both devices, for a month | $1.60 | | 100 pages with Run Lighthouse on Apify, mobile | $2.50 | Pricing: $0.004 per audit through PageSpeed Insights, $0.025 per audit with Run Lighthouse on Apify. Failed audits are free. Platform usage is included. ### Next steps with your results - Get every URL of a site first with [Sitemap Extractor](https://apify.com/saliga/sitemap-extractor), then audit them here. - Find broken links on the same pages with [Broken Link Checker](https://apify.com/saliga/broken-link-checker). - See which CMS, frameworks and tag managers a slow site uses with [Tech Stack Detector](https://apify.com/saliga/tech-stack-detector). - Capture what the pages look like on mobile with [Website Screenshot](https://apify.com/saliga/website-screenshot-change-detection). ### Good to know - **PageSpeed Insights or Lighthouse on Apify.** By default every audit goes through Google PageSpeed Insights, so the scores are the ones people see on pagespeed.web.dev, and real-user data comes with them. With *Run Lighthouse on Apify* the Actor runs Lighthouse 13.5 itself in Chrome. Lighthouse's CPU slowdown for mobile is then calibrated to the machine's speed with Lighthouse's own formula, but performance scores can still differ from PageSpeed Insights, especially on desktop and on heavy pages. Accessibility, Best Practices, SEO and Agentic Browsing results do not depend on the machine. - **Scores vary a little between runs,** as they do in PageSpeed Insights, because networks and servers vary. For tracking over time, compare trends rather than single points. - **What is charged:** each audit that finishes with a Lighthouse report. Pages that do not load, time out, are blocked or answer with an error status (404, 500…) are free, and the row's `error` says why. - **PageSpeed Insights limits.** If Google's daily limit for PageSpeed Insights is reached during a run, the run stops starting new audits and says so; nothing is charged for the audits left out. Run them later or turn on *Run Lighthouse on Apify*. - Private and internal addresses (localhost, 10.x, 192.168.x, cloud metadata) are refused. With *Run Lighthouse on Apify* they are blocked through redirects and sub-resources too. Custom proxy URLs must be http:// and must not point to such addresses. - Sites with strong bot protection may show a challenge page instead of the content; Lighthouse then audits that page. - Lighthouse and PageSpeed Insights are by Google; Lighthouse is open source (Apache-2.0). This Actor is not affiliated with Google. ### FAQ **Is this the same as PageSpeed Insights?** Yes, by default: every audit runs through PageSpeed Insights, with its lab scores and its real-user data. You do not need your own Google API key. **What is the Agentic Browsing score?** A new Lighthouse category (still under development by the Lighthouse team) that checks whether AI agents can understand and use a page: an accessibility tree agents can read, `llms.txt`, WebMCP tools and form annotations, and layout stability. It is shown as passed checks out of total, for example "1/2". **Am I charged for pages that fail?** No. Only audits that finish with a report are charged. **How many URLs can I audit in one run?** Up to 10,000 audits per run. An audit takes 10-60 seconds depending on the page; with 5 at a time, 1,000 audits take about an hour or two. **When should I use "Run Lighthouse on Apify"?** When you need a proxy (audit from another country), or when PageSpeed Insights' daily limit is reached. For the scores people see on pagespeed.web.dev, keep the default. **Can I run it from Make, Zapier, n8n, my own code or an AI agent?** Yes, like any Apify Actor: through Apify's integrations, the Apify API or the Apify MCP server. ### More from this developer - [Sitemap Extractor](https://apify.com/saliga/sitemap-extractor): every URL a website lists in its sitemaps, with lastmod, images and hreflang, $0.25 per 1,000 URLs. - [Broken Link Checker](https://apify.com/saliga/broken-link-checker): crawl a site and find broken links, redirects and missing pages. - [Tech Stack Detector](https://apify.com/saliga/tech-stack-detector): which CMS, ecommerce platform, analytics and hosting a website uses, $1.50 per 1,000 websites. - [Website Screenshot + Change Detection](https://apify.com/saliga/website-screenshot-change-detection): screenshots of many URLs on desktop, tablet and mobile, with visual change alerts, $1 per 1,000 screenshots. - [Domain SEO Overview](https://apify.com/saliga/domain-seo-overview): organic keywords, estimated traffic and top-10 rankings for thousands of domains, $5 per 1,000 domains. - [Google SERP Rank Tracker](https://apify.com/saliga/serp-rank-tracker): Google positions for your keywords by country and device, with AI Overview checks, $2 per 1,000 result pages. - [Keyword Research](https://apify.com/saliga/keyword-research): keyword ideas, suggestions and related keywords with volume, difficulty and search intent, $2 per 1,000 keywords. - [Competitor Keywords](https://apify.com/saliga/competitor-keywords): every Google keyword a domain or page ranks for, and its organic competitors, $2 per 1,000 rows. Code examples (curl, Python, Node.js, n8n) for this and the other Actors: [github.com/msalihk/apify-actor-examples](https://github.com/msalihk/apify-actor-examples). Questions or a missing feature: open an issue on the Actor page. # Actor input Schema ## `urls` (type: `array`): Pages to audit. One Lighthouse audit per URL and device. A URL without http(s):// gets https://. ## `devices` (type: `array`): Audit each URL on every selected device, as PageSpeed Insights does: mobile (Moto G Power, slow 4G, 4x CPU slowdown) and desktop. Each device is a separate audit. ## `categories` (type: `array`): Lighthouse categories to run. Agentic Browsing checks whether AI agents can use the page (accessibility tree, llms.txt, WebMCP tools). Fewer categories make audits a little faster; the price is the same. ## `saveHtmlReport` (type: `boolean`): Save the full Lighthouse HTML report of every audit (the same report as in Chrome DevTools) and link it in the results. ## `saveJsonReport` (type: `boolean`): Also save the full Lighthouse JSON result (about 0.5 MB per audit) for your own processing. ## `maxIssuesPerCategory` (type: `integer`): How many failed audits to list in the "issues" field for each category, biggest savings first. 0 lists none (the count is still given). ## `localLighthouse` (type: `boolean`): Off (default): audits run through Google PageSpeed Insights, the same scores as pagespeed.web.dev, plus real-user Chrome data. On: this Actor runs Lighthouse itself in Chrome on Apify. Use it for pages PageSpeed Insights cannot reach the way you want (through a proxy, from another country), or when its daily quota is used up. Local audits are priced higher and their performance scores can differ from PageSpeed Insights. ## `throttling` (type: `string`): Only with "Run Lighthouse on Apify". Simulated (default) estimates load times on a slow network and CPU, like PageSpeed Insights. None measures the page as it loads in Apify's data center. ## `cpuSlowdownMultiplier` (type: `integer`): Only with "Run Lighthouse on Apify". Leave empty: the slowdown is calibrated to the machine's speed with Lighthouse's own formula. Set a number (for example 4, Lighthouse's default) to fix it. ## `locale` (type: `string`): Language of audit titles and the HTML report, for example en-US, de, fr, es, ja, pt-BR, tr. ## `proxyConfiguration` (type: `object`): Only with "Run Lighthouse on Apify": audit a page as seen from another country. Proxies add latency to measured times. ## `concurrency` (type: `integer`): Audits at the same time. Default 5 with PageSpeed Insights (up to 10), 1 with "Run Lighthouse on Apify" (up to 4: audits there share the CPU, which can lower performance scores; give the run more memory for 2+). ## `timeoutSecs` (type: `integer`): How long Lighthouse waits for a page to load. ## `maxRetries` (type: `integer`): Try a failed audit again this many times. Failed audits are not charged. ## Actor input object example ```json { "urls": [ "https://www.bbc.com", "https://example.com" ], "devices": [ "mobile", "desktop" ], "categories": [ "performance", "accessibility", "best-practices", "seo", "agentic-browsing" ], "saveHtmlReport": true, "saveJsonReport": false, "maxIssuesPerCategory": 10, "localLighthouse": false, "throttling": "simulate", "locale": "en-US", "timeoutSecs": 60, "maxRetries": 1 } ``` # Actor output Schema ## `results` (type: `string`): One row per URL and device: category scores, Core Web Vitals, failed audits and a link to the HTML report. ## `files` (type: `string`): Lighthouse HTML (and optionally JSON) reports in the run's key-value store. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "urls": [ "https://www.bbc.com", "https://example.com" ], "devices": [ "mobile", "desktop" ] }; // Run the Actor and wait for it to finish const run = await client.actor("saliga/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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "urls": [ "https://www.bbc.com", "https://example.com", ], "devices": [ "mobile", "desktop", ], } # Run the Actor and wait for it to finish run = client.actor("saliga/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://www.bbc.com", "https://example.com" ], "devices": [ "mobile", "desktop" ] }' | apify call saliga/lighthouse-bulk-audit --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,saliga/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 ` 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/6cfVnBtOZYmT2HyOF/builds/5JPu7KE0vtf9ZxAqb/openapi.json