Bulk PageSpeed Insights for a Sitemap

Run Google PageSpeed Insights on every page of your site in one go. Give it a sitemap, a homepage or a list of URLs. You get the Lighthouse performance score and Core Web Vitals (LCP, CLS, INP, TBT, FCP) for mobile and desktop, plus real-user Chrome data where Google has it, all in one spreadsheet.

• Bulk Lighthouse tests from a sitemap. No list to build by hand. It reads the sitemap, including nested indexes and gzipped files.
• Or just one page. Put a single URL in Page URLs to test and get mobile and desktop results in under a minute. One page works without an API key, on a shared quota that can run out.
• Ready for code and AI agents. Every output field is typed, and agents can run it through Apify's MCP server.
• Lab and field data. Lighthouse lab metrics, plus real-user INP, LCP and CLS from Chrome where Google has enough data.
• The fixes that save the most time. Lighthouse's top opportunities for each page, biggest saving first.
• Uses your free Google API key, so the daily quota is yours alone. Setup takes about two minutes (steps below).
• $2.50 per 1,000 tests, and failed tests are free. Other bulk PageSpeed Actors in the Store charge $5 to $100 per 1,000.

Read this first

Every run ends with a short summary in plain English, so you see which pages pass without reading the table. It's the first line of the run's status, SUMMARY.md on the Output tab (Summary), and the last row of the dataset (summaryText). It reads like this:

1 of 2 page tests fail Core Web Vitals.

## Core Web Vitals (2 page tests)
Field data is from real Chrome users (CrUX). Lab data is one Lighthouse test, where TBT stands in for INP. Limits: LCP 2.5 s, INP 200 ms, CLS 0.1, TBT 200 ms.

- Fail: https://example.com/, mobile, field data. LCP 3.4 s (limit 2.5 s). INP 120 ms. CLS 0.02.
- Pass: https://example.com/pricing, mobile, lab data. LCP 1.9 s. CLS 0.01. TBT 90 ms.

## Top fixes
1. Reduce unused JavaScript: up to 1.2 s faster, on 2 of 2 page tests.
2. Properly size images: up to 600 ms faster, on 1 of 2 page tests.
3. Render-blocking requests: up to 300 ms faster, on 2 of 2 page tests.

## Run
2 URLs on mobile: 2 tests done.

Each page is judged on real-user data when Google has it, and on the lab test otherwise, and the summary says which. Tests that didn't run are listed with the reason, such as a missing API key.

Quick start

1. Get a free Google API key (steps below) and paste it into Google API key.
2. Put your sitemap URL or homepage in Websites or sitemap URLs.
3. Click Start, then sort the results by performanceScore to find your slowest pages.

You can try it without a key. The form starts at 2 URLs on mobile, which costs $0.005.

What does Bulk PageSpeed Insights do?

Give it a website, a sitemap URL or a list of URLs. It reads the sitemap, then runs a PageSpeed Insights test on each URL, once for mobile and once for desktop (you can pick one). You get one row per URL and device, with the performance score and the metrics behind it.

It tests a few URLs without a key. For more, add your own Google API key. That takes about two minutes to get, and the steps are below.

When a test fails, the run doesn't fail with it. A page that times out, a quota limit or a bad key gives you a row that says what happened.

Here's what five rows look like:

url	device	performanceScore	lcpMs	cls	fieldInpMs
https://example.com/	mobile	62	4,100	0.12	240
https://example.com/	desktop	91	1,300	0.02	90
https://example.com/pricing	mobile	78	2,900	0.04	(no field data)
https://example.com/blog/launch	mobile	45	6,200	0.31	380
https://example.com/docs/start	desktop	97	800	0.00	(no field data)

(Example data.)

How to get a free Google PageSpeed API key (about two minutes)

Without a key, a run tests up to 2 URLs on a shared quota that can run out. For more, the Actor needs your own key. Here's why. Google's API works without one, but it's meant for occasional use, and Google recommends a key for frequent, automated queries. A bulk run is exactly that. With your own key, the daily quota is yours and nobody else's run can use it up. The key is free.

1. Open Google's PageSpeed Insights API: Get Started page and follow "Acquiring and using an API key". It takes you to the Credentials page in Google Cloud.
2. Pick or create a project, then click Create credentials and API key.
3. Turn on the PageSpeed Insights API for that project, if Google asks.
4. Optional but a good idea: restrict the key to the PageSpeed Insights API only.
5. Paste the key into the Actor's Google API key field.

The key is stored as a secret input. It's sent only to Google, in a request header, and it isn't shown in the run log, the dataset or any error message.

Who uses it

• SEO audits. Find the slowest pages on a site, not just the homepage.
• Before and after a release. Run it on the same sitemap twice and compare the scores.
• Agencies. Score every page of a client's site in one run and hand them the spreadsheet.
• Monitoring. Run it weekly on a schedule and catch a page that got slower.

Input

Field	What it does	Default
Websites or sitemap URLs	Homepages or sitemap URLs. Each is expanded to every URL in its sitemap.	none
Page URLs to test	Single pages, tested as given, before any sitemap pages.	none
Google API key	Your PageSpeed Insights API key (see above). Without one, a run tests at most 2 URLs on a shared quota, which can be used up.	none
Devices	Mobile, desktop or both.	both
Maximum URLs	Stops after this many URLs. Use it to test on a big site first.	100
Opportunities per test	How many of Lighthouse's improvement suggestions to list, biggest time saving first.	5
Tests in flight at once	Tests running at once. Keep it low if your key has a small quota.	4
Test timeout (seconds)	The longest one test may take, start to finish, retries included.	120

Give at least one website, sitemap or page URL. Input field names in the API: startUrls, urls, apiKey, devices, maxUrls, maxOpportunities, maxConcurrency, requestTimeoutSecs.

The form starts at 2 URLs on mobile. That runs without a Google API key and costs $0.005. Add your own free key to test more.

Example input:

{
  "startUrls": [{ "url": "https://example.com/sitemap.xml" }],
  "apiKey": "YOUR_GOOGLE_API_KEY",
  "devices": ["mobile", "desktop"],
  "maxUrls": 100
}

Output: Core Web Vitals for every URL

One row per URL and device. Export it from the Console as CSV, JSON, Excel, XML or HTML, or read it through the Apify API.

Field	What it holds
type	result for a test that ran, error for one that didn't, summary for the run's summary, always the last row.
url	The page tested.
device	mobile or desktop.
performanceScore	Lighthouse performance score, 0 to 100.
lcpMs	Largest Contentful Paint from the lab test, in milliseconds.
cls	Cumulative Layout Shift from the lab test.
tbtMs	Total Blocking Time from the lab test. The lab stand-in for INP.
fcpMs	First Contentful Paint from the lab test.
speedIndexMs	Speed Index from the lab test.
fieldInpMs	Interaction to Next Paint from real Chrome users, if Google has enough data for the page. Empty otherwise.
fieldLcpMs	Largest Contentful Paint from real Chrome users, if available.
fieldCls	Cumulative Layout Shift from real Chrome users, if available.
fieldFcpMs	First Contentful Paint from real Chrome users, if available.
fieldCategory	Google's overall rating from real users: FAST, AVERAGE or SLOW, if available.
fieldDataScope	url when the real-user data is for this page, origin when Google only has it for the whole site.
topOpportunities	Lighthouse's biggest improvement opportunities: id, title, savingsMs, savingsBytes.
topOpportunitiesText	The same, as one line for spreadsheets, e.g. render-blocking-resources (~1210 ms).
finalUrl	The URL Lighthouse ended on after redirects.
lighthouseVersion, fetchTime	Which Lighthouse ran the test, and when.
error	Empty when the row is fine. Otherwise it says what went wrong, like "quota exceeded" or "invalid API key".
summaryText	Only on the summary row. The run in plain English, the same text as SUMMARY.md (see Read this first).

Example row (JSON):

{
  "type": "result",
  "url": "https://example.com/",
  "device": "mobile",
  "performanceScore": 62,
  "lcpMs": 4100,
  "cls": 0.12,
  "tbtMs": 350,
  "fcpMs": 1800,
  "fieldInpMs": 240,
  "fieldLcpMs": 3200,
  "fieldCls": 0.08,
  "fieldCategory": "AVERAGE",
  "fieldDataScope": "url",
  "topOpportunitiesText": "render-blocking-resources (~1210 ms); unused-javascript (~450 ms, ~120 KiB)",
  "error": null
}

How much does it cost?

You pay per test: one URL on one device. There's no monthly fee, and Google doesn't charge for the API.

• Each test: $0.0025. Mobile and desktop are two tests, so a page on both devices is $0.005.
• A test that fails (quota, bad key, timeout, a page Lighthouse can't load) isn't charged.

A worked example. A site has 200 pages in its sitemap. Both devices: 400 tests × $0.0025 = $1.00. Mobile only: 200 tests × $0.0025 = $0.50.

Apify also charges its standard start fee for each run. Set Maximum URLs, or a maximum cost per run, for a hard ceiling: when the next test wouldn't fit under your maximum cost, the run stops and says so.

How it handles the hard cases

• No sitemap. You get one row with the error "no sitemap found" and nothing else is charged. The run finishes normally.
• Nested sitemap indexes and gzipped sitemaps. It reads them the same way as Sitemap URL Extractor & Status Checker.
• Quota limit (429 from Google). Retrying won't help until the quota resets, so the run stops at once. You keep every result so far, plus one error row with Google's own message and how many tests weren't run. Nothing is charged for the tests that didn't run. If Google says the quota limit is 0, the row says so, since waiting won't help.
• No key, and the shared quota is used up. Without a key, a run uses a shared quota, and it can be used up. Then no test runs: the run finishes with one error row that starts "0 tests ran", says the shared quota is used up and links to the page where you get a free key. The run's status says the same. Nothing is charged.
• No key, and no quota at all. Google's own keyless quota can be 0 tests a day (it was in October 2026). When Google answers that way, the row says an API key is required, not that a quota is used up.
• More URLs than the keyless limit. Without a key, only the first 2 URLs are tested. The rest are counted in the tests not run, in the error row or the run's status.
• Bad key. If Google refuses the key, the run stops on the first test. You get one error row with Google's message and a link to check the key, and the status says 0 tests ran. You aren't charged for a run of errors.
• When a run is marked failed. Only when the Actor itself breaks, or when every test failed on Google's side and the run stopped for that. A missing key, a used-up quota or a refused key is something you fix, so it's a finished run with a row that says what to do.
• Google's own hiccups. A 503 from Google is tried up to 3 times in all, with a pause between, as Google's API guidance says, and all within the test timeout. Any other error from Google comes back as an error row for that URL, not retried.
• Slow pages. A PageSpeed test usually takes 10 to 30 seconds. Each test gets 2 minutes by default (Test timeout), start to finish, retries and pauses included; past that it comes back as an error row.
• robots.txt. It reads robots.txt to find sitemaps and follows its rules for reading them. The page tests themselves are run by Google's servers, not by this Actor.
• Nothing but failures. If 20 tests in a row fail (or 10 minutes go on failed tests), the run stops and says so, instead of spending your time on a site Google can't test. Failed tests are never charged.
• Private addresses. Sitemaps on private or internal network addresses are refused with an error row.

Bulk PageSpeed Insights vs. the free tools

You can do this for free, one page at a time. Paste a URL into PageSpeed Insights and you get the same scores this Actor returns. Google Search Console has a Core Web Vitals report that groups your pages by real-user data. Lighthouse runs in Chrome's developer tools. For a handful of pages, that's all you need.

This Actor fits when you have dozens or hundreds of pages, want them in one spreadsheet, or want the same test every week. It reads the sitemap for you, runs the tests in the cloud and hands the results to your code through the API.

Compared with other PageSpeed Actors in the store, the difference is the sitemap input and how it fails. You give it a site, not a list you built by hand. A test that fails gives you a row that says why, not a failed run.

Not made by or affiliated with Google.

FAQ

How do I run PageSpeed Insights on many URLs at once? Put your sitemap URL or homepage in the input, add your Google API key and run it. You get one row per URL and device. Export it as CSV.

How do I test a single page? Put it in Page URLs to test (urls) and leave the sitemap field empty. No sitemap is read, mobile and desktop run in parallel, and the run usually takes 10 to 30 seconds. One page works without an API key, on the shared quota (which can run out).

How do I check Core Web Vitals for every page on my site? Give it your homepage or sitemap. Each row has the lab metrics (LCP, CLS, TBT) and, when Google has enough real-user data, the field values for LCP, CLS and INP. fieldDataScope says whether that field data is for the page itself or the whole site.

Why do I need my own API key? Google recommends a key for frequent, automated queries, and a bulk run is that. Your own key means the quota is yours alone. It's free, and the steps are in "Get your Google API key" above.

Why is INP empty for some pages? PageSpeed Insights only reports INP from real Chrome users. A page without enough visitors has no field data, so INP is empty. Use tbtMs from the lab test as the stand-in.

Why are my scores different from last time? Lab scores move a few points between runs, even on the same page. Compare trends across several runs, not one number.

What happens when I hit Google's quota? The run stops, keeps the results so far and adds one error row with Google's message and how many tests weren't run. If none ran, the row and the run's status start with "0 tests ran". The tests that didn't run aren't charged. You can see your key's quota on the Quotas page for the PageSpeed Insights API in Google Cloud.

Is my API key safe? It's stored as a secret input, sent only to Google in a request header, and never written to the log, the dataset or an error message. Restricting the key to the PageSpeed Insights API limits what it can be used for.

Can I run it on a schedule? Yes. Use Apify Schedules to run it weekly with the same input. Each run makes a new dataset, so you can compare scores over time.

Can an AI agent run it? Yes. Claude, ChatGPT and other MCP clients can find and run it through the Apify MCP server. It needs only a URL (in urls or startUrls), the API key is optional for up to 2 URLs, every output field is typed and described in the dataset schema, and it's approved for Apify's agentic payments, so an agent can pay for its own runs.

Can I call it from my own code? Yes. Start it and read the results through the Apify API or the Python and JavaScript clients. It also works with webhooks, Make, Zapier and Google Sheets.

Limits

• It needs your own Google API key for more than 2 URLs. Your key's daily quota caps how many URLs you can test in a day.
• It tests public pages. Google can't reach pages behind a login.
• Tests are slow, usually 10 to 30 seconds each, 4 at a time by default. A 500-URL run on both devices takes a while.
• It reads XML sitemaps, including gzipped ones. Plain-text and RSS sitemaps aren't read in this version.
• It runs in 256 MB by default. A sitemap file over 55 MB uncompressed is refused.

Integrations

This Actor runs on Apify, so everything the platform does works with it.

• API. Start a run and read the results from your own code, in any language. Apify API
• Schedules. Run it weekly and catch a page that got slower. Schedules
• Tasks. Save your input once as a task and run it again with one click, or on a schedule. Tasks
• Webhooks. Get a call to your own URL when a run succeeds or fails. Webhooks
• Google Sheets and Drive. Download the results as CSV or Excel and open them in Sheets. Or add a Google Sheets step after this Actor in Make or Zapier. Or send the files to a Google Drive folder. Datasets and exports, Google Drive
• Zapier, Make and n8n. Start a run from another app and send the results on to the next step. Zapier, Make, n8n
• AI agents (MCP). Claude, ChatGPT and other MCP clients can find and run this Actor through the Apify MCP server. Apify MCP server
• Other Actors. Pass this Actor's results to another Actor when a run finishes. Actor-to-Actor

The SEO toolkit

Five Actors that work together. All are priced per result, with no monthly fee.

Actor	What you get	Price
Website SEO Audit & Crawler	A 0–100 SEO score and a fix list for every page, with week-over-week changes	$5 / 1,000 pages
Broken Link Checker	Every 404, server error and redirect chain, with the page it's on	$1 / 1,000 links
Bulk PageSpeed Insights (this one)	Lighthouse score and Core Web Vitals for every URL, mobile and desktop	$2.50 / 1,000 tests
Sitemap URL Extractor	Every URL in a site's sitemaps, with lastmod and status codes	$0.50 / 1,000 URLs
Website Screenshot API	A clean full-page screenshot of every URL, with cookie banners and pop-ups hidden	$8 / 1,000 screenshots

Support

Found a bug or need a feature? Open an issue on this Actor's Issues tab. Include the run ID and the URL you gave it.

If it saved you time, a quick review on the Reviews tab helps other people find it.