Bulk PageSpeed Insights & Core Web Vitals Checker

Run Google Lighthouse / PageSpeed Insights audits on hundreds of URLs in one run and get a clean table of performance, accessibility, SEO and best-practices scores, the Core Web Vitals (LCP, CLS, TBT, FCP, Speed Index, plus real-user INP field data when available) and the top opportunities to make each page faster, for mobile, desktop or both.

No more pasting URLs into pagespeed.web.dev one by one.

What does the Bulk PageSpeed Auditor do?

• Audits a list of URLs (one per line) with Lighthouse, for mobile and/or desktop.
• Returns 0–100 category scores: Performance, Accessibility, Best Practices, SEO.
• Returns lab metrics: Largest Contentful Paint (LCP), Cumulative Layout Shift (CLS), Total Blocking Time (TBT, the lab stand-in for INP), First Contentful Paint (FCP), Speed Index, server response time and total page weight.
• With your own free Google API key, adds Chrome UX Report (CrUX) field data: real-user p75 LCP, INP, CLS, FCP and TTFB for the page (or the whole origin if the page has too little traffic).
• Lists the top improvement opportunities for each page (e.g. "Reduce unused JavaScript", "Eliminate render-blocking resources") with estimated savings.
• Runs audits in parallel, retries transient failures and gives a clear error per URL (invalid URL, DNS failure, page didn't load, quota exceeded...) instead of failing the whole run.

Two engines: PageSpeed Insights API or local Lighthouse

	PageSpeed Insights API (with your API key)	Local Lighthouse (no key)
Where the test runs	Google's servers	Inside this Actor (headless Chrome on Apify)
Lab scores & metrics	✅	✅
CrUX real-user field data (INP etc.)	✅	❌
Needs a Google API key	Yes (free)	No
Speed	Faster, up to 20 parallel audits	~10–40 s per audit, one audit per CPU core (Apify gives 1 core per 4 GB of run memory)

In the default auto mode the Actor uses the PSI API when you supply an API key. Without a key it first checks Google's shared keyless quota; that quota is shared by everyone on the internet and is usually exhausted, in which case the Actor automatically runs Lighthouse itself, so your run still succeeds.

The local engine is CPU-bound, so run it with at least 4 GB of memory (the default). Scores from the two engines are produced by the same Lighthouse audits but on different hardware and networks, so expect them to differ by a few points, just as two runs on pagespeed.web.dev do.

How to get a free Google API key (2 minutes)

1. Open the Google Cloud Console and enable the PageSpeed Insights API for any project.
2. Go to APIs & Services → Credentials → Create credentials → API key.
3. Paste the key into the Google API key input. It is stored as a secret input and never written to the dataset or logs.

Google's free PSI quota is generous for most audit volumes; you can check your project's limits on the Quotas page of the Google Cloud Console.

Use cases

• SEO audits of a whole site or of every landing page before and after a release.
• Agency reporting: score all client sites monthly and export to Google Sheets or Looker Studio.
• Competitor benchmarking: compare your Core Web Vitals with competitors' pages.
• Regression monitoring: schedule the Actor daily and alert when performance drops.
• Accessibility triage: find the pages with the lowest accessibility scores first.

Input

Field	Description	Default
urls	URLs to audit, one per line	["https://example.com"]
strategies	mobile, desktop or both	["mobile"]
categories	Lighthouse categories to score	all four
apiKey	Optional Google API key (secret)	–
engine	auto, psi or local	auto
includeFieldData	Add CrUX real-user data (PSI engine only)	true
maxOpportunities	Opportunities per result	5
maxConcurrency	Parallel audits	auto (10 for PSI API, 1 per CPU core locally)
maxRetries	Retries for transient errors	2
locale	Language of audit titles	en

Example input:

{
  "urls": ["https://example.com", "https://web.dev"],
  "strategies": ["mobile", "desktop"],
  "apiKey": "YOUR_OPTIONAL_GOOGLE_API_KEY"
}

Output

One dataset row per URL × strategy. Download it as JSON, CSV, Excel or HTML, or read it via the Apify API.

{
  "url": "https://web.dev/",
  "strategy": "mobile",
  "engine": "local-lighthouse",
  "status": "ok",
  "finalUrl": "https://web.dev/",
  "performanceScore": 83,
  "accessibilityScore": 90,
  "bestPracticesScore": 100,
  "seoScore": 92,
  "lcpMs": 2831,
  "fcpMs": 2831,
  "cls": 0.002,
  "tbtMs": 301,
  "speedIndexMs": 3773,
  "ttfbMs": 420,
  "totalByteWeightKb": 2602.9,
  "topOpportunities": [
    { "id": "render-blocking-resources", "title": "Eliminate render-blocking resources", "displayValue": "Est savings of 620 ms", "savingsMs": 622, "savingsKb": 0, "score": 0 },
    { "id": "unused-css-rules", "title": "Reduce unused CSS", "displayValue": "Est savings of 130 KiB", "savingsMs": 600, "savingsKb": 129.9, "score": 0 }
  ],
  "lighthouseVersion": "12.8.2",
  "attempts": 1,
  "checkedAt": "2026-10-19T03:50:12.000Z"
}

With the PSI engine and field data the row also contains fieldLcpP75Ms, fieldInpP75Ms, fieldClsP75, fieldCategory (FAST / AVERAGE / SLOW) and a fieldData object with page-level and origin-level CrUX values.

Failed URLs are kept in the dataset with status: "error", an errorType (e.g. INVALID_URL, PAGE_LOAD_FAILED, QUOTA_EXCEEDED_DAILY, INVALID_API_KEY, TIMEOUT) and a readable error message. A run summary is saved in the key-value store as SUMMARY.

Example tasks

Copy one of these into the JSON tab of the input (or save it as a Task) to get started quickly.

Core Web Vitals for your key landing pages (mobile + desktop)

{
  "urls": [
    "https://www.example.com/",
    "https://www.example.com/pricing",
    "https://www.example.com/blog/"
  ],
  "strategies": [
    "mobile",
    "desktop"
  ]
}

Fast bulk audit with your free Google API key (adds CrUX real-user INP/LCP/CLS)

{
  "urls": [
    "https://web.dev",
    "https://developer.mozilla.org"
  ],
  "strategies": [
    "mobile"
  ],
  "engine": "psi",
  "apiKey": "YOUR_GOOGLE_API_KEY",
  "includeFieldData": true
}

Performance-only competitor benchmark

{
  "urls": [
    "https://www.shopify.com",
    "https://www.wix.com",
    "https://www.squarespace.com"
  ],
  "strategies": [
    "mobile"
  ],
  "categories": [
    "performance"
  ],
  "maxOpportunities": 3
}

How much does a bulk PageSpeed audit cost?

You pay per successful audit (one URL on one device). Failed audits are free and there is no start fee.

Job	Audits	With your free Google API key ($0.004/audit)	Built-in Lighthouse, no key ($0.015/audit)
100 URLs, mobile	100	$0.40	$1.50
1,000 URLs, mobile	1,000	$4	$15
1,000 URLs, mobile + desktop	2,000	$8	$30
50 key pages daily for a month (mobile)	1,500	$6	$22.50

• Apify's free plan includes $5 of monthly credit: about 1,250 audits with your own key or 330 local Lighthouse audits every month at no cost.
• Paid Apify plans get automatic discounts: Silver -10%, Gold and above -20%.
• Set Maximum cost per run on the run options to hard-cap spend; the Actor stops cleanly at the limit.
• Google's PageSpeed Insights API itself is free within Google's quota, which is why bringing a key is the cheapest way to audit at scale.

Bulk PageSpeed checker vs. the alternatives

	This Actor	pagespeed.web.dev by hand	Calling the PSI API yourself	Monitoring SaaS (subscription)
Many URLs in one go	✅ hundreds per run	❌ one at a time	✅ after you write the code	✅
Works without a Google API key	✅ built-in Lighthouse fallback	✅	❌ (keyless quota is usually exhausted)	✅
Core Web Vitals + CrUX field data (INP)	✅ with a key	✅	✅	✅
Top fix-it opportunities per page	✅	✅	needs parsing	✅
CSV / Excel / JSON / Sheets export	✅	❌	DIY	varies
Retries, quota handling, per-URL errors	✅	–	DIY	✅
Cost model	pay per audit, no subscription	free, manual	free + your time	monthly fee

Use it as an API (Python, JavaScript, cURL, MCP)

Every Apify Actor is also a REST API, so you can call this bulk PageSpeed / Core Web Vitals checker from your own code, a no-code tool or an AI agent.

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datawright-labs/pagespeed-auditor").call(run_input={"urls": ["https://example.com"], "strategies": ["mobile"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

JavaScript / Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('datawright-labs/pagespeed-auditor').call({"urls": ["https://example.com"], "strategies": ["mobile"]});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

cURL (run and get results in one request)

curl -X POST "https://api.apify.com/v2/acts/datawright-labs~pagespeed-auditor/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com"], "strategies": ["mobile"]}'

AI agents (MCP)

Add https://mcp.apify.com/?tools=datawright-labs/pagespeed-auditor to Claude, Cursor or any MCP client and the agent can run it as a tool.

Results can also go straight to Google Sheets, Slack, Make, Zapier, n8n, Airbyte or a webhook via Apify integrations, and you can run it on a Schedule.

FAQ

Why are my scores different from pagespeed.web.dev?

Lighthouse scores vary between runs and machines. The PSI engine runs on Google's infrastructure like pagespeed.web.dev; the local engine runs on Apify servers. Run important pages more than once and compare trends rather than single numbers.

Where is INP?

INP is a field (real-user) metric and cannot be measured in a lab test. You get it from CrUX when you use the PSI engine with an API key and the page or origin has enough Chrome traffic. In lab results, TBT is the closest proxy.

Can I audit pages behind a login?

No. Both engines load pages as an anonymous visitor.

Can I schedule it?

Yes. Use Apify Schedules to run daily or weekly and integrations (Google Sheets, Slack, webhooks, Zapier, Make) to send results where you need them.

Is this affiliated with Google?

No. It is an independent tool that uses the public PageSpeed Insights API and the open-source Lighthouse project.

Something broke?

Open an issue on the Issues tab with the run ID and the URL, and we'll look at it.

Is there a free bulk PageSpeed Insights checker?

Apify's free plan gives $5 of credit every month, which covers about 1,250 audits with your own free Google API key, so for most small sites this checker is effectively free.

How do I check Core Web Vitals for many URLs at once?

Paste the URLs (or a whole sitemap's worth, see the Sitemap URL Extractor) into the urls field, pick mobile and/or desktop, and run. You get LCP, CLS, TBT and, with an API key, real-user INP for every page in one table.

Can I export PageSpeed scores to Google Sheets or CSV?

Yes. Download the dataset as CSV/Excel/JSON or connect the Google Sheets integration so every scheduled run appends fresh scores.

More tools from Datawright Labs

• Sitemap URL Extractor: get every URL of a site from its sitemaps.
• Website Screenshot API: bulk full-page screenshots and PDFs.
• Google Autocomplete Keyword Scraper: long-tail keyword ideas from Google, YouTube and Bing.
• Greenhouse, Lever & Ashby Jobs Scraper: normalized job feeds from 5 ATS platforms.
• Broken Link Checker: find broken links, images and redirects across a whole site.
• App Store Top Charts & Rank Tracker: daily top free/paid/grossing app rankings with rank changes.

Tip: feed it the output of the Sitemap URL Extractor to audit a whole website.

Made by Datawright Labs: reliable, fairly priced web data tools. Questions or a missing feature? Open an issue on the Issues tab; we usually reply within a day.