Bulk PageSpeed and Core Web Vitals Checker

Use it to audit hundreds of URLs with Google PageSpeed Insights and get Lighthouse scores and real-user Core Web Vitals (including INP) in one table.

Cost: $1.50 per 1,000 audits (one audit = one URL and one strategy). Requires your own Google PageSpeed Insights API key, which is free (setup below takes about 2 minutes). A run without a key makes no API calls, returns one free guidance row, and costs only the $0.00005 start fee.

Why this one

• Lab and field data in one row. You get Lighthouse scores and timings plus 75th-percentile real-user metrics from Google's Chrome UX Report (CrUX) API, with page-to-origin fallback and the source recorded in fieldDataSource. Included in the audit price.
• A bad URL never fails the run. Timeouts, 500s and quota errors become rows with errorKind, and every other URL is still audited.
• Quota-aware with your own key, so you never share Google's exhausted anonymous quota. It can also chain straight from a sitemap run and audit only added or changed URLs.

Sample output (real run, Oct 20, 2026):

url	strategy	performance	accessibility	seo	labLcpMs	fieldLcpMs	fieldInpMs
https://example.com/	mobile	100	96	80	757	1125	88

Audit hundreds or thousands of URLs with Google's official PageSpeed Insights API and get Lighthouse scores plus real-user Core Web Vitals in one dataset.

Feed it a URL list, or point it at the output of a sitemap Actor and audit a whole site. Each URL produces one row per strategy with performance, accessibility, SEO and best-practices scores, lab LCP/FCP/CLS/TBT, and CrUX field LCP/INP/CLS/FCP/TTFB where Google has enough real-user traffic.

What it does

• Uses the official API. Google's PageSpeed Insights v5 endpoint. No headless browser, no scraping, no anti-bot problems.
• Both lab and field data. Lighthouse lab timings for every successfully audited URL, plus 75th-percentile CrUX field metrics (including INP, which only exists as field data). Where a page has too little traffic for URL-level CrUX, it falls back to origin-level and records which you got in fieldDataScope.
• Per-URL errors, not a failed run. A URL that times out, 500s, or trips a quota limit becomes a row with ok: false, errorKind and a readable errorMessage. Every other URL still gets audited.
• Quota-aware. A token-bucket rate limiter enforces your requests-per-minute ceiling. A per-minute throttle is retried with backoff; an exhausted daily quota is detected and the remaining URLs are written as skipped rows immediately, because a daily quota cannot clear inside a run.
• Chains after a sitemap run. Point sourceDatasetId at a sitemap Actor's dataset and audit every URL it found — or, in change-tracking mode, only the URLs that were added or changed.

About the API key — read this first

A key is required, and it is free. Without one, PageSpeed Insights bills calls to a single Google-owned project shared by every anonymous caller in the world, and its daily quota is routinely already exhausted. In testing from a cloud IP, keyless calls returned this on the very first request:

Quota exceeded for quota metric 'Queries' and limit 'Queries per day'
of service 'pagespeedonline.googleapis.com'
for consumer 'project_number:583797351490'.

That is the shared project, not yours. Get your own key (free):

1. Open the Google Cloud Console and create (or pick) a project.
2. Enable the PageSpeed Insights API.
3. Enable the Chrome UX Report API in the same project (APIs & Services > Library > "Chrome UX Report API" > Enable). This powers the real-user (field) columns. It is also free.
4. Create an API key credential under APIs & Services > Credentials. If you restrict the key, allow both APIs.
5. Paste it into the apiKey input. It is marked secret, is only ever sent to googleapis.com, and is redacted from logs and error rows.

If the Chrome UX Report API is not enabled, audits still succeed: the field columns fall back to the data embedded in the PageSpeed Insights response, and each row carries cruxError: "crux_api_not_enabled" with a link to enable it. Lookups stop after the first such error, so the run doesn't keep calling a disabled API.

Keyed projects get 25,000 queries per day and 240 queries per minute. These are commonly cited limits; check your Quotas page in Google Cloud Console for the numbers that actually apply to your project.

If you run it without a key, the Actor makes no PageSpeed Insights calls. It returns one row with ok: false and errorKind: "missing_api_key" explaining how to get a key, charges no audit (only the $0.00005 start fee), and the run finishes as SUCCEEDED. Add the key and run again.

Input

Minimum viable input:

{
  "urls": ["https://example.com", "https://example.com/pricing"],
  "apiKey": "YOUR_PAGESPEED_API_KEY"
}

Mobile and desktop, with opportunity audits:

{
  "urls": ["https://example.com"],
  "strategy": "both",
  "categories": ["performance", "accessibility", "best-practices", "seo"],
  "includeAudits": true,
  "apiKey": "YOUR_PAGESPEED_API_KEY"
}

Nightly audit of only what changed on a site, chained after the Sitemap URL Extractor:

{
  "sourceDatasetId": "SITEMAP_RUN_DATASET_ID",
  "sourceDatasetField": "url",
  "sourceDatasetChangeTypes": ["added", "changed"],
  "maxUrlsFromSourceDataset": 500,
  "strategy": "mobile",
  "concurrency": 6,
  "maxRequestsPerMinute": 120,
  "apiKey": "YOUR_PAGESPEED_API_KEY"
}

Key settings

Field	Default	Notes
urls	—	Pages to audit, or set sourceDatasetId. With neither, the run uses the demo URL https://example.com instead of failing.
strategy	mobile	both doubles the API calls and the quota used.
apiKey	—	Required (free). Without it the run returns one guidance row and makes no API calls. See above.
categories	all four	Quota is charged per call, not per category.
includeFieldData	true	Real-user (CrUX) metrics, where available. No extra charge.
includeCrux	true	Get field data from the CrUX API (page, then origin; PHONE for mobile, DESKTOP for desktop). Off = use only the field data inside the PSI response.
includeAudits	false	Adds Lighthouse opportunity audits; larger rows.
concurrency	4	A PSI call typically takes 10–45 s, so this is what makes a batch finish.
maxRequestsPerMinute	60	Hard ceiling. 240/min is the commonly cited keyed limit; check your Quotas page in Google Cloud Console.
stopOnDailyQuotaExhausted	true	Skip remaining URLs rather than retry into a wall.
requestTimeoutSecs	120	Below ~60 s you start timing out audits that would have passed.

Output

One row per URL and strategy:

{
  "url": "https://example.com/",
  "finalUrl": "https://example.com/",
  "strategy": "mobile",
  "ok": true,
  "performanceScore": 74,
  "accessibilityScore": 91,
  "bestPracticesScore": 100,
  "seoScore": 92,
  "labLcpMs": 3605,
  "labFcpMs": 2184,
  "labCls": 0.041,
  "labTbtMs": 311,
  "labSpeedIndexMs": 3901,
  "hasFieldData": true,
  "fieldDataSource": "crux_url",
  "fieldDataScope": "url",
  "fieldLcpMs": 3120,
  "fieldLcpCategory": "needs-improvement",
  "fieldInpMs": 184,
  "fieldInpCategory": "good",
  "fieldCls": 0.12,
  "fieldOverallCategory": "needs-improvement",
  "lighthouseVersion": "12.2.1",
  "analysisTimestamp": "2026-10-19T00:11:22.333Z",
  "fetchedAt": "2026-10-19T00:11:40.901Z",
  "durationMs": 18234
}

A failed audit, in the same dataset:

{
  "url": "https://example.com/slow-page",
  "strategy": "mobile",
  "ok": false,
  "errorKind": "quota_exceeded",
  "errorMessage": "PSI daily quota exhausted for this API key. Quota exceeded for quota metric 'Queries' and limit 'Queries per day' of service 'pagespeedonline.googleapis.com'.",
  "errorStatusCode": 429,
  "fetchedAt": "2026-10-19T00:12:03.441Z"
}

The dataset ships four views: Scores, Core Web Vitals (field), Lab metrics and Failed audits. RUN_SUMMARY in the key-value store records totals, failures by kind, and whether the daily quota ran out.

Use cases

• Agency reporting. Audit a client's top 500 pages on mobile and desktop and export straight to a spreadsheet.
• Core Web Vitals monitoring. Schedule a weekly run and track fieldLcpMs, fieldInpMs and fieldCls over time.
• Pre- and post-release comparison. Audit the same URL set before and after a deploy and diff the scores.
• Competitive benchmarking. Audit your key landing pages next to competitors' equivalents.
• Site-wide audit from a sitemap. Chain it after the Sitemap URL Extractor and audit everything, or only what changed.

Limits and things to know

• Quota is the real constraint. Each URL-and-strategy pair is one API call. 1,000 URLs on both is 2,000 calls. Plan against your project's daily quota.
• PSI is slow by nature. 10–45 seconds per call is normal (heavy pages take longer). At the default concurrency 4 that is roughly 400–600 URLs per hour, so raise concurrency or the run timeout for bigger lists. Concurrency, not raw speed, is what gets a large batch done.
• Lab numbers vary between runs. Lighthouse runs on Google's infrastructure under variable load; small score movements between runs are noise, not regressions. Field (CrUX) data is the stable signal.
• Not every page has field data. CrUX needs enough real Chrome traffic. The Actor asks the CrUX API for the page, then for the whole origin (fieldDataSource: "crux_origin"). When CrUX has neither, the field columns stay empty, hasFieldData is false and fieldDataSource is "none"; the audit is still delivered.
• Field data source. fieldDataSource is crux_url, crux_origin, psi_loadingExperience (CrUX API off, or the lookup failed) or none. CrUX lookups are rate-limited to 100/minute, below Google's default of 150/minute per project.
• INP is field-only. Lighthouse has no lab INP for a single page load; labTbtMs is the lab proxy. fieldInpMs is the real thing.
• Lighthouse can fail on a 200. When the audited page itself errors, PSI returns HTTP 200 with a runtimeError. Those rows come back ok: false with errorKind: "lighthouse:…".
• Public pages only. PSI audits what Google can reach anonymously; pages behind a login cannot be audited.
• Review Google's API terms for your own use of the output before relying on it commercially.

Pricing events

Event	Price	Charged when
Actor start	$0.00005	Once per run (per GB of memory).
audit	$0.0015 ($1.50 per 1,000)	One URL was successfully audited, for one strategy.

Nothing else is billable. Real-user CrUX data is part of the audit row and is never a separate charge. A quota error, a timeout, a URL skipped after the daily quota ran out, and a page Lighthouse could not load all produce a row so you can see what happened, but none of them is charged, because you received no audit. A run where every URL failed costs only the start fee, and so does a run without a key, whose single guidance row is free.

Auditing on both strategies charges twice per URL, because it is two Lighthouse runs.

When the run reaches your maximum total charge it stops cleanly: remaining URLs are written as skipped rows and the reason is recorded in RUN_SUMMARY rather than failing. Audits already in flight finish and are delivered free of charge, so a run can return slightly more results than it billed for, never fewer. RUN_SUMMARY.charging shows the units of work performed next to the units actually billed.

Attribution

Results from Google PageSpeed Insights (Lighthouse); field data from the Chrome UX Report, CC BY 4.0. Not affiliated with or endorsed by Google. Requires your own Google API key.

This Actor ships no API key and has no built-in fallback key. The apiKey input is the only source, it is sent only to googleapis.com, and it is redacted from logs and error rows. Without one, the Actor makes no PageSpeed Insights calls at all and returns a single guidance row instead.

FAQ

Do I need a Google API key?

Yes, and it is free. Create one in Google Cloud Console in about 2 minutes (steps above) and paste it into apiKey. Without a key the run makes no PageSpeed Insights calls, returns one free guidance row and finishes SUCCEEDED.

How do I audit a whole website?

Run a sitemap Actor first, then set sourceDatasetId to its dataset. Every URL it found is audited, or, in change-tracking mode, only the URLs that were added or changed.

Why do my scores change between runs?

Lighthouse lab scores vary with Google's server load, so small movements are noise. The real-user (CrUX) field metrics are the stable signal for trends.

Why are the field data columns empty for some pages?

Google only has real-user data for pages and sites with enough Chrome traffic. The Actor falls back from page to origin level and records the source in fieldDataSource; the lab audit is delivered either way.

Can I track Core Web Vitals every week and export them?

Yes. Schedule the Actor (Console > Schedules) and download each run as CSV, Excel or JSON, or send it to Google Sheets, Slack, Zapier, Make, n8n or a webhook with Apify's integrations.

Feedback

This Actor is new and actively maintained. If a run fails, a field is missing, or a result looks wrong, please open an issue on the Issues tab with the run ID. We read and reply to every issue, and suggestions for new filters or fields are very welcome.