# Lighthouse Audit — scores, lab metrics and failing audits (`hermeskd/lighthouse-audit`) Actor

Run Google's open-source Lighthouse in a real browser on page URLs, for mobile, desktop or both. Return performance, accessibility, best-practices and SEO scores, FCP, LCP, TBT, CLS and Speed Index, plus failing audits with fix hints. No Google account or key needed.

- **URL**: https://apify.com/hermeskd/lighthouse-audit.md
- **Developed by:** [Logan Parker](https://apify.com/hermeskd) (community)
- **Categories:** SEO tools, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.60 / 1,000 lighthouse audit runs

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

Give it page URLs; it runs Google's open-source Lighthouse in a real browser and returns the performance, accessibility, best-practices and SEO scores, the lab metrics (FCP, LCP, TBT, CLS, Speed Index) and every failing audit with its fix hint, for mobile, desktop or both. No Google account, key or quota is involved.

Development validation produced actual successful public-input records using the production Dockerfile and SDK entrypoint on GitHub-hosted Linux. The smoke input, all three tasks and every defined benchmark passed their exact expectations. The independent review completed on 2026-10-19; its findings are tracked in the committed fix report. Platform costs, settlement, publication and daily tests remain unverified.

### Call it from an agent

Through Apify's MCP server (https://mcp.apify.com) use `call-actor`:

```json
{
  "actor": "hermeskd/lighthouse-audit",
  "input": {
    "urls": [
      "https://docs.apify.com/platform/actors/publishing/monetize"
    ],
    "formFactor": "mobile"
  },
  "callOptions": {
    "maxTotalChargeUsd": 0.05,
    "timeout": 900
  },
  "waitSecs": 30
}
```

Then call `get-dataset-items` with the returned defaultDatasetId. Dedicated tool URL: https://mcp.apify.com?tools=hermeskd/lighthouse-audit

### Input

| Field | Type | Meaning |
|---|---|---|
| `urls` | array | Public HTTP(S) URLs to process; errors are uncharged. |
| `formFactor` | string | Audit mobile, desktop, or both; both is two successful audit events. |
| `categories` | array | Non-empty subset of the four Lighthouse categories. |
| `includeFullReport` | boolean | Write and verify the complete JSON report in key-value storage. |

### Output

| Field | Meaning |
|---|---|
| `url` | Input URL. |
| `finalUrl` | Final displayed URL. |
| `ok` | True only for a completed readable audit. |
| `formFactor` | Audited device profile. |
| `scores` | Integer percent scores; null for unselected/unscored categories. |
| `metrics` | Laboratory metrics; time in milliseconds and CLS unitless. |
| `failedAudits` | Every failing numeric/error audit; not-applicable audits omitted. |
| `lighthouseVersion` | Actual Lighthouse version. |
| `reportKey` | Readable JSON report key, only when requested. |
| `error` | Failure, always uncharged. |

Actual production-container record from 2026-10-18T20:25:37.778263+00:00 (code `f063187693578dd7551fa2bec552281e2f0f3e33`, smoke input, SDK local storage). The saved record is unchanged; local event logs do not prove Apify settlement.

```json
{
  "url": "https://docs.apify.com/platform/actors/publishing/monetize",
  "finalUrl": "https://docs.apify.com/actors/publishing/monetize",
  "ok": true,
  "formFactor": "mobile",
  "scores": {
    "performance": 44,
    "accessibility": 93,
    "bestPractices": 75,
    "seo": 92
  },
  "metrics": {
    "fcpMs": 2276.2038199999997,
    "lcpMs": 5706.97198,
    "tbtMs": 4802.846080000004,
    "cls": 0,
    "speedIndexMs": 4236.38681757417
  },
  "failedAudits": [
    {
      "title": "First Contentful Paint",
      "score": 0.75,
      "displayValue": "2.3 s",
      "description": "First Contentful Paint marks the time at which the first text or image is painted. [Learn more about the First Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-contentful-paint/).",
      "id": "first-contentful-paint"
    },
    {
      "title": "Largest Contentful Paint",
      "score": 0.16,
      "displayValue": "5.7 s",
      "description": "Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)",
      "id": "largest-contentful-paint"
    },
    {
      "title": "Speed Index",
      "score": 0.77,
      "displayValue": "4.2 s",
      "description": "Speed Index shows how quickly the contents of a page are visibly populated. [Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).",
      "id": "speed-index"
    },
    {
      "title": "Total Blocking Time",
      "score": 0,
      "displayValue": "4,800 ms",
      "description": "Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).",
      "id": "total-blocking-time"
    },
    {
      "title": "Max Potential First Input Delay",
      "score": 0,
      "displayValue": "1,310 ms",
      "description": "The maximum potential First Input Delay that your users could experience is the duration of the longest task. [Learn more about the Maximum Potential First Input Delay metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-max-potential-fid/).",
      "id": "max-potential-fid"
    },
    {
      "title": "Browser errors were logged to the console",
      "score": 0,
      "displayValue": null,
      "description": "Errors logged to the console indicate unresolved problems. They can come from network request failures and other browser concerns. [Learn more about this errors in console diagnostic audit](https://developer.chrome.com/docs/lighthouse/best-practices/errors-in-console/)",
      "id": "errors-in-console"
    },
    {
      "title": "Time to Interactive",
      "score": 0,
      "displayValue": "33.9 s",
      "description": "Time to Interactive is the amount of time it takes for the page to become fully interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).",
      "id": "interactive"
    },
    {
      "title": "Avoid multiple page redirects",
      "score": 0,
      "displayValue": "Est savings of 760 ms",
      "description": "Redirects introduce additional delays before the page can be loaded. [Learn how to avoid page redirects](https://developer.chrome.com/docs/lighthouse/performance/redirects/).",
      "id": "redirects"
    },
    {
      "title": "Uses third-party cookies",
      "score": 0,
      "displayValue": "19 cookies found",
      "description": "Third-party cookies may be blocked in some contexts. [Learn more about preparing for third-party cookie restrictions](https://privacysandbox.google.com/cookies/prepare/overview).",
      "id": "third-party-cookies"
    },
    {
      "title": "Minimize main-thread work",
      "score": 0,
      "displayValue": "10.7 s",
      "description": "Consider reducing the time spent parsing, compiling and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to minimize main-thread work](https://developer.chrome.com/docs/lighthouse/performance/mainthread-work-breakdown/)",
      "id": "mainthread-work-breakdown"
    },
    {
      "title": "Reduce JavaScript execution time",
      "score": 0,
      "displayValue": "8.0 s",
      "description": "Consider reducing the time spent parsing, compiling, and executing JS. You may find delivering smaller JS payloads helps with this. [Learn how to reduce Javascript execution time](https://developer.chrome.com/docs/lighthouse/performance/bootup-time/).",
      "id": "bootup-time"
    },
    {
      "title": "Preconnect to required origins",
      "score": 0,
      "displayValue": "Est savings of 140 ms",
      "description": "Consider adding `preconnect` or `dns-prefetch` resource hints to establish early connections to important third-party origins. [Learn how to preconnect to required origins](https://developer.chrome.com/docs/lighthouse/performance/uses-rel-preconnect/).",
      "id": "uses-rel-preconnect"
    },
    {
      "title": "Ensure text remains visible during webfont load",
      "score": 0.5,
      "displayValue": null,
      "description": "Leverage the `font-display` CSS feature to ensure text is user-visible while webfonts are loading. [Learn more about `font-display`](https://developer.chrome.com/docs/lighthouse/performance/font-display/).",
      "id": "font-display"
    },
    {
      "title": "Reduce the impact of third-party code",
      "score": 0,
      "displayValue": "Third-party code blocked the main thread for 4,630 ms",
      "description": "Third-party code can significantly impact load performance. Limit the number of redundant third-party providers and try to load third-party code after your page has primarily finished loading. [Learn how to minimize third-party impact](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/loading-third-party-javascript/).",
      "id": "third-party-summary"
    },
    {
      "title": "Some third-party resources can be lazy loaded with a facade",
      "score": 0.5,
      "displayValue": "1 facade alternative available",
      "description": "Some third-party embeds can be lazy loaded. Consider replacing them with a facade until they are required. [Learn how to defer third-parties with a facade](https://developer.chrome.com/docs/lighthouse/performance/third-party-facades/).",
      "id": "third-party-facades"
    },
    {
      "title": "Image elements do not have explicit `width` and `height`",
      "score": 0.5,
      "displayValue": null,
      "description": "Set an explicit width and height on image elements to reduce layout shifts and improve CLS. [Learn how to set image dimensions](https://web.dev/articles/optimize-cls#images_without_dimensions)",
      "id": "unsized-images"
    },
    {
      "title": "Missing source maps for large first-party JavaScript",
      "score": 0,
      "displayValue": null,
      "description": "Source maps translate minified code to the original source code. This helps developers debug in production. In addition, Lighthouse is able to provide further insights. Consider deploying source maps to take advantage of these benefits. [Learn more about source maps](https://developer.chrome.com/docs/devtools/javascript/source-maps/).",
      "id": "valid-source-maps"
    },
    {
      "title": "ARIA input fields do not have accessible names",
      "score": 0,
      "displayValue": null,
      "description": "When an input field doesn't have an accessible name, screen readers announce it with a generic name, making it unusable for users who rely on screen readers. [Learn more about input field labels](https://dequeuniversity.com/rules/axe/4.10/aria-input-field-name).",
      "id": "aria-input-field-name"
    },
    {
      "title": "Links do not have a discernible name",
      "score": 0,
      "displayValue": null,
      "description": "Link text (and alternate text for images, when used as links) that is discernible, unique, and focusable improves the navigation experience for screen reader users. [Learn how to make links accessible](https://dequeuniversity.com/rules/axe/4.10/link-name).",
      "id": "link-name"
    },
    {
      "title": "Serve static assets with an efficient cache policy",
      "score": 0.5,
      "displayValue": "44 resources found",
      "description": "A long cache lifetime can speed up repeat visits to your page. [Learn more about efficient cache policies](https://developer.chrome.com/docs/lighthouse/performance/uses-long-cache-ttl/).",
      "id": "uses-long-cache-ttl"
    },
    {
      "title": "Avoid enormous network payloads",
      "score": 0.5,
      "displayValue": "Total size was 4,564 KiB",
      "description": "Large network payloads cost users real money and are highly correlated with long load times. [Learn how to reduce payload sizes](https://developer.chrome.com/docs/lighthouse/performance/total-byte-weight/).",
      "id": "total-byte-weight"
    },
    {
      "title": "Defer offscreen images",
      "score": 0.5,
      "displayValue": "Est savings of 3 KiB",
      "description": "Consider lazy-loading offscreen and hidden images after all critical resources have finished loading to lower time to interactive. [Learn how to defer offscreen images](https://developer.chrome.com/docs/lighthouse/performance/offscreen-images/).",
      "id": "offscreen-images"
    },
    {
      "title": "Eliminate render-blocking resources",
      "score": 0,
      "displayValue": "Est savings of 1,320 ms",
      "description": "Resources are blocking the first paint of your page. Consider delivering critical JS/CSS inline and deferring all non-critical JS/styles. [Learn how to eliminate render-blocking resources](https://developer.chrome.com/docs/lighthouse/performance/render-blocking-resources/).",
      "id": "render-blocking-resources"
    },
    {
      "title": "Minify CSS",
      "score": 0.5,
      "displayValue": "Est savings of 6 KiB",
      "description": "Minifying CSS files can reduce network payload sizes. [Learn how to minify CSS](https://developer.chrome.com/docs/lighthouse/performance/unminified-css/).",
      "id": "unminified-css"
    },
    {
      "title": "Reduce unused CSS",
      "score": 0,
      "displayValue": "Est savings of 81 KiB",
      "description": "Reduce unused rules from stylesheets and defer CSS not used for above-the-fold content to decrease bytes consumed by network activity. [Learn how to reduce unused CSS](https://developer.chrome.com/docs/lighthouse/performance/unused-css-rules/).",
      "id": "unused-css-rules"
    },
    {
      "title": "Reduce unused JavaScript",
      "score": 0.5,
      "displayValue": "Est savings of 1,164 KiB",
      "description": "Reduce unused JavaScript and defer loading scripts until they are required to decrease bytes consumed by network activity. [Learn how to reduce unused JavaScript](https://developer.chrome.com/docs/lighthouse/performance/unused-javascript/).",
      "id": "unused-javascript"
    },
    {
      "title": "Enable text compression",
      "score": 0.5,
      "displayValue": "Est savings of 1,444 KiB",
      "description": "Text-based resources should be served with compression (gzip, deflate or brotli) to minimize total network bytes. [Learn more about text compression](https://developer.chrome.com/docs/lighthouse/performance/uses-text-compression/).",
      "id": "uses-text-compression"
    },
    {
      "title": "Avoid serving legacy JavaScript to modern browsers",
      "score": 0.5,
      "displayValue": "Est savings of 1 KiB",
      "description": "Polyfills and transforms enable legacy browsers to use new JavaScript features. However, many aren't necessary for modern browsers. Consider modifying your JavaScript build process to not transpile [Baseline](https://web.dev/baseline) features, unless you know you must support legacy browsers. [Learn why most sites can deploy ES6+ code without transpiling](https://philipwalton.com/articles/the-state-of-es5-on-the-web/)",
      "id": "legacy-javascript"
    },
    {
      "title": "Issues were logged in the `Issues` panel in Chrome Devtools",
      "score": 0,
      "displayValue": null,
      "description": "Issues logged to the `Issues` panel in Chrome Devtools indicate unresolved problems. They can come from network request failures, insufficient security controls, and other browser concerns. Open up the Issues panel in Chrome DevTools for more details on each issue.",
      "id": "inspector-issues"
    },
    {
      "title": "Links are not crawlable",
      "score": 0,
      "displayValue": null,
      "description": "Search engines may use `href` attributes on links to crawl websites. Ensure that the `href` attribute of anchor elements links to an appropriate destination, so more pages of the site can be discovered. [Learn how to make links crawlable](https://support.google.com/webmasters/answer/9112205)",
      "id": "crawlable-anchors"
    },
    {
      "title": "Use efficient cache lifetimes",
      "score": 0,
      "displayValue": "Est savings of 2,761 KiB",
      "description": "A long cache lifetime can speed up repeat visits to your page. [Learn more](https://web.dev/uses-long-cache-ttl/).",
      "id": "cache-insight"
    },
    {
      "title": "Document request latency",
      "score": 0,
      "displayValue": "Est savings of 50 ms",
      "description": "Your first network request is the most important.  Reduce its latency by avoiding redirects, ensuring a fast server response, and enabling text compression.",
      "id": "document-latency-insight"
    },
    {
      "title": "Duplicated JavaScript",
      "score": 0.5,
      "displayValue": "Est savings of 76 KiB",
      "description": "Remove large, duplicate JavaScript modules from bundles to reduce unnecessary bytes consumed by network activity.",
      "id": "duplicated-javascript-insight"
    },
    {
      "title": "Font display",
      "score": 0.5,
      "displayValue": "Est savings of 10 ms",
      "description": "Consider setting [font-display](https://developer.chrome.com/blog/font-display) to swap or optional to ensure text is consistently visible. swap can be further optimized to mitigate layout shifts with [font metric overrides](https://developer.chrome.com/blog/font-fallbacks).",
      "id": "font-display-insight"
    },
    {
      "title": "Forced reflow",
      "score": 0,
      "displayValue": null,
      "description": "A forced reflow occurs when JavaScript queries geometric properties (such as offsetWidth) after styles have been invalidated by a change to the DOM state. This can result in poor performance. Learn more about [forced reflows](https://developers.google.com/web/fundamentals/performance/rendering/avoid-large-complex-layouts-and-layout-thrashing#avoid-forced-synchronous-layouts) and possible mitigations.",
      "id": "forced-reflow-insight"
    },
    {
      "title": "Legacy JavaScript",
      "score": 0.5,
      "displayValue": "Est savings of 11 KiB",
      "description": "Polyfills and transforms enable older browsers to use new JavaScript features. However, many aren't necessary for modern browsers. Consider modifying your JavaScript build process to not transpile [Baseline](https://web.dev/articles/baseline-and-polyfills) features, unless you know you must support older browsers. [Learn why most sites can deploy ES6+ code without transpiling](https://philipwalton.com/articles/the-state-of-es5-on-the-web/)",
      "id": "legacy-javascript-insight"
    },
    {
      "title": "Network dependency tree",
      "score": 0,
      "displayValue": null,
      "description": "[Avoid chaining critical requests](https://developer.chrome.com/docs/lighthouse/performance/critical-request-chains) by reducing the length of chains, reducing the download size of resources, or deferring the download of unnecessary resources to improve page load.",
      "id": "network-dependency-tree-insight"
    },
    {
      "title": "Render blocking requests",
      "score": 0,
      "displayValue": "Est savings of 1,450 ms",
      "description": "Requests are blocking the page's initial render, which may delay LCP. [Deferring or inlining](https://web.dev/learn/performance/understanding-the-critical-path#render-blocking_resources) can move these network requests out of the critical path.",
      "id": "render-blocking-insight"
    }
  ],
  "lighthouseVersion": "12.8.2"
}
```

### Events and prices

| Event | Title | Charged when | FREE / BRONZE | SILVER | GOLD / PLATINUM / DIAMOND |
|---|---|---|---|---|---|
| `lighthouse-audit` | Lighthouse audit run | One successful URL audit for one form factor. | $0.012 | $0.0108 | $0.0096 |

Platform usage is not passed through. Apify's automatic actor-start event remains $0.00005 per started GB (one GB or less counts once). The synthetic dataset-item event is absent. Charge limits stop further paying work; unprocessed inputs receive uncharged errors. Completed readable pending events are settled on abort.

Worked cost example: ten successful primary events cost $0.12 at list, plus actor start. Failures are not included in that count.

### Limits and run time

1–20 URLs. mobile, desktop or both; both is two successful audits. Four categories or a non-empty subset. Each audit has a 120-second execution bound; every page request retains the shared 30-second deadline. JSON reports are bounded to 32 MiB. Scores are integers; missing/unselected scores and metrics are null. Browser traffic uses the connection guard and independently checked document/frame navigation. The browser uses its own user-agent with HermesBot appended. Page loads are limited to two per host per second; subresources belong to that page load.

Default run timeout is 900 seconds. Typical cold platform time, costs and the smallest passing memory have not been measured for this new implementation. Memory probes are evidence to collect later; configured memories are specification defaults, not measured claims.

### Errors

| Code | Meaning |
|---|---|
| `download_failed` | The request or connection failed within its bounded deadline. |
| `http_error` | The source answered an unsuccessful HTTP status. |
| `login_required` | The page is a sign-in wall; no authentication is attempted. |
| `lighthouse_error` | The audit engine failed; its runtime code is carried when available. |
| `robots_disallowed` | robots.txt forbids fetching the URL; no request was made to it. |
| `blocked_host` | The host is on the deny-list or resolves to a private or local address; no request was made. |
| `timeout` | The input did not finish within the run's time budget. |
| `source_schema_changed` | A source or tool response no longer has the verified protocol shape. |
| `internal_error` | Unexpected failure; the message carries the error class. |
| `invalid_input` | The run input passed the input schema but cannot be used; the message names the field. |
| `charge_limit_reached` | The run reached its maximum total charge; this input was not processed. |
| `too_large` | A documented response, expansion or traversal cap was exceeded. |

No failure record is charged. A run fails only when all input outcomes are Actor-side failures; caller errors and a mixture of caller/Actor failures do not fail the run.

### Sources and terms

Only process content you have the right to process. URL fetches obey HermesBot robots-group selection, the shared deny-list, public-address checks on connections and redirects, honest identity, deadlines and rate limits. No caller credentials, cookies, CAPTCHA solving, residential proxies or evasion. Public pages named by the caller are audited locally with Lighthouse 12.8.2 (Apache-2.0) and Chromium. This uses no Google account, PageSpeed API key or quota. Browser document navigations receive independent robots checks and every connection passes the address guard. Source reads and the exact release are recorded in the committed enumeration; a source-only HTTP read is not a public Actor run.

### Not affiliated

This Actor is not affiliated with Google, Apify, IANA, Verisign or other named protocol/source providers. Third-party names describe compatibility and source material.

### Related Hermes Actors

website-screenshot, lighthouse-audit, seo-page-audit, domain-availability, dns-and-email-auth, broken-links and sitemap-urls.

### Changelog

2026-10-17 (historical): initial implementation and fixture contracts; packaging and public production validation were incomplete on that date.

2026-10-18: all six production images, public smoke inputs, three tasks per Actor and defined benchmarks passed on GitHub-hosted Linux; exact code, records and image provenance are retained with the examples. These local SDK runs do not prove platform costs, settlement, publication, minimum memory, daily tests or payouts.

2026-10-19: independent-review repairs cover DNS privacy, malformed publisher URLs, empty sitemap failures, responsive assets and schema prefill, as applicable to this Actor. See the committed unit 4 fix report for measured verification and remaining platform NO-COVERAGE.

# Actor input Schema

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

Public HTTP(S) URLs to process; errors are uncharged.

## `formFactor` (type: `string`):

Audit mobile, desktop, or both; both is two successful audit events.

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

Non-empty subset of the four Lighthouse categories.

## `includeFullReport` (type: `boolean`):

Write and verify the complete JSON report in key-value storage.

## Actor input object example

```json
{
  "urls": [
    "https://docs.apify.com/platform/actors/publishing/monetize"
  ],
  "formFactor": "mobile",
  "categories": [
    "performance",
    "accessibility",
    "best-practices",
    "seo"
  ],
  "includeFullReport": false
}
```

# Actor output Schema

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

No description

## `files` (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://docs.apify.com/platform/actors/publishing/monetize"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hermeskd/lighthouse-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://docs.apify.com/platform/actors/publishing/monetize"] }

# Run the Actor and wait for it to finish
run = client.actor("hermeskd/lighthouse-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://docs.apify.com/platform/actors/publishing/monetize"
  ]
}' |
apify call hermeskd/lighthouse-audit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hermeskd/lighthouse-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/dSbr9k1Bgsk9JybrH/builds/5S7bGPkAhM1rDz8Wd/openapi.json