# Competitor Website Change Monitor & Briefing (`solutionssmart/competitor-website-change-briefing`) Actor

Monitor competitor websites, detect meaningful changes across runs, and turn them into decision-ready competitive intelligence and briefings.

- **URL**: https://apify.com/solutionssmart/competitor-website-change-briefing.md
- **Developed by:** [Solutions Smart](https://apify.com/solutionssmart) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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

## Competitor Website Change Briefing

This Actor turns website changes into competitive intelligence.

Track what competitors changed on their websites, understand why it may matter, and turn that into a briefing your team can actually use.

This Actor monitors competitor and SaaS websites across recurring runs, detects meaningful changes, groups them into business signals, and produces decision-ready output for product marketing, sales enablement, founder, strategy, and competitive intelligence teams.

It is built for practical questions such as:

- Did a competitor change pricing, packaging, or plans?
- Did they reposition their homepage or value proposition?
- Are they pushing harder into AI, enterprise, security, or a new buyer workflow?
- Did they add new partner, integration, or solution pages worth flagging internally?

### What It Does

The Actor crawls one or more websites, stores normalized snapshots, compares each run against prior history, and publishes grouped business signals instead of raw page diffs.

It is designed to surface meaningful website change intelligence, not just scraped pages.

### Why It Is Different

This is not a generic site crawler and not a page-diff dump.

The Actor is optimized for monitoring:

- `focused` crawl mode prioritizes homepage, pricing, product, trust, case studies, and other commercial pages first
- repeated runs use persistent snapshot memory so the Actor behaves like a monitor, not a first-run scraper every time
- findings are grouped into business signals such as `pricing_update`, `homepage_repositioning`, `partner_expansion`, and `ai_positioning_expansion`
- evidence is filtered and condensed so the output is readable by operators and stakeholders

### Why This Actor Stands Out

Most Apify Actors are built for one-time extraction.
This one is built for recurring competitive monitoring.

What makes it different:

- built for change detection across runs, not one-off scraping
- produces grouped business signals, not raw page-level crawl output
- includes baseline-vs-monitoring logic so first runs are framed credibly
- outputs briefings and review-ready artifacts, not just data you still need to interpret manually

This makes it meaningfully different from:

- generic crawlers
- one-site content scrapers
- raw website data extractors
- Actors that collect pages but do not explain what changed and why it may matter

### Why Not Just Use A Crawler?

A crawler can tell you which pages were fetched.
It usually cannot tell you which website changes are commercially meaningful.

Most teams do not need:

- a pile of page HTML
- hundreds of low-signal diffs
- one dataset row for every crawled URL

They need:

- a short list of meaningful changes
- evidence tied to those changes
- language that helps someone decide whether to care

This Actor is opinionated around that outcome. It compares runs, reduces boilerplate noise, groups related changes, and produces business-facing output instead of crawl exhaust.

### First Run Vs Monitoring Runs

The Actor distinguishes baseline capture from true monitoring:

- On the first run, findings are framed as baseline discovery, for example:
  - `Baseline pricing structure captured`
  - `Initial homepage positioning captured`
  - `Initial partner footprint discovered`
- On later runs, the Actor compares against stored snapshots and emits actual `added`, `updated`, or `removed` changes when it has enough evidence

This makes the output much more credible for recurring competitive monitoring.

### Best For

- Product marketing teams tracking competitor positioning changes
- Sales enablement teams updating battlecards and objections
- Founders and leadership teams reviewing weekly market movement
- Strategy, corp-dev, and market intelligence teams monitoring GTM shifts and expansion signals
- Teams tracking enterprise messaging, trust, and AI positioning

### Common Use Cases

- Weekly competitor briefings for product marketing
- Pricing and packaging monitoring for revenue and leadership reviews
- Battlecard refresh inputs for sales enablement
- Tracking AI, enterprise, trust, and integration messaging shifts
- Monitoring solution, use-case, and partner ecosystem expansion
- Detecting when a competitor starts speaking to a new buyer segment

### How Teams Use This

- Replace manual competitor checks across multiple websites
- Replace Slack threads like "did anyone notice X changed pricing?"
- Feed weekly briefings into product, sales, or leadership syncs
- Provide structured inputs for battlecards, strategy docs, and market reviews

### Typical Signals

The Actor can publish signals such as:

- `pricing_update` - detect plan, packaging, or enterprise motion changes
- `homepage_repositioning` - detect shifts in value proposition or target audience
- `partner_expansion` - track integration and ecosystem growth
- `solution_expansion` - surface new use-case, workflow, or solution coverage
- `ai_positioning_expansion` - identify AI-related messaging changes
- `product_capability_expansion` - highlight broader platform or capability emphasis
- `customer_proof_update` - monitor case studies, testimonials, and proof points
- `compliance_update` - flag security, trust, and enterprise-readiness updates
- `announcement_activity` - capture launch and announcement-oriented content changes

### Why It Is Cost-Efficient

This Actor is designed to spend compute on signal quality, not broad crawl volume.

Cost efficiency comes from:

- `focused` mode prioritizing commercially important sections first
- family caps that prevent partner, integration, or similar page clusters from consuming the whole crawl budget
- grouped output that produces one public signal for a business theme instead of one record per page
- persistent monitoring memory, so recurring runs compare against prior snapshots instead of acting like full rediscovery every time

For most competitor-monitoring workflows, that is a better tradeoff than paying to crawl large portions of a site just to produce noisy page-level output.

### Input

Minimum input:

```json
{
  "startUrls": [
    "https://competitor-a.com/",
    "https://competitor-a.com/pricing",
    "https://competitor-b.com/"
  ]
}
````

Recommended recurring-monitoring input:

```json
{
  "monitorId": "weekly-saas-monitor",
  "startUrls": [
    "https://competitor-a.com/",
    "https://competitor-a.com/pricing",
    "https://competitor-b.com/",
    "https://competitor-b.com/pricing"
  ],
  "allowedDomains": [
    "competitor-a.com",
    "competitor-b.com"
  ],
  "crawlMode": "focused",
  "prioritySections": [
    "homepage",
    "pricing",
    "product",
    "case-studies",
    "security"
  ],
  "watchKeywords": [
    "enterprise",
    "SOC 2",
    "usage-based pricing",
    "AI agents"
  ],
  "changeThreshold": "medium",
  "enableBriefing": true,
  "enableHtmlDashboard": true
}
```

Important inputs:

- `monitorId`: use this for scheduled recurring runs so the same monitor keeps stable history
- `crawlMode`: `focused` is recommended for weekly monitoring; `sitewide` is broader but noisier
- `changeThreshold`: `medium` is the best default for buyer-readable output
- `watchKeywords`: highlights terms you care about in the final dataset and briefing

### Output

The Actor produces:

- dataset items grouped by business signal
- `SUMMARY` for quick review
- `BRIEFING_MD` for email, Slack, Notion, or human review
- `BRIEFING_JSON` for automations
- `DASHBOARD` for browser-friendly visual review

The dataset is intentionally not one row per page.

Instead, each item is a grouped signal with fields such as:

- `siteKey`
- `signalType`
- `severity`
- `status`
- `summary`
- `whyItMatters`
- `evidence`
- `evidenceUrls`
- `relatedPagesCount`
- `confidence`

### Example Output

Example baseline discovery item:

```json
{
  "siteKey": "example.com",
  "signalType": "pricing_update",
  "severity": "medium",
  "status": "baseline",
  "summary": "example.com baseline pricing structure captured across 1 pricing page.",
  "whyItMatters": "Establishes the current pricing structure for future monitoring.",
  "evidence": [
    "Starter: $29 / month",
    "Business: $199 / month",
    "Contact sales for enterprise"
  ],
  "evidenceUrls": [
    "https://example.com/pricing"
  ],
  "relatedPagesCount": 1,
  "confidence": 0.74
}
```

Example true monitoring update:

```json
{
  "siteKey": "example.com",
  "signalType": "homepage_repositioning",
  "severity": "medium",
  "status": "updated",
  "summary": "example.com repositioned homepage messaging toward AI agents and enterprise use cases.",
  "whyItMatters": "Suggests a change in market messaging or strategic positioning.",
  "evidence": [
    "The data platform for AI agents",
    "Trusted by enterprise data teams",
    "Connect workflows with real-time web data"
  ],
  "evidenceUrls": [
    "https://example.com/"
  ],
  "relatedPagesCount": 1,
  "confidence": 0.83
}
```

### How It Works

Each run:

1. Crawls seeded sites with a focused or sitewide strategy
2. Extracts normalized text, headings, sections, nav labels, and structured clues
3. Loads prior snapshots from persistent state
4. Detects meaningful changes between runs
5. Aggregates related page findings into grouped business signals
6. Writes dataset items plus briefing artifacts

Noise reduction includes:

- filtering weak first-run claims into baseline wording
- suppressing weak or low-proof public signals
- deduplicating repetitive snippets
- capping partner and similar page families in focused mode

### Scheduling Tips

Recommended schedule:

- run daily for fast-moving competitors
- run weekly for broader market monitoring

Recommended setup:

- create one saved task per monitoring group
- set a stable `monitorId`
- review `SUMMARY` for triage
- share `BRIEFING_MD` or `DASHBOARD` with stakeholders
- use `BRIEFING_JSON` or dataset output for internal workflows

### Good Monitoring Practices

- seed both homepage and pricing pages when possible
- keep `allowedDomains` narrow
- use `focused` mode unless you truly need wider discovery
- keep `watchKeywords` short and decision-oriented
- schedule recurring runs instead of treating the Actor as a one-off crawl

### Limitations

- This Actor monitors public websites only
- It does not monitor social channels, ads, email, or app-store changes
- First-run output is baseline discovery, not proof of historical change
- Very aggressive page caps can suppress edge-case additions or removals until they recur across runs

### Stored Artifacts

Key-Value Store records include:

- `SUMMARY`
- `BRIEFING_MD`
- `BRIEFING_JSON`
- `DASHBOARD`
- persistent monitor state and snapshot records used for recurring monitoring

### Compliance

Use responsibly and in line with target-site terms, privacy law, and internal monitoring policy.

### Support

If you want to monitor a specific competitor set or tune the Actor for a particular workflow, adapt the task input with your own `monitorId`, domains, page caps, and watch keywords.

# Actor input Schema

## `monitorId` (type: `string`):

Optional stable identifier for persistent run-to-run memory. Use this when the same monitor should keep history across scheduled runs.

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

Homepage or section URLs to seed monitoring from. One site can have multiple seed URLs.

## `allowedDomains` (type: `array`):

Domains that are allowed for crawl discovery. Defaults to domains derived from start URLs.

## `includeUrlPatterns` (type: `array`):

Optional glob-style patterns or regex-prefixed rules such as regex:/pricing|security/i.

## `excludeUrlPatterns` (type: `array`):

Glob-style patterns that should be ignored during crawl and change detection.

## `maxPagesPerSite` (type: `integer`):

Maximum number of pages to crawl per monitored site.

## `crawlMode` (type: `string`):

Focused prioritizes key commercial sections. Sitewide follows all in-scope links until the page cap is reached.

## `prioritySections` (type: `array`):

Sections to prioritize first during focused crawls.

## `watchKeywords` (type: `array`):

Business terms that should be highlighted when they appear or disappear.

## `outputLanguage` (type: `string`):

Language code for generated briefings.

## `changeThreshold` (type: `string`):

Minimum severity that will be included in the output briefing.

## `summarizationMode` (type: `string`):

Deterministic mode is fully functional. LLM mode only enhances deterministic outputs in v1.

## `enableBriefing` (type: `boolean`):

Generate Markdown and JSON briefing artifacts.

## `enableHtmlDashboard` (type: `boolean`):

Generate a compact self-contained HTML dashboard.

## `callbackUrl` (type: `string`):

Optional webhook URL that receives the JSON briefing after a successful run.

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

Upper bound for concurrent browser pages. This Actor uses a conservative maximum of 4 browser pages to keep monitoring runs stable and cost-efficient.

## `requestTimeoutSecs` (type: `integer`):

Per-page processing timeout.

## `saveRawSnapshots` (type: `boolean`):

Store raw HTML in per-page snapshots for debugging and offline review.

## `includeDocsSignals` (type: `boolean`):

Include docs/help/reference signals in public output. Disabled by default to reduce noise.

## `includeDebugFields` (type: `boolean`):

Expose internal classification and aggregation hints in public dataset items for debugging.

## Actor input object example

```json
{
  "startUrls": [
    "https://example.com/",
    "https://example.com/pricing"
  ],
  "maxPagesPerSite": 40,
  "crawlMode": "focused",
  "prioritySections": [
    "homepage",
    "pricing",
    "product",
    "blog",
    "careers",
    "case-studies",
    "security"
  ],
  "outputLanguage": "en",
  "changeThreshold": "medium",
  "summarizationMode": "deterministic",
  "enableBriefing": true,
  "enableHtmlDashboard": false,
  "maxConcurrency": 4,
  "requestTimeoutSecs": 30,
  "saveRawSnapshots": false,
  "includeDocsSignals": false,
  "includeDebugFields": false
}
```

# Actor output Schema

## `businessSignalsDataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `state` (type: `string`):

No description

## `snapshotIndex` (type: `string`):

No description

## `briefingMarkdown` (type: `string`):

No description

## `briefingJson` (type: `string`):

No description

## `dashboardHtml` (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": [
        "https://example.com/",
        "https://example.com/pricing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solutionssmart/competitor-website-change-briefing").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": [
        "https://example.com/",
        "https://example.com/pricing",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("solutionssmart/competitor-website-change-briefing").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": [
    "https://example.com/",
    "https://example.com/pricing"
  ]
}' |
apify call solutionssmart/competitor-website-change-briefing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solutionssmart/competitor-website-change-briefing",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Website Change Monitor & Briefing",
        "description": "Monitor competitor websites, detect meaningful changes across runs, and turn them into decision-ready competitive intelligence and briefings.",
        "version": "0.1",
        "x-build-id": "nJTnJSP3usGar4rG1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solutionssmart~competitor-website-change-briefing/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solutionssmart-competitor-website-change-briefing",
                "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/solutionssmart~competitor-website-change-briefing/runs": {
            "post": {
                "operationId": "runs-sync-solutionssmart-competitor-website-change-briefing",
                "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/solutionssmart~competitor-website-change-briefing/run-sync": {
            "post": {
                "operationId": "run-sync-solutionssmart-competitor-website-change-briefing",
                "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"
                ],
                "properties": {
                    "monitorId": {
                        "title": "Monitor ID",
                        "type": "string",
                        "description": "Optional stable identifier for persistent run-to-run memory. Use this when the same monitor should keep history across scheduled runs."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Homepage or section URLs to seed monitoring from. One site can have multiple seed URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "allowedDomains": {
                        "title": "Allowed domains",
                        "type": "array",
                        "description": "Domains that are allowed for crawl discovery. Defaults to domains derived from start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeUrlPatterns": {
                        "title": "Include URL patterns",
                        "type": "array",
                        "description": "Optional glob-style patterns or regex-prefixed rules such as regex:/pricing|security/i.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeUrlPatterns": {
                        "title": "Exclude URL patterns",
                        "type": "array",
                        "description": "Glob-style patterns that should be ignored during crawl and change detection.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerSite": {
                        "title": "Max pages per site",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl per monitored site.",
                        "default": 40
                    },
                    "crawlMode": {
                        "title": "Crawl mode",
                        "enum": [
                            "focused",
                            "sitewide"
                        ],
                        "type": "string",
                        "description": "Focused prioritizes key commercial sections. Sitewide follows all in-scope links until the page cap is reached.",
                        "default": "focused"
                    },
                    "prioritySections": {
                        "title": "Priority sections",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Sections to prioritize first during focused crawls.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "homepage",
                                "pricing",
                                "product",
                                "blog",
                                "careers",
                                "case-studies",
                                "security",
                                "docs"
                            ]
                        },
                        "default": [
                            "homepage",
                            "pricing",
                            "product",
                            "blog",
                            "careers",
                            "case-studies",
                            "security"
                        ]
                    },
                    "watchKeywords": {
                        "title": "Watch keywords",
                        "type": "array",
                        "description": "Business terms that should be highlighted when they appear or disappear.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputLanguage": {
                        "title": "Output language",
                        "type": "string",
                        "description": "Language code for generated briefings.",
                        "default": "en"
                    },
                    "changeThreshold": {
                        "title": "Change threshold",
                        "enum": [
                            "low",
                            "medium",
                            "high"
                        ],
                        "type": "string",
                        "description": "Minimum severity that will be included in the output briefing.",
                        "default": "medium"
                    },
                    "summarizationMode": {
                        "title": "Summarization mode",
                        "enum": [
                            "deterministic",
                            "llm"
                        ],
                        "type": "string",
                        "description": "Deterministic mode is fully functional. LLM mode only enhances deterministic outputs in v1.",
                        "default": "deterministic"
                    },
                    "enableBriefing": {
                        "title": "Enable briefing output",
                        "type": "boolean",
                        "description": "Generate Markdown and JSON briefing artifacts.",
                        "default": true
                    },
                    "enableHtmlDashboard": {
                        "title": "Enable HTML dashboard",
                        "type": "boolean",
                        "description": "Generate a compact self-contained HTML dashboard.",
                        "default": false
                    },
                    "callbackUrl": {
                        "title": "Callback URL",
                        "type": "string",
                        "description": "Optional webhook URL that receives the JSON briefing after a successful run."
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 4,
                        "type": "integer",
                        "description": "Upper bound for concurrent browser pages. This Actor uses a conservative maximum of 4 browser pages to keep monitoring runs stable and cost-efficient.",
                        "default": 4
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-page processing timeout.",
                        "default": 30
                    },
                    "saveRawSnapshots": {
                        "title": "Save raw HTML snapshots",
                        "type": "boolean",
                        "description": "Store raw HTML in per-page snapshots for debugging and offline review.",
                        "default": false
                    },
                    "includeDocsSignals": {
                        "title": "Include docs signals",
                        "type": "boolean",
                        "description": "Include docs/help/reference signals in public output. Disabled by default to reduce noise.",
                        "default": false
                    },
                    "includeDebugFields": {
                        "title": "Include debug fields",
                        "type": "boolean",
                        "description": "Expose internal classification and aggregation hints in public dataset items for debugging.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
