# Google Ads Transparency Scraper — Creatives & Reach Data (`openclawai/google-ads-transparency-scraper`) Actor

\[💰 $1/1K flat] Scrape Google Ads Transparency Center by brand, domain or advertiser ID. Ad creatives, run dates, days active, per-country reach & advertiser legal entity included. All Google surfaces, 230+ countries, no login.

- **URL**: https://apify.com/openclawai/google-ads-transparency-scraper.md
- **Developed by:** [Pika Choo](https://apify.com/openclawai) (community)
- **Categories:** Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Google Ads Transparency Scraper — Competitor Creatives, Reach & Advertisers

**Google Ads Transparency Scraper: $1 per 1,000 results, everything included, no API key, no login.** Turn the Google Ads Transparency Center into clean, structured JSON. Search by **brand name, website domain, advertiser ID or Transparency Center URL** and get every ad an advertiser runs across **Google Search, YouTube, Display, Shopping and Maps**, with the actual creatives, run dates, days active and the **per-country impression ranges** most Google ads scrapers never return. Covers **230+ countries**, works with AI agents through MCP, and runs on a schedule or from the API.

### Why this Google Ads scraper

- 💰 **One flat price.** $1/1K results with reach data, creatives and dates included. No actor-start fee, no tiers, no separate "detail" upcharge.
- 📈 **Reach data others skip.** Per-country impression ranges, per-surface breakdown, total reach, creative variation counts and the advertiser's verified **legal entity name**.
- ⏱️ **Days active per ad.** Instantly separate an advertiser's long-running winners from fresh tests.
- 🖼️ **Real creatives, not just IDs.** Banner image URLs for image ads, rendered screenshots for text ads, renderable previews and video links for video ads.
- 🛡️ **Does not die mid-run.** Google rate-limits a single IP after roughly 25 requests. This Actor rotates residential IPs proactively and retries automatically.

### Who uses this

- **Performance marketers and PPC agencies** monitoring competitor Google Ads, YouTube ads and Display creatives.
- **Creative strategists** building swipe files of ads that have survived for months (high `days_active`).
- **Media planners and analysts** who need per-country reach to see where a competitor concentrates budget.
- **Sales and lead-generation teams** screening prospect lists for "does this company run Google ads?".
- **Brand protection and legal teams** finding advertisers bidding on a brand or impersonating a domain, with their verified legal entity.
- **AI and data teams** feeding structured ad data into models, dashboards and market research.

### What you can do with it

| Mode | How | Cost |
|---|---|---|
| Scrape all ads of an advertiser, reach data included | domain / name / `AR…` ID in `queries` | $1 per 1K ads |
| Screen domains: "do they run Google ads?" | `fetchAds: false` | $1 per 1K domains |
| Only video (or text / image) ads | `formats: ["VIDEO"]` | pay only for kept ads |
| One country's ads only | `region: "DE"` | same rate |
| Fast listing without reach data | `fetchAdDetails: false` | same rate, much faster |

### Input

```json
{
    "queries": ["nike", "booking.com", "AR02934798844673654785"],
    "advertisersPerQuery": 3,
    "maxAdsPerAdvertiser": 50,
    "fetchAds": true,
    "fetchAdDetails": true,
    "formats": [],
    "region": ""
}
```

- **queries**: brand names, domains, `AR…` advertiser IDs or full Transparency Center URLs, mixed freely. The type is detected automatically. *Domain queries are the most reliable* because they resolve directly to the verified advertiser.
- **advertisersPerQuery**: how many advertisers to keep per brand-name query (1 to 20). Domains and IDs always resolve to exactly one.
- **maxAdsPerAdvertiser**: up to 2,000 ads per advertiser per run. Ads are fetched newest-first in pages of 40.
- **fetchAds**: turn off to get advertiser records only (cheap domain screening).
- **fetchAdDetails**: adds the reach / region / variations / legal-entity layer per ad. Turn off for a faster run when you only need formats, dates and creative URLs.
- **formats**: keep only `TEXT`, `IMAGE` and/or `VIDEO` ads.
- **region**: 2-letter ISO country code (`US`, `GB`, `DE`…). Empty means worldwide.
- **proxyConfiguration**: Apify residential proxies are on by default and strongly recommended.

### What you get

Every ad is one flat JSON row:

| Field | Example | Notes |
|---|---|---|
| `item_type` | `ad` | `ad`, `advertiser`, `hint` or `error` |
| `advertiser_id` / `advertiser_name` | `AR0293…` / `Booking.com` | verified advertiser |
| `creative_id` / `ad_url` | `CR1058…` / permalink | link opens the live ad |
| `format` | `TEXT` | `IMAGE` | `VIDEO` | |
| `first_shown` / `last_shown` | `2021-11-04` / `2026-08-15` | |
| `days_active` | `1747` | longevity signal |
| `image_url` | `https://tpc.googlesyndication.com/…` | banner, or rendered screenshot for text ads |
| `preview_url` / `video_url` | | renderable preview / direct video link |
| `legal_name` | `Booking.com B.V.` | with full details on |
| `variation_count` | `2` | A/B variations, with full details on |
| `total_reach_low` / `total_reach_high` | `15000` / `20000` | impression range, where disclosed |
| `region_stats` | see below | with full details on |
| `has_detail` | `true` | whether the full detail record was fetched |
| `source_query` / `region` | `booking.com` / `anywhere` | which input produced the row |
| `scraped_at` | `2026-08-15T14:02:11Z` | ISO timestamp |

Advertiser rows carry `advertiser_id`, `advertiser_name`, `advertiser_domain` and `declared_ad_count`, which is Google's own total ad count for that advertiser.

#### Sample JSON output

```json
{
    "item_type": "ad",
    "advertiser_id": "AR02934798844673654785",
    "advertiser_name": "Booking.com",
    "creative_id": "CR10586047617038745601",
    "ad_url": "https://adstransparency.google.com/advertiser/AR02934798844673654785/creative/CR10586047617038745601",
    "format": "IMAGE",
    "first_shown": "2021-11-04",
    "last_shown": "2026-08-15",
    "days_active": 1747,
    "image_url": "https://tpc.googlesyndication.com/archive/simgad/…",
    "video_url": null,
    "preview_url": null,
    "legal_name": "Booking.com B.V.",
    "variation_count": 2,
    "total_reach_low": 15000,
    "total_reach_high": 20000,
    "region_stats": [
        {
            "region": "DE",
            "region_name": "Germany",
            "reach_low": 1000,
            "reach_high": 2000,
            "first_shown": "2023-03-04",
            "last_shown": "2026-08-15",
            "surfaces": [{"surface_code": 3, "reach_low": 1000, "reach_high": 2000}]
        }
    ],
    "has_detail": true,
    "source_query": "booking.com",
    "region": "anywhere",
    "scraped_at": "2026-08-15T14:02:11Z"
}
```

`region_stats` holds one entry per country the ad ran in. Export the whole dataset as JSON, CSV, Excel, XML or RSS from the Apify Console or API.

### Pricing: how much does it cost to scrape 1,000 Google ads?

**One event, one price: $0.001 per result ($1 per 1,000).** A result is one row in your dataset, either an ad (with creatives, dates, days active and reach data) or an advertiser record. Hints and errors are free, ads filtered out by `formats` are never charged, and there is no actor-start fee.

**Worked examples**

| Job | Rows | Cost |
|---|---|---|
| One advertiser, 1,000 ads with full reach data | 1 advertiser + 1,000 ads = 1,001 | **$1.00** |
| One advertiser, 100 ads | 101 | **$0.10** |
| Screen 500 domains for ad activity (`fetchAds: false`) | 500 | **$0.50** |
| 10 competitors, 200 ads each, video only | 10 + up to 2,000 kept ads | **up to $2.01** |

Apify platform usage (compute and residential proxy traffic) is billed separately by Apify on top of the per-result price, as with any Actor. Runs are light, so this is typically a small fraction of the result cost.

### Use cases

- **Competitor ad monitoring**: every ad a competitor runs, how long each has been live (`days_active`), and in which countries it actually gets impressions. Schedule daily runs and diff the results.
- **Creative research and swipe files**: real banners, text-ad renders and video previews from any industry.
- **Media planning and spend intelligence**: per-country impression ranges reveal where competitors concentrate budget and which creatives they scale.
- **Lead generation**: screen prospect lists with `fetchAds: false`. One cheap advertiser record tells you who invests in Google ads before you pitch.
- **Brand protection**: find advertisers bidding on your brand or impersonating your domain, with their verified legal entity.
- **AI and research datasets**: structured Google ads data for models, dashboards and market research.

### Use with AI agents and MCP

This Actor is available as a tool for Claude, Cursor, ChatGPT and any other MCP-capable agent through the Apify MCP server. Point your client at:

```
https://mcp.apify.com/?tools=fetch-actor-details,openclawai/google-ads-transparency-scraper
```

An agent can then ask "what Google ads is booking.com running in Germany right now?" and receive the structured rows directly. For a step-by-step setup guide and prompt examples see the [Datapika guide for this Actor](https://datapika.com/actors/google-ads-transparency-scraper).

### Integrations

Run it on a schedule, trigger it via the [Apify API](https://docs.apify.com/api/v2) from any language, or use the official [Python](https://docs.apify.com/api/client/python) and [JavaScript](https://docs.apify.com/api/client/js) clients. Export to CSV, Excel or JSON, or pipe results to Google Sheets, Make, Zapier, n8n, LangChain, LlamaIndex and MCP like any other Actor. Webhooks let you trigger a downstream job the moment a run finishes.

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("openclawai/google-ads-transparency-scraper").call(run_input={
    "queries": ["booking.com"],
    "maxAdsPerAdvertiser": 100,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["advertiser_name"], row["format"], row["days_active"], row["ad_url"])
```

### FAQ

#### Does Google have an official Ads Transparency Center API?

No. Google publishes the Ads Transparency Center as a website only, with no public API, no bulk export and no way to pull reach data programmatically. This Actor gives you that API: send a brand, domain or advertiser ID and get structured JSON back, with no Google account, cookies or API key.

#### How much does it cost to scrape 1,000 Google ads?

$1.00 plus a small amount of Apify platform usage. Every result row costs $0.001, whether it is a full ad with reach data or a bare advertiser record. See the pricing table above for more worked examples.

#### Where does the data come from?

The public Google Ads Transparency Center, which lists ads from verified advertisers across Search, YouTube, Display, Shopping and Maps. No login, cookies or API keys are required.

#### Which queries work best?

Domains (`nike.com`). Brand-name queries use Google's suggestion search, which can surface smaller same-name advertisers, so keep `advertisersPerQuery` low to stay focused. Advertiser IDs and full Transparency Center URLs resolve to exactly one advertiser.

#### Why do reach fields show `null` for some ads?

Google only discloses impression ranges where regulation requires it, mainly for ads shown in the EU. Ads outside those regions still return format, dates and creatives.

#### Why do some video ads have a preview URL but no video URL?

Google serves some video creatives only as renderable previews. A direct video link is included whenever it is exposed.

#### How many ads can I get, and how fast is it?

`maxAdsPerAdvertiser` goes up to 2,000 per advertiser per run, fetched newest-first in pages of 40. Segment bigger inventories with the `region` filter. Turning `fetchAdDetails` off skips the per-ad detail call and is much faster when you only need formats, dates and creative URLs.

#### Can I export to CSV or Excel?

Yes. Every run produces an Apify dataset that you can download as JSON, CSV, Excel, XML or RSS, or read through the API and clients above.

#### How does this compare to the Google Ads Transparency Center website?

The website shows one advertiser at a time with no export. This Actor processes lists of brands, domains and IDs in one run, adds `days_active`, flattens per-country reach and surface data into rows, and delivers real image, preview and video URLs ready for spreadsheets, dashboards or AI agents.

### Is it legal to scrape the Google Ads Transparency Center?

The Actor only accesses data Google publishes for transparency purposes, available to anyone without an account. It collects ad creatives and advertiser business information, not personal data. You are responsible for how you use the output, so review your own compliance requirements and the terms that apply to your use case. If you need help, contact us through the Actor's Issues tab.

# Actor input Schema

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

One per line. Accepts any mix of: a brand / advertiser name ('nike'), a website domain ('nike.com'), an advertiser ID ('AR01234567890123456789') or a full Transparency Center URL. The Actor detects the type automatically.

## `advertisersPerQuery` (type: `integer`):

When a query is a brand name, how many matching advertisers to keep (the platform returns up to 20). Domains and IDs always resolve to exactly one.

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

Maximum number of ads to return for each advertiser (1–2000). Ads are fetched newest-first in pages of 40.

## `fetchAds` (type: `boolean`):

On (default): return every ad for each matched advertiser. Off: return advertiser records only — the cheapest way to screen a list of domains or brands for whether they run Google ads at all.

## `formats` (type: `array`):

Only keep ads of these formats. Leave empty for all formats.

## `fetchAdDetails` (type: `boolean`):

On (default): fetch each ad's full record — per-country impression ranges with first/last-shown dates, surface breakdown, every creative variation and the advertiser's legal entity name. Off: still returns format, dates and image/preview URLs per ad — much faster when you don't need reach data. Same price either way.

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

Filter ads to one country using its 2-letter ISO code — e.g. 'US', 'GB', 'DE', 'FR', 'BR', 'JP'. Leave empty to search worldwide. An unknown code stops the run with a clear message instead of silently returning zero ads.

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

Residential proxies are strongly recommended — the platform rate-limits a single IP after roughly 25 requests. The Actor rotates IPs automatically during the run.

## Actor input object example

```json
{
  "queries": [
    "booking.com"
  ],
  "advertisersPerQuery": 3,
  "maxAdsPerAdvertiser": 50,
  "fetchAds": true,
  "formats": [],
  "fetchAdDetails": true,
  "region": "US",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "booking.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("openclawai/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": ["booking.com"] }

# Run the Actor and wait for it to finish
run = client.actor("openclawai/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": [
    "booking.com"
  ]
}' |
apify call openclawai/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,openclawai/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/y5Aa42I1s547XJz00/builds/OPf9N0Zh35NrHbqYi/openapi.json