# Lighthouse Checker (`literal_jacktree/lighthouse-checker`) Actor

Run batch Lighthouse audits for one or more URLs and return normalized performance, accessibility, best-practices, and SEO scores with key metrics and top failed audits.

- **URL**: https://apify.com/literal\_jacktree/lighthouse-checker.md
- **Developed by:** [Janice](https://apify.com/literal_jacktree) (community)
- **Categories:** SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Lighthouse Checker

Run structured Lighthouse audits for one or more URLs and get API-ready results with normalized scores, key metrics, and the top failed audits for each page.

### Why this actor exists

Most site audit tools either return too much raw Lighthouse data or bundle Lighthouse into a broader crawler. Lighthouse Checker stays narrow:

- batch Lighthouse audits for one or more URLs
- mobile or desktop presets
- normalized scores for performance, accessibility, best practices, and SEO
- key metrics like FCP, LCP, Speed Index, TBT, and CLS
- top failed audits with short recommendation text
- clean JSON output for automations, QA workflows, and agency reporting backends

Best fit for:
- developers and technical SEO operators
- agencies auditing multiple landing pages
- QA teams that want repeatable page-quality checks
- automations that need structured Lighthouse results, not raw report sprawl

### What you get

Each result returns:
- target URL and final URL
- device preset used
- normalized 0-100 scores
- key Lighthouse performance metrics
- top failed audits ranked by severity
- concise recommendation text
- clean per-URL error objects when an audit fails or times out

### Input

#### Minimal run

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

#### Batch run

```json
{
  "startUrls": [
    "https://example.com",
    "https://apify.com"
  ],
  "device": "desktop",
  "maxUrls": 10,
  "requestTimeoutSecs": 45,
  "topAudits": 5
}
```

### Example output

```json
{
  "summary": {
    "requestedUrlCount": 2,
    "auditedUrlCount": 2,
    "successCount": 2,
    "errorCount": 0,
    "device": "desktop",
    "timeoutSecs": 45,
    "topAuditsPerUrl": 5
  },
  "results": [
    {
      "url": "https://example.com/",
      "device": "desktop",
      "status": "ok",
      "scores": {
        "performance": 99,
        "accessibility": 100,
        "bestPractices": 93,
        "seo": 80
      },
      "metrics": {
        "firstContentfulPaintMs": 777.52,
        "largestContentfulPaintMs": 777.52,
        "speedIndexMs": 777.52,
        "totalBlockingTimeMs": 0,
        "cumulativeLayoutShift": 0
      },
      "topFailedAuditCount": 4,
      "topFailedAudits": [
        {
          "id": "meta-description",
          "title": "Document does not have a meta description",
          "score": 0,
          "displayValue": null,
          "recommendation": "Write a concise meta description that reflects the page content."
        }
      ],
      "error": null
    }
  ]
}
```

Full example files live in:

- `examples/basic-input.json`
- `examples/agency-batch-input.json`
- `examples/sample-output.json`
- `store-assets/pricing.md`
- `store-assets/screenshots.md`
- `store-assets/positioning.md`

### Pricing recommendation

Start with simple usage-based pricing in the Apify Store:

- free: small trial usage so buyers can validate output shape
- paid: usage-based per compute unit / per run through Apify standard billing
- positioning: cheaper than manual audits, faster than custom Lighthouse scripting

Detailed pricing notes are in `store-assets/pricing.md`.

### Positioning

**Positioning line:** Run batch Lighthouse audits and get clean JSON summaries you can plug into automations, dashboards, or client workflows.

Not positioned as:

- a full crawler
- a dashboard product
- an authenticated session tester
- a PDF reporting tool

That tighter scope keeps the actor easier to understand, cheaper to try, and more store-friendly.

### Categories and keywords

Recommended Apify Store categories:

- SEO
- Developer tools
- Monitoring and alerting

Core keywords:

- lighthouse
- pagespeed
- performance
- accessibility
- seo
- website audit
- qa
- developer tools

### Limits in v1

Deliberately not included in this version:

- dashboards or historical trends
- authenticated or cookie-injected audits
- custom throttling profiles
- PDF or HTML report exports
- screenshots, filmstrips, or trace artifacts in run output
- field-data enrichment from external APIs
- multi-run comparisons or diffing

### Local verification

```bash
cd ~/clawd/income-engine/streams/lighthouse-checker
npm run health
npm run test:local
node src/main.js
```

### Author

Built by [Janice / literal\_jacktree](https://apify.com/literal_jacktree).

# Actor input Schema

## `url` (type: `string`):

Optional single absolute URL to audit. If provided with startUrls, both sources are merged and de-duplicated.

## `startUrls` (type: `array`):

One or more absolute URLs to audit in a batch run. Duplicate URLs are removed automatically.

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

Choose the Lighthouse preset. Mobile is stricter, desktop is usually faster and less latency-sensitive.

## `maxUrls` (type: `integer`):

Safety cap for the batch size in one run. Extra URLs are ignored after de-duplication.

## `requestTimeoutSecs` (type: `integer`):

Hard timeout per audited URL. Timed-out pages return a clean per-URL error object instead of failing the whole run.

## `topAudits` (type: `integer`):

Maximum number of failed audits returned per URL in the summary output.

## Actor input object example

```json
{
  "url": "https://example.com",
  "startUrls": [
    "https://example.com"
  ],
  "device": "mobile",
  "maxUrls": 10,
  "requestTimeoutSecs": 60,
  "topAudits": 5
}
```

# 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 = {
    "url": "https://example.com",
    "startUrls": [
        "https://example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("literal_jacktree/lighthouse-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 = {
    "url": "https://example.com",
    "startUrls": ["https://example.com"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "url": "https://example.com",
  "startUrls": [
    "https://example.com"
  ]
}' |
apify call literal_jacktree/lighthouse-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=literal_jacktree/lighthouse-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lighthouse Checker",
        "description": "Run batch Lighthouse audits for one or more URLs and return normalized performance, accessibility, best-practices, and SEO scores with key metrics and top failed audits.",
        "version": "0.1",
        "x-build-id": "Pp4Ob1qFhHMjfmFLC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/literal_jacktree~lighthouse-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-literal_jacktree-lighthouse-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/literal_jacktree~lighthouse-checker/runs": {
            "post": {
                "operationId": "runs-sync-literal_jacktree-lighthouse-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/literal_jacktree~lighthouse-checker/run-sync": {
            "post": {
                "operationId": "run-sync-literal_jacktree-lighthouse-checker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "url": {
                        "title": "Single URL",
                        "type": "string",
                        "description": "Optional single absolute URL to audit. If provided with startUrls, both sources are merged and de-duplicated."
                    },
                    "startUrls": {
                        "title": "URLs to audit",
                        "type": "array",
                        "description": "One or more absolute URLs to audit in a batch run. Duplicate URLs are removed automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "device": {
                        "title": "Device preset",
                        "enum": [
                            "mobile",
                            "desktop"
                        ],
                        "type": "string",
                        "description": "Choose the Lighthouse preset. Mobile is stricter, desktop is usually faster and less latency-sensitive.",
                        "default": "mobile"
                    },
                    "maxUrls": {
                        "title": "Max URLs",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap for the batch size in one run. Extra URLs are ignored after de-duplication.",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Per-URL timeout seconds",
                        "minimum": 15,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Hard timeout per audited URL. Timed-out pages return a clean per-URL error object instead of failing the whole run.",
                        "default": 60
                    },
                    "topAudits": {
                        "title": "Top failed audits to return",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of failed audits returned per URL in the summary output.",
                        "default": 5
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
