PageSpeed Insights Bulk Checker: Lighthouse & Core Web Vitals

Run a bulk website speed test on hundreds or thousands of URLs, or a whole sitemap, with Google's official PageSpeed Insights (Lighthouse) API and Chrome UX Report real-user data. For every page you get the four Lighthouse scores, lab metrics, real-user Core Web Vitals (LCP, INP, CLS) pass/fail, and a prioritized fix list in plain English. Set budgets, then get Slack or webhook alerts when a page misses them or gets slower than your last run. A shareable HTML report is included.

No API key needed. $0.003 per URL check ($3 per 1,000). Failed checks are free.

Built only on Google's official PageSpeed Insights API v5 and the Chrome UX Report (CrUX) API. No scraping, no headless browser to break, and the numbers match what you see on pagespeed.web.dev.

What does this PageSpeed Insights bulk checker do?

• ⚡ Bulk PageSpeed checks: paste a list of URLs, upload a CSV/TXT file, or give it your sitemap.xml (sitemap indexes and .xml.gz work too).
• 📱 Mobile, desktop or both: one clean row per URL and device.
• 🏆 All 4 Lighthouse scores: Performance, Accessibility, Best Practices, SEO (0–100).
• 🧪 Lab metrics: LCP, CLS, TBT, FCP, Speed Index, TTI and server response time.
• 👥 Real-user Core Web Vitals (28-day p75 from the Chrome UX Report): LCP, INP, CLS, FCP and TTFB with Google's FAST / AVERAGE / SLOW ratings and a Core Web Vitals passed: true/false verdict. Falls back to origin-level data when a page has too little traffic.
• 🛠️ What to fix first: the top failing audits ranked by estimated time saved, in plain English (for example "Serve images in WebP/AVIF ... (~1.2 s faster, ~955 KiB smaller)").
• 🚨 Alerts: set budgets such as Performance < 70 or LCP > 2500 ms and the pages that miss them get flagged.
• 📉 Regression tracking: compares every run with the previous one and flags pages whose score dropped or whose LCP, TBT or CLS got worse.
• 🔔 Webhook notifications: Slack, Google Chat, Discord, Zapier, Make, n8n or your own endpoint.
• 📊 HTML report + JSON summary: averages, medians, Core Web Vitals pass rate, worst pages and the most common issues across the site.
• 🧯 Bad URLs don't break the run. Invalid, private or unreachable URLs come back as rows with a clear error code, and you aren't charged for them.

Use cases: who runs a bulk PageSpeed / Lighthouse audit?

SEO agencies and consultants

• Audit a client's whole sitemap in minutes and hand over the HTML report.
• Monitor Core Web Vitals for many clients on a schedule (one monitorId per client) and get a Slack ping when something regresses.
• Use the "most common issues" list to estimate the work in a proposal.

Developers and performance engineers

• Check every important template after a deploy and catch regressions before Google does.
• Call it from CI through the Apify API and fail the build when alerts is not empty.
• Get the raw Lighthouse JSON (saveFullReports) for deeper analysis.

Marketers and site owners

• Find out which landing pages are slow on mobile, where most of your paid traffic lands.
• Benchmark your pages against competitors' pages in one table.
• Export to Excel or Google Sheets without writing code.

Why this Actor?

	This Actor	Typical bulk PageSpeed tools
Official Google APIs only	✅ PSI v5 + CrUX API	often PSI only, sometimes scraping
Real-user CWV with pass/fail	✅ CrUX API, URL → origin fallback	PSI field data only, which Google plans to remove from PSI
Prioritized, plain-English fix list with savings	✅	raw audit IDs or nothing
Threshold alerts + regression detection	✅ built in	❌
Slack/webhook alerts	✅	❌
HTML report + summary	✅	❌
Sitemap input	✅ (indexes, gzip)	sometimes
Failed URLs	free error rows	sometimes charged or crash the run

Bulk Lighthouse vs PageSpeed Insights vs website speed test tools

This Actor runs Google PageSpeed Insights, which means Lighthouse executed on Google's own servers, and adds real-user Core Web Vitals from the Chrome UX Report API. The scores are the ones you'd get on pagespeed.web.dev, just for many URLs at once with alerts and history. It is not a self-hosted Lighthouse: you can't change throttling or the test location (Google uses a simulated mid-range phone on a throttled network for mobile, from US servers). If you need custom throttling, private pages or multi-location tests, a self-hosted Lighthouse or a dedicated speed-test service is the better fit.

How to use it

1. Click Try for free.
2. Paste your URLs (or add a sitemap URL).
3. Optional: paste your own free Google API key for bigger and faster runs (2-minute guide below). Without one, the Actor's built-in key is used.
4. Pick Mobile, Desktop or Both, then click Start.
5. Open the Overview table, download CSV/Excel/JSON, or open the HTML report under Storage → Key-value store → REPORT.

To monitor over time, turn on Compare with previous run, set a few alert thresholds, add a Slack webhook URL, and schedule the Actor daily or weekly.

Input example

{
  "startUrls": [
    { "url": "https://example.com" },
    { "url": "https://www.wikipedia.org" },
    { "url": "https://web.dev" }
  ],
  "sitemapUrls": ["https://www.yoursite.com/sitemap.xml"],
  "maxSitemapUrls": 200,
  "strategy": "both",
  "categories": ["performance", "accessibility", "best-practices", "seo"],
  "minPerformanceScore": 70,
  "maxLcpMs": 2500,
  "failOnCoreWebVitals": true,
  "compareWithPrevious": true,
  "monitorId": "client-acme",
  "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX"
}

All fields except the URLs are optional. Leave a threshold empty to switch it off. No Google API key is needed. To add your own for faster runs, see How to get a free Google API key.

Output example

You get one dataset row per URL and device. This is a real row from a cloud run on 22 Oct 2026 (python.org, mobile; the fix list is shortened to the top 2):

{
  "url": "https://www.python.org/",
  "strategy": "mobile",
  "status": "ok",
  "finalUrl": "https://www.python.org/",
  "scores": {
    "performance": 81,
    "accessibility": 75,
    "bestPractices": 100,
    "seo": 92
  },
  "lab": {
    "lcpMs": 4051,
    "cls": 0.003,
    "tbtMs": 16,
    "fcpMs": 3017,
    "speedIndexMs": 3017,
    "ttiMs": 4051,
    "ttfbMs": 5
  },
  "field": {
    "source": "crux-url",
    "lcpP75Ms": 1270,
    "lcpCategory": "FAST",
    "inpP75Ms": 88,
    "inpCategory": "FAST",
    "clsP75": 0,
    "clsCategory": "FAST",
    "fcpP75Ms": 1198,
    "fcpCategory": "FAST",
    "ttfbP75Ms": 543,
    "ttfbCategory": "FAST",
    "coreWebVitalsPassed": true,
    "overallCategory": null,
    "collectionPeriod": {
      "firstDate": "2026-09-22",
      "lastDate": "2026-10-19"
    }
  },
  "fieldDataNote": null,
  "opportunities": [
    {
      "id": "render-blocking-insight",
      "title": "Render-blocking requests",
      "fix": "Stop CSS/JS from blocking the first paint: inline critical CSS, add defer/async to scripts and load the rest later.",
      "estimatedSavingsMs": 2400,
      "estimatedSavingsKiB": null,
      "estimatedClsReduction": null,
      "affectedMetrics": [
        "FCP",
        "LCP"
      ],
      "auditScore": 0,
      "displayValue": "Est savings of 2,380 ms",
      "savingsType": "load-time"
    },
    {
      "id": "unused-css-rules",
      "title": "Reduce unused CSS",
      "fix": "Remove unused CSS, or split CSS per page so each page loads only what it needs.",
      "estimatedSavingsMs": 750,
      "estimatedSavingsKiB": 128.2,
      "estimatedClsReduction": null,
      "affectedMetrics": [
        "FCP",
        "LCP"
      ],
      "auditScore": 0,
      "displayValue": "Est savings of 128 KiB",
      "savingsType": "load-time"
    }
  ],
  "fixList": "1. Stop CSS/JS from blocking the first paint: inline critical CSS, add defer/async to scripts and load the rest later. (~2.4 s faster)\n2. Remove unused CSS, or split CSS per page so each page loads only what it needs. (~750 ms faster, ~128 KiB smaller)",
  "alerts": [],
  "hasAlerts": false,
  "regression": {},
  "error": null,
  "psiReportUrl": "https://pagespeed.web.dev/report?url=https%3A%2F%2Fwww.python.org%2F&form_factor=mobile",
  "lighthouseVersion": "13.5.0",
  "analysisTimestamp": "2026-10-22T08:42:03.694Z",
  "checkedAt": "2026-10-22T08:42:17Z",
  "durationMs": 16663,
  "attempts": 1,
  "runWarnings": [],
  "lighthouseRuntimeError": null
}

Main fields

Field	Meaning
scores.performance / accessibility / bestPractices / seo	Lighthouse scores, 0–100
lab.lcpMs, cls, tbtMs, fcpMs, speedIndexMs, ttiMs, ttfbMs	Lighthouse lab metrics
field.lcpP75Ms, inpP75Ms, clsP75, fcpP75Ms, ttfbP75Ms	Real-user 75th percentile (Chrome UX Report, last 28 days)
field.*Category	Google's FAST / AVERAGE / SLOW rating
field.coreWebVitalsPassed	true if p75 LCP ≤ 2.5 s, INP ≤ 200 ms and CLS ≤ 0.1 (null = not enough traffic)
field.source	crux-url, crux-origin, psi-url or psi-origin (field is {} when no real-user data exists)
opportunities[]	Top fixes: title, plain-English fix, estimatedSavingsMs, estimatedSavingsKiB, affectedMetrics
fixList	The same fixes as numbered text, handy in CSV/Excel
alerts[]	Threshold violations with a readable message
regression	Deltas against the previous run and the list of regressions ({} when comparison is off or there is no previous result)
error	null, or {code, message, httpStatus} when the page could not be analyzed
psiReportUrl	Opens the same test on pagespeed.web.dev
analysisTimestamp, checkedAt	When Google ran Lighthouse, and when the Actor saved the row (UTC)

Dataset views

• Overview: scores, key metrics, CWV verdict, alert and regression flags.
• Details & fixes: every lab and field metric plus the fix list.
• Alerts, regressions & errors: only the rows that need attention.

Key-value store

• OUTPUT: a JSON summary with average scores and median metrics per device, Core Web Vitals pass rate, the 10 worst pages, the most common issues, all alerts, regressions and errors.
• REPORT: a self-contained HTML report you can send to a client.

Error codes

Code	What happened	Charged?
INVALID_URL	Malformed, non-http(s), localhost or private IP	No
LIGHTHOUSE_ERRORED_DOCUMENT_REQUEST	The page answered with an HTTP error (404, 500 ...)	No
LIGHTHOUSE_FAILED_DOCUMENT_REQUEST, LIGHTHOUSE_DNS_FAILURE	Google could not reach the site	No
LIGHTHOUSE_NO_FCP	Blank page, bot protection or extremely slow page	No
RATE_LIMITED, GOOGLE_SERVER_ERROR, TIMEOUT	Still failing after all retries	No
DAILY_QUOTA_EXCEEDED	The Google key's daily quota is used up	No
API_KEY_INVALID	Wrong key, or the API isn't enabled in your Google project	No
SKIPPED_*	Not attempted because the quota or your max cost was reached	No

Alerts, budgets and regression tracking (Core Web Vitals monitor)

• Budgets: minPerformanceScore, maxLcpMs and failOnCoreWebVitals flag every page that misses them, in alerts[] with a readable message.
• Regressions: turn on compareWithPrevious and keep the same monitorId. Each run is compared with the previous one, and pages whose score dropped or whose LCP, TBT or CLS got worse are listed in regression.
• Notifications: paste a Slack, Google Chat, Discord, Zapier, Make, n8n or custom webhook URL. By default it only posts when there are alerts or regressions.
• Schedule the Actor daily or weekly to turn it into a Core Web Vitals monitor.

How much does a bulk PageSpeed test cost?

This Actor uses pay-per-event pricing. You pay a fixed price only for each URL + device that was analyzed successfully (url-analyzed event). There's no start fee and no monthly rental, and Apify platform usage is included.

• Price: $0.003 per URL check, i.e. $3.00 per 1,000. One check = one URL on one device (mobile or desktop).
• No Google API key needed. The built-in key is included in the price; add your own free key only for bigger or faster runs.
• Failed checks are free: invalid URLs, pages Google can't load, quota errors and skipped rows cost nothing.
• Both devices count as 2 results per URL.
• Set Maximum cost per run in the run options and the Actor stops cleanly at that budget. URLs that didn't fit are listed as free SKIPPED_CHARGE_LIMIT_REACHED rows.

You analyze	You pay (at $0.003/URL)
100 URLs	$0.30
1,000 URLs	$3.00
10,000 URLs	$30.00

The Google APIs themselves are free.

How to get a free Google API key

A key gives you your own quota of 25,000 checks per day (about 240 per minute) and lets the Actor run 5–20 URLs in parallel. It takes about 2 minutes and costs nothing:

1. Open the Google Cloud Console and sign in with any Google account.
2. Create a project (top bar → New project), or select an existing one.
3. Go to APIs & Services → Library, search for PageSpeed Insights API and click Enable.
4. Recommended: also enable the Chrome UX Report API to get better real-user data.
5. Go to APIs & Services → Credentials → Create credentials → API key and copy the key (it starts with AIza).
6. Recommended: click the key → API restrictions → Restrict key and select only the two APIs above.
7. Paste the key into the Google API key field. Apify stores it encrypted, and it is never written to the log or the results.

A billing account is not needed for these APIs. Google's quick link is on its get-started page.

FAQ

Do I need a Google API key? No. The Actor has a built-in Google API key, so it works out of the box. That key's quota is shared by all users, so the Actor runs at most 3 URLs in parallel with it. For big or frequent runs, add your own free key: you get your own 25,000 checks a day and up to 20 parallel requests. If no key were available at all, Google's anonymous quota is often exhausted for the day, and the Actor would stop with a free DAILY_QUOTA_EXCEEDED row.

Why are the scores slightly different from my last run? Lighthouse lab tests vary a little between runs because of network and server conditions. Regression detection ignores small changes by default (a score drop under 5 points or an LCP increase under 500 ms). You can tune both values.

Why is field empty for some pages? The Chrome UX Report only has data for pages and sites with enough Chrome traffic. The Actor tries page-level data first, then the whole origin. If neither has enough traffic, fieldDataNote explains why the field is empty.

What's the difference between lab and field data? Lab data comes from a single simulated Lighthouse load (a mid-range phone on a throttled network for mobile). Field data is what real Chrome users experienced over the last 28 days. Google uses field data for ranking.

Can I test pages behind a login, on localhost or on staging? No. Google's servers load the page, so it must be publicly reachable. Private and local addresses are rejected upfront as free INVALID_URL rows.

How fast is it? Google takes about 10–60 seconds per analysis. With your own key and 5 parallel requests, expect around 300–600 URL checks per hour. Raise Parallel requests for more speed.

How do I get alerts in Slack? Create a Slack incoming webhook and paste its URL into Alert webhook URL. The payload has a text field, so Slack displays it as is. Discord (content), Zapier, Make and n8n work too.

Can I monitor several clients separately? Yes. Give each scheduled task its own Monitor ID (for example client-acme). Each one keeps its own history.

Is this the same score as pagespeed.web.dev? Yes, it uses the same PageSpeed Insights API. Lighthouse scores vary a little from run to run on PageSpeed Insights itself too, so compare trends rather than single points.

Can I test a whole sitemap? Yes. Add the sitemap URL (sitemap indexes and .xml.gz work). Use Max URLs from sitemaps to cap how many pages are tested.

Can I use it from an AI agent or MCP client? Yes. Like every Apify Actor, it can be called through Apify's MCP server or the API.

Can I use it from code or CI? Yes. Use the Apify API or the JavaScript/Python clients, run the Actor synchronously and read the dataset. You can fail your pipeline when any row has hasAlerts: true.

Speed and limitations

• Google takes about 10–60 seconds per analysis. With the built-in key, at most 3 URLs run in parallel; with your own free key, up to 20 (about 300–600 checks per hour at 5 parallel).

• PageSpeed Insights tests one page load from Google's servers (US-based) with simulated throttling. That load is not your users' real network.

• Pages behind logins, paywalls, cookie walls that block bots, or IP allowlists can't be tested.

• The built-in key is shared by all users (max 3 parallel requests, 25,000 checks/day in total). For large or frequent jobs, use your own key.

• Your own key is limited to 25,000 checks a day and about 240 a minute, per Google Cloud project.

• Google has announced it will remove real-user (CrUX) data from the PageSpeed Insights API. This Actor already reads field data from the dedicated CrUX API, using your key or the built-in one.

• Fix advice is in English. Lighthouse audit titles follow the locale input.

Support

Found a bug or missing a feature? Open an issue on the Issues tab of this Actor.