# B2B Website Lead Scoring & ICP Fit (`jorokotev/public-website-lead-fit`) Actor

B2B website lead scoring + company enrichment API for CRM enrichment, ICP fit, ABM/account research, Clay/Apollo/HubSpot/Salesforce, MCP/x402 AI agents. No contacts.

- **URL**: https://apify.com/jorokotev/public-website-lead-fit.md
- **Developed by:** [Joro Kotev](https://apify.com/jorokotev) (community)
- **Categories:** Marketing, Business
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

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

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

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

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

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

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

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

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


# README

## B2B Website Lead Scoring & Company Enrichment API — Apify Actor

Score public company websites as a low-cost **company enrichment API** for B2B lead scoring, CRM enrichment, ICP fit, account qualification, ABM account scoring, lead prioritization, sales prospecting, RevOps, GTM research, market mapping, account research, and website analysis. It returns one company-level row per website so growth teams can prioritize accounts before deeper manual research.

This Actor is designed for an **Apify Store / Pay-Per-Event (PPE)** path, not direct email outreach. It does **not** harvest emails, phone numbers, people, LinkedIn profiles, or login-wall data.

### Fast buyer workflow

1. Paste a list of public company website URLs from a CRM export, CSV, Clay table, Apollo account export, HubSpot/Salesforce/Pipedrive/Zoho account list, ABM target-account list, or AI-agent workflow.
2. Add your ICP keywords, such as `B2B`, `SaaS`, `RevOps`, `GTM`, `automation`, `integration`, `lead scoring`, `CRM`, `ABM`, `account research`, `account scoring`, `lead prioritization`, `buying signals`, `website analysis`, `HubSpot`, `Salesforce`, `Pipedrive`, `Zoho`, `Clay`, `Apollo`, `Zapier`, `n8n`, or `Make.com`.
3. Export the dataset rows to JSON/CSV or read them through the Apify API/MCP server.
4. Route `fit_score`, `crm_segment`, `fit_reasons`, and `recommended_action` back into Clay, HubSpot, Salesforce, Pipedrive, Zoho, Airtable, Google Sheets, Zapier, n8n, Make.com, or an AI sales/research agent.

The output is intentionally flat, company-level JSON so it works in Apify API calls, MCP/AI-agent tools, Clay's Apify integration, CRM imports, and spreadsheet workflows without custom parsing.

### Buyer use cases

Use this Actor when you need quick, low-cost account screening from public websites:

- score B2B lead lists before SDR/BDR outreach;
- qualify inbound accounts against an ICP;
- enrich CRM/company records with public positioning signals;
- compare SaaS, agency, platform, and service-provider websites;
- map a market segment for RevOps, GTM, sales ops, demand generation, or agency prospecting;
- filter out poor-fit or risky websites before paying for deeper enrichment.

Search terms this Actor is designed to satisfy: B2B lead scoring, website lead scoring, website qualification, ICP fit, account qualification, account research lead scoring, CRM account research, CRM enrichment, CRM enrichment API, company enrichment, company enrichment API, domain enrichment, domain enrichment API, public web research CRM, ABM account scoring, account-based marketing lead scoring, lead prioritization CRM, demand generation account scoring, RevOps account scoring, sales intelligence website analysis, website analysis lead generation, company scoring API, B2B website analyzer CRM, website qualification API, MCP CRM enrichment, GTM research, RevOps, Clay enrichment, Apollo account enrichment, HubSpot enrichment, Salesforce account scoring, Pipedrive CRM enrichment, Zoho CRM enrichment, Airtable lead scoring, Google Sheets lead scoring, Zapier lead scoring, n8n enrichment, Make.com workflow automation, no-code CRM lead scoring, sales pipeline scoring, MCP, AI agents, x402, agentic payments, lead generation, company scoring, account scoring, website analysis.

### Copy-paste API quickstart

Use the Actor as a small company scoring API or B2B website analyzer when a workflow needs flat lead-fit rows instead of a contact database.

Apify API callers can run a sample synchronously:

```bash
curl -X POST "https://api.apify.com/v2/actors/jorokotev~public-website-lead-fit/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"source":"sample","maxResults":3}'
````

AI-agent and MCP buyers can also probe Apify's x402 payment flow without an Apify token. A valid payment client should receive payment terms first, then retry with a payment signature:

```bash
curl -i -X POST "https://api.apify.com/v2/actors/jorokotev~public-website-lead-fit/run-sync-get-dataset-items" \
  -H "X-APIFY-PAYMENT-PROTOCOL: X402" \
  -H "Content-Type: application/json" \
  -d '{"source":"sample","maxResults":1}'
```

For CRM and Clay workflows, map `fit_score`, `fit_label`, `crm_segment`, `fit_reasons`, `recommended_action`, and `summary` back into account fields, then use your approved contact-data provider only if the account passes your ICP gate.

### Published example tasks

Use the public example tasks when you want a pre-filled buyer workflow instead of starting from a blank input form:

- [Score B2B SaaS websites for ICP fit](https://apify.com/jorokotev/public-website-lead-fit/examples/score-b2b-saas-websites-for-icp-fit) — sample SaaS account scoring for ICP fit and B2B lead qualification.
- [Qualify RevOps and sales automation accounts](https://apify.com/jorokotev/public-website-lead-fit/examples/qualify-revops-and-sales-automation-accounts) — RevOps, sales automation, CRM, pipeline, and revenue-intelligence account screening.
- [Enrich a CRM company list from public websites](https://apify.com/jorokotev/public-website-lead-fit/examples/enrich-crm-company-list-from-websites) — company-level CRM enrichment rows from public website URLs.

### What it does

Input public company website URLs, choose target ICP keywords, and get one structured lead-fit row per returned company:

- fit score and label;
- matched ICP keywords;
- trust-signal gaps;
- public page title / HTTP status / fetch status;
- risk flags;
- fit reasons, CRM segment, and recommended next action;
- concise summary;
- redacted text excerpt.

### Data and privacy policy

- Public website URLs only.
- Company-level analysis only.
- Emails, phone numbers, social profile URLs, and simple person-role hints are redacted from excerpts.
- No contact harvesting or contact export.
- No LinkedIn/login-wall/profile scraping.
- URL mode fetches only user-supplied URLs; it is not an open-ended crawler.
- URL mode blocks localhost, embedded credentials, cloud metadata hosts, private/link-local/reserved IPs, and redirects to non-public addresses before fetch.
- `robots.txt` is respected by default.

### Apify monetization posture

The intended Apify-only monetization path is PPE:

1. Keep the synthetic `apify-actor-start` event at the default low price.
2. Use Apify's synthetic default dataset item event (`apify-default-dataset-item`) for per-result charging, because every pushed result row is the value unit.
3. Keep result pricing at the current cautious first-launch setting Joro selected: `$0.002/result` unless manually changed later.
4. Keep strict caps: `maxUrls <= 50`, `maxResults <= 50`, per-URL timeout <= 30s, max bytes <= 300 KB.
5. Do **not** enable custom `Actor.charge()` events for this first Store launch; per-result billing should come from Apify's automatic dataset-item synthetic event to avoid double-charging or charge-without-row edge cases.

### Example input — live URL mode

```json
{
  "source": "urls",
  "startUrls": [
    {"url": "https://example.com"}
  ],
  "targetKeywords": ["B2B", "SaaS", "RevOps", "GTM", "automation", "integration", "lead scoring", "CRM", "ABM", "account research", "account scoring", "lead prioritization", "buying signals", "website analysis", "Clay", "HubSpot", "Salesforce", "Pipedrive", "Zoho", "Apollo", "Zapier", "n8n", "Make.com", "Airtable", "Google Sheets"],
  "negativeKeywords": ["casino", "adult", "crypto pump", "personal blog"],
  "minFitScore": 0,
  "maxUrls": 10,
  "maxResults": 10,
  "timeoutSeconds": 10,
  "maxBytes": 300000,
  "respectRobotsTxt": true,
  "includeErrorRows": false
}
```

### Example input — sample mode

```json
{
  "source": "sample",
  "targetKeywords": ["B2B", "SaaS", "RevOps", "GTM", "automation", "integration"],
  "negativeKeywords": ["casino", "adult", "crypto pump"],
  "minFitScore": 50
}
```

### Output fields

- `company`, `url`, `page_title`
- `http_status`, `fetch_status`
- `fit_score`, `fit_label`
- `matched_keywords`, `negative_keywords`
- `trust_signals`, `missing_trust_signals`
- `risk_flags`
- `fit_reasons`
- `crm_segment`
- `recommended_action`
- `automation_note`
- `summary`
- `redacted_text_excerpt`
- `observed_at`, `source_mode`

### API, MCP, Clay, and CRM usage

- Apify API users can run the Actor synchronously and receive dataset items directly, or run asynchronously and read the default dataset.
- AI agents and API buyers can also use Apify's x402 agentic-payment flow: call the Actor without an Apify token using `X-APIFY-PAYMENT-PROTOCOL: X402`, receive `402 Payment Required`, then retry with a valid `PAYMENT-SIGNATURE` header from an x402-compatible wallet/client.
- MCP / AI-agent users can expose Apify Actors through the Apify MCP server and consume the same flat dataset rows.
- Clay users can launch Apify Actor runs or retrieve results through Clay's Apify integration, then map `fit_score`, `crm_segment`, and `recommended_action` into a table.
- Apollo, HubSpot, Salesforce, Pipedrive, Zoho, and CRM users can import CSV/JSON rows as account-level enrichment, ABM scoring, and lead-prioritization fields. This Actor only scores companies; use your approved CRM/contact-data provider for any person/contact enrichment.
- Zapier, n8n, Make.com, Airtable, and Google Sheets users can trigger small public-URL batches and route flat result rows into existing review or enrichment workflows.

### Local checks

```bash
cd /home/hercules/hermes-workspace/deep-research/apify-hermes-passive-income-20260704/templates/public-website-lead-fit-actor
python3 -m py_compile src/lead_fit.py src/main.py tests/conftest.py tests/test_lead_fit.py
PYTHONPATH=. uvx --with pytest pytest -q
PYTHONPATH=. python3 -m src.main
APIFY_CLI_DISABLE_TELEMETRY=1 apify validate-schema
```

### Verified public Store / PPE status

- Public Actor slug: `jorokotev/public-website-lead-fit`.
- Pricing: Apify Pay Per Event (PPE), with one value event per default dataset item (`apify-default-dataset-item`) at `$0.002/result`.
- The Actor uses Apify's synthetic dataset-item charging; there is no custom `Actor.charge()` path in the code.
- Public URL guardrails, input schema validation, dataset schema validation, and local tests are part of the release package.
- Buyer guidance: start with sample mode or a small public-URL batch, then increase up to the documented `maxUrls` / `maxResults` caps.

# Actor input Schema

## `source` (type: `string`):

Use sample mode for testing or URL mode to score public company website URLs. URL mode fetches only the URLs you provide, with strict caps.

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

Company website URLs to score. Public pages only. The Actor blocks localhost, embedded credentials, metadata hosts, and private/link-local/reserved IP targets. Do not add LinkedIn/login-wall/profile/contact-export URLs.

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

Alternative simple URL list for API callers.

## `targetKeywords` (type: `array`):

Company-level keywords that increase fit score when present in public website text.

## `negativeKeywords` (type: `array`):

Keywords that reduce fit score when present.

## `minFitScore` (type: `integer`):

Return only companies with fit\_score >= this value.

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

Hard-capped at 50 to control cost and avoid runaway crawls.

## `maxResults` (type: `integer`):

Hard-capped at 50. In PPE, each pushed result may be billable depending on your Console pricing setup.

## `timeoutSeconds` (type: `integer`):

Network timeout per URL. Hard-capped at 30 seconds.

## `maxBytes` (type: `integer`):

Maximum bytes read from each page body. Hard-capped at 300000 bytes to control cost and memory.

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

When enabled, URLs disallowed by robots.txt are skipped without output.

## `includeErrorRows` (type: `boolean`):

If false, failed/robots-denied URLs are skipped. If true, error rows may be written to the dataset and may be billable under per-result pricing.

## `sites` (type: `array`):

Optional static site fixtures with company, url, and text fields. Used only in sample mode.

## Actor input object example

```json
{
  "source": "sample",
  "startUrls": [
    {
      "url": "https://example.com"
    }
  ],
  "targetKeywords": [
    "B2B",
    "SaaS",
    "RevOps",
    "GTM",
    "automation",
    "integration",
    "lead scoring",
    "CRM",
    "ABM",
    "account research",
    "account scoring",
    "lead prioritization",
    "buying signals",
    "website analysis",
    "HubSpot",
    "Salesforce",
    "Pipedrive",
    "Zoho",
    "Clay",
    "Apollo",
    "Zapier",
    "n8n",
    "Make.com",
    "Airtable",
    "Google Sheets"
  ],
  "negativeKeywords": [
    "casino",
    "adult",
    "crypto pump",
    "personal blog"
  ],
  "minFitScore": 0,
  "maxUrls": 10,
  "maxResults": 10,
  "timeoutSeconds": 10,
  "maxBytes": 300000,
  "respectRobotsTxt": true,
  "includeErrorRows": false
}
```

# 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://example.com"
        }
    ],
    "targetKeywords": [
        "B2B",
        "SaaS",
        "RevOps",
        "GTM",
        "automation",
        "integration",
        "lead scoring",
        "CRM",
        "ABM",
        "account research",
        "account scoring",
        "lead prioritization",
        "buying signals",
        "website analysis",
        "HubSpot",
        "Salesforce",
        "Pipedrive",
        "Zoho",
        "Clay",
        "Apollo",
        "Zapier",
        "n8n",
        "Make.com",
        "Airtable",
        "Google Sheets"
    ],
    "negativeKeywords": [
        "casino",
        "adult",
        "crypto pump",
        "personal blog"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jorokotev/public-website-lead-fit").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://example.com" }],
    "targetKeywords": [
        "B2B",
        "SaaS",
        "RevOps",
        "GTM",
        "automation",
        "integration",
        "lead scoring",
        "CRM",
        "ABM",
        "account research",
        "account scoring",
        "lead prioritization",
        "buying signals",
        "website analysis",
        "HubSpot",
        "Salesforce",
        "Pipedrive",
        "Zoho",
        "Clay",
        "Apollo",
        "Zapier",
        "n8n",
        "Make.com",
        "Airtable",
        "Google Sheets",
    ],
    "negativeKeywords": [
        "casino",
        "adult",
        "crypto pump",
        "personal blog",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("jorokotev/public-website-lead-fit").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://example.com"
    }
  ],
  "targetKeywords": [
    "B2B",
    "SaaS",
    "RevOps",
    "GTM",
    "automation",
    "integration",
    "lead scoring",
    "CRM",
    "ABM",
    "account research",
    "account scoring",
    "lead prioritization",
    "buying signals",
    "website analysis",
    "HubSpot",
    "Salesforce",
    "Pipedrive",
    "Zoho",
    "Clay",
    "Apollo",
    "Zapier",
    "n8n",
    "Make.com",
    "Airtable",
    "Google Sheets"
  ],
  "negativeKeywords": [
    "casino",
    "adult",
    "crypto pump",
    "personal blog"
  ]
}' |
apify call jorokotev/public-website-lead-fit --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jorokotev/public-website-lead-fit",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "B2B Website Lead Scoring & ICP Fit",
        "description": "B2B website lead scoring + company enrichment API for CRM enrichment, ICP fit, ABM/account research, Clay/Apollo/HubSpot/Salesforce, MCP/x402 AI agents. No contacts.",
        "version": "0.1",
        "x-build-id": "RoPgdnFA35otP92af"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jorokotev~public-website-lead-fit/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jorokotev-public-website-lead-fit",
                "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/jorokotev~public-website-lead-fit/runs": {
            "post": {
                "operationId": "runs-sync-jorokotev-public-website-lead-fit",
                "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/jorokotev~public-website-lead-fit/run-sync": {
            "post": {
                "operationId": "run-sync-jorokotev-public-website-lead-fit",
                "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": [
                    "source"
                ],
                "properties": {
                    "source": {
                        "title": "Source mode",
                        "enum": [
                            "sample",
                            "urls"
                        ],
                        "type": "string",
                        "description": "Use sample mode for testing or URL mode to score public company website URLs. URL mode fetches only the URLs you provide, with strict caps.",
                        "default": "sample"
                    },
                    "startUrls": {
                        "title": "Public website URLs",
                        "type": "array",
                        "description": "Company website URLs to score. Public pages only. The Actor blocks localhost, embedded credentials, metadata hosts, and private/link-local/reserved IP targets. Do not add LinkedIn/login-wall/profile/contact-export URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "urls": {
                        "title": "URLs as simple strings",
                        "type": "array",
                        "description": "Alternative simple URL list for API callers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "targetKeywords": {
                        "title": "Target ICP keywords",
                        "type": "array",
                        "description": "Company-level keywords that increase fit score when present in public website text.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "negativeKeywords": {
                        "title": "Negative keywords",
                        "type": "array",
                        "description": "Keywords that reduce fit score when present.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minFitScore": {
                        "title": "Minimum fit score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Return only companies with fit_score >= this value.",
                        "default": 0
                    },
                    "maxUrls": {
                        "title": "Maximum URLs to fetch",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Hard-capped at 50 to control cost and avoid runaway crawls.",
                        "default": 10
                    },
                    "maxResults": {
                        "title": "Maximum returned results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Hard-capped at 50. In PPE, each pushed result may be billable depending on your Console pricing setup.",
                        "default": 10
                    },
                    "timeoutSeconds": {
                        "title": "Per-URL timeout seconds",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Network timeout per URL. Hard-capped at 30 seconds.",
                        "default": 10
                    },
                    "maxBytes": {
                        "title": "Maximum bytes per page",
                        "minimum": 10000,
                        "maximum": 300000,
                        "type": "integer",
                        "description": "Maximum bytes read from each page body. Hard-capped at 300000 bytes to control cost and memory.",
                        "default": 300000
                    },
                    "respectRobotsTxt": {
                        "title": "Respect robots.txt",
                        "type": "boolean",
                        "description": "When enabled, URLs disallowed by robots.txt are skipped without output.",
                        "default": true
                    },
                    "includeErrorRows": {
                        "title": "Include error rows",
                        "type": "boolean",
                        "description": "If false, failed/robots-denied URLs are skipped. If true, error rows may be written to the dataset and may be billable under per-result pricing.",
                        "default": false
                    },
                    "sites": {
                        "title": "Sample fixture sites",
                        "type": "array",
                        "description": "Optional static site fixtures with company, url, and text fields. Used only in sample mode."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
