# Competitor Ads Radar — Google Ads Library (`vanborn_labs/competitor-ads-radar`) Actor

Competitor ad monitoring report from the Google Ads Transparency Center: unified ad records, a per-brand summary (formats, regions, first/last seen) and a new-since-last-run diff of fresh creatives. Built for weekly schedules. No login. $5 per 1,000 ads.

- **URL**: https://apify.com/vanborn_labs/competitor-ads-radar.md
- **Developed by:** [Van Born Labs](https://apify.com/vanborn_labs) (community)
- **Categories:** Marketing, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 ad records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Competitor Ads Radar — Google Ads Library

**Competitor Ads Radar** is a weekly competitor-ads report, not just a raw scrape. Give it brand names or domains and it reads the **Google Ads Transparency Center**, then returns unified ad records, an **advertiser summary** per brand (ad count, formats, regions, first and last seen) and a **"new since last run" diff** that shows exactly which creatives launched or stopped since your previous run.

Schedule it weekly for your competitor set and you get a change report instead of thousands of rows to compare by hand. For a cheaper raw export, use our Google Ads Transparency Scraper.

### What is Competitor Ads Radar?

Competitor Ads Radar is an Apify Actor by Van Born Labs. It runs in the cloud, so you can start it from the Apify Console, call it through the Apify API, schedule it, or plug it into Make, n8n, Zapier, Google Sheets and AI agents through the Apify MCP server. Results can be exported as JSON, CSV, Excel, XML or HTML.

#### Key features

- 🔎 One input list of **advertiser names**, **domains** or **Google AR advertiser ids** — one call per advertiser. Google Ads Transparency Center is the live source.
- 🧩 Returns a **unified ad record**: `platform`, `advertiser`, `adId`, `firstSeen`, `lastSeen`, `format`, `text`, `cta`, `landingUrl`, `mediaUrls`, `regions` and a library permalink when the source exposes one.
- 📊 Adds a **per-advertiser summary**: ad counts by platform and format, landing domains, date range, and which libraries were queried, parked or failed.
- 🆕 Optional **new-since-last-run** diff via a named Apify key-value store snapshot of ad ids. The first run is the baseline (`isFirstSnapshot: true`, no ads marked new). Later runs set `isNewSinceLastRun` on creatives that were not in the snapshot.
- 🎯 Caps per platform, per advertiser and per run, so a test or a daily monitor stays predictable to bill.
- 🌍 Choose a **region** (US, GB, DE and other ISO country codes). Google uses this directly. TikTok's public library covers EU/EEA, UK, Brazil and Turkey; a US request is searched in GB and noted on the summary.
- 🛡️ Uses the **Apify datacenter proxy (`group=auto`)** on platform runs and does **not** use residential proxy.

**Current library coverage.** Google Ads Transparency is the production-grade source in this version (official public RPCs, the same ones the Transparency Center website uses). **Meta Ad Library** and **LinkedIn Ad Library** are **parked**: the official Meta ads archive API needs a verified access token we do not use, and the public Meta and LinkedIn library pages return bot / Cloudflare challenges from cloud IPs, with no stable login-free JSON feed. **TikTok Ad Library** is implemented against the public library JSON the website calls; when cloud IPs get HTTP 421 (`system busy`), that platform is parked for the run and explained on the summary instead of returning fake rows. Parked libraries are listed, not billed as ads.

### What data can Competitor Ads Radar extract?

| Field | What it means |
|---|---|
| `recordType` | Record type — ad or advertiser_summary |
| `platform` | Platform |
| `query` | Search query |
| `advertiser` | Advertiser |
| `advertiserId` | Advertiser ID |
| `adId` | Ad ID |
| `firstSeen` | First seen |
| `lastSeen` | Last seen |
| `format` | Format |
| `text` | Ad text |
| `cta` | Call to action |
| `landingUrl` | Landing page |
| `mediaUrls` | Media URLs |
| `imageUrls` | Image URLs |
| `videoUrls` | Video URLs |
| `regions` | Regions |
| `permalink` | Library permalink |
| `isNewSinceLastRun` | New since last run |
| `adCount` | Ad count (summary) |
| `newSinceLastRun` | New ads (summary) |
| `adCountByPlatform` | Ads by platform |
| `adCountByFormat` | Ads by format |
| `platformsQueried` | Platforms queried |
| `platformsParked` | Platforms parked |
| `platformsFailed` | Platforms failed |
| `landingDomains` | Landing domains |
| `isFirstSnapshot` | First snapshot |
| `snapshotKey` | Snapshot key |
| `scrapedAt` | Scraped at |

### How to use Competitor Ads Radar

1. Open the Actor and click **Try for free** (an Apify account is free and includes monthly platform credit).
2. Enter competitor brand names or domains, pick a region, and keep "Compare with last run" on for diffs.
3. Click **Start** and wait for the run to finish. Small runs finish in seconds.
4. Download the results as JSON, CSV or Excel, or connect them to your app with the Apify API, a webhook or an integration.
5. To monitor changes, save your input as a task and add a **schedule** (hourly, daily or weekly).

### How much does it cost to use Competitor Ads Radar?

This Actor uses **pay-per-event** pricing: **$5.00 per 1,000 ads** plus a tiny $0.00005 start fee per run. You only pay for ads actually returned; failed lookups are not charged. Platform usage is included in the price.

| Ads | Price |
|---|---|
| 100 | $0.50 |
| 1,000 | $5.00 |
| 10,000 | $50.00 |

Apify's free plan includes $5 of monthly credit, which covers about **1,000 ads** with this Actor. Set **Max cost per run** in the run options if you want a hard spending cap.

### Use cases

- **Competitor ad research for agencies**: pull a brand's public creatives from every reachable ad library in one run, then drop the unified rows into a report or a sheet.
- **Creative monitoring**: schedule a daily or weekly run and keep only ads with `isNewSinceLastRun: true`.
- **Ad spy / media databases**: collect public advertiser ids, permalinks, landing pages and creative media URLs without maintaining four separate actors.
- **Brand and category watch**: paste a list of competing domains and see format mix, date ranges and new creative volume in the summaries.
- **Automation**: pipe ads and summaries into n8n, a warehouse, or a weekly client digest.

### Input

Full field descriptions are on the **Input** tab. Example input (this is also the default run, which finishes in under a minute):

```json
{
  "advertisers": [
    "Nike"
  ],
  "region": "US",
  "platforms": [
    "google"
  ],
  "maxAdsPerPlatform": 10
}
```

### Output

Each result is one row in the dataset. Example output item from a real run:

```json
{
  "recordType": "ad",
  "platform": "google",
  "query": "Nike",
  "advertiser": "Nike, Inc.",
  "advertiserId": "AR16735076323512287233",
  "adId": "CR03708909800050917377",
  "firstSeen": "2022-11-30",
  "lastSeen": "2026-11-18",
  "format": "image",
  "text": null,
  "cta": null,
  "landingUrl": null,
  "mediaUrls": [
    "https://tpc.googlesyndication.com/archive/simgad/3393474210464605364"
  ],
  "imageUrls": [
    "https://tpc.googlesyndication.com/archive/simgad/3393474210464605364"
  ],
  "videoUrls": [],
  "regions": [
    "US"
  ],
  "permalink": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR03708909800050917377?region=US",
  "isNewSinceLastRun": false,
  "scrapedAt": "2026-11-18T05:55:05.291037+00:00",
  "daysServed": 1391,
  "alternativeAdvertisers": [
    {
      "advertiserId": "AR04119126533128323073",
      "advertiserName": "Nike, Inc."
    },
    {
      "advertiserId": "AR13144659079110590465",
      "advertiserName": "Nike, Inc."
    },
    {
      "advertiserId": "AR06535278389996027905",
      "advertiserName": "NIKE, Inc."
    }
  ]
}
```

You can view results as a table in the Console, or get them from the API in JSON, CSV, Excel, XML or HTML.

### FAQ

#### Do I need logins or official API tokens?

No. The Actor only reads public ad-library interfaces. It does not log into advertiser accounts and it does not use a Meta, TikTok or LinkedIn developer token.

#### Why are Meta and LinkedIn parked?

The official Meta ads archive API requires identity verification and a token, and it still omits most US commercial ads. The public Meta and LinkedIn library websites challenge unauthenticated cloud IPs. Rather than return incomplete or blocked pages as if they were ads, this version documents the gap on the summary and charges nothing for those libraries. Google remains the reliable source.

#### What about TikTok?

The Actor calls the public TikTok Ad Library JSON used by the official library site (EU/UK and a few other transparency regions). If the search endpoint is anti-bot blocked (HTTP 421), TikTok is parked for that run. Creative Center APIs that require a signed session are not used.

#### How does “new since last run” work?

Turn `compareWithLastRun` on and keep the same `snapshotStoreName` on a schedule. The named key-value store keeps the last set of `platform:adId` keys per advertiser and region. The first run only writes the baseline. Later runs mark creatives that were not in that set.

#### Is this impression or spend data?

No. A successful row is a *public creative listing* from an official transparency library, not an impression log or an audited spend figure.

#### Will a short brand name always resolve to the national advertiser?

Google name search ranks advertisers by public ad volume, but a short name can have several legitimate entities. Check `alternativeAdvertisers` on Google rows, or pass the `AR…` id / a domain directly.

**Make sure your use of the data complies with each library's terms and applicable law for your purpose.**

#### Can I use it through the API, MCP or integrations?

Yes. Every run is available through the Apify API and the official Python and JavaScript clients, and the Actor can be called by AI agents through the Apify MCP server. Integrations include Make, n8n, Zapier, Google Sheets, Slack and webhooks.

#### Is it legal to scrape this data?

The Actor only collects publicly available data and does not log in or bypass access controls. You are responsible for how you use the results: respect the source site's terms, copyright and privacy laws such as GDPR, and do not collect personal data without a legal basis. If in doubt, ask a lawyer.

#### Something did not work. What should I do?

Open an issue on the **Issues** tab with your run link. We usually answer within a day and fix breakages quickly.

### Other Van Born Labs Actors

| Actor | What it does |
|---|---|
| [Google Ads Transparency Scraper — Ad Library](https://apify.com/vanborn_labs/google-ads-transparency-scraper) | Scrape the Google Ads Transparency Center (Google ad library) by advertiser name, domain or AR id |
| [Google Trends Trending Now — Real-Time Keywords](https://apify.com/vanborn_labs/google-trends-trending-now) | Scrape Google Trends Trending Now: rising searches, search volume, related queries, categories and start time for any country or US state, past 4 hours to 7 days |
| [Website SEO Audit — Meta Tags, Sitemap & Robots](https://apify.com/vanborn_labs/website-seo-audit) | Technical SEO audit for URLs or a sitemap: title, meta description, canonical, hreflang, OG/Twitter, H1/H2, word count, status, redirects, broken links, image alt, robots.txt, sitemap, noindex, TTFB and page size |
| [Google News RSS Scraper — Keywords, Topics & Sites](https://apify.com/vanborn_labs/google-news-rss-scraper) | Google News scraper by keyword, topic or site via official RSS |

More tools: [Van Born Labs on Apify](https://apify.com/vanborn_labs).

# Actor input Schema

## `advertisers` (type: `array`):

Brand names (Nike), domains (bmw.com, pepsico.com), or a Google Ads Transparency AR advertiser id. One lookup is run per item across the selected ad libraries.

## `region` (type: `string`):

ISO country code used as the primary region (e.g. US, GB, DE). Google Ads Transparency uses this directly. TikTok's public Ad Library covers EU/EEA, UK, Brazil and Turkey; a US request is searched in GB and noted on the summary.

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

Ad libraries to query. Meta and LinkedIn are parked in this version when their public pages are not reliably reachable without a login; they are still listed on the summary so you can see the gap.

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

Cap on ads fetched (and charged) from each library for each advertiser.

## `maxAdsPerAdvertiser` (type: `integer`):

Optional overall cap across all libraries for one advertiser. Defaults to max ads per platform times the number of platforms.

## `maxTotal` (type: `integer`):

Optional hard cap on ad records across all advertisers in this run.

## `compareWithLastRun` (type: `boolean`):

When on, ad ids are compared to a snapshot in a named key-value store. First run builds the baseline (isNewSinceLastRun is false). Later runs flag new creatives.

## `snapshotStoreName` (type: `string`):

Named Apify key-value store used to remember the last ad-id set per advertiser and region. Same name across scheduled runs enables the diff.

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

How many advertisers to query in parallel (keep low to avoid rate limits).

## Actor input object example

```json
{
  "advertisers": [
    "Nike"
  ],
  "region": "US",
  "platforms": [
    "google"
  ],
  "maxAdsPerPlatform": 10,
  "compareWithLastRun": true,
  "snapshotStoreName": "competitor-ads-radar-snapshots",
  "maxConcurrency": 2
}
```

# Actor output Schema

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

One item per ad (recordType=ad) and one advertiser_summary per input advertiser.

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

JSON counters stored as RUN_SUMMARY.

# 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 = {
    "advertisers": [
        "Nike"
    ],
    "region": "US",
    "platforms": [
        "google"
    ],
    "maxAdsPerPlatform": 10,
    "snapshotStoreName": "competitor-ads-radar-snapshots"
};

// Run the Actor and wait for it to finish
const run = await client.actor("vanborn_labs/competitor-ads-radar").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 = {
    "advertisers": ["Nike"],
    "region": "US",
    "platforms": ["google"],
    "maxAdsPerPlatform": 10,
    "snapshotStoreName": "competitor-ads-radar-snapshots",
}

# Run the Actor and wait for it to finish
run = client.actor("vanborn_labs/competitor-ads-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "advertisers": [
    "Nike"
  ],
  "region": "US",
  "platforms": [
    "google"
  ],
  "maxAdsPerPlatform": 10,
  "snapshotStoreName": "competitor-ads-radar-snapshots"
}' |
apify call vanborn_labs/competitor-ads-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vanborn_labs/competitor-ads-radar"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NQ523b5AOhWQEUCmH/builds/JkDeFosDG18lr0Qse/openapi.json
