# Lighthouse CI Regression Gate (`hero98/lighthouse-release-regression-gate`) Actor

Lighthouse CI performance regression and pass/fail gate for 1–10 authorised public URLs, with explicit baselines, thresholds, and Core Web Vitals.

- **URL**: https://apify.com/hero98/lighthouse-release-regression-gate.md
- **Developed by:** [Suliman Tadros](https://apify.com/hero98) (community)
- **Categories:** Developer tools, SEO tools
- **Stats:** 2 total users, 0 monthly users, 57.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 url auditeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 CI Regression Gate

Lighthouse CI performance regression and pass/fail gate for one to ten
caller-authorised public URLs. It compares current Lighthouse category scores and Core
Web Vitals with explicit caller-supplied baselines, then returns `SNAPSHOT`, `PASS`, or
`REGRESSION` per URL.

This is an engineering signal, not a WCAG conformance test, legal opinion, usability
study, or guarantee of search/performance outcomes.

### Why it exists

One-off scores are noisy and easy to ignore. A release gate answers the narrower
question: **did this deployment get materially worse than the baseline we chose?**

The Actor checks:

- Lighthouse performance, accessibility, best-practices and SEO category scores;
- Largest Contentful Paint, Cumulative Layout Shift and Total Blocking Time deltas;
- optional minimum category scores; and
- configurable regression tolerances so tiny measurement variation does not fail a
  build.

### Use cases

- **Release and deployment gates:** fail a CI job when a new release crosses the
  performance or loading-metric tolerances your team selected.
- **Performance-budget checks:** enforce minimum Lighthouse scores and maximum changes
  in LCP, CLS and TBT without silently replacing the baseline.
- **Client-site maintenance:** let an agency recheck a bounded set of authorised public
  pages after a CMS, theme, tag-manager or dependency release.
- **Accessibility change detection:** flag a fall in Lighthouse's automated
  accessibility score so the team can investigate it alongside manual WCAG testing.
- **EAA-readiness engineering:** use repeatable automated checks as one input to a
  broader WCAG 2.2 AA / EN 301 549 review. This Actor does not determine legal scope or
  establish conformance.

### Input

The Store form starts with a publisher-owned demonstration URL so Apify's automated
quality test can exercise the real browser path without asserting permission on behalf
of another site owner. That exact demo is the only URL allowed without
`confirmPermission: true`; replace it with a public URL you control or may audit and
affirm permission explicitly.

```json
{
  "startUrls": [{ "url": "https://example.com/" }],
  "confirmPermission": true,
  "device": "mobile",
  "baselines": [
    {
      "url": "https://example.com/",
      "scores": {
        "performance": 92,
        "accessibility": 100,
        "bestPractices": 96,
        "seo": 100
      },
      "metrics": {
        "lcpMs": 1800,
        "cls": 0.02,
        "tbtMs": 100
      }
    }
  ],
  "thresholds": {
    "maxScoreDrop": 5,
    "maxLcpIncreaseMs": 500,
    "maxClsIncrease": 0.05,
    "maxTbtIncreaseMs": 200
  },
  "minimumScores": {
    "performance": 80,
    "accessibility": 90,
    "bestPractices": 80,
    "seo": 80
  },
  "failRunOnRegression": true
}
````

Run once without `baselines` to obtain the first snapshot. Copy the returned `scores`
and `metrics` into the next task/run input. Keeping the baseline explicit prevents a
hidden mutable state from silently changing the standard a release is judged against.

### Use through Apify MCP

AI agents can discover this Actor through Apify's hosted MCP server at
`https://mcp.apify.com`. Connect the official Apify MCP integration, search the Actor
Store for `Lighthouse CI Regression Gate`, inspect its input schema, and add the Actor
as a tool. Running an Actor requires the user's own Apify authentication and uses the
same pay-per-event pricing and input safeguards described below.

### GitHub Actions release gate

A dedicated
[GitHub Actions template repository](https://github.com/Hero988/lighthouse-release-regression-gate-ci)
contains the same capped workflow, setup instructions, and a **Use this template** path.

A complete copy-ready workflow is below and is also kept in
`examples/github-actions.yml` in the source package:

```yaml
name: Lighthouse release regression

on:
  workflow_dispatch:

permissions:
  contents: read

jobs:
  lighthouse-gate:
    runs-on: ubuntu-latest
    timeout-minutes: 7
    env:
      # Replace with a public URL you control or have permission to test.
      AUDIT_URL: https://hero988.github.io/-five-page-focus/
      APIFY_TOKEN: ${{ secrets.APIFY_TOKEN }}
    steps:
      - name: Run the capped regression gate
        shell: bash
        run: |
          set -euo pipefail
          test -n "${APIFY_TOKEN}"

          # Replace these baseline values with a snapshot from your URL.
          jq -n --arg url "${AUDIT_URL}" '{
            startUrls: [{url: $url}],
            confirmPermission: true,
            device: "desktop",
            baselines: [{
              url: $url,
              scores: {
                performance: 100,
                accessibility: 100,
                bestPractices: 96,
                seo: 100
              },
              metrics: {lcpMs: 251, cls: 0, tbtMs: 0}
            }],
            thresholds: {
              maxScoreDrop: 5,
              maxLcpIncreaseMs: 500,
              maxClsIncrease: 0.05,
              maxTbtIncreaseMs: 200
            },
            minimumScores: {
              performance: 80,
              accessibility: 90,
              bestPractices: 80,
              seo: 80
            },
            failRunOnRegression: true
          }' > actor-input.json

          curl --fail-with-body --silent --show-error --max-time 330 \
            --request POST \
            --header "Authorization: Bearer ${APIFY_TOKEN}" \
            --header "Content-Type: application/json" \
            --data-binary @actor-input.json \
            "https://api.apify.com/v2/acts/hero98~lighthouse-release-regression-gate/run-sync-get-dataset-items?timeout=300&maxTotalChargeUsd=0.05" \
            > actor-result.json

          jq -e 'length == 1 and .[0].verdict == "PASS"' actor-result.json
```

The workflow:

- keeps the Apify token in a repository secret named `APIFY_TOKEN` and sends it in an
  authorization header rather than a URL;
- confirms that the configured public target is authorised;
- supplies explicit baseline scores, metrics and tolerances;
- caps a one-URL run at `$0.05`; and
- fails the job unless the returned Dataset has exactly one `PASS` verdict.

Copy the workflow into `.github/workflows/lighthouse-regression.yml`, replace
`AUDIT_URL` and the example baseline with a snapshot from your own site, and add the
token under **Settings → Secrets and variables → Actions**. Start with
`workflow_dispatch`; once the result is stable, attach the job to the deployment event
that should be gated. GitHub does not pass repository secrets to workflows triggered
from forks, so do not weaken that boundary or print the token for pull-request tests.

### Output and billing

One Dataset item is returned per successfully audited URL. `OUTPUT` contains aggregate
counts and uncharged errors. Invalid, private/local, unresolved, robots-disallowed and
failed URLs create no Dataset result and no paid event.

Every completed result uses the configured `url-audited` event. Invalid, private/local,
unresolved, robots-disallowed and failed URLs remain uncharged.

Store pricing:

- event name: `url-audited`
- title: `URL audited`
- price: `$0.05`
- primary event: yes
- platform usage: paid by the user

Set a maximum cost per run when calling the Actor if you need a hard spending cap. A
one-URL run can be capped at `$0.05`; a ten-URL run can be capped at `$0.50`. The
separate Apify platform-usage cost depends on the run resources and is shown by Apify.

Uncharged execution is restricted in code to private `CLI`, `DEVELOPMENT`, or `TEST`
runs. If the platform does not supply an active pay-per-event pricing record, normal
API, web, scheduler and MCP runs fail closed rather than giving away an unmetered result.

The Actor uses Apify's lightweight official API client rather than importing a crawler
stack it does not need. It deliberately stores no credentials, cookies, authenticated pages, page HTML,
or screenshots. Apify's normal per-run Dataset and key-value retention still applies to
the returned scores, requested/final URLs, regressions and aggregate errors.

### Responsible use

- Test only public URLs you control or have permission to audit.
- Do not submit credentials, account/dashboard URLs, private-network hosts or sensitive
  query strings.
- The Actor rejects local/private DNS targets and respects an applicable `robots.txt`
  disallow rule for its declared user agent.
- It does not circumvent access controls, rate limits, anti-bot measures or robots.
- Lighthouse and automated accessibility scores cannot establish WCAG conformance.

### Frequently asked questions

#### Does this replace Lighthouse CI?

No. It is a hosted, bounded pass/fail workflow for teams that want an Apify API, task,
scheduler or MCP route with explicit baselines. If the open-source Lighthouse CI stack
already fits your infrastructure, keep using it.

#### Can this certify WCAG 2.2 AA, EN 301 549 or EAA compliance?

No. Automated tools cannot determine accessibility or legal compliance. Use the
accessibility score and reported audits as engineering signals, then complete manual
keyboard, screen-reader, zoom/reflow and content checks with a qualified human review.

#### Does the Actor choose or update my baseline?

No. The caller supplies the baseline on every comparison run. A first run without a
baseline returns `SNAPSHOT`; it does not silently create a mutable standard.

#### What causes a paid event?

Only a successfully completed URL that stores a result creates one `url-audited`
event. Invalid, private, disallowed, unreachable and failed URLs do not create that
event. Apify platform usage is separate.

#### Can I test authenticated or private pages?

No. The Actor accepts only public pages the caller confirms they control or may test.
It rejects credential-bearing URLs and local or private-network targets.

### Local development

```bash
npm ci
npm test
npm run test:integration
```

The integration test audits the public Five Page Focus demonstration by default. Set
`TEST_URL` to another authorised public page when needed.

# Actor input Schema

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

One to ten public HTTP(S) pages you control or have permission to test.

## `confirmPermission` (type: `boolean`):

Required for every URL except the prefilled publisher-owned demo. The Actor does not bypass authentication, robots rules, rate limits, or anti-bot controls.

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

Use Lighthouse's standard mobile or desktop configuration.

## `baselines` (type: `array`):

Previous scores/metrics keyed by the exact requested URL. Omit to create a first snapshot.

## `thresholds` (type: `object`):

A regression is reported only when a drop/increase exceeds these values.

## `minimumScores` (type: `object`):

Set any Lighthouse category floor from 0 to 100. Zero disables that floor.

## `failRunOnRegression` (type: `boolean`):

Useful as a CI gate. Results and summary are stored before the run fails.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://hero988.github.io/-five-page-focus/"
    }
  ],
  "confirmPermission": false,
  "device": "mobile",
  "baselines": [],
  "thresholds": {
    "maxScoreDrop": 5,
    "maxLcpIncreaseMs": 500,
    "maxClsIncrease": 0.05,
    "maxTbtIncreaseMs": 200
  },
  "minimumScores": {
    "performance": 0,
    "accessibility": 0,
    "bestPractices": 0,
    "seo": 0
  },
  "failRunOnRegression": false
}
```

# Actor output Schema

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

No description

## `summary` (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://hero988.github.io/-five-page-focus/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hero98/lighthouse-release-regression-gate").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://hero988.github.io/-five-page-focus/" }] }

# Run the Actor and wait for it to finish
run = client.actor("hero98/lighthouse-release-regression-gate").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 '{
  "startUrls": [
    {
      "url": "https://hero988.github.io/-five-page-focus/"
    }
  ]
}' |
apify call hero98/lighthouse-release-regression-gate --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Lighthouse CI Regression Gate",
        "description": "Lighthouse CI performance regression and pass/fail gate for 1–10 authorised public URLs, with explicit baselines, thresholds, and Core Web Vitals.",
        "version": "0.1",
        "x-build-id": "qOOgdJQEi6vaPSLQ8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hero98~lighthouse-release-regression-gate/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hero98-lighthouse-release-regression-gate",
                "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/hero98~lighthouse-release-regression-gate/runs": {
            "post": {
                "operationId": "runs-sync-hero98-lighthouse-release-regression-gate",
                "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/hero98~lighthouse-release-regression-gate/run-sync": {
            "post": {
                "operationId": "run-sync-hero98-lighthouse-release-regression-gate",
                "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",
                "required": [
                    "startUrls",
                    "confirmPermission"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Public URLs",
                        "minItems": 1,
                        "maxItems": 10,
                        "type": "array",
                        "description": "One to ten public HTTP(S) pages you control or have permission to test.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "description": "Public HTTP(S) page to audit.",
                                    "type": "string"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "confirmPermission": {
                        "title": "I have permission to test these URLs",
                        "type": "boolean",
                        "description": "Required for every URL except the prefilled publisher-owned demo. The Actor does not bypass authentication, robots rules, rate limits, or anti-bot controls.",
                        "default": false
                    },
                    "device": {
                        "title": "Lighthouse device profile",
                        "enum": [
                            "mobile",
                            "desktop"
                        ],
                        "type": "string",
                        "description": "Use Lighthouse's standard mobile or desktop configuration.",
                        "default": "mobile"
                    },
                    "baselines": {
                        "title": "Optional baselines",
                        "type": "array",
                        "description": "Previous scores/metrics keyed by the exact requested URL. Omit to create a first snapshot.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "Baseline URL",
                                    "description": "Exact requested URL this baseline belongs to.",
                                    "type": "string"
                                },
                                "scores": {
                                    "title": "Baseline scores",
                                    "description": "Previous Lighthouse category scores from 0 to 100.",
                                    "type": "object",
                                    "properties": {
                                        "performance": {
                                            "title": "Performance",
                                            "description": "Previous performance score.",
                                            "type": "number",
                                            "minimum": 0,
                                            "maximum": 100
                                        },
                                        "accessibility": {
                                            "title": "Accessibility",
                                            "description": "Previous automated accessibility score.",
                                            "type": "number",
                                            "minimum": 0,
                                            "maximum": 100
                                        },
                                        "bestPractices": {
                                            "title": "Best practices",
                                            "description": "Previous best-practices score.",
                                            "type": "number",
                                            "minimum": 0,
                                            "maximum": 100
                                        },
                                        "seo": {
                                            "title": "SEO",
                                            "description": "Previous automated SEO score.",
                                            "type": "number",
                                            "minimum": 0,
                                            "maximum": 100
                                        }
                                    }
                                },
                                "metrics": {
                                    "title": "Baseline metrics",
                                    "description": "Previous Lighthouse numeric loading metrics.",
                                    "type": "object",
                                    "properties": {
                                        "lcpMs": {
                                            "title": "LCP (ms)",
                                            "description": "Previous Largest Contentful Paint in milliseconds.",
                                            "type": "number",
                                            "minimum": 0
                                        },
                                        "cls": {
                                            "title": "CLS",
                                            "description": "Previous Cumulative Layout Shift value.",
                                            "type": "number",
                                            "minimum": 0
                                        },
                                        "tbtMs": {
                                            "title": "TBT (ms)",
                                            "description": "Previous Total Blocking Time in milliseconds.",
                                            "type": "number",
                                            "minimum": 0
                                        },
                                        "fcpMs": {
                                            "title": "FCP (ms)",
                                            "description": "Previous First Contentful Paint in milliseconds.",
                                            "type": "number",
                                            "minimum": 0
                                        },
                                        "speedIndexMs": {
                                            "title": "Speed Index (ms)",
                                            "description": "Previous Speed Index in milliseconds.",
                                            "type": "number",
                                            "minimum": 0
                                        }
                                    }
                                }
                            },
                            "required": [
                                "url"
                            ]
                        },
                        "default": []
                    },
                    "thresholds": {
                        "title": "Regression thresholds",
                        "type": "object",
                        "description": "A regression is reported only when a drop/increase exceeds these values.",
                        "properties": {
                            "maxScoreDrop": {
                                "title": "Maximum score drop",
                                "description": "Allowed category-score drop before regression.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 100
                            },
                            "maxLcpIncreaseMs": {
                                "title": "Maximum LCP increase (ms)",
                                "description": "Allowed LCP increase before regression.",
                                "type": "number",
                                "minimum": 0
                            },
                            "maxClsIncrease": {
                                "title": "Maximum CLS increase",
                                "description": "Allowed CLS increase before regression.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 1
                            },
                            "maxTbtIncreaseMs": {
                                "title": "Maximum TBT increase (ms)",
                                "description": "Allowed TBT increase before regression.",
                                "type": "number",
                                "minimum": 0
                            }
                        },
                        "default": {
                            "maxScoreDrop": 5,
                            "maxLcpIncreaseMs": 500,
                            "maxClsIncrease": 0.05,
                            "maxTbtIncreaseMs": 200
                        }
                    },
                    "minimumScores": {
                        "title": "Optional minimum category scores",
                        "type": "object",
                        "description": "Set any Lighthouse category floor from 0 to 100. Zero disables that floor.",
                        "properties": {
                            "performance": {
                                "title": "Performance minimum",
                                "description": "Performance floor; zero disables it.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 100
                            },
                            "accessibility": {
                                "title": "Accessibility minimum",
                                "description": "Automated accessibility floor; zero disables it.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 100
                            },
                            "bestPractices": {
                                "title": "Best practices minimum",
                                "description": "Best-practices floor; zero disables it.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 100
                            },
                            "seo": {
                                "title": "SEO minimum",
                                "description": "Automated SEO floor; zero disables it.",
                                "type": "number",
                                "minimum": 0,
                                "maximum": 100
                            }
                        },
                        "default": {
                            "performance": 0,
                            "accessibility": 0,
                            "bestPractices": 0,
                            "seo": 0
                        }
                    },
                    "failRunOnRegression": {
                        "title": "Fail Actor run on regression",
                        "type": "boolean",
                        "description": "Useful as a CI gate. Results and summary are stored before the run fails.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
