# SiteVerdict — Core Web Vitals, Dead Click & SEO Scanner (`siteverdict/siteverdict-speed-revenue-scanner`) Actor

Real-browser scan on mobile (390px) and desktop: LCP, CLS with the exact elements that shift, TBT, TTFB, page weight, render-blocking files, oversized images, dead clicks, small tap targets, SEO basics and an optional revenue-impact estimate. Top 5 fixes ranked by impact + HTML report.

- **URL**: https://apify.com/siteverdict/siteverdict-speed-revenue-scanner.md
- **Developed by:** [Aman Thakran](https://apify.com/siteverdict) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## SiteVerdict: Core Web Vitals, Speed & Revenue Scanner

**Find out exactly what makes a site slow, which element to fix, what each tag costs, and roughly what slowness costs in revenue, in about 35–45 seconds per site.**

PageSpeed tells you a score. SiteVerdict tells you **what to do on Monday morning**:

- Which element is your LCP, with a screenshot, and why it is late: TTFB, late discovery, download or render delay.
- Which elements jump around, with close-up screenshots and a likely cause.
- How fast the page reacts to taps. We tap real menus and buttons and time them: a lab INP proxy.
- Which "buttons" do nothing. Every suspected dead click is clicked in a sandbox and kept only if nothing happens.
- Which third-party tags block the main thread, and for how many milliseconds each.
- A fix list ranked by impact ÷ effort, with the estimated LCP saving and revenue per fix.
- Optional extras: real-user data (CrUX), you vs 5 competitors, daily monitoring with Slack alerts, a white-label PDF, and AI-written code fixes using your own key.

It uses Lighthouse's scoring curves and PageSpeed's throttling constants, and it is benchmarked against Lighthouse; see the [benchmark](#benchmark-vs-lighthouse--pagespeed) for where the numbers agree and where they don't.

***

### Three ways people use it

**1. Agencies: win the pitch and the retainer.**

- Scan the prospect and up to 5 of their competitors in one run.
- Send a white-label PDF that says "you're #4 of 6 on mobile speed, here are the 5 fixes, ≈£2,300/month at stake (estimate)".
- Then schedule it daily with Slack alerts so you catch regressions before the client does.

**2. E-commerce owners: know which fix pays first.**

- Add your monthly visitors, conversion rate and order value.
- Every fix gets an effort rating and, where it affects LCP, an estimated monthly gain.
- The method and its sources are printed under every estimate.

**3. CRO and dev teams: catch UX killers before release.**

- Get verified dead clicks, slow taps (with the script responsible) and layout-shift culprits with screenshots.
- Run it after each deploy with `monitoringMode` so you only hear about changes.

***

### Before / after: what you get

**A typical PageSpeed wrapper gives you:**

```json
{ "url": "https://shop.example", "performance": 41, "LCP": 4800, "CLS": 0.21, "TBT": 760 }
```

**SiteVerdict gives you** (real output, trimmed, from the benchmark run on https://wordpress.org/ with the default Slow 4G profile, 11 Oct 2026):

```json
{
  "url": "https://wordpress.org/",
  "scores": { "overall": 89, "performance": 76, "ux": 100, "seo": 100 },
  "summary": "Overall 89/100 (performance 76, UX 100, SEO 100). Mobile LCP 3.81 s, CLS 0.017, tap response 144 ms, 0 dead click(s). Best first fix: Third-party tags block the main thread for ≈597 ms on mobile (top: Google Tag Manager) (medium effort).",
  "devices": { "mobile": {
    "lcpMs": 3808, "cls": 0.0168, "tbtMs": 590, "inpProxyMs": 144,
    "lcpElement": { "tag": "img", "selector": "figure.wp-block-image.size-full > img.wp-image-48979", "url": "https://i0.wp.com/wordpress.org/files/2025/12/wporg-69-design.png?w=720&ssl=1", "fetchpriority": null, "preloaded": false },
    "lcpPhases": { "ttfbMs": 591, "loadDelayMs": 417, "loadDurationMs": 729, "renderDelayMs": 2071, "bottleneck": "render-delay" },
    "interactions": [{ "kind": "button", "text": "Open menu", "latencyMs": 144, "inputDelayMs": 35, "processingMs": 86, "presentationMs": 23,
                       "scripts": [{ "entity": "First party (wordpress.org)", "durationMs": 78 }, { "entity": "Google Tag Manager", "durationMs": 5 }] }]
  } },
  "thirdPartyBreakdown": [{ "entity": "Google Tag Manager", "category": "tag-manager", "blockingMs": 597, "scriptMs": 754, "requests": 2, "transferBytes": 331410,
                            "topScripts": [{ "url": "https://www.googletagmanager.com/gtag/js?id=G-...", "scriptMs": 505 }] }],
  "topFixes": [
    { "id": "third-party-cost", "title": "Third-party tags block the main thread for ≈597 ms on mobile (top: Google Tag Manager)", "effort": "medium", "impact": 5.1, "priorityScore": 2.55 },
    { "id": "lcp-not-prioritised", "title": "The LCP image starts downloading 417 ms after the HTML arrives", "effort": "low", "impact": 1.6, "estLcpSavingsMs": 250,
      "fix": "Add fetchpriority=\"high\" to the LCP <img> (or <link rel=\"preload\" as=\"image\" fetchpriority=\"high\">)..." }
  ],
  "elementScreenshots": [{ "role": "lcp", "key": "shot-wordpress-org-lcp-0" }, { "role": "layout-shift", "key": "shot-wordpress-org-layout-shift-1" }]
}
```

Add `monthlyVisitors`, `conversionRatePct` and `averageOrderValue` and each LCP fix also gets `estMonthlyRevenueGain`, plus a site-level `revenueImpact` block labelled "ESTIMATE - not a guarantee" with its assumptions and dated sources. The full item is in `docs/sample-output.json`.

In the key-value store you also get:

- an HTML report (`REPORT`)
- optional PDFs (`REPORT-<site>.pdf`)
- `COMPARISON`
- an agent-ready `SUMMARY`
- per-site `EVIDENCE-<site>` packs
- all screenshots

***

### Benchmark vs Lighthouse / PageSpeed

Measured 11 Oct 2026 against **Lighthouse 12.8.2** (the engine behind PageSpeed Insights), run locally on the same Chromium. The run was partial: 13–14 of 27 public sites are complete, because heavy jobs were paused while the shared server was overloaded. Full tables are in BENCHMARK.md.

| What we checked (mobile unless noted) | Result |
|---|---|
| Same LCP **element** as Lighthouse | **92%** of 12 sites |
| Desktop LCP / FCP / CLS in the same Google rating bucket | **93% / all / all** of the 13–14 completed sites (small, partial sample) |
| Mobile performance score: rank correlation with Lighthouse (Spearman ρ) | **0.71** |
| Mobile TBT: rank correlation | 0.64 |
| Wall time per URL, both devices | **35 s** for everything on this page vs 40 s for Lighthouse's performance audit only |
| Extras Lighthouse wrappers don't output | LCP screenshot on 13/13 sites, shift-culprit screenshots on 10, tap-test INP proxy on 12 |

**Honest caveat.** On mobile, Lighthouse/PageSpeed *simulate* a slow phone. Their absolute numbers come out higher than real, applied throttling: median LCP 5.3 s vs our 2.8 s. On an overloaded machine Lighthouse's simulated TBT also balloons (166 s on one site). So mobile **ranks** agree better than mobile **buckets** (31% same LCP bucket). Real-user CrUX data, which Google ranks on, is one input away (`googleApiKey`).

Method: Lighthouse runs back to back with SiteVerdict for each site; full method and per-site numbers in BENCHMARK.md.

#### Feature comparison (top Apify Store tools for "lighthouse / pagespeed / core web vitals", Oct 2026)

| | SiteVerdict | Lighthouse wrappers (e.g. lighthouse-auditor, website-speed-checker) | PSI API wrappers (e.g. page-speed-analyzer) |
|---|---|---|---|
| Mobile + desktop in one result | ✅ | ✅ / one per run | one device per report |
| LCP element + LCP breakdown | ✅ with screenshot | in the raw report only | in the raw report only |
| Layout-shift culprits | ✅ with screenshots + likely cause | ❌ | ❌ |
| Tap-response test (INP proxy) | ✅ | ❌ (lab has no INP) | ❌ |
| Dead clicks, verified by clicking | ✅ | ❌ | ❌ |
| Third-party cost per vendor (ms) | ✅ | ❌ | ❌ |
| Real-user CrUX data | ✅ (your key) | ❌ | some |
| You vs 5 competitors table | ✅ | ❌ | ❌ |
| Monitoring + Slack/webhook alerts | ✅ | ✅ (lighthouse-auditor) | ❌ |
| White-label PDF | ✅ | ❌ | ❌ |
| AI code fixes (your key) | ✅ | ❌ | ❌ |
| Revenue estimate with sources | ✅ (labelled estimate) | ❌ | ❌ |
| Needs Google PSI quota | no | no | yes |

***

### Pricing (pay per event)

| Event | Price |
|---|---|
| Page scanned (mobile + desktop, everything above) | $0.04 per page |
| Extra lab run (each extra load when "runs per device" is above 1) | $0.01 |
| Field data: real-user CrUX data returned (your Google key) | $0.005 per site |
| Competitor comparison | $0.05 per run |
| PDF report | $0.10 per site |
| AI fix pack (your LLM key returned usable fixes) | $0.05 per site |
| Regression alert delivered to Slack and/or a webhook | $0.01 |

**Examples:**

- 100 sites (home page each): 100 × $0.04 = **$4**.
- 100 sites with a PDF each: 100 × ($0.04 + $0.10) = **$14**.
- You vs 5 competitors: 6 × $0.04 + $0.05 = **$0.29**.
- 20 client sites monitored daily for 30 days with 3 runs per device: 600 × ($0.04 + 4 × $0.01) + about 10 alerts × $0.01 = **about $48/month**.

Nothing is charged for failed pages, robots-blocked pages, undelivered alerts or empty AI answers. Set "Max total charge" on the run to cap spend.

*These are the prices configured on the Actor (checked 15 Oct 2026). The Actor's pricing tab is always the authoritative source.*

***

### Input examples

**Audit a site and get the money estimate**

```json
{ "startUrls": [{ "url": "https://www.example-shop.co.uk" }], "monthlyVisitors": 80000, "conversionRatePct": 1.8, "averageOrderValue": 65, "currency": "GBP" }
```

**You vs competitors, with a white-label PDF**

```json
{ "startUrls": [{ "url": "https://client.com" }], "competitorUrls": [{ "url": "https://rival-a.com" }, { "url": "https://rival-b.com" }],
  "pdfReport": true, "agencyName": "Northwind Digital", "agencyLogoUrl": "https://northwind.example/logo.png" }
```

**Daily monitoring with Slack alerts** (schedule the Actor in Apify)

```json
{ "startUrls": [{ "url": "https://client.com" }, { "url": "https://client.com/pricing" }], "monitoringMode": true, "monitorName": "client-daily",
  "runsPerDevice": 3, "onlyChanged": true, "slackWebhookUrl": "https://hooks.slack.com/services/..." }
```

**Real-user data + AI fixes** (both keys are yours, stored as secrets)

```json
{ "startUrls": [{ "url": "https://example.com" }], "googleApiKey": "AIza...", "aiProvider": "anthropic", "aiApiKey": "sk-ant-..." }
```

***

### How it works

1. **Real Chrome.** Each page loads on a 390×844 phone (touch, 4× CPU, Slow 4G by default: the PageSpeed profile) and on a 1366×768 desktop.
2. **Lab metrics.** LCP, CLS (session windows), TBT, FCP and TTFB come from Chrome's own performance APIs and are scored on Lighthouse's curves. Three to five runs per device give medians.
3. **Element evidence.** The LCP element and the top layout-shift nodes are marked, outlined and photographed. LCP is split into its four phases.
4. **Tap test.** Up to 6 safe elements are tapped under CPU throttling and timed with the Event Timing API. Scripts are attributed with the Long Animation Frames API.
5. **Click sandbox.** During the tap test and the dead-click checks, main-frame navigation and every non-GET request (forms, carts, APIs) are blocked. Pop-ups are closed and dialogs dismissed. We never click anything that reads buy, add to cart, checkout, pay, submit, sign in, register, book, accept or consent.
6. **Third parties.** Network bytes and long-frame script time are grouped by vendor (about 80 known vendors, the rest by domain).
7. **Fix list.** Each finding has an impact (score points), an effort rating and, where it can be reasoned about, an LCP saving and a revenue estimate.

***

### FAQ

**Why are my numbers different from PageSpeed Insights?** Several reasons:

- **Throttling method.** Lab tests vary run to run. PageSpeed simulates throttling, while we apply real network and CPU throttling.
- **Location.** PSI runs from Google's data centres.
- **What to rely on.** Our benchmark shows how closely we track PageSpeed. For decisions, use `runsPerDevice: 3` and add your Google key for real-user (CrUX) data, which is what Google ranks on.

**Is the revenue figure real?** It is an **estimate**, and every result is labelled that way.

- **Method:** each second of mobile LCP above 2.5 s is assumed to cost 4.42% of conversions (Portent 2019, 100M+ page views), capped at 5 s and compounded per second.
- **Basis:** real-user LCP is used when you supply a Google key.
- **Sources:** larger effects reported by Deloitte/Google 2020 and by the web.dev Vodafone case study are cited but not used.
- **Validation:** check it with an A/B test.

**Is clicking on my site safe?**

- Navigation and all non-GET requests are blocked during the click tests, so no form is posted and nothing is added to a basket.
- Risky-looking buttons are never clicked.
- You can turn off `testInteractions` and `verifyDeadClicks`.

**What is the INP proxy?** INP is measured from real users' interactions. In the lab we tap a few menus and buttons and time the next paint, the same measurement Chrome uses. Because we only try a few safe taps, it is a **lower bound**. Real-user INP comes from CrUX (Google key).

**Do you need my Google or LLM keys?** No, both are optional and stored as secrets. They are never logged or written to the output. The CrUX API is free; enable "Chrome UX Report API" in Google Cloud.

**Can I white-label the report?** Yes: set `agencyName`, `agencyLogoUrl` and `reportAccentColor`. The PDF footer then says "Generated by SiteVerdict for <your agency>".

**Does it work behind logins or on staging?** Only on publicly reachable pages. It does not log in or bypass bot protection. If a site blocks automated browsers, the result says so.

***

### Limits

- **Lab numbers vary.** Expect ±10–20% run to run. Use 3 runs per device for monitoring.
- **The INP proxy is a lower bound.** It covers up to 6 safe interactions per device.
- **CrUX needs traffic.** Small sites often have no real-user data; we fall back from URL to origin level and say so.
- **Third-party cost counts long frames only.** It covers script time inside long animation frames (>50 ms), which is what blocks users. Short scripts are not counted.
- **Some things are heuristics.** The layout-shift "likely cause" and the effort ratings are labelled as such.
- **Pages per run.** Up to 10 internal pages per site and 5 competitors per run.

### Compliance and sources

- **Respectful crawling:**
  - Loads only public pages, like a browser.
  - Respects robots.txt for start URLs and internal pages (it can be turned off only for sites you own or are authorised to test).
  - Identifies itself with a `SiteVerdict-SpeedScanner` user-agent token.
  - Never bypasses CAPTCHAs, logins or bot protection.
  - No proxy rotation by default.
- **No personal data is collected.** Screenshots show the public page as any visitor would see it.
- **Real-user data:** Chrome UX Report API (Google), via your own key, with the collection period shown on every result.
- **Revenue sources** are cited with dates and links in every result:
  - Portent 2019 (archived) and 2022
  - Deloitte & Google "Milliseconds Make Millions" 2020
  - web.dev Vodafone case study
  - web.dev Web Vitals thresholds
- **Lighthouse:** scoring curves follow Lighthouse's published control points. Lighthouse is Apache-2.0 and is not bundled in this Actor.
- **Not legal or financial advice.** The revenue estimate is indicative only.
- **Where results are stored:** the default dataset and key-value store of the run (results, screenshots, HTML/PDF reports), inside your own Apify account. These default storages are unnamed. How long Apify keeps them is set by Apify and your plan, not by SiteVerdict ([Apify data retention](https://docs.apify.com/platform/storage/usage#data-retention)); you can delete them sooner in Apify Console.
- **Monitoring (off by default):** when you turn it on, each site's previous scores and finding IDs are kept in a **named** key-value store in your account called `siteverdict-speed-<your monitor name>`. Apify keeps named stores until you delete them.
- **Third parties you choose:** real-user data comes from Google's Chrome UX Report API with your own key (Google receives the URLs/origins queried). The optional AI fix pack sends the page URL, detected platform, the trimmed `<head>` and the findings to Anthropic or OpenAI under your own key and their terms. Alerts go only to the Slack/webhook URLs you enter.
- **What SiteVerdict keeps:** nothing. The Actor runs in your Apify account and sends no data to SiteVerdict.
- **Contact:** Use the Issues tab on this Actor's Store page.

# Changelog

This Actor's version history is a separate document: https://apify.com/siteverdict/siteverdict-speed-revenue-scanner/changelog.md

# Actor input Schema

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

Home pages or landing pages to scan. One dataset item per URL. A missing https:// is added automatically. In competitor mode the FIRST URL is treated as your site.

## `competitorUrls` (type: `array`):

Adds a side-by-side 'you vs competitors' table: same device, same throttling, same run. Each competitor is billed as one scanned page. Leave empty for a normal audit.

## `maxInternalPages` (type: `integer`):

Also scan up to this many internal pages (taken from home-page links, same host, robots.txt respected). Scores are averaged across all scanned pages. Every scanned page is billed as one 'page-scanned' event.

## `devices` (type: `string`):

Mobile = 390x844 px phone with touch and throttling; desktop = 1366x768 px, no throttling.

## `mobileThrottling` (type: `string`):

Slow 4G is the PageSpeed Insights / Lighthouse mobile profile (150 ms RTT, 1.6 Mbps, 4x CPU) - pick it when your client compares with PageSpeed. Fast 4G is a realistic UK/EU 4G connection and gives faster numbers.

## `runsPerDevice` (type: `integer`):

Load each page this many times per device and report the median (Google recommends 3-5 runs to smooth out lab noise; strongly recommended for monitoring). Each extra run is billed as 'extra-lab-run'.

## `testInteractions` (type: `boolean`):

Taps up to 6 safe elements (menus, accordions, tabs, plain buttons) and times the next paint with Chrome's Event Timing API. Navigation and every non-GET request are blocked during the test, and anything that looks like buy / submit / sign in / consent is never clicked.

## `verifyDeadClicks` (type: `boolean`):

Clicks each suspected dead click in the same sandbox and watches for any DOM, visual (CSS hover/focus menus), navigation or network reaction. Working elements are removed; confirmed ones are marked 'verifiedByClick'. Strongly reduces false positives.

## `saveScreenshots` (type: `boolean`):

Stores a mobile screenshot with layout-shift elements (red), dead clicks (orange) and the LCP element (blue) outlined, plus close-up crops of the LCP element and the top 3 layout-shift culprits.

## `googleApiKey` (type: `string`):

Your own Google Cloud API key with the free 'Chrome UX Report API' enabled. Adds real-user Core Web Vitals (LCP, INP, CLS, FCP, TTFB at p75, last 28 days) next to the lab numbers, and makes the revenue estimate use real-user LCP. Billed as 'field-data' only when Google returns data.

## `monthlyVisitors` (type: `integer`):

For the revenue-impact estimate. Leave empty for no money estimate.

## `conversionRatePct` (type: `number`):

Share of visits that convert, e.g. 2.1 for 2.1%.

## `averageOrderValue` (type: `number`):

Average revenue per conversion, in your currency.

## `currency` (type: `string`):

ISO currency code for the estimate, e.g. GBP, EUR, USD.

## `conversionLossPerSecondPct` (type: `number`):

Benchmark used for the estimate. Default 4.42 (Portent 2019 site-speed study). Replace it with your own data if you have it.

## `monitoringMode` (type: `boolean`):

Remembers each site's last scan (in a named key-value store in your account) and reports regressions/improvements vs that scan. Schedule the Actor (e.g. daily) to get continuous monitoring.

## `monitorName` (type: `string`):

Separate histories per client or project (e.g. 'client-a-weekly'). Same name = same history.

## `onlyChanged` (type: `boolean`):

In monitoring mode, sites whose numbers did not change meaningfully are left out of the dataset (they still appear in the SUMMARY record and are still billed, because they were scanned).

## `alertScoreDrop` (type: `integer`):

Overall or performance score drop that counts as a regression.

## `alertLcpIncreasePct` (type: `integer`):

Relative LCP increase that counts as a regression (it must also be at least 300 ms).

## `slackWebhookUrl` (type: `string`):

https://hooks.slack.com/services/... - a message is posted when a site regresses. Billed as 'regression-alert' only when delivered.

## `webhookUrl` (type: `string`):

Public https:// endpoint (Zapier, Make, n8n, your API) that receives a JSON payload when a site regresses.

## `pdfReport` (type: `boolean`):

Saves an A4 PDF per site (not for competitors) with scores, prioritised fixes, screenshots, the LCP breakdown, third-party costs and the revenue estimate. Billed as 'pdf-report' per PDF.

## `agencyName` (type: `string`):

Shown in the report title and footer (white label).

## `agencyLogoUrl` (type: `string`):

Public https:// image shown at the top of the HTML and PDF report.

## `reportAccentColor` (type: `string`):

Hex colour for the report header line, e.g. #0f766e.

## `aiProvider` (type: `string`):

Optional. Uses YOUR own API key to turn the top 5 findings into concrete code/config changes for the detected platform (WordPress, Shopify, Next.js...). Only scan evidence is sent (URLs, selectors, file names, metrics, a trimmed <head>). Billed as 'ai-fix-pack' per site only when fixes are returned; your LLM usage is billed by your provider.

## `aiApiKey` (type: `string`):

Your Anthropic or OpenAI API key. Never logged or stored in the output.

## `aiModel` (type: `string`):

Leave empty for the default (Anthropic: claude-sonnet-5-5; OpenAI: gpt-4.1-mini).

## `brokenLinkSample` (type: `integer`):

How many internal links from the home page to test for 4xx/5xx errors (light HEAD requests). 0 = skip.

## `saveEvidence` (type: `boolean`):

Stores a JSON evidence record per site (timestamps, user agents, HAR-lite request list with timings, screenshot links) in the key-value store.

## `respectRobotsTxt` (type: `boolean`):

Skip pages that robots.txt disallows for all user agents (not billed). Turn off only for sites you own or are authorised to test.

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

Sites scanned in parallel. Keep it low (1-2) for the most accurate timings; raise memory if you raise this.

## `settleTimeSecs` (type: `integer`):

Extra time after the load event to catch late layout shifts and long tasks.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time to wait for the load event.

## `userAgent` (type: `string`):

Leave empty to use standard Chrome desktop / Android user agents with a 'SiteVerdict-SpeedScanner' token (like PageSpeed's 'Chrome-Lighthouse').

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

Optional. Use Apify Proxy with a country to measure from your customers' region (proxies add latency, so timings will be a little slower).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.python.org/"
    }
  ],
  "maxInternalPages": 0,
  "devices": "both",
  "mobileThrottling": "slow-4g",
  "runsPerDevice": 1,
  "testInteractions": true,
  "verifyDeadClicks": true,
  "saveScreenshots": true,
  "currency": "GBP",
  "conversionLossPerSecondPct": 4.42,
  "monitoringMode": false,
  "monitorName": "default",
  "onlyChanged": false,
  "alertScoreDrop": 5,
  "alertLcpIncreasePct": 20,
  "pdfReport": false,
  "aiProvider": "none",
  "brokenLinkSample": 15,
  "saveEvidence": true,
  "respectRobotsTxt": true,
  "maxConcurrency": 2,
  "settleTimeSecs": 2,
  "navigationTimeoutSecs": 45,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `report` (type: `string`):

No description

## `summary` (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 = {
    "startUrls": [
        {
            "url": "https://www.python.org/"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("siteverdict/siteverdict-speed-revenue-scanner").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 = {
    "startUrls": [{ "url": "https://www.python.org/" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("siteverdict/siteverdict-speed-revenue-scanner").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 '{
  "startUrls": [
    {
      "url": "https://www.python.org/"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call siteverdict/siteverdict-speed-revenue-scanner --silent --output-dataset

```

## MCP server setup

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

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/EK6shRPXePRaddmUs/builds/8i7cEZiyCzqKEhk9n/openapi.json