# Lighthouse Audit + Agentic Browsing (Chrome, no API key) (`budoucnost-ai/lighthouse-agentic-audit`) Actor

Google Lighthouse 13 in real Chrome: Performance, Accessibility, Best Practices, SEO and the new Agentic Browsing category for AI agents (llms.txt, ARD manifest, WebMCP). Core Web Vitals, every audit with affected elements, HTML/JSON reports, mobile and desktop. No API key or PageSpeed quota.

- **URL**: https://apify.com/budoucnost-ai/lighthouse-agentic-audit.md
- **Developed by:** [Budoucnost AI](https://apify.com/budoucnost-ai) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $40.00 / 1,000 lighthouse audits

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Lighthouse Audit with Agentic Browsing do?

This Actor runs **Google Lighthouse 13 in a real Chrome browser** on the Apify platform and returns the complete audit for any public URL: **Performance, Accessibility, Best Practices, SEO** and the new **Agentic Browsing** category that checks how well a website works for **AI agents** (llms.txt, the ARD manifest `/.well-known/ard.json`, WebMCP tools and forms, a well-formed accessibility tree). You get Core Web Vitals, every single audit with the affected elements, prioritised opportunities and the full HTML report, on **mobile and desktop**.

It is a **Lighthouse / PageSpeed Insights API alternative** that needs **no Google API key and no PageSpeed quota**, and it is the only way to get the Agentic Browsing category outside of Chrome DevTools, because the PageSpeed Insights API does not expose it.

### Why audit websites with this Actor?

- **Agentic Browsing included** – the Lighthouse category Google introduced for the agentic web: is your `llms.txt` valid Markdown with an H1, do you publish an `/.well-known/ard.json` manifest (Agentic Resource Discovery), are WebMCP tools registered with valid schemas, can an agent navigate your accessibility tree.
- **Everything Lighthouse knows, in one dataset item** – 150+ audits grouped by category with status (passed / failed / needs work / informative / manual / not applicable), display values and up to five affected elements per audit. No need to open the HTML report to find out *what* failed.
- **Real Chrome, stable scores** – simulated throttling with the same Moto G Power / slow 4G profile PageSpeed Insights uses; switch to DevTools throttling or none when you need it.
- **Bulk and scheduled** – audit up to 200 URLs per run, schedule weekly or monthly runs, and build a time series of scores. Works with the Apify API, webhooks, Zapier, Make and the Apify MCP server, so AI agents can call it directly.
- **Fair, per-audit pricing** – you pay per successful audit (one URL on one device). Pages that cannot be loaded or time out are returned as error rows and are free.

### What data does the Lighthouse Actor return?

| Field | Type | Description |
| --- | --- | --- |
| `url`, `finalUrl`, `strategy` | string | Audited URL, URL after redirects, `mobile` or `desktop` |
| `performanceScore`, `accessibilityScore`, `bestPracticesScore`, `seoScore`, `agenticBrowsingScore` | number 0–100 | Category scores exactly as Lighthouse shows them |
| `lcpMs`, `cls`, `tbtMs`, `inpMs`, `fcpMs`, `speedIndexMs`, `ttiMs`, `ttfbMs`, `totalByteWeight` | number | Core Web Vitals and lab metrics (milliseconds, CLS as a unitless number) |
| `opportunities` | array | Performance opportunities sorted by estimated savings (`savingsMs`, `savingsBytes`, `displayValue`) |
| `failedAudits`, `failedAuditsCount` | array, number | IDs of scored audits below 0.9 |
| `agenticBrowsing` | object | Score, `passed` flag and every Agentic Browsing check with status, description and affected elements |
| `audits` | array | Every category with its groups and all audits: `id`, `title`, `description`, `score`, `status`, `displayValue`, `group`, `weight`, `items` |
| `stackPacks`, `runWarnings` | array | Detected frameworks (React, WordPress…) and Lighthouse warnings |
| `reportUrl`, `reportJsonUrl` | string | Full HTML report and raw Lighthouse JSON in the run's key-value store |
| `lighthouseVersion`, `userAgent`, `benchmarkIndex`, `auditedAt`, `durationSecs`, `error` | mixed | Run metadata; `error` is set (and the row is free) when the page could not be audited |

### How to run a Lighthouse audit on Apify

1. Open the Actor and paste one or more **URLs** (one per line).
2. Pick the **device**: mobile, desktop or both.
3. Keep all five **categories** or deselect the ones you do not need (fewer categories run a bit faster).
4. Click **Start**. One audit takes 10–40 seconds on 4 GB of memory.
5. Read the scores in the **Output** tab, open the HTML report from `reportUrl`, or download the dataset as JSON, CSV or Excel.

To monitor a site, create a **Schedule** in Apify Console (for example the first day of every month) and compare `performanceScore` over time. Remember that Lighthouse scores naturally vary by 5–10 points between runs; react to trends, not to single measurements.

### How much does a Lighthouse audit cost?

The Actor uses **pay-per-event** pricing: a fixed price per **audit** (one URL on one device, see the pricing section of this page). Auditing a URL on both devices is two audits. Failed audits (unreachable page, sign-in wall, timeout) are not charged. There are no extra platform-usage fees on Apify paid plans; the price already includes the Chrome run.

With 4 GB of memory and the default concurrency of 1, a run audits roughly 90–200 pages per hour depending on how heavy the pages are.

### Input

See the **Input** tab for all options. The important ones:

- `urls` – pages to audit (https:// is added when missing, duplicates are removed, max 200 per run).
- `strategy` – `mobile` (default), `desktop` or `both`.
- `categories` – defaults to all five including `agentic-browsing`.
- `throttling` – `simulate` (default, like PageSpeed Insights), `devtools` or `none`.
- `includeAudits` – add the full audit list to each item (default on).
- `includeHtmlReport` / `includeJsonReport` – save the HTML report (default on) and the raw Lighthouse JSON (default off) to the key-value store.
- `locale` – language of audit titles and descriptions, e.g. `en`, `cs`, `de`, `es`.
- `timeoutSecs`, `maxConcurrency`, `extraChromeFlags` – for advanced tuning.

### Output example

```json
{
  "url": "https://www.example.com/",
  "finalUrl": "https://www.example.com/",
  "strategy": "mobile",
  "performanceScore": 79,
  "accessibilityScore": 100,
  "bestPracticesScore": 100,
  "seoScore": 100,
  "agenticBrowsingScore": 100,
  "lcpMs": 5213,
  "cls": 0,
  "tbtMs": 34,
  "inpMs": null,
  "fcpMs": 1846,
  "speedIndexMs": 3142,
  "ttfbMs": 108,
  "opportunities": [
    { "id": "image-delivery-insight", "title": "Improve image delivery", "displayValue": "Est savings of 367 KiB", "score": 0.5, "savingsMs": 150, "savingsBytes": 375808 }
  ],
  "failedAudits": ["image-delivery-insight", "largest-contentful-paint", "render-blocking-insight"],
  "agenticBrowsing": {
    "score": 100,
    "passed": true,
    "checks": [
      { "id": "agent-accessibility-tree", "title": "Accessibility tree is well-formed", "status": "pass" },
      { "id": "llms-txt", "title": "llms.txt follows recommendations", "status": "pass" },
      { "id": "webmcp-registered-tools", "title": "WebMCP tools registered", "status": "na" },
      { "id": "ard-schema", "title": "ARD manifest is valid", "status": "na" }
    ]
  },
  "audits": [
    { "id": "performance", "title": "Performance", "score": 79, "groups": [{ "id": "metrics", "title": "Metrics" }], "audits": [ { "id": "largest-contentful-paint", "title": "Largest Contentful Paint", "score": 0.36, "status": "fail", "displayValue": "5.2 s", "group": "metrics", "weight": 25, "items": [] } ] }
  ],
  "reportUrl": "https://api.apify.com/v2/key-value-stores/…/records/lh-www-example-com-mobile.html",
  "lighthouseVersion": "13.6.0",
  "auditedAt": "2026-11-01T17:50:12.000Z",
  "durationSecs": 24.3,
  "error": null
}
```

Field names (`performanceScore`, `lcpMs`, `opportunities`, `reportUrl`…) are compatible with the other Lighthouse Actors on Apify Store, so you can switch without changing your integration; `agenticBrowsing` and `audits` are additional.

### Tips

- **Mobile first.** Google ranks by the mobile experience; a performance score under 50 and red Core Web Vitals (LCP over 4 s, CLS over 0.25) deserve attention before anything else.
- **Lighthouse ≠ real users.** Lab metrics are measured in a simulated environment. For field data (Chrome UX Report) combine this Actor with Google Search Console or PageSpeed Insights.
- **Agentic Browsing is new.** Google marks the category as under development; expect checks to be added. "Not applicable" means the page has no forms or WebMCP tools to validate, not a failure.
- **Keep concurrency at 1** unless you give the run 8 GB; Lighthouse needs about two CPU cores per audit for accurate scores.

### FAQ

#### Does this Actor need a Google API key or PageSpeed Insights quota?

No. Lighthouse runs inside the Actor in a real Chrome browser. There is no daily quota.

#### Why do my scores differ from PageSpeed Insights or Chrome DevTools?

Lighthouse scores depend on the machine, network and moment of measurement; a 5–10 point spread between runs is normal. Simulated throttling (the default) is the most stable option. For a consistent trend, measure at the same time of day and compare medians of several runs.

#### What is the Agentic Browsing category?

A Lighthouse category introduced in version 13.5 that audits whether a website is usable by AI agents: a well-formed accessibility tree, a valid `llms.txt`, an optional Agentic Resource Discovery manifest at `/.well-known/ard.json` and WebMCP tool registrations. See the [Lighthouse documentation](https://developer.chrome.com/docs/lighthouse/agentic-browsing) for details.

#### Can I audit pages behind a login?

Not with this Actor; it audits public pages only. Pages that require sign-in return an error row and are not charged.

### Disclaimer

The Actor only loads public pages the way a browser does and stores the resulting audit; it does not extract or store personal data. Websites' terms of service still apply to how you use the results. Found a problem or need a feature? Open an issue in the **Issues** tab. Integrate the Actor through the **API** tab or the Apify MCP server.

# Actor input Schema

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

Pages to audit with Lighthouse, one per line. A missing https:// is added, duplicates are removed. Each URL is audited once per selected device.

## `strategy` (type: `string`):

Mobile emulates a Moto G Power on slow 4G (the same profile as PageSpeed Insights). Desktop uses a desktop profile. Both runs two audits per URL.

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

Lighthouse categories to run. Agentic Browsing is the new Lighthouse 13 category for AI agents (llms.txt, ARD manifest, WebMCP, accessibility tree); it is not available through the PageSpeed Insights API.

## `throttling` (type: `string`):

Simulate (default) matches PageSpeed Insights and gives the most stable scores. DevTools applies real network and CPU throttling and is slower. None measures raw speed from the Apify data centre.

## `includeAudits` (type: `boolean`):

Adds the complete list of audits per category (status, value, up to five affected elements) to each dataset item, so you do not need to download the report to see what failed.

## `maxOpportunities` (type: `integer`):

How many top improvement opportunities to include, sorted by estimated savings.

## `includeHtmlReport` (type: `boolean`):

Saves the full Lighthouse HTML report of every audit to the key-value store; the dataset item links to it in reportUrl.

## `includeJsonReport` (type: `boolean`):

Also saves the raw Lighthouse result JSON for your own tooling, linked in reportJsonUrl.

## `locale` (type: `string`):

Locale of audit titles and descriptions (any locale Lighthouse supports, e.g. en, cs, de, es, fr).

## `timeoutSecs` (type: `integer`):

Hard limit for one Lighthouse audit. A failed or timed-out audit is retried once and is not charged.

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

How many Chrome instances run at once. Keep 1 for the most accurate scores (Lighthouse needs about 2 CPU cores per audit); use 2 only with 8 GB of memory.

## `extraChromeFlags` (type: `array`):

Advanced: additional command-line flags for Chrome, e.g. --lang=cs.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "strategy": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo",
    "agentic-browsing"
  ],
  "throttling": "simulate",
  "includeAudits": true,
  "maxOpportunities": 10,
  "includeHtmlReport": true,
  "includeJsonReport": false,
  "locale": "en",
  "timeoutSecs": 120,
  "maxConcurrency": 1,
  "extraChromeFlags": []
}
```

# Actor output Schema

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

No description

## `reports` (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("budoucnost-ai/lighthouse-agentic-audit").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("budoucnost-ai/lighthouse-agentic-audit").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 budoucnost-ai/lighthouse-agentic-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,budoucnost-ai/lighthouse-agentic-audit"
        }
    }
}
```

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/WNYBFaDuAXk9vPAFR/builds/8aHUkIuphJNJ5PFnK/openapi.json