The Mine Works
Audit Core Web Vitals for Hundreds of URLs at Once
← All posts
tutorial November 20, 2026 · 8 min read Updated November 20, 2026

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.

Try the scraper

The actor referenced in this article. Pay only for results delivered.

View the scraper →

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

FieldWhat it holds
url, final_url, strategy, statusThe page, where it ended up after redirects, the device, and ok
performance_score, accessibility_score, best_practices_score, seo_scoreLighthouse scores from 0 to 100
lcp_ms, cls, tbt_ms, fcp_msLab Core Web Vitals, each with a good, needs-improvement or poor rating at Google’s own thresholds
speed_index_ms, tti_ms, server_response_msOther timings, when Lighthouse reports them
total_byte_weight, request_count, dom_sizePage weight
opportunitiesPerformance fixes, biggest saving first: id, title, display_value, savings_ms, savings_bytes
failed_auditsAccessibility, best practices and SEO checks that failed: category, id, title, item_count
field_lcp_ms, field_inp_ms, field_cls, field_overallReal user data for the URL, only with your own key
origin_lcp_ms, origin_inp_ms, origin_cls, origin_overallReal user data for the whole site, only with your own key
engine, benchmark_index, lighthouse_version, audited_atHow 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
}
  • urls takes up to 1,000 pages per run. https:// is added when missing, and duplicates are audited once.
  • strategy is mobile (the default, and what Google uses for ranking), desktop or both. Both gives two rows per URL, and each is one audit.
  • categories picks which scores come back. Asking for fewer does not lower the price, so leave all four on unless you want a narrower sheet.
  • maxOpportunities sets how many performance fixes to list per page, 0 to 30.
  • pageLoadTimeoutSecs is how long Lighthouse waits for a page to load, 15 to 90 seconds.
  • apiKey is optional and covered in the next section.

With or without your own Google key

No key (default)Your own Google key
Who runs LighthouseThe actor’s own ChromeGoogle, as on pagespeed.web.dev
Event chargedauditaudit-own-key
Free plan, per audit$0.027$0.0135
Gold and above, per audit$0.0216$0.0108
Real user INP, LCP and CLSNoYes, when Google has data for the page or site
Pages audited at once14

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

EventWhen it is chargedFree planBronzeSilverGold and above
auditOne page on one device audited in the actor’s Chrome$0.027$0.0254$0.0235$0.0216
audit-own-keyOne page on one device audited with your Google key$0.0135$0.0127$0.01175$0.0108
run-startOnce 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_index before 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 Actor

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.

Apify Store

Find a ready-made scraper for your job

Apify has over 80,000 scrapers and automations, ours included. Start free with $5 of platform credit every month.