# Google Ads Transparency Center Scraper (`xtracto/google-ads-transparency`) Actor

Pull every ad an advertiser is running from Google's Ads Transparency Center by domain or advertiser ID. Returns each ad's preview, format, first/last shown dates, and optional per-country reach breakdown. Competitive ad intelligence with no login and no API key.

- **URL**: https://apify.com/xtracto/google-ads-transparency.md
- **Developed by:** [Farhan Febrian Nauval](https://apify.com/xtracto) (community)
- **Categories:** Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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.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

## Google Ads Transparency Center Scraper

See every ad a company is running on Google — Search, Display, and YouTube — straight from Google's own public **Ads Transparency Center**. Give the actor an advertiser's domain (like `nike.com`) or advertiser ID and it returns each ad's preview, format, and the dates it ran, plus an optional per-country reach breakdown.

It's a fast, no-cost way to watch a competitor's advertising: what they're promoting, where, and for how long. No account, no API key, no login.

### Why use this actor

- **No account, no login, no API key** — the data is Google's public transparency record.
- **Complete ad library per advertiser** — every creative Google has on file for a domain or advertiser ID.
- **Ad previews** — a direct preview link for every ad, plus all creative variants.
- **Run dates** — when each ad was first and last shown.
- **Per-country reach (optional)** — impression ranges per country, split by where the ad ran (Search, Display, YouTube).
- **Any market** — pick the country you want to see ads for (US, GB, DE, JP, and more).
- **Clean, stable JSON** ready for a spreadsheet, database, or competitive-intel pipeline. Export to JSON, CSV, or Excel, with automatic retries.

### How it works

1. You give it an advertiser domain (e.g. `nike.com`) or an advertiser ID, and a country.
2. The actor looks up every ad that advertiser is running and pages through all of them.
3. Optionally, it opens each ad for the full per-country reach breakdown and all variants.
4. It returns one tidy record per ad.

You don't manage any scrapers, browsers, or blocks — just set the inputs and run.

### Input

```json
{
  "domain": "nike.com",
  "advertiserId": "",
  "regionCode": "US",
  "fetchDetail": true,
  "maxCreatives": 100,
  "maxConcurrency": 5
}
````

| Field | Type | Description |
| --- | --- | --- |
| `domain` | string | Advertiser website domain to look up (e.g. `nike.com`). Use this **or** `advertiserId`. |
| `advertiserId` | string | A specific advertiser ID starting with `AR` (e.g. `AR18378488041124659201`). Use when you already know the exact advertiser; otherwise leave blank and search by domain. |
| `regionCode` | string | Country to see ads for, as a 2-letter code (`US`, `GB`, `DE`, `JP`, `TH`, …). Default `US`. |
| `fetchDetail` | boolean | When on, enriches each ad with its per-country reach breakdown (impression ranges, surface split) and all creative variants. Slower — one extra lookup per ad. Default `false`. |
| `maxCreatives` | integer | Maximum number of ads to return. Default 100. |
| `maxConcurrency` | integer | How many detail lookups to run at once (only used when `fetchDetail` is on). Default 5. |
| `proxyConfiguration` | object | Optional. The country is chosen by `regionCode`, not by your IP, so a proxy is not required. Enable it only to spread request volume on large runs. |

### Output

One record per ad (creative). Real sample below — a Nike ad, with `fetchDetail` on, arrays truncated:

```json
{
  "_input": "nike.com",
  "_source": "S1-search-detail",
  "_scrapedAt": "2026-07-10T11:55:17Z",
  "advertiserId": "AR18378488041124659201",
  "creativeId": "CR17671898696104542209",
  "advertiserName": "Nike Retail BV",
  "domain": "nike.com",
  "formatCode": 1,
  "format": "TEXT",
  "firstShownDate": "2025-10-22",
  "lastShownDate": "2026-07-10",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&creativeId=779544926776&...",
  "creativeUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR17671898696104542209",
  "regions": [
    {
      "regionCode": 2380,
      "impressionsMin": "100000",
      "impressionsMax": "125000",
      "firstShownDate": "2025-10-22",
      "lastShownDate": "2026-07-10",
      "surfaceSplit": [
        { "surfaceCode": 2, "surface": "SEARCH",  "impressionsMin": null,     "impressionsMax": "1000" },
        { "surfaceCode": 3, "surface": "DISPLAY", "impressionsMin": "100000", "impressionsMax": "125000" },
        { "surfaceCode": 4, "surface": "YOUTUBE", "impressionsMin": null,     "impressionsMax": "1000" }
      ],
      "raw": { "...": "raw numbered region object" }
    },
    { "regionCode": 2724, "impressionsMin": "1000", "...": "1 more region" }
  ],
  "variantPreviewUrls": [
    "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...&creativeId=779544926776&..."
  ],
  "aggregate": { "2": "100000", "3": "125000", "...": "raw aggregate impressions" },
  "raw": { "...": "raw numbered search object" },
  "rawDetail": { "...": "raw numbered detail object" }
}
```

| Field | Type | Description |
| --- | --- | --- |
| `advertiserId` | string | Google advertiser ID (starts with `AR`). |
| `creativeId` | string | Unique ad (creative) ID (starts with `CR`). |
| `advertiserName` | string | Advertiser's verified legal name. |
| `domain` | string | Advertiser's website domain. |
| `format` | string | Ad format: `TEXT`, `IMAGE`, or `VIDEO`. |
| `formatCode` | integer | Raw Google format code behind `format`. |
| `firstShownDate` | string | Date the ad was first shown (`YYYY-MM-DD`). |
| `lastShownDate` | string | Date the ad was last shown (`YYYY-MM-DD`). |
| `previewUrl` | string | Direct link to Google's rendered preview of the ad. |
| `creativeUrl` | string | Human-readable Ads Transparency Center page for this ad. |
| `regions` | array | *(fetchDetail only)* Per-country reach: impression range, run dates, and a split by surface (Search / Display / YouTube). |
| `variantPreviewUrls` | array | *(fetchDetail only)* Preview links for every variant of the ad. |
| `aggregate` | object | *(fetchDetail only)* Aggregate impression totals and date range across all countries. |
| `raw` | object | The raw record for the ad, exactly as Google returned it (nothing dropped). |
| `rawDetail` | object | *(fetchDetail only)* The raw detail record for the ad. |

When `fetchDetail` is off, records carry only the fast search-level fields (through `creativeUrl` plus `raw`) and `_source` is `S1-search`.

#### About region codes

Reach in the `regions` array is reported using Google's internal country codes (e.g. `2840` = US, `2826` = GB, `2380` = Italy, `2724` = Spain). The code is the country's ISO numeric code plus 2000. You set the country you want with a simple 2-letter `regionCode` in the input.

### Notes & limits

- **Domain or advertiser ID:** give one or the other. A domain search returns every ad tied to that domain; an advertiser ID targets one specific advertiser.
- **Impression ranges, not exact counts:** Google publishes reach as ranges (e.g. 100,000–125,000), not precise numbers. Values are passed through exactly as Google reports them; a sparsely-run ad may show `null` for one end of the range.
- **`fetchDetail` cost:** turning it on adds one lookup per ad. For a quick inventory of what an advertiser is running, leave it off; turn it on when you need reach and variants.
- **Region is a parameter, not your location:** you see a country's ads by setting `regionCode`, regardless of where the actor runs — no proxy needed.
- **Coverage:** whatever Google publishes in its Ads Transparency Center. Advertisers with no verified ads return no records.

### Other actors in this collection

| Actor | What it does |
| --- | --- |
| SEC Form D Funding Tracker | US private-placement funding rounds and the people behind them. |
| US Customs Bill-of-Lading (ImportYeti) | US maritime import intelligence per company. |
| North Data Companies | European company registry and financial data. |

# Actor input Schema

## `domain` (type: `string`):

The advertiser's website domain to look up (e.g. 'nike.com'). Use this OR an advertiser ID. Returns every ad this domain has run.

## `advertiserId` (type: `string`):

A specific advertiser ID starting with 'AR' (e.g. 'AR03005330488370921473'). Use this when you already know the exact advertiser. Leave blank to search by domain.

## `regionCode` (type: `string`):

The country to see ads for, as a 2-letter code (e.g. US, GB, DE, JP, TH). Ads and their reach are reported per country. Default: US.

## `fetchDetail` (type: `boolean`):

Enrich each ad with its per-country reach breakdown (impression ranges, first/last shown dates) and all creative variants. Slower — one extra lookup per ad.

## `maxCreatives` (type: `integer`):

Maximum number of ads (creatives) to return.

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

How many detail lookups to run at once (only used when 'Fetch per-region detail' is on).

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

Optional. The region is chosen by the input above, not by your IP, so a proxy is not required. Enable it only to spread request volume across IPs on large runs.

## Actor input object example

```json
{
  "domain": "nike.com",
  "regionCode": "US",
  "fetchDetail": false,
  "maxCreatives": 100,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "domain": "nike.com",
    "advertiserId": "",
    "regionCode": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtracto/google-ads-transparency").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 = {
    "domain": "nike.com",
    "advertiserId": "",
    "regionCode": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("xtracto/google-ads-transparency").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 '{
  "domain": "nike.com",
  "advertiserId": "",
  "regionCode": "US"
}' |
apify call xtracto/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Transparency Center Scraper",
        "description": "Pull every ad an advertiser is running from Google's Ads Transparency Center by domain or advertiser ID. Returns each ad's preview, format, first/last shown dates, and optional per-country reach breakdown. Competitive ad intelligence with no login and no API key.",
        "version": "0.1",
        "x-build-id": "EXoByMTJN8sE3jA8E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtracto~google-ads-transparency/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtracto-google-ads-transparency",
                "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/xtracto~google-ads-transparency/runs": {
            "post": {
                "operationId": "runs-sync-xtracto-google-ads-transparency",
                "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/xtracto~google-ads-transparency/run-sync": {
            "post": {
                "operationId": "run-sync-xtracto-google-ads-transparency",
                "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": {
                    "domain": {
                        "title": "Advertiser domain",
                        "type": "string",
                        "description": "The advertiser's website domain to look up (e.g. 'nike.com'). Use this OR an advertiser ID. Returns every ad this domain has run."
                    },
                    "advertiserId": {
                        "title": "Advertiser ID",
                        "type": "string",
                        "description": "A specific advertiser ID starting with 'AR' (e.g. 'AR03005330488370921473'). Use this when you already know the exact advertiser. Leave blank to search by domain."
                    },
                    "regionCode": {
                        "title": "Region",
                        "type": "string",
                        "description": "The country to see ads for, as a 2-letter code (e.g. US, GB, DE, JP, TH). Ads and their reach are reported per country. Default: US."
                    },
                    "fetchDetail": {
                        "title": "Fetch per-region detail",
                        "type": "boolean",
                        "description": "Enrich each ad with its per-country reach breakdown (impression ranges, first/last shown dates) and all creative variants. Slower — one extra lookup per ad.",
                        "default": false
                    },
                    "maxCreatives": {
                        "title": "Max ads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of ads (creatives) to return.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent lookups",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "How many detail lookups to run at once (only used when 'Fetch per-region detail' is on).",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Optional. The region is chosen by the input above, not by your IP, so a proxy is not required. Enable it only to spread request volume across IPs on large runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
