# Page Speed Checker - Website Speed Test & Lighthouse Scores (`tenfoldfleet/page-speed-checker`) Actor

Check the page speed of any website or list of URLs: run a Lighthouse speed test on mobile or desktop and get performance, accessibility, best practices and SEO scores, LCP, CLS, TBT and the issues to fix. Lab data. $12 per 1,000 page checks; failed URLs are free.

- **URL**: https://apify.com/tenfoldfleet/page-speed-checker.md
- **Developed by:** [Tenfold Fleet](https://apify.com/tenfoldfleet) (community)
- **Categories:** SEO tools, Agents, MCP servers
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.40 / 1,000 page checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Page Speed Checker do?

**Page Speed Checker** runs a **Lighthouse speed test** on every URL you give it, **in bulk**, and returns one clean row per page: the four **Lighthouse scores** (performance, accessibility, best practices, SEO, each 0-100), the **Core Web Vitals lab metrics** (LCP, CLS, TBT) with a good / needs improvement / poor rating, FCP, Speed Index, server response time, page weight, request counts and the **list of issues to fix** with estimated savings.

Test pages as a **phone**, as a **desktop** computer, or both. It works as a **page speed test API**: call it from the Apify API, a schedule, Make, Zapier, n8n or an AI agent through the Apify MCP server, and read the results as JSON, CSV or Excel. No API key and no browser to set up.

**Lab data only.** Every number comes from a fresh Lighthouse run in a controlled environment with simulated throttling. The Actor does **not** return real-user field data (the Chrome UX Report, CrUX), so there is no INP and no 28-day origin history. Lab scores change a little from run to run; compare trends, not single points. Not affiliated with Google.

### Why use a bulk website speed test?

- **SEO audits at scale:** score every landing page of a site in one run and sort by the slowest LCP.
- **Agency reports and pitches:** show a prospect their mobile performance score next to their competitors'.
- **Release and migration QA:** rerun the same URL list after a deploy and compare scores and page weight.
- **Monitoring:** schedule a daily or weekly run and alert when a page drops below 90 or its LCP passes 2.5 seconds.
- **Lead generation:** find businesses with slow websites and offer them a fix.
- **AI agents:** give an agent one tool that answers "how fast is this page and what should be fixed first?".

Need a full on-page crawl (titles, meta descriptions, canonicals, broken links, structured data)? Use our [SEO Audit Tool](https://apify.com/tenfoldfleet/seo-audit-tool). For a quick PASS/FAIL check of viewport and responsive CSS on thousands of URLs, use our [Mobile Friendly Test](https://apify.com/tenfoldfleet/mobile-friendly-test).

### What data can it extract?

![Sample output of Page Speed Checker, rows from a real run: URL, Device, Performance, Accessibility, Best practices, SEO](https://api.apify.com/v2/key-value-stores/4TBgG7fopkYMNWnX2/records/page-speed-checker-output.png)

| Field | What it tells you |
|---|---|
| `performanceScore`, `accessibilityScore`, `bestPracticesScore`, `seoScore` | The four Lighthouse category scores, 0-100 |
| `performanceRating` | good (90-100), needs improvement (50-89) or poor (0-49) |
| `lcpMs`, `lcpRating` | Largest Contentful Paint in milliseconds and its rating (good up to 2,500 ms) |
| `cls`, `clsRating` | Cumulative Layout Shift and its rating (good up to 0.1) |
| `tbtMs`, `tbtRating` | Total Blocking Time, the lab stand-in for responsiveness (good up to 200 ms) |
| `fcpMs`, `speedIndexMs`, `timeToInteractiveMs` | First Contentful Paint, Speed Index and Time to Interactive |
| `serverResponseTimeMs` | How long the server took to send the main document |
| `pageWeightBytes`, `requestCount`, `scriptCount`, `stylesheetCount`, `fontCount` | Total transfer size and how many requests the page makes |
| `mainThreadWorkMs`, `jsExecutionMs` | Main-thread work and JavaScript execution time |
| `issues` | Every failed audit: `category`, `id`, `title`, `score`, `detail`, `savingsMs`, `savingsBytes` |
| `issueCount`, `topIssues` | Number of failed audits and the five worst as one line of text |
| `device`, `finalUrl`, `warnings`, `lighthouseVersion`, `testedAt` | How and when the page was tested |

### How to check page speed for a list of URLs

1. Open the Actor and paste your pages into **URLs to check**, one per line. A bare domain such as `example.com` tests the home page.
2. Pick the **Device**: Mobile (default), Desktop, or Both for two rows per URL.
3. Click **Start**. One test takes about 15 to 60 seconds (heavy pages take the longest) and five run in parallel, so 100 URLs finish in roughly 10 minutes.
4. Open the **Page speed results** table, sort by `performanceScore` or `lcpMs`, and download the results as JSON, CSV or Excel.

### How much does it cost?

**$12 per 1,000 page checks** ($0.012 per check), plus a start fee of $0.00005 per run. One page check is one URL on one device, so testing mobile and desktop together is two checks per URL. All four score categories are included in that price.

**Free:** invalid URLs, duplicates, domains that do not resolve, sites that refuse the test browser, pages that do not load or time out after 120 seconds, and any row skipped because of a limit. Each gives a row with an `error` and costs nothing. Set a **maximum cost per run** and the Actor stops before it would pass it.

**Free Apify plan: 2 page checks per run, 10 per day.** Every test costs us a data fee and free-plan runs earn nothing, so runs on the free Apify plan test **the first 2 page checks** only, up to 10 new checks per day (UTC); the rest come back as free rows without data. Any paid Apify plan checks up to 500 URLs per run with no daily limit. A free run that repeats a check from the last 7 days gets the stored result of that check (`fromCache: true`); paid runs always test live.

### Input

```json
{
    "urls": ["https://apify.com", "https://apify.com/store"],
    "device": "both",
    "categories": ["performance", "accessibility", "bestPractices", "seo"],
    "includeIssues": true,
    "maxConcurrency": 5
}
```

Only `urls` is required. `device` is `mobile`, `desktop` or `both`. `categories` defaults to all four. Set `includeIssues` to `false` for compact rows with scores and metrics only.

### Output

One row per URL and device. Download the dataset as JSON, CSV, Excel or HTML, or read it through the API.

```json
{
    "input": "https://apify.com",
    "url": "https://apify.com/",
    "finalUrl": "https://apify.com/",
    "device": "mobile",
    "performanceScore": 60,
    "accessibilityScore": 100,
    "bestPracticesScore": 77,
    "seoScore": 85,
    "performanceRating": "needs improvement",
    "lcpMs": 2838,
    "lcpRating": "needs improvement",
    "cls": 0.009,
    "clsRating": "good",
    "tbtMs": 2840,
    "tbtRating": "poor",
    "fcpMs": 2203,
    "speedIndexMs": 5414,
    "timeToInteractiveMs": 30470,
    "serverResponseTimeMs": 180,
    "pageWeightBytes": 4713431,
    "requestCount": 196,
    "scriptCount": 97,
    "stylesheetCount": 3,
    "fontCount": 3,
    "mainThreadWorkMs": 9031,
    "jsExecutionMs": 5402,
    "issueCount": 19,
    "topIssues": "Minimize main-thread work; Reduce JavaScript execution time; Use efficient cache lifetimes; Forced reflow; Network dependency tree",
    "issues": [
        {
            "category": "performance",
            "id": "mainthread-work-breakdown",
            "title": "Minimize main-thread work",
            "score": 0,
            "detail": "9.0 s",
            "savingsMs": 2850,
            "savingsBytes": null
        },
        {
            "category": "performance",
            "id": "bootup-time",
            "title": "Reduce JavaScript execution time",
            "score": 0,
            "detail": "5.4 s",
            "savingsMs": 2700,
            "savingsBytes": null
        }
    ],
    "warnings": [],
    "dataType": "lab",
    "lighthouseVersion": "13.4.0",
    "testedAt": "2026-11-10T00:35:25.865Z",
    "fromCache": false,
    "error": null
}
```

A URL that could not be tested looks like this and is not charged:

```json
{
    "input": "not a url",
    "url": null,
    "device": null,
    "error": "Not a URL or domain: \"not a url\" (not charged)"
}
```

The `issues` array above is shortened to two entries; a real row lists every failed audit (19 for this page).

### Tips

- **Mobile scores are lower than desktop scores** for the same page: the mobile test slows the CPU four times and uses a slow 4G network profile. Compare like with like.
- **Scores vary a few points between runs.** For a decision, test the page two or three times on different days and look at the median.
- **Test the pages that earn money,** not only the home page: product, pricing, checkout and top blog posts.
- **Sort by `savingsMs` and `savingsBytes`** inside `issues` to find the fix with the biggest payoff.
- **Schedule it** and connect a webhook or an integration to track scores after every release.
- Pages behind a login or a bot-protection wall are tested as an anonymous visitor would see them, so the result may describe the login or challenge page.

### FAQ

#### Is this the same as PageSpeed Insights?

It runs the same open-source Lighthouse engine, so the lab scores and metrics mean the same thing. It does not include the field data section (real-user Core Web Vitals from the Chrome UX Report). Scores can differ by a few points because the test servers and their network location differ.

#### Does it return INP?

No. Interaction to Next Paint needs real user interactions, which only field data has. The lab metric closest to it is Total Blocking Time (`tbtMs`).

#### How many URLs can I check in one run?

Up to 500 URLs per run on a paid Apify plan (1,000 page checks with both devices). Split longer lists into several runs: URLs past the limit come back as free rows and are not tested. If a run gets close to its timeout, it stops starting new tests and lists the remaining URLs as free rows.

#### Why did a URL come back with an error?

The domain did not resolve, the site refused the test browser (some large sites block automated tests), the page did not load, or it did not finish within 120 seconds. Those rows are free. Check the URL in a browser and run it again.

#### Can I use it from an AI agent or my own code?

Yes. Call the Actor through the Apify API, the Apify client for JavaScript or Python, or the Apify MCP server. The input is a list of URLs and the output is plain JSON.

### Disclaimer

Lighthouse is an open-source project; this Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google. Results are lab measurements for diagnostics and do not predict search rankings. Test only pages you are allowed to load.

### More tools from Tenfold Fleet

| Actor | Output |
|---|---|
| [Facebook Page Email & Phone Finder - Leads from Page Links](https://apify.com/tenfoldfleet/facebook-page-contact-finder) | page with contact details |
| [Amazon Search Volume - Keyword Demand for Sellers & PPC](https://apify.com/tenfoldfleet/amazon-search-volume) | keyword with amazon volume |
| [ASO Keyword Rank Tracker: iOS & Android App Positions](https://apify.com/tenfoldfleet/aso-keyword-rank-tracker-app-store-google-play) | keyword check |
| [Backlinks Checker - Referring Domains, Anchors & Domain Rank](https://apify.com/tenfoldfleet/backlinks-checker) | backlink |
| [Bing Search Volume: Microsoft Ads Keyword Data in Bulk](https://apify.com/tenfoldfleet/bing-search-volume) | bing keyword batch |
| [ChatGPT Search Scraper: Brand Mentions & Citations per Prompt](https://apify.com/tenfoldfleet/chatgpt-search-scraper-answers-citations-brand-mentions) | prompt answered |
| [Google AI Overviews Checker - Citations & Domain Tracker](https://apify.com/tenfoldfleet/google-ai-overviews-checker) | keyword checked |
| [Google Images API - Image Search Results in 90+ Countries](https://apify.com/tenfoldfleet/google-images-api) | image result |
| [Google Keyword Planner Alternative - Ideas, Bids & Volume](https://apify.com/tenfoldfleet/google-keyword-planner) | keyword idea |
| [Google Maps Rank Tracker - Geo-Grid Rank Changes & Competitors](https://apify.com/tenfoldfleet/google-maps-rank-tracker) | grid point checked |
| [Google Trends Scraper - Search Interest by Region and Over Time](https://apify.com/tenfoldfleet/google-trends-scraper) | keyword |
| [Keyword Ideas & Related Keywords - Difficulty, Volume & CPC](https://apify.com/tenfoldfleet/keyword-ideas) | keyword idea |

All 122 tools: [apify.com/tenfoldfleet](https://apify.com/tenfoldfleet). If this Actor saves you time, save it (the bookmark on its Store page) and leave a review: both help other people find it. Found a bug or need another field? Tell us on the Issues tab of this page.

# Changelog

This Actor's version history is a separate document: https://apify.com/tenfoldfleet/page-speed-checker/changelog.md

# Actor input Schema

## `urls` (type: `array`):

Pages to test, one per line: full URLs (https://example.com/pricing) or bare domains (example.com, tested at its home page). Up to 500 URLs per run. One URL on one device = one page check at $0.012. Invalid, duplicate, unreachable and timed-out URLs are free. Free Apify plan: the first 2 page checks per run are tested, up to 10 new checks per day; the rest come back as free rows without data.

## `device` (type: `string`):

Test each page as a phone (throttled mobile network and CPU), as a desktop computer, or both. "Both" makes two page checks per URL and returns two rows.

## `categories` (type: `array`):

Which Lighthouse categories to score. All four cost the same as one, so leave them all on unless you want smaller rows. Speed metrics (LCP, CLS, TBT and the rest) need Performance.

## `includeIssues` (type: `boolean`):

Add an issues array to each row: every failed audit with its category, title, score and estimated savings (up to 40 per page). Turn off for compact rows with scores and metrics only.

## `maxConcurrency` (type: `integer`):

How many pages to test in parallel. One test takes about 15 to 60 seconds.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "device": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "bestPractices",
    "seo"
  ],
  "includeIssues": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tenfoldfleet/page-speed-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "urls": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("tenfoldfleet/page-speed-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://apify.com"
  ]
}' |
apify call tenfoldfleet/page-speed-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tenfoldfleet/page-speed-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ycokMSoXXKuH7V3I6/builds/KVl916mqTUG82NEWY/openapi.json
