# Google Ads Transparency Scraper - Competitor Ads Library (`despottt/google-ads-transparency-scraper`) Actor

Scrape competitor ads from the Google Ads Transparency Center by advertiser name, ID or domain: text, image and video ads, first/last shown dates, regions, platforms, impression ranges, ad text, YouTube links and verification. Monitor new ads on a schedule.

- **URL**: https://apify.com/despottt/google-ads-transparency-scraper.md
- **Developed by:** [Luca Despot](https://apify.com/despottt) (community)
- **Categories:** Marketing, Lead generation, SEO tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 ads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/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

## Google Ads Transparency Scraper: Competitor Ads Library by Advertiser or Domain

**Download every ad a company runs on Google** (Search, YouTube, Display, Maps, Play and Shopping) from the public [Google Ads Transparency Center](https://adstransparency.google.com) and export it to JSON, CSV or Excel. Search by **advertiser name, advertiser ID or website domain**. Filter by **country, date range and format** (text, image, video).

For each ad you get the creative ID, format, first/last shown dates, the regions and platforms where it ran, impression ranges, image/video/preview URLs, the ad text and the advertiser's verification status.

It uses the same public JSON endpoints the Transparency Center website calls in your browser. There is no login, no headless browser and no proxy cost, so it is fast (about 100 ads in 25 s with full details) and cheap.

### What can this Google Ads scraper do?

- ✅ **Any input:** `Nike, Inc.`, `AR18378488041124659201`, `nike.com` or a Transparency Center URL. The type is detected automatically.
- ✅ **Filters:** region (any country, or anywhere), format (text / image / video), date range or "last N days".
- ✅ **Rich details:** per-country first/last shown dates, impression ranges per platform (Google Search, YouTube, Maps, Play, Shopping), all creative variations, and the advertiser's country, legal name and **verified** status.
- ✅ **Ad content (optional):** headlines and descriptions for local, shopping and responsive ads, the **YouTube video ID and URL** for video ads, and image URLs.
- ✅ **Competitor monitoring (`onlyNew`):** remembers ads already returned. With a daily or weekly schedule you get, and pay for, **only new ads**.
- ✅ **Many advertisers and domains in one run**, with automatic pagination (tens of thousands of ads per advertiser).
- ✅ **REST API (Standby mode):** `GET /?queries=nike.com&region=US&format=video&maxItems=20` returns JSON instantly.

### Use cases

- **Competitor ad intelligence:** see which creatives a competitor runs, in which countries, since when and on which Google platforms.
- **Agencies and media buyers:** creative inspiration, swipe files, pitch research and client audits.
- **Brand protection:** find advertisers bidding on your domain or brand name, and unverified look-alike accounts.
- **Market research:** track launch dates of campaigns (the first-shown date) and how long ads run.
- **Alerts:** a scheduled `onlyNew` run plus a webhook sends a Slack or email alert when a competitor launches a new ad.

### How to use it

The input is a simple form, no code needed:

1. Type advertiser names, websites, advertiser IDs or Transparency Center URLs into **🔎 Advertisers or websites** (one per line).
2. Pick the **Country where the ads were shown** from the dropdown (or keep 🌍 Anywhere) and the **Ad format** (All, Text, Image, Video).
3. Set **Max ads per advertiser / website** and, if you want, **Max ads in total**.
4. Optional, in **📅 Dates**: **Shown in the last … days**, or a **Shown from** / **Shown until** date picker.
5. Optional, in **📄 Output**: turn on **Include ad text, images and video** if you need ad text, YouTube links and image URLs (slower).
6. Click **Start** and download the ads from the *Output* tab, or read them through the API.
7. For monitoring, open **🔔 Monitoring**, turn on **Only new ads since the last run**, save the input as a Task and add a Schedule.

**⚙️ Advanced options**: name matching (exact or contains), separate lists for names / IDs / websites, and the proxy (used only if Google rate-limits; leave as is).

### Input example

```json
{
  "queries": ["nike.com", "The Coca-Cola Company", "AR18378488041124659201"],
  "region": "US",
  "format": "all",
  "lastDays": 30,
  "includeDetails": true,
  "includeAdContent": true,
  "maxItemsPerQuery": 200,
  "onlyNew": false
}
```

| Field | What it does |
|---|---|
| `queries` | Advertiser names, advertiser IDs (`AR…`), domains or Transparency Center URLs. You can also use `advertiserNames`, `advertiserIds` and `domains` separately. |
| `nameMatch` | `exact` (default) takes every advertiser account with exactly that name, for example the US, TR and FR accounts of "The Coca-Cola Company". `all` takes every suggestion that contains the text. |
| `region` | 2-letter country code where the ad was shown (`US`, `GB`, `IT`, `DE`, …) or `anywhere`. |
| `format` | `all`, `text`, `image` or `video`. |
| `dateFrom` / `dateTo` / `lastDays` | Only ads shown in this period. |
| `includeDetails` | Regions, impressions, platforms, variations and verification (on by default). |
| `includeAdContent` | Ad text, YouTube video and image URLs from the ad preview (off by default, slower). |
| `maxItemsPerQuery` / `maxItems` | Limits per advertiser/domain and in total (0 = no limit). |
| `onlyNew` / `stateKey` | Monitoring mode (see above). |

### Output example (one item per ad)

```json
{
  "advertiserName": "Nike Retail BV",
  "advertiserId": "AR18378488041124659201",
  "advertiserCountry": "NL",
  "advertiserVerified": true,
  "advertiserLegalName": "Nike Retail BV",
  "creativeId": "CR11715540743232684033",
  "format": "TEXT",
  "domain": "nike.com",
  "firstShown": "2025-10-24T11:14:08Z",
  "lastShown": "2026-10-28T17:41:19Z",
  "daysShown": 370,
  "regions": [
    {
      "regionCode": "SK",
      "regionName": "Slovakia",
      "geoId": 2703,
      "firstShown": "2025-10-25",
      "lastShown": "2026-10-27",
      "impressionsMin": 0,
      "impressionsMax": 1000,
      "platforms": [
        {
          "platform": "GOOGLE_SEARCH",
          "impressionsMin": 0,
          "impressionsMax": 1000
        },
        {
          "platform": "GOOGLE_MAPS",
          "impressionsMin": 0,
          "impressionsMax": 1000
        }
      ]
    }
  ],
  "regionCodes": ["SK", "FI", "PL", "BE", "MT", "EG", "NL", "RO", "…"],
  "platforms": ["GOOGLE_MAPS", "GOOGLE_SEARCH", "GOOGLE_SHOPPING"],
  "impressionsMin": 125000,
  "impressionsMax": 150000,
  "variations": [
    {
      "previewUrl": null,
      "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/17766060261377364950"
    }
  ],
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/17766060261377364950",
  "previewUrl": null,
  "adTexts": ["nike.com", "The Official Nike Site", "Zuidplein Hoog 770", "Discover Products Online At Nike.com. Shop The Official Nike Site."],
  "adKind": "Local Ad",
  "videoId": null,
  "videoUrl": null,
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR11715540743232684033?region=anywhere",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201?region=anywhere",
  "detailsError": null,
  "query": "nike.com",
  "queryType": "domain",
  "scrapedAt": "2026-10-28T18:26:32Z"
}
```

*(Real output from a cloud run on 28 Oct 2026. Lists and URLs are shortened.)*

Text (Search) ads are published by Google as a rendered image, so `imageUrl` shows the ad exactly as users saw it. `adTexts` gives the text when the preview contains it (local, shopping, responsive and app ads).

The dataset has two views: **Overview** (image, advertiser, format, dates, regions, platforms, impressions and link) and **All fields**.

### FAQ

**Where do I find an advertiser ID?** Open the advertiser on adstransparency.google.com. The URL contains `/advertiser/AR…`. You can also paste the whole URL as a query.

**Name or domain: which is better?** A domain (`nike.com`) returns every advertiser account whose ads lead to that site, including resellers and affiliates. A name or ID returns only that advertiser.

**Why do some ads have no impressions?** Google publishes impression ranges only for some regions (mainly the EU/EEA, plus political ads). Elsewhere `impressionsMin`/`impressionsMax` are `null`.

**What does `advertiserVerified` mean?** It is `true` when Google confirmed the advertiser's identity. New and suspicious accounts are often unverified.

**How far back does it go?** As far as the Transparency Center shows. Use `lastDays` or the dates to narrow the results.

**Can I call it as an API?** Yes. Use Standby mode (`GET` or `POST` with the same fields as the input), or the normal Apify API, webhooks and integrations (Make, Zapier, n8n, Google Sheets).

### Pricing

Pay per event, with platform usage included and no subscription. You pay only for:

- **$0.002 per run start** (one start event per GB of memory; the default 512 MB run counts as one).
- **$0.0015 per ad returned**, which is **$1.50 per 1,000 ads**, with all details included.

Error rows (for example a name with no matching advertiser) are **free**. With `onlyNew` you pay only for new ads. Example: 1,000 ads cost about $1.50. Set a maximum cost per run in the run options to cap spend.

### Limitations

- It shows only what the Transparency Center publishes: **no spend, clicks, keywords or targeting data**, and impression ranges only where Google publishes them (mainly the EU/EEA and political ads).
- Text (Search) ads come as rendered images; `adTexts` is filled only when the preview contains the text.
- `includeAdContent` opens each ad preview, so runs with it on are slower.
- It relies on the Transparency Center's public web endpoints. If Google changes them, the Actor may need an update.

### Responsible use

This Actor reads only public data that Google publishes for ad transparency. It does not log in or collect personal data beyond what advertisers publish. Respect Google's terms and use reasonable volumes. Issues and feature requests are welcome in the *Issues* tab.

# Actor input Schema

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

One per line: advertiser name (<code>Nike, Inc.</code>), website (<code>nike.com</code>), advertiser ID (<code>AR18378488041124659201</code>) or a Transparency Center URL.

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

Pick a country or keep Anywhere.

## `format` (type: `string`):

Show only this type of ad.

## `maxItemsPerQuery` (type: `integer`):

0 = no limit (big brands have tens of thousands of ads).

## `maxItems` (type: `integer`):

0 = no limit.

## `lastDays` (type: `integer`):

e.g. 30. 0 = any time.

## `dateFrom` (type: `string`):

Only ads shown on or after this date.

## `dateTo` (type: `string`):

Only ads shown on or before this date. Empty = today.

## `includeDetails` (type: `boolean`):

Per-country first/last shown dates, impression ranges, platforms (Search, YouTube, Maps, Play, Shopping), ad variations and advertiser verification. One extra fast request per ad.

## `includeAdContent` (type: `boolean`):

Opens the ad preview to read headline and description text, image URLs and the YouTube video of video ads. Slower.

## `onlyNew` (type: `boolean`):

Remember ads already returned; later runs return (and charge) only new ads.

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

Give each monitor its own name if you run several with similar input.

## `nameMatch` (type: `string`):

Exact: every account with exactly this name (falls back to the biggest similar one).

## `advertiserNames` (type: `array`):

Same as the main list, but always treated as names, e.g. <code>The Coca-Cola Company</code>.

## `advertiserIds` (type: `array`):

IDs starting with AR, from the Transparency Center URL.

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

Websites the ads point to, e.g. <code>booking.com</code>.

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

Requests go direct first; Apify Proxy is used automatically only when needed. Leave as is.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "region": "anywhere",
  "format": "all",
  "maxItemsPerQuery": 20,
  "maxItems": 0,
  "lastDays": 0,
  "includeDetails": true,
  "includeAdContent": false,
  "onlyNew": false,
  "nameMatch": "exact",
  "advertiserNames": [],
  "advertiserIds": [],
  "domains": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All dataset items produced by the run

# 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 = {
    "queries": [
        "nike.com"
    ],
    "maxItemsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("despottt/google-ads-transparency-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 = {
    "queries": ["nike.com"],
    "maxItemsPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("despottt/google-ads-transparency-scraper").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 '{
  "queries": [
    "nike.com"
  ],
  "maxItemsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call despottt/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,despottt/google-ads-transparency-scraper"
        }
    }
}
```

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/KJsnWtnbzmnNIr5vA/builds/EQNGhdLqEV2ue5bEc/openapi.json