# Competitor Ads Intelligence Monitor (`scraping_scrap/competitor-ads-intelligence-monitor`) Actor

Monitor public competitor ads across Google Ads Transparency Center and LinkedIn Ads Library. Extract normalized ad records, detect new ads with stateful deduplication, enrich landing pages, classify offers, and send webhook summaries.

- **URL**: https://apify.com/scraping\_scrap/competitor-ads-intelligence-monitor.md
- **Developed by:** [Вадим Захаров](https://apify.com/scraping_scrap) (community)
- **Categories:** Lead generation, SEO tools, Social media
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 ad results

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 Ads Intelligence Monitor

Monitor public competitor ads from Google Ads Transparency Center and LinkedIn Ads Library. Extract normalized ad records, detect new ads with stateful deduplication, enrich landing pages, classify offers, and export clean datasets for marketing intelligence.

Use this Actor as a Google Ads Transparency Center scraper, LinkedIn Ads Library scraper, competitor ads monitor, ad library scraper, Google Ads scraper, LinkedIn Ads scraper, public ads monitor, and repeatable ad intelligence feed for competitor research.

### What this Actor does

Competitor Ads Intelligence Monitor collects public ad-library records for the brands, domains, and queries you care about, then turns them into a clean dataset you can analyze, schedule, export, or send to your workflow tools.

- Monitors public competitor ads across Google Ads Transparency Center and LinkedIn Ads Library.
- Normalizes Google and LinkedIn records into one consistent dataset.
- Detects new ads across scheduled runs with `onlyNewSinceLastRun`.
- Adds stable fingerprints for deduplication and long-term tracking.
- Enriches landing pages when public landing URLs are available.
- Classifies offers such as demos, trials, discounts, webinars, launches, and lead magnets.
- Writes a structured `OUTPUT` summary with counts, samples, warnings, errors, `sourceHealth`, and `platformQualitySummary`.
- Sends webhook summaries to downstream systems.

### Who this Actor is for

This Actor is useful for teams that need practical competitor ad intelligence without building and maintaining their own ad library scraper.

- Growth and performance marketing teams tracking competitor campaigns.
- Agencies monitoring client competitors across public ad libraries.
- Founders and operators researching positioning, offers, CTAs, and landing pages.
- Sales and product marketing teams watching category messaging.
- Analysts building marketing intelligence and competitor research datasets.
- No-code operators exporting public ads to Google Sheets, Make, Zapier, Airtable, CRMs, or BI tools.

### Supported sources

Store V1 / production V1 supports these public sources:

- `google_ads`: Google Ads Transparency Center public data.
- `linkedin`: LinkedIn Ads Library public data.

TikTok is not included in Store V1 supported platforms. It is not shown as a production source because the public TikTok CCL search surface returned rate-limit / limit-exceed responses in cloud smoke tests.

### What data you get

Each dataset item is a normalized public ad record. Fields are populated when the public source exposes them.

Common fields include:

- `platform`
- `source`
- `sourceUrl`
- `scrapedAt`
- `targetType`
- `targetValue`
- `query`
- `advertiserName`
- `advertiserId`
- `advertiserDomain`
- `adId`
- `adUrl`
- `adText`
- `headline`
- `description`
- `cta`
- `landingPageUrl`
- `landingDomain`
- `landingPageTitle`
- `landingPageDescription`
- `landingPageH1`
- `landingPageCtas`
- `creativeAssetUrls`
- `creativeTypes`
- `countries`
- `firstShownAt`
- `lastShownAt`
- `offerType`
- `funnelStage`
- `marketingAngle`
- `classificationMethod`
- `classificationConfidence`
- `fingerprint`
- `isNew`
- `isDuplicate`
- `firstSeenAt`
- `lastSeenAt`
- `warnings`
- `status`
- `platformData`

The Actor also writes `OUTPUT` to the default key-value store. `OUTPUT` contains run-level counts, platform summaries, source diagnostics, samples, webhook status, warnings, and errors.

### Input configuration

At least one of `brands`, `domains`, or `queries` is required.

Key inputs:

- `brands`: Brand names to monitor.
- `domains`: Domains to monitor, especially useful for Google Ads Transparency Center.
- `queries`: Keyword-style searches where the public source supports them.
- `platforms`: Use `["google_ads"]`, `["linkedin"]`, or `["google_ads", "linkedin"]`.
- `countries`: Two-letter country codes such as `US`.
- `maxResultsPerQuery`: Maximum records to collect per platform / target / country call.
- `onlyNewSinceLastRun`: Emit only records not seen in previous runs with the same `stateKey`.
- `stateKey`: Persistent dedupe namespace for scheduled monitoring.
- `includeLandingPage`: Fetch public landing page metadata when landing URLs are available.
- `webhookUrl`: Send a final run summary to your webhook endpoint.
- `maxSourceCalls`: Guardrail for large platform x target x country matrices.
- `maxTotalAds`: Guardrail for total records processed in a run.

### Input examples

Example inputs for common workflows:

#### Example 1 - Google competitor ads

```json
{
  "brands": ["Nike", "HubSpot"],
  "platforms": ["google_ads"],
  "countries": ["US"],
  "maxResultsPerQuery": 10
}
````

#### Example 2 - LinkedIn competitor ads

```json
{
  "brands": ["Microsoft", "Salesforce", "HubSpot"],
  "platforms": ["linkedin"],
  "countries": ["US"],
  "maxResultsPerQuery": 10
}
```

#### Example 3 - Mixed Google and LinkedIn monitor

```json
{
  "brands": ["Nike", "HubSpot", "Microsoft"],
  "domains": ["nike.com", "hubspot.com"],
  "platforms": ["google_ads", "linkedin"],
  "countries": ["US"],
  "maxResultsPerQuery": 10
}
```

#### Example 4 - Scheduled onlyNewSinceLastRun monitor

```json
{
  "brands": ["Microsoft", "Salesforce", "HubSpot"],
  "platforms": ["google_ads", "linkedin"],
  "countries": ["US"],
  "onlyNewSinceLastRun": true,
  "stateKey": "my-competitor-ads-monitor"
}
```

### Output example

Example output from a normalized public ad record:

```json
{
  "recordType": "ad",
  "platform": "linkedin",
  "source": "linkedin_ads_library",
  "sourceUrl": "https://www.linkedin.com/ad-library/search",
  "scrapedAt": "2026-05-31T10:15:30.000Z",
  "targetType": "brand",
  "targetValue": "HubSpot",
  "query": "HubSpot",
  "advertiserName": "HubSpot",
  "adId": "urn:li:sponsoredCreative:123456789",
  "adUrl": "https://www.linkedin.com/ad-library/detail/123456789",
  "adText": "Grow faster with connected marketing, sales, and service tools.",
  "headline": "Scale customer growth",
  "description": "See how HubSpot helps teams turn campaigns into revenue.",
  "cta": "Book demo",
  "landingPageUrl": "https://www.hubspot.com/demo",
  "countries": ["US"],
  "firstShownAt": "2026-05-01T00:00:00.000Z",
  "lastShownAt": "2026-05-30T00:00:00.000Z",
  "offerType": "demo",
  "classificationMethod": "rule_based_v1",
  "classificationConfidence": "medium",
  "fingerprint": "sha256:example-public-ad-fingerprint",
  "isNew": true,
  "isDuplicate": false,
  "status": "ok",
  "warnings": [],
  "sourceHealth": {
    "extractionMethod": "html_patterns",
    "sourceConfidence": "medium"
  },
  "platformData": {
    "publicSource": "linkedin_ads_library",
    "creativeType": "single_image"
  }
}
```

`sourceHealth` is also available in the run-level `OUTPUT` summary. It explains what each source call returned, which extraction method was used, how many public candidates were found, and whether any warnings or errors occurred.

### Understanding sourceHealth

`sourceHealth` helps you understand why a public source returned many ads, few ads, no ads, or warnings. It includes the platform, target type, country, source URL, extraction method, source confidence, normalized ad count, warnings, and errors for each source call.

`platformQualitySummary` gives a faster executive view: records found, records pushed, source confidence, extraction method, and unique warning codes by platform.

### Interpreting warnings

Warnings usually mean the Actor still completed the run, but a source, target type, country, landing page, or webhook had limited information. For example, Google keyword-style searches may be unsupported, LinkedIn public previews can be partial, and landing page enrichment can be skipped when a URL is unavailable or unsafe.

### Incremental monitoring with onlyNewSinceLastRun

Use `onlyNewSinceLastRun` when you want a scheduled competitor ads monitor instead of a one-time export.

When enabled, the Actor stores stable fingerprints under your `stateKey`. Future runs with the same `stateKey` compare current public ads against previously seen fingerprints.

Recommended pattern:

- Use one stable `stateKey` per client, market, or monitoring project.
- Keep the same `brands`, `platforms`, and `countries` for scheduled runs.
- Run daily, weekly, or before campaign reviews.
- Send `sampleNewAds` to a webhook for alerts.

This is useful for tracking new campaigns, new offers, fresh landing pages, and changes in competitor messaging over time.

This is the incremental monitoring and stateKey workflow for a scheduled onlyNewSinceLastRun monitor.

### Webhook alerts

Set `webhookUrl` to receive a JSON summary after each run.

The webhook payload includes:

- Run status.
- Dataset and key-value store IDs.
- Total ads found and pushed.
- New and duplicate counts.
- Platform-level summaries.
- `sampleNewAds`.
- Warnings and errors.
- Source diagnostics.

Use webhooks to send competitor ad intelligence to Make, Zapier, Airtable, Slack, a CRM, a warehouse, or an internal BI workflow.

Webhook example: send the final `OUTPUT` payload to a Make webhook, a Zapier catch hook, or your own HTTPS endpoint after each run.

### Use cases

- Monitor competitor ads across public ad libraries.
- Track new campaigns and creative launches.
- Collect Google Ads Transparency Center records.
- Collect LinkedIn Ads Library records.
- Build competitor ad intelligence datasets.
- Research ad copy, CTAs, offers, funnel stages, and marketing angles.
- Compare competitor positioning across channels.
- Export public ad records to Google Sheets, Make, Zapier, Airtable, CRM, or BI tools.
- Monitor landing pages and marketing offers.
- Create repeatable public ads monitor workflows for clients or categories.

### Limitations

- The Actor uses public sources only.
- No login, no cookies, and no private Ads APIs.
- No CAPTCHA bypass or challenge evasion.
- Completeness depends on public source availability, country, platform policy, and retention windows.
- Google keyword-style monitoring may be limited because Google Ads Transparency Center does not expose every search mode as a reliable public surface.
- Some LinkedIn ads may be partial if the public preview is restricted.
- Landing page enrichment depends on public page availability and safe public URLs.
- TikTok is not included in public V1.

Backlog / not included in V1: TikTok is intentionally excluded from public Store V1 until a stable production-safe source is available.

### What it does not do

- It does not log in to Google, LinkedIn, ad accounts, or private dashboards.
- It does not use cookies or user browser sessions.
- It does not use private Ads APIs.
- It does not bypass CAPTCHA or anti-bot challenges.
- It does not promise full market coverage when public ad libraries limit availability.

### Pricing notes

This Actor is designed for clean, bounded runs. Use `maxResultsPerQuery`, `maxSourceCalls`, and `maxTotalAds` to control the size of each run.

Apify Store pricing may include a small Actor start charge and a per-result charge for normalized ad records. Check the current pricing shown on the Actor page before running large jobs.

### FAQ

#### Is this a Google Ads Transparency Center scraper?

Yes. It collects public Google Ads Transparency Center data when Google exposes usable public records for the requested brand, domain, and country.

#### Is this a LinkedIn Ads Library scraper?

Yes. It collects public LinkedIn Ads Library records and normalizes them into the same dataset shape as Google records.

#### Does it use private APIs?

No. The Actor uses public sources only. It does not use account cookies, logins, private Ads APIs, Ads Manager access, or CAPTCHA bypass.

#### Does it guarantee every ad a competitor is running?

No. Public ad libraries can be incomplete. Coverage depends on public source availability, country, retention windows, source UI changes, and platform policy.

#### Can I use it as a scheduled competitor ads monitor?

Yes. Enable `onlyNewSinceLastRun`, set a stable `stateKey`, and run it on an Apify schedule. The Actor will mark records as new or duplicate based on previously seen fingerprints.

#### Can I export results to Google Sheets or other tools?

Yes. You can download the dataset as JSON, CSV, Excel, or connect the output to Google Sheets, Make, Zapier, Airtable, CRM systems, warehouses, and BI tools.

#### Is TikTok included?

TikTok is not included in public V1. The public TikTok CCL surface returned rate-limit / limit-exceed responses in cloud smoke tests, so TikTok is not positioned as a production source in this Actor.

# Actor input Schema

## `brands` (type: `array`):

Competitor or monitored brand names. Replace the example brands with your competitors. Provide at least one brand, domain, or query.

## `domains` (type: `array`):

Competitor or monitored domains. Provide at least one brand, domain, or query.

## `queries` (type: `array`):

Search queries or ad-library queries to monitor. Provide at least one brand, domain, or query.

## `platforms` (type: `array`):

Production V1 advertising platforms to monitor.

## `countries` (type: `array`):

Country codes to monitor.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of results to collect per query.

## `onlyNewSinceLastRun` (type: `boolean`):

Only emit records that were not seen in previous runs.

## `stateKey` (type: `string`):

Key for persisted run state.

## `includeLandingPage` (type: `boolean`):

Fetch landing page title, description, H1, and CTA text for ad landing URLs.

## `includeCreativeAssets` (type: `boolean`):

Include creative asset metadata and URLs when available.

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

Optional webhook endpoint for sampled run results.

## `webhookSampleSize` (type: `integer`):

Maximum number of records to include in webhook samples.

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

Maximum crawler concurrency.

## `maxSourceCalls` (type: `integer`):

Maximum platform/target/country source calls allowed for a run. The Actor rejects inputs whose estimated source calls exceed this value.

## `maxTotalAds` (type: `integer`):

Maximum normalized ad candidates to process and push across the whole run.

## `emitChangedAds` (type: `boolean`):

Preview flag for future changed-ad detection. Current runs emit a design-only warning instead of changed records.

## `debugSourceFetch` (type: `boolean`):

Include a short sanitized source response snippet in sourceHealth diagnostics. Never stores full HTML, credentials, cookies, or headers.

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

Apify proxy configuration.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "brands": [
    "Nike",
    "HubSpot",
    "Microsoft"
  ],
  "domains": [],
  "queries": [],
  "platforms": [
    "google_ads",
    "linkedin"
  ],
  "countries": [
    "US"
  ],
  "maxResultsPerQuery": 5,
  "onlyNewSinceLastRun": false,
  "stateKey": "default",
  "includeLandingPage": false,
  "includeCreativeAssets": true,
  "webhookUrl": "",
  "webhookSampleSize": 10,
  "maxConcurrency": 5,
  "maxSourceCalls": 1000,
  "maxTotalAds": 10000,
  "emitChangedAds": false,
  "debugSourceFetch": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestTimeoutSecs": 45
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Normalized public ad records pushed to the default dataset.

## `runSummary` (type: `string`):

Final run summary stored as OUTPUT in the default key-value store.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scraping_scrap/competitor-ads-intelligence-monitor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scraping_scrap/competitor-ads-intelligence-monitor").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 '{}' |
apify call scraping_scrap/competitor-ads-intelligence-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraping_scrap/competitor-ads-intelligence-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Ads Intelligence Monitor",
        "description": "Monitor public competitor ads across Google Ads Transparency Center and LinkedIn Ads Library. Extract normalized ad records, detect new ads with stateful deduplication, enrich landing pages, classify offers, and send webhook summaries.",
        "version": "1.0",
        "x-build-id": "qvdzlGyUSxh9rdbFh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraping_scrap~competitor-ads-intelligence-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraping_scrap-competitor-ads-intelligence-monitor",
                "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/scraping_scrap~competitor-ads-intelligence-monitor/runs": {
            "post": {
                "operationId": "runs-sync-scraping_scrap-competitor-ads-intelligence-monitor",
                "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/scraping_scrap~competitor-ads-intelligence-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-scraping_scrap-competitor-ads-intelligence-monitor",
                "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",
                "properties": {
                    "brands": {
                        "title": "Brands",
                        "maxItems": 200,
                        "type": "array",
                        "description": "Competitor or monitored brand names. Replace the example brands with your competitors. Provide at least one brand, domain, or query.",
                        "default": [
                            "Nike",
                            "HubSpot",
                            "Microsoft"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "domains": {
                        "title": "Domains",
                        "maxItems": 200,
                        "type": "array",
                        "description": "Competitor or monitored domains. Provide at least one brand, domain, or query.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Queries",
                        "maxItems": 200,
                        "type": "array",
                        "description": "Search queries or ad-library queries to monitor. Provide at least one brand, domain, or query.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "Production V1 advertising platforms to monitor.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "google_ads",
                                "linkedin"
                            ],
                            "enumTitles": [
                                "Google Ads",
                                "LinkedIn"
                            ]
                        },
                        "default": [
                            "google_ads",
                            "linkedin"
                        ]
                    },
                    "countries": {
                        "title": "Countries",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Country codes to monitor.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{2}$"
                        },
                        "default": [
                            "US"
                        ]
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of results to collect per query.",
                        "default": 5
                    },
                    "onlyNewSinceLastRun": {
                        "title": "Only new since last run",
                        "type": "boolean",
                        "description": "Only emit records that were not seen in previous runs.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "State key",
                        "maxLength": 128,
                        "type": "string",
                        "description": "Key for persisted run state.",
                        "default": "default"
                    },
                    "includeLandingPage": {
                        "title": "Include landing page",
                        "type": "boolean",
                        "description": "Fetch landing page title, description, H1, and CTA text for ad landing URLs.",
                        "default": false
                    },
                    "includeCreativeAssets": {
                        "title": "Include creative assets",
                        "type": "boolean",
                        "description": "Include creative asset metadata and URLs when available.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional webhook endpoint for sampled run results.",
                        "default": ""
                    },
                    "webhookSampleSize": {
                        "title": "Webhook sample size",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of records to include in webhook samples.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum crawler concurrency.",
                        "default": 5
                    },
                    "maxSourceCalls": {
                        "title": "Max source calls",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum platform/target/country source calls allowed for a run. The Actor rejects inputs whose estimated source calls exceed this value.",
                        "default": 1000
                    },
                    "maxTotalAds": {
                        "title": "Max total ads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum normalized ad candidates to process and push across the whole run.",
                        "default": 10000
                    },
                    "emitChangedAds": {
                        "title": "Emit changed ads",
                        "type": "boolean",
                        "description": "Preview flag for future changed-ad detection. Current runs emit a design-only warning instead of changed records.",
                        "default": false
                    },
                    "debugSourceFetch": {
                        "title": "Debug source fetch",
                        "type": "boolean",
                        "description": "Include a short sanitized source response snippet in sourceHealth diagnostics. Never stores full HTML, credentials, cookies, or headers.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 45
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
