Audit Core Web Vitals for Hundreds of URLs at Once
Run Lighthouse on a whole list of pages, mobile and desktop, and get scores, Core Web Vitals and the top fixes as one spreadsheet row per page, with or without your own Google key.
The actor referenced in this article. Pay only for results delivered.
You need Core Web Vitals for more than one page. A client wants the speed of every template on their site, an SEO audit covers 300 product pages, or you want to know which of your blog posts fail LCP on mobile. pagespeed.web.dev checks one URL at a time, and the PageSpeed Insights API no longer answers without a key: every call the actor’s authors tried without one on 4 Nov 2026 came back 429 with a quota of 0. So you either click through hundreds of pages or set up a Google Cloud project and write a script around the quota.
Try it live: PageSpeed Audit. Pay per result delivered.
The PageSpeed Audit actor takes a list of URLs and runs Lighthouse 13 on each, on mobile, desktop or both. Every page and device becomes one flat row with four scores, lab Core Web Vitals with ratings, the biggest performance fixes and the checks that failed. It needs no key. If you do have a Google key, you can add it to get real user data and pay half.
What one row holds
| Field | What it holds |
|---|---|
url, final_url, strategy, status | The page, where it ended up after redirects, the device, and ok |
performance_score, accessibility_score, best_practices_score, seo_score | Lighthouse scores from 0 to 100 |
lcp_ms, cls, tbt_ms, fcp_ms | Lab Core Web Vitals, each with a good, needs-improvement or poor rating at Google’s own thresholds |
speed_index_ms, tti_ms, server_response_ms | Other timings, when Lighthouse reports them |
total_byte_weight, request_count, dom_size | Page weight |
opportunities | Performance fixes, biggest saving first: id, title, display_value, savings_ms, savings_bytes |
failed_audits | Accessibility, best practices and SEO checks that failed: category, id, title, item_count |
field_lcp_ms, field_inp_ms, field_cls, field_overall | Real user data for the URL, only with your own key |
origin_lcp_ms, origin_inp_ms, origin_cls, origin_overall | Real user data for the whole site, only with your own key |
engine, benchmark_index, lighthouse_version, audited_at | How and when the audit ran |
A page that could not be audited gets a row with _type: "not_audited", plus url, status and a note saying why. Those rows are free. Audit rows have no _type field, which makes them easy to separate.
The input
{
"urls": [
"https://example.com",
"https://example.com/pricing",
"https://example.com/blog"
],
"strategy": "both",
"categories": ["performance", "accessibility", "best-practices", "seo"],
"maxOpportunities": 5,
"pageLoadTimeoutSecs": 45
}
urlstakes up to 1,000 pages per run.https://is added when missing, and duplicates are audited once.strategyismobile(the default, and what Google uses for ranking),desktoporboth. Both gives two rows per URL, and each is one audit.categoriespicks which scores come back. Asking for fewer does not lower the price, so leave all four on unless you want a narrower sheet.maxOpportunitiessets how many performance fixes to list per page, 0 to 30.pageLoadTimeoutSecsis how long Lighthouse waits for a page to load, 15 to 90 seconds.apiKeyis optional and covered in the next section.
With or without your own Google key
| No key (default) | Your own Google key | |
|---|---|---|
| Who runs Lighthouse | The actor’s own Chrome | Google, as on pagespeed.web.dev |
| Event charged | audit | audit-own-key |
| Free plan, per audit | $0.027 | $0.0135 |
| Gold and above, per audit | $0.0216 | $0.0108 |
| Real user INP, LCP and CLS | No | Yes, when Google has data for the page or site |
| Pages audited at once | 1 | 4 |
To get a key, create a project in Google Cloud, enable the PageSpeed Insights API and create an API key. Google gives 25,000 queries a day for free. Paste the key into apiKey. It is stored encrypted and never appears in the output. If Google refuses the key or its quota runs out, the run stops with a message and that audit is not charged.
The key matters most for INP. INP needs real visitors, which a lab page load cannot measure, so rows without a key use TBT as the stand in. With a key, field_inp_ms and origin_inp_ms hold the real user numbers, but only for pages and sites with enough traffic for Google to have them.
Run it from Python
This reads a list of URLs from a file, audits each on both devices, writes a CSV, lists the pages that were skipped, and counts which fix shows up on the most pages, which is usually the one to make in a shared template.
pip install apify-client
import csv
import os
from collections import Counter
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
urls = [line.strip() for line in open("urls.txt", encoding="utf-8") if line.strip()]
run_input = {
"urls": urls,
"strategy": "both",
"categories": ["performance", "accessibility", "best-practices", "seo"],
"maxOpportunities": 5,
"pageLoadTimeoutSecs": 45,
}
if os.environ.get("PAGESPEED_API_KEY"):
run_input["apiKey"] = os.environ["PAGESPEED_API_KEY"] # half price, adds real user data
run = client.actor("themineworks/pagespeed-audit").call(run_input=run_input)
audits, skipped = [], []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
if item.get("_type") == "not_audited":
skipped.append(item)
elif "_type" not in item and item.get("status") == "ok":
audits.append(item)
with open("pagespeed.csv", "w", newline="", encoding="utf-8") as f:
writer = csv.writer(f)
writer.writerow(["url", "strategy", "performance", "accessibility", "best_practices", "seo",
"lcp_ms", "cls", "tbt_ms", "fcp_ms", "field_inp_ms", "top_fix"])
for a in audits:
fixes = a.get("opportunities") or []
writer.writerow([a["url"], a["strategy"], a.get("performance_score"), a.get("accessibility_score"),
a.get("best_practices_score"), a.get("seo_score"), a.get("lcp_ms"), a.get("cls"),
a.get("tbt_ms"), a.get("fcp_ms"), a.get("field_inp_ms", ""),
fixes[0]["title"] if fixes else ""])
mobile = [a for a in audits if a["strategy"] == "mobile"]
print(f"{len(audits)} audits, {len(skipped)} pages not audited")
for s in skipped:
print(f" skipped {s['url']}: {s.get('note', '')}")
print("\nSlowest mobile pages:")
for a in sorted(mobile, key=lambda a: a.get("performance_score") or 0)[:10]:
print(f" {a.get('performance_score')} LCP {a.get('lcp_ms')} ms {a['url']}")
common = Counter(fix["title"] for a in mobile for fix in a.get("opportunities") or [])
print("\nFixes found on the most mobile pages:")
for title, n in common.most_common(5):
print(f" {n} pages: {title}")
The last block is the useful one for a site audit. A fix that appears on 180 of 200 pages usually lives in one layout or one script, so one change moves them all.
What it costs
| Event | When it is charged | Free plan | Bronze | Silver | Gold and above |
|---|---|---|---|---|---|
audit | One page on one device audited in the actor’s Chrome | $0.027 | $0.0254 | $0.0235 | $0.0216 |
audit-own-key | One page on one device audited with your Google key | $0.0135 | $0.0127 | $0.01175 | $0.0108 |
run-start | Once per run, after the first audit row reached your dataset | $0.008 | $0.008 | $0.008 | $0.008 |
A worked example: 200 URLs on both devices is 400 audits. Without a key that is $10.80 on the Free plan or $8.64 on Gold and above, plus the $0.008 start fee. With your own key the same run is $5.40 on the Free plan or $4.32 on Gold.
Never charged: pages stopped by the first plain request (dead domain, 404, a file that is not a web page, a site that refuses automated visits), audits Lighthouse could not finish or score, duplicates, invalid addresses, the summary, info and error rows, and anything past your “Max cost per run”, because the budget is checked before each audit. A run with no finished audit pays no start fee.
Run it on a schedule
Save your input as a task in Apify Console, open Schedules and pick weekly or monthly. Compare each page with its own earlier rows, not with other sites: Lighthouse scores move by several points between runs even when nothing changed. A page that drops 5 points once is noise; a page that drops 20 and stays there is a regression. To get alerts, connect the run to Make, Zapier or n8n and post to Slack when a key page falls below a score you choose.
Limits worth knowing
- Lab numbers, not your users’ numbers. Without a key every metric is a lab measurement from one page load. Use your own key for real user INP, LCP and CLS.
- The machine affects the score. Check
benchmark_indexbefore comparing runs, and expect some difference from pagespeed.web.dev. - One page at a time without a key. Each page and device took 8 to 81 seconds in a test of 16 sites, about 25 on average. 400 audits at that pace is close to three hours. With your key, 4 pages run at once.
- Public pages only. Sign in pages and private network addresses cannot be audited, and a site that blocks automated visits returns a free not audited row.
- INP needs traffic. Even with a key, a page with few visitors has no field data, and those fields stay empty.
Related
Explore the scraper referenced in this article: inputs, outputs, and pricing, then run it on Apify.
Frequently asked questions
Do I need a Google PageSpeed API key? +
No. Without a key the actor runs Lighthouse in its own Chrome. A key is optional: with it, Google runs each audit, the row adds real user field data such as INP when Google has it, and the audit is charged at the lower audit-own-key price.
Why does my score differ from pagespeed.web.dev? +
Without your key the audit runs on a different machine, and performance scores depend on CPU, so they can differ by some points. benchmark_index on each row records the machine speed. With your own key Google runs the audit, which is what pagespeed.web.dev shows.
Am I charged for pages that fail? +
No. A dead domain, a 404, a file that is not a web page, a site that refuses automated visits, an audit Lighthouse could not finish, duplicates and invalid addresses all come back as free rows or are skipped. The $0.008 start fee is charged only after the first audit row.
How many URLs can one run take? +
Up to 1,000. Choosing both devices doubles the audits, so 1,000 URLs on both is 2,000 audits. Pages run one at a time without a key and four at a time with one, so large lists take a while.
Build a Labeled Image Dataset From Google Images Search Terms
Turn one search term per class into a labeled image manifest with Google Images Scraper: full size URLs, width, height and the source page to check.
Track Which Sites Rank in Google Images for Your Keywords
Use Google Images Scraper to see which domains hold the top image positions for your keywords in each country, then rerun weekly to catch movement.
Track Whether Your Brand Is Cited in ChatGPT, Gemini, Google AI Mode and AI Overviews
Four actors, one job: ask the questions your buyers ask ChatGPT, Gemini, Google AI Mode and Google AI Overviews, and record whether your brand is named and your site is cited.
Compare Grocery Prices Across Woolworths, Coles and ALDI Australia
Pull the same aisle from Woolworths, Coles and ALDI Australia, put every product on a price per kg or per litre, and join Woolworths and Coles on the barcode.