# Website Speed Checker (`onescales/website-speed-checker`) Actor

Easily get Website Speed Data with Google Lighthouse performance metrics & Core Web Vitals Tool (Performance Score, FCP, LCP, TBT, CLS, Speed Index) from any webpage/URL, whether you're analyzing or testing a single URL or thousands in bulk. Run scraper in seconds for one time, on schedule, or API.

- **URL**: https://apify.com/onescales/website-speed-checker.md
- **Developed by:** [One Scales](https://apify.com/onescales) (community)
- **Categories:** SEO tools, Developer tools, E-commerce
- **Features:** Limited permissions
- **Stats:** 224 total users, 5 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Website Speed Checker

Analyze website performance using Google Lighthouse. Get detailed speed metrics for both desktop and mobile devices automatically—no external APIs required, runs Lighthouse directly in this Apify app.

**Perfect for:** SEO audits, performance monitoring, competitor analysis, site optimization, and development testing.

**Important Note:** Lighthouse will provide results only for status code 200 - If any pages are 404, 301, 302, etc, the output result will show the status code along with 0's. Please make sure to provide valid pages.

### What You Get

This Actor runs Google Lighthouse performance audits and delivers comprehensive metrics for every URL you test:

- **Performance Score** - Overall score from 0-100
- **Core Web Vitals** - FCP, LCP, TBT, and CLS metrics
- **Speed Index** - How quickly content appears
- **Both Desktop & Mobile** - Automatically tests both devices with realistic throttling

Test one URL or thousands in a single run. Each URL takes approximately 30-60 seconds to analyze completely.

### Use Cases

- **Performance Monitoring** - Track speed metrics over time to maintain optimal user experience
- **Site Optimization** - Identify performance bottlenecks across your entire website
- **Competitor Analysis** - Benchmark your speed against competitors
- **Development Testing** - Validate performance improvements before going live
- **Client Reporting** - Generate detailed speed reports with hard data
- **SEO Audits** - Core Web Vitals are ranking factors—monitor them continuously

### How It Works

The Actor launches a real Chrome browser and runs Google Lighthouse with industry-standard configurations:

- **Desktop testing** - Simulated fast connection with desktop viewport (1920x1080)
- **Mobile testing** - Simulated 4G connection with mobile viewport (375x667)
- **Realistic throttling** - CPU and network throttling matches real-world conditions
- **Automatic status codes** - Captures HTTP responses including error pages

### Quick Start (Using the UI)

1. **Open the Actor** in your Apify Console
2. **Add your URLs**:
   - Click **+ Add URL** to add one URL at a time
   - Or use **Bulk edit** to paste multiple URLs (one per line)
   - Example URLs:
     ```
     https://example.com
     https://example.com/about
     https://example.com/contact
     ```
3. **Click Start** - That's it! The Actor automatically tests both desktop and mobile
4. **View results** in the Dataset tab when complete with the option to export to csv, excel (or google sheets) or json.

#### Optional Settings

- **Proxy Configuration** - Use Apify proxies to avoid rate limiting

### Understanding Your Results

Each URL returns these metrics for both desktop and mobile:

#### Performance Score (0-100)

- **90-100** - Excellent, fast site
- **50-89** - Needs improvement
- **0-49** - Poor, significant optimization needed

#### Core Web Vitals

**First Contentful Paint (FCP)**

- Time until first text or image appears
- **Good:** < 1,800ms | **Poor:** > 3,000ms

**Largest Contentful Paint (LCP)**

- Time until main content loads
- **Good:** < 2,500ms | **Poor:** > 4,000ms

**Total Blocking Time (TBT)**

- How long the page is unresponsive
- **Good:** < 200ms | **Poor:** > 600ms

**Cumulative Layout Shift (CLS)**

- Visual stability (lower is better)
- **Good:** < 0.1 | **Poor:** > 0.25

**Speed Index**

- How quickly content becomes visible
- **Good:** < 3,400ms | **Poor:** > 5,800ms

### Using the API (JSON Input)

For programmatic usage, send JSON input to the Actor:

#### Basic Example

```json
{
  "urls": [
    "https://example.com"
  ]
}
```

#### Multiple URLs Example

```json
{
  "urls": [
    "https://example.com",
    "https://example.com/about",
    "https://example.com/contact"
  ]
}
```

#### With Proxy Configuration

```json
{
  "urls": [
    "https://example.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

#### Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `urls` | array | Yes | Array of URLs to test (e.g., `["https://example.com"]`) |
| `proxyConfiguration` | object | No | Apify proxy settings |

### Output Format

Results are saved to the dataset with this structure:

```json
{
  "URL": "https://example.com",
  "Desktop-statusCode": 200,
  "Desktop-performanceScore": 95,
  "Desktop-firstContentfulPaint": 820,
  "Desktop-largestContentfulPaint": 1450,
  "Desktop-totalBlockingTime": 45,
  "Desktop-cumulativeLayoutShift": 0.012,
  "Desktop-speedIndex": 1200,
  "Mobile-statusCode": 200,
  "Mobile-performanceScore": 78,
  "Mobile-firstContentfulPaint": 1650,
  "Mobile-largestContentfulPaint": 2890,
  "Mobile-totalBlockingTime": 380,
  "Mobile-cumulativeLayoutShift": 0.089,
  "Mobile-speedIndex": 2450,
  "error": ""
}
```

#### Field Reference

| Field | Description | Values |
|-------|-------------|--------|
| `URL` | Tested webpage URL | string |
| `*-statusCode` | HTTP response code | 200 (success), 404 (not found), 0 (error) |
| `*-performanceScore` | Overall performance | 0-100 (higher is better) |
| `*-firstContentfulPaint` | First content render time | milliseconds |
| `*-largestContentfulPaint` | Main content load time | milliseconds |
| `*-totalBlockingTime` | Time page is unresponsive | milliseconds |
| `*-cumulativeLayoutShift` | Visual stability score | 0-1+ (lower is better) |
| `*-speedIndex` | Visual display speed | milliseconds |
| `error` | Error message if failed | string (empty if successful) |

All time values are in milliseconds. All metrics are captured for both Desktop and Mobile devices.

### Exporting Your Data

After the Actor completes:

1. Go to the **Dataset** tab in the Apify Console
2. Click **Export** and choose your format:
   - **CSV** - Best for Excel/spreadsheet analysis
   - **JSON** - Best for programmatic use
   - **Excel** - Formatted spreadsheet
   - **XML/RSS** - For feed integrations

For API access, retrieve results programmatically using the Apify API.

### Tips for Best Results

**Batch Processing**

- Testing 100 URLs takes approximately 50-100 minutes
- For large batches (1,000+ URLs), consider breaking into smaller runs
- Keep `maxConcurrency` at 1-2 for accurate results

**Timing Considerations**

- Each URL requires ~30-60 seconds for both desktop and mobile tests
- Budget ~1 minute per URL when planning runs
- Add buffer time for slower websites

**Troubleshooting**

- If you see status code 0, check if the URL is accessible
- Error messages appear in the `error` field
- Ensure URLs include `https://` or `http://`

### Need Help?

Questions or want to request features? We're here to help!

**Contact us:** [Fill out this form](https://docs.google.com/forms/d/e/1FAIpQLSfsKyzZ3nRED7mML47I4LAfNh_mBwkuFMp1FgYYJ4AkDRgaRw/viewform?usp=dialog)

***

### Related Keywords

core web vitals, cwt, website speed, bulk, actor, AI, API, apify, at scale, auditor, automated, automation, batch, bulk, checker, converter, crawler, cron, CSV, dataset, detector, downloader, Excel, export, exporter, extractor, fetcher, finder, free tool, generator, Google Sheets, HTML, ifttt, instant, JSON, lookup, make, make.com, maker, mass, MCP, monitor, n8n, no-code, no API key required, parser, PDF, pipeline, report, scanner, schedule, scheduled, scraper, spreadsheet, tool, validator, verifier, webhook, workflow, XML, zapier

Made in Austin, TX by <a href="https://onescales.com/">One Scales AI SEO Agency</a>

# Actor input Schema

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

List of URLs to test with Google Lighthouse. Each URL will be tested on both desktop and mobile devices. Click '+ Add URL' to add URLs one at a time, or use the bulk edit option to paste multiple URLs.

## `proxyConfiguration` (type: `object`):

Select proxies to use for your tests. Residential proxies are recommended for avoiding blocks.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://example.com/about",
    "https://example.com/contact"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `performanceMetrics` (type: `string`):

Complete Lighthouse performance data for all audited URLs

# 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://example.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("onescales/website-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://example.com"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("onescales/website-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://example.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call onescales/website-speed-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,onescales/website-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/0agGNDsYzPJbAje8T/builds/vhu20ebvaOovgeW3d/openapi.json