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

Scrape live and recent ads shown through Google - search by advertiser name, domain, or exact advertiser ID. Get ad format, preview image/creative, advertiser identity, and first/last shown dates from the public Ads Transparency Center.

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

## Pricing

from $3.00 / 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 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 Center Scraper

Scrape live and recent ads shown through Google — search by landing-page domain or exact advertiser ID. Get ad format, preview creative, advertiser identity, and first/last shown dates from the public [Ads Transparency Center](https://adstransparency.google.com). No login, no API key, no cookies.

### What this actor does

- **Two modes:** `byQuery` (landing-page domain — most reliable) and `byAdvertiserId` (exact ID lookup)
- **Filters:** region/market, ad format (text/image/video), platform (Search/Maps/Shopping/Play/YouTube), last-shown date range
- **Preview assets:** static thumbnail image URL (and dimensions) when available, or the live rich-media preview script URL
- **Empty fields are omitted**

### Output per ad

- `advertiserId`, `advertiserName`
- `creativeId`, `creativeUrl` — deep link to the ad's page on Ads Transparency Center
- `advertiserUrl` — deep link to the advertiser's page
- `format` — `Text`, `Image`, or `Video`
- `previewImageUrl`, `previewWidth`, `previewHeight` — static thumbnail (when the ad renders as an archived screenshot)
- `previewContentUrl` — live rich-media/video preview script URL (when applicable)
- `firstShownAt`, `lastShownAt` — ISO-8601 UTC
- `firstShownTimestamp`, `lastShownTimestamp` — Unix epoch seconds
- `region`
- `recordType: "ad"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `byQuery` | `byQuery` / `byAdvertiserId` |
| `query` | string | `nike.com` | Landing-page domain (mode=byQuery). The upstream search endpoint reliably matches domains (e.g. `nike.com`) — free-text advertiser names (e.g. `Nike`) frequently return zero results, so a domain is strongly recommended. Use `mode=byAdvertiserId` for a name-independent, always-stable lookup once you have an `advertiserId`. |
| `advertiserIds` | array | – | Exact advertiser IDs, e.g. `AR16735076323512287233` (mode=byAdvertiserId) |
| `region` | string | `US` | Market to tag results with |
| `adFormat` | string | – | `TEXT` / `IMAGE` / `VIDEO` |
| `platform` | string | – | `SEARCH` / `MAPS` / `SHOPPING` / `PLAY` / `YOUTUBE` |
| `dateFrom` | string | – | Only ads last shown on/after this date (`YYYY-MM-DD`) |
| `dateTo` | string | – | Only ads last shown on/before this date (`YYYY-MM-DD`) |
| `maxItems` | int | `40` | Hard cap, 1–100 |

#### Example: all ads for a domain

```json
{
  "mode": "byQuery",
  "query": "nike.com",
  "region": "US",
  "maxItems": 40
}
```

#### Example: video ads only, by exact advertiser ID

```json
{
  "mode": "byAdvertiserId",
  "advertiserIds": ["AR16735076323512287233"],
  "adFormat": "VIDEO",
  "maxItems": 50
}
```

### Use cases

- **Competitive intelligence** — see what ad creatives a competitor is running right now
- **Ad compliance monitoring** — audit an advertiser's messaging and formats
- **Creative research** — collect a swipe file of live ad copy and imagery by niche
- **Brand safety** — verify what ads are (and aren't) associated with a domain

### FAQ

**Is this the official Google Ads API?**  No — Google does not publish a public API for the Ads Transparency Center. This actor calls the same backend endpoint the public web app at adstransparency.google.com uses, exactly as your browser does when you search there.

**Do I need a Google account or API key?**  No. The Ads Transparency Center is a public tool; no login is required to browse or search it.

**Why is `maxItems` capped at 100?**  The upstream endpoint serves ads in a single page of up to 100 per lookup; a working pagination cursor is not exposed on the public surface.

**Some ads have `previewImageUrl` and others have `previewContentUrl` — why?**  Text-format ads are shown as an archived screenshot (`previewImageUrl`). Image and video ads with interactive/rich-media elements are served through a live rendering script (`previewContentUrl`) instead of a static image.

**Does `region` actually filter results?**  It's passed to the upstream API the same way the website's region selector does. For some advertisers the set of ads returned does not change much across regions, since global advertisers run largely the same catalog everywhere — this mirrors what you'd see switching regions on the website itself.

**How do I find an advertiser ID?**  Run `mode=byQuery` first with the advertiser's name or domain — the `advertiserId` field in the results is reusable as input to `mode=byAdvertiserId` for a stable, unambiguous lookup.

**How fresh is the data?**  Near real-time — this reflects Google's live transparency index of ads currently or recently served.

**Why does `dateTo` (an older cutoff) sometimes return 0 results for popular advertisers?**  Because there's no pagination cursor (see above), only the single most-recent page of up to 100 creatives is ever fetched, and for an advertiser running continuous/ongoing campaigns essentially every creative on that page has a `lastShownAt` of today or yesterday. A `dateTo` cutoff further in the past than that will correctly exclude all of them — that's not a bug, it means none of the currently-fetchable creatives are that stale. `dateTo` is most useful for advertisers whose campaigns have genuinely paused/ended, or combined with `dateFrom` for a recent window (e.g. "last shown in the past week").

# Actor input Schema

## `mode` (type: `string`):

How to look up ads.

## `query` (type: `string`):

A landing-page domain, e.g. `nike.com`. The upstream endpoint reliably matches domains; free-text brand names (e.g. `Nike`) frequently return zero results, so a domain is strongly recommended. For a name-independent lookup, find the `advertiserId` from a first byQuery run and reuse it with mode=byAdvertiserId.

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

Exact Google Ads Transparency Center advertiser IDs, e.g. `AR16735076323512287233`. Find one via mode=byQuery first, or from a `adstransparency.google.com/advertiser/...` URL.

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

Country/market to tag results with (matches the region selector on the Ads Transparency Center site).

## `adFormat` (type: `string`):

Restrict to a single ad format. Leave unset for all formats.

## `platform` (type: `string`):

Restrict to ads shown on a single Google surface. Leave unset for all platforms.

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

Only keep ads last shown on/after this date.

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

Only keep ads last shown on/before this date.

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

Hard cap on emitted records. The upstream API serves at most 100 ads per lookup (no working pagination cursor is exposed publicly).

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

The Ads Transparency RPC endpoint occasionally bot-checks (302) requests from a given datacenter IP, especially for mode=byAdvertiserId. This actor retries failed requests through Apify's free AUTO datacenter proxy group (a fresh IP per retry) — no paid/residential proxy is required.

## Actor input object example

```json
{
  "mode": "byQuery",
  "query": "nike.com",
  "advertiserIds": [],
  "region": "US",
  "adFormat": "",
  "platform": "",
  "maxItems": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `ads` (type: `string`):

Dataset containing all scraped ad creative records.

# 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 = {
    "mode": "byQuery",
    "query": "nike.com",
    "advertiserIds": [],
    "region": "US",
    "adFormat": "",
    "platform": "",
    "maxItems": 40,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/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 = {
    "mode": "byQuery",
    "query": "nike.com",
    "advertiserIds": [],
    "region": "US",
    "adFormat": "",
    "platform": "",
    "maxItems": 40,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/google-ads-transparency-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 '{
  "mode": "byQuery",
  "query": "nike.com",
  "advertiserIds": [],
  "region": "US",
  "adFormat": "",
  "platform": "",
  "maxItems": 40,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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