# Competitor Ads Scraper (`trovevault/competitor-ads-scraper`) Actor

Find competitor ads across Google, Meta, TikTok, LinkedIn, and Microsoft/Bing with normalized creative text, headlines, dates, landing pages, creative media URLs, formats, and ad links.

- **URL**: https://apify.com/trovevault/competitor-ads-scraper.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** SEO tools, Social media, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.70 / 1,000 ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

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

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

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

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

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

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

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

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


# README

## Competitor Ads Scraper

Search competitor ads across Google, Meta, TikTok, LinkedIn, and Microsoft/Bing ad libraries in one Apify run. The actor uses built-in platform adapters and returns one normalized dataset with advertiser names, creative text, headlines, descriptions, CTA labels, dates, landing pages, creative media URLs, formats, and ad detail links.

### Why Use This Actor

Competitor ad research is usually split across separate public libraries, each with different search behavior, country coverage, field names, and media formats. This actor gives agencies, growth teams, founders, and competitive intelligence teams a single workflow for monitoring what competitors are running across paid channels.

Use it when you want to:

- collect competitor ad examples before a creative strategy review;
- monitor how a brand changes messaging across platforms;
- compare ad copy, CTAs, landing pages, images, and videos by channel;
- build recurring ad intelligence datasets in Apify, Google Sheets, BI tools, or agent workflows;
- avoid maintaining five separate ad library scrapers yourself.

### What It Extracts

The normalized output includes, when available:

- `platform` and `country`
- `advertiserName`
- `adId`
- `status` and `isActive`
- `firstShownDate` and `lastShownDate`
- `adFormat` and `mediaAvailability`
- `creativeText`, `headline`, `description`, `caption`, and `callToAction`
- `landingPageUrl` and `landingPageUrls`
- `creativeUrl`, `creativeUrls`, and `creativeMediaType`
- `imageUrl`, `imageUrls`, `videoUrl`, and `videoUrls`
- `adDetailsUrl`

`creativeUrl` is the best available media asset for quick workflows, selected from video URLs first, then image URLs, then logo or cover image URLs. `creativeUrls` keeps the normalized media list. `creativeMediaType` reports `video`, `image`, `mixed`, `logo_or_cover`, or `none` based only on returned source data.

Each platform exposes different public fields. The actor preserves useful creative fields when the underlying library returns them and omits fields that do not apply to a row.

### Supported Platforms

The default run includes:

- Google Ads Transparency Center
- Meta Ad Library
- TikTok Ads Library
- LinkedIn Ad Library
- Microsoft/Bing Ad Library

Platform-country support is not identical. EU/EEA countries such as `FR`, `DE`, `PT`, and `ES` provide the broadest coverage across all five. Markets such as `US` are still useful, but some platforms may be skipped because their public library does not expose that country through the underlying actor. Skips are reported in `RUN_SUMMARY`.

### Input

```json
{
  "targets": ["Nike"],
  "country": "FR",
  "maxAdsPerPlatform": 25,
  "platforms": ["google", "meta", "tiktok", "linkedin", "bing"],
  "shownSince": "2026-07-01"
}
````

#### Fields

- `targets` - brand names, company names, domains, or ad keywords to search.
- `country` - ISO 3166-1 alpha-2 market code. Use an EU/EEA country for the broadest five-platform coverage.
- `maxAdsPerPlatform` - maximum ads to request from each selected platform per target.
- `platforms` - optional channel filter. Defaults to all five platforms.
- `shownSince` - optional date filter applied where compatible public dates exist.
- `firstShownAfter` - optional first-shown date filter applied where compatible public dates exist.
- `datasetId` - optional existing Apify dataset ID for pipeline runs.
- `runId` - optional external workflow ID copied to output rows and `RUN_SUMMARY`.

### Output Example

```json
{
  "target": "Nike",
  "platform": "meta",
  "country": "FR",
  "advertiserName": "Nike",
  "adId": "1234567890",
  "isActive": true,
  "firstShownDate": "2026-07-01",
  "lastShownDate": "2026-07-16",
  "adFormat": "video",
  "mediaAvailability": "video",
  "creativeText": "New running shoes for race day.",
  "headline": "Run your fastest",
  "description": "Shop the latest Nike running collection.",
  "callToAction": "Shop now",
  "landingPageUrl": "https://www.nike.com/",
  "creativeUrl": "https://...",
  "creativeUrls": ["https://..."],
  "creativeMediaType": "mixed",
  "imageUrl": "https://...",
  "videoUrl": "https://...",
  "adDetailsUrl": "https://..."
}
```

### API Usage

```bash
curl "https://api.apify.com/v2/acts/trovevault~competitor-ads-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "targets": ["Nike", "Adidas"],
    "country": "FR",
    "maxAdsPerPlatform": 10
  }'
```

Fetch dataset items after the run:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### Run Summary

The actor writes `RUN_SUMMARY` to the default key-value store with:

- requested targets and platforms;
- skipped platforms for unsupported countries;
- per-platform row counts;
- suppressed platform errors.

This keeps the main dataset focused on usable ad records while still making orchestration diagnostics available.

### Limitations

- Public ad libraries differ in country coverage, pagination, media URLs, dates, and creative fields.
- Some fields are absent because the source platform does not expose them for that ad.
- `creativeMediaType: "none"` means the selected source returned ad metadata but no usable video, image, logo, or cover URL.
- Video and image URLs may be temporary or platform-hosted.
- `US` and other non-EU markets may not return all five platforms because some public libraries focus on EU/EEA transparency coverage.
- Runtime and compute cost scale with the selected platforms and `maxAdsPerPlatform`.

### Related Actors

- Google Ads Transparency Scraper
- Meta Ads Library Scraper
- TikTok Ads Library Scraper
- LinkedIn Ads Library Scraper
- Microsoft Bing Ads Library Scraper

### Changelog

- `0.1.0` - Initial cross-platform competitor ads scraper with normalized output across five ad library actors.

# Actor input Schema

## `targets` (type: `array`):

Brand names, company names, domains, or ad keywords to search. Examples: Nike, Shopify, nike.com, running shoes. Use specific brand names for cleaner competitor monitoring.

## `country` (type: `string`):

Market to search using ISO 3166-1 alpha-2 country codes. Use an EU/EEA country such as FR, DE, PT, or ES for the broadest five-platform coverage. US returns platforms that support US public ad library results.

## `maxAdsPerPlatform` (type: `integer`):

Maximum ad records to request from each selected platform per target. Use 5-25 for quick competitor checks and higher values for deeper monitoring. Higher values increase runtime and compute cost.

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

Ad library platforms to include. Default: all five. Some platforms only support specific countries; unsupported platform-country combinations are skipped and reported in RUN\_SUMMARY.

## `shownSince` (type: `string`):

Only keep ads shown on or after this date when the platform exposes compatible dates. Use YYYY-MM-DD, for example 2026-07-01. Leave empty to keep the platform default range.

## `firstShownAfter` (type: `string`):

Only keep ads first shown on or after this date when the platform exposes compatible first-shown dates. Use YYYY-MM-DD, for example 2026-01-01. Leave empty to keep all returned dates.

## `datasetId` (type: `string`):

Optional existing Apify dataset ID for pipeline runs. Rows are appended there in addition to the default run dataset. Leave empty for normal one-off runs.

## `runId` (type: `string`):

Optional external run or workflow ID to include in output rows and RUN\_SUMMARY. Use it to join scheduled runs with your own monitoring jobs; leave empty when not needed.

## Actor input object example

```json
{
  "targets": [
    "Nike"
  ],
  "country": "FR",
  "maxAdsPerPlatform": 25,
  "platforms": [
    "google",
    "meta",
    "tiktok",
    "linkedin",
    "bing"
  ]
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

No description

## `runSummaryUrl` (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 = {
    "targets": [
        "Nike"
    ],
    "platforms": [
        "google",
        "meta",
        "tiktok",
        "linkedin",
        "bing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/competitor-ads-scraper").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 = {
    "targets": ["Nike"],
    "platforms": [
        "google",
        "meta",
        "tiktok",
        "linkedin",
        "bing",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/competitor-ads-scraper").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 '{
  "targets": [
    "Nike"
  ],
  "platforms": [
    "google",
    "meta",
    "tiktok",
    "linkedin",
    "bing"
  ]
}' |
apify call trovevault/competitor-ads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Competitor Ads Scraper",
        "description": "Find competitor ads across Google, Meta, TikTok, LinkedIn, and Microsoft/Bing with normalized creative text, headlines, dates, landing pages, creative media URLs, formats, and ad links.",
        "version": "0.1",
        "x-build-id": "uP4VAbC6UJKihvuCP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~competitor-ads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-competitor-ads-scraper",
                "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/trovevault~competitor-ads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-competitor-ads-scraper",
                "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/trovevault~competitor-ads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-competitor-ads-scraper",
                "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": [
                    "targets",
                    "country"
                ],
                "properties": {
                    "targets": {
                        "title": "Competitors or Keywords",
                        "type": "array",
                        "description": "Brand names, company names, domains, or ad keywords to search. Examples: Nike, Shopify, nike.com, running shoes. Use specific brand names for cleaner competitor monitoring.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Nike"
                        ]
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "GB",
                            "FR",
                            "DE",
                            "ES",
                            "PT",
                            "IT",
                            "NL",
                            "BE",
                            "SE",
                            "DK",
                            "FI",
                            "IE",
                            "PL",
                            "AT",
                            "CA",
                            "AU",
                            "BR"
                        ],
                        "type": "string",
                        "description": "Market to search using ISO 3166-1 alpha-2 country codes. Use an EU/EEA country such as FR, DE, PT, or ES for the broadest five-platform coverage. US returns platforms that support US public ad library results.",
                        "default": "FR"
                    },
                    "maxAdsPerPlatform": {
                        "title": "Maximum Ads Per Platform",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum ad records to request from each selected platform per target. Use 5-25 for quick competitor checks and higher values for deeper monitoring. Higher values increase runtime and compute cost.",
                        "default": 25
                    },
                    "platforms": {
                        "title": "Platforms",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Ad library platforms to include. Default: all five. Some platforms only support specific countries; unsupported platform-country combinations are skipped and reported in RUN_SUMMARY.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "google",
                                "meta",
                                "tiktok",
                                "linkedin",
                                "bing"
                            ],
                            "enumTitles": [
                                "Google",
                                "Meta",
                                "TikTok",
                                "LinkedIn",
                                "Microsoft/Bing"
                            ]
                        },
                        "default": [
                            "google",
                            "meta",
                            "tiktok",
                            "linkedin",
                            "bing"
                        ]
                    },
                    "shownSince": {
                        "title": "Shown Since",
                        "type": "string",
                        "description": "Only keep ads shown on or after this date when the platform exposes compatible dates. Use YYYY-MM-DD, for example 2026-07-01. Leave empty to keep the platform default range."
                    },
                    "firstShownAfter": {
                        "title": "First Shown After",
                        "type": "string",
                        "description": "Only keep ads first shown on or after this date when the platform exposes compatible first-shown dates. Use YYYY-MM-DD, for example 2026-01-01. Leave empty to keep all returned dates."
                    },
                    "datasetId": {
                        "title": "Dataset ID",
                        "type": "string",
                        "description": "Optional existing Apify dataset ID for pipeline runs. Rows are appended there in addition to the default run dataset. Leave empty for normal one-off runs."
                    },
                    "runId": {
                        "title": "Run ID",
                        "type": "string",
                        "description": "Optional external run or workflow ID to include in output rows and RUN_SUMMARY. Use it to join scheduled runs with your own monitoring jobs; leave empty when not needed."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
