# Free Google Ads Transparency Scraper — Ad History (`s-r/google-ads-transparency`) Actor

Free Google Ads Transparency Center scraper. Pull every ad an advertiser is or has been running across Google Search, YouTube, Display, and Shopping in 50+ countries. Returns text, image, and video creatives with full metadata.

- **URL**: https://apify.com/s-r/google-ads-transparency.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $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/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

## Free Google Ads Transparency Scraper — Ad History & Spy

The free Google Ads Transparency Center scraper. Pull every ad an
advertiser is or has been running across **Google Search**, **YouTube**,
**Display**, and **Shopping** in 50+ countries — text, image, and video
creatives with full metadata.

Use it as a **Google Ads Transparency tool** for **competitor ad
intelligence**, **paid-search benchmarking**, **ad creative analysis**,
and **brand monitoring** without scraping Google yourself or fighting
CAPTCHAs.

### What you get

- **All ad formats** in one call — text (RSA), image / display, video
- **Full creative content** — headlines, descriptions, image URLs, YouTube
  thumbnails and video IDs, business address for local ads
- **Per-region impressions** with low / high ranges across Search,
  YouTube, Display, Maps, and Shopping placements
- **Date ranges** — first-shown, last-shown, total days running
- **Political ad data** — spend ranges and funding entities where Google
  discloses them
- **Pagination** — pull thousands of creatives across multiple runs
- **Structured output** — every dataset item is a flat JSON object you
  can pipe straight into a spreadsheet, BigQuery, or your own analytics

### Why scrape the Google Ads Transparency Center

Google launched the Transparency Center in 2023 as a public ads library
covering every advertiser worldwide. It's the most complete picture of
what your competitors are running across Google's surface — but the UI
gives you no export, no API, no bulk access, and aggressively
rate-limits casual scrapers.

This Actor handles:
- The rotating proxies
- The reverse-engineered RPC endpoints
- Format-specific parsers (`pla=` protobuf for Shopping, WIZ `data-p`
  JSON for text ads, `insertPreviewImageContent` for video)
- Variation rollups and metadata enrichment

You get clean structured data instead of HTML.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domain` | string | — | Advertiser domain (e.g. `redable.nl`). One of `domain`, `search`, or `advertiser_id` is required |
| `search` | string | — | Free-text search by brand name |
| `advertiser_id` | string | — | Direct lookup by Google advertiser ID |
| `creative_id` | string | — | Direct lookup by creative ID. Requires `advertiser_id` |
| `region` | string (enum) | `NL` | ISO country code; 50+ supported |
| `format` | string (enum) | all | `text`, `image`, or `video` |
| `start_date` | string | — | YYYY-MM-DD lower bound for ad's last-shown date |
| `end_date` | string | — | YYYY-MM-DD upper bound |
| `ads_count` | integer | 40 | 1-100 creatives per run |
| `detail` | boolean | false | Fetch impressions / regions / platforms / variations / spend per ad. Slower |
| `political` | boolean | false | Filter to political ads (includes spend where disclosed) |
| `page_token` | string | — | Pagination token from previous run's `_next_page_token` |

### Output (sample)

```json
{
  "advertiser_id": "AR10129747575264247809",
  "creative_id": "CR12965115384414863361",
  "format": "image",
  "advertiser_name": "Example Retailer",
  "first_shown": "2026-01-08",
  "last_shown": "2026-03-14",
  "days_shown": 66,
  "target_domain": "example.com",
  "image_url": "https://encrypted-tbn.gstatic.com/shopping?q=tbn:...",
  "ad_text": "Premium running shoes — free shipping",
  "deeplink": "https://adstransparency.google.com/advertiser/.../creative/...",
  "region": "NL",
  "detail": {
    "impressions_low": 100000,
    "impressions_high": 1000000,
    "platforms": { "google_search": {}, "youtube": {} },
    "regions": [{ "region_code": "NL", "impressions_low": 100000 }]
  }
}
````

### Use cases

#### Competitor ad spy and creative monitoring

Watch what your competitors put in market every week. Schedule this
Actor weekly per domain, push the dataset to your warehouse, and diff
new creatives against last week's run to surface new campaigns, killed
creatives, and creative refresh patterns.

#### Paid-search and Shopping audit

Pull every Google Shopping creative a merchant runs to audit feed
quality, missing GTINs, broken images, and pricing strategy across a
category — the kind of intelligence an SEM team would otherwise pay
hundreds of dollars per seat per month for an ad-spy SaaS to surface.

#### Brand-safety and policy enforcement

If you run an affiliate or partner program, pull every creative running
under your brand domain and spot unauthorized partners, trademark
infringement, or off-brand messaging in regions you don't directly
manage.

#### Ad creative analysis at scale

Combine output with an LLM to cluster creatives by message, extract
value props, identify USPs across a vertical, and benchmark your own
creative against the field. Far cheaper than a competitive intelligence
vendor.

### Limits

- **One advertiser per run.** Multi-domain batch input is intentionally
  out of scope — orchestrate from your side or open multiple parallel runs
- **Google rate-limits** even through proxies. Zero items + the run's
  `errors` key-value entry pointing at a Google block = wait 30 minutes
- **No OCR.** Text inside ad images is not extracted in v1
- **Political-ad spend** only available where Google publishes it
  (mostly US, EU, India elections)

### FAQ

**Is there an official Google Ads Transparency API?**
No. Google publishes the Transparency Center as a web UI only. This
Actor calls the same internal RPC endpoints the UI uses and parses the
responses into structured JSON.

**How is this different from the Meta Ads Library or TikTok Creative
Center scrapers?**
This Actor covers Google's surface — Search, Shopping, YouTube, Display,
Maps. For Meta and TikTok ad libraries, use the dedicated Actors.

**Can I get historical impressions back further than 90 days?**
Yes. Google retains ad metadata for the lifetime of the creative;
`first_shown` and `last_shown` reflect actual dates Google records,
which can stretch back years for long-running campaigns.

**Can I export to CSV?**
Yes — every Apify dataset can be exported to CSV, JSON, XML, Excel, or
HTML directly from the run page or via the API.

# Actor input Schema

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

Advertiser domain to look up (e.g. "redable.nl"). One of domain, search, or advertiser\_id is required.

## `search` (type: `string`):

Brand or advertiser name to search (e.g. "Nike"). Use instead of domain when you don't know the exact domain.

## `advertiser_id` (type: `string`):

Direct advertiser lookup (e.g. "AR10129747575264247809"). Required when creative\_id is set.

## `creative_id` (type: `string`):

Direct creative lookup (e.g. "CR12965115384414863361"). Requires advertiser\_id.

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

ISO country code for the region filter.

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

Filter by ad format. Leave empty for all formats.

## `start_date` (type: `string`):

Lower bound of the ad's last-shown date (YYYY-MM-DD).

## `end_date` (type: `string`):

Upper bound of the ad's last-shown date (YYYY-MM-DD).

## `ads_count` (type: `integer`):

How many ad creatives to return (1-100).

## `detail` (type: `boolean`):

Fetch impressions, regions, platforms, variations, and spend for every returned creative. Slower but richer.

## `political` (type: `boolean`):

Filter to political / election ads (these include spend ranges where available).

## `page_token` (type: `string`):

Pagination token from a previous run's `_next_page_token` field. Leave empty for the first page.

## Actor input object example

```json
{
  "domain": "redable.nl",
  "region": "NL",
  "format": "",
  "ads_count": 40,
  "detail": false,
  "political": 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{}' |
apify call s-r/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Free Google Ads Transparency Scraper — Ad History",
        "description": "Free Google Ads Transparency Center scraper. Pull every ad an advertiser is or has been running across Google Search, YouTube, Display, and Shopping in 50+ countries. Returns text, image, and video creatives with full metadata.",
        "version": "0.1",
        "x-build-id": "5ULdKflcf33NgM1fu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/s-r~google-ads-transparency/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-s-r-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/s-r~google-ads-transparency/runs": {
            "post": {
                "operationId": "runs-sync-s-r-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/s-r~google-ads-transparency/run-sync": {
            "post": {
                "operationId": "run-sync-s-r-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": "Domain",
                        "type": "string",
                        "description": "Advertiser domain to look up (e.g. \"redable.nl\"). One of domain, search, or advertiser_id is required."
                    },
                    "search": {
                        "title": "Free-text search",
                        "type": "string",
                        "description": "Brand or advertiser name to search (e.g. \"Nike\"). Use instead of domain when you don't know the exact domain."
                    },
                    "advertiser_id": {
                        "title": "Advertiser ID",
                        "type": "string",
                        "description": "Direct advertiser lookup (e.g. \"AR10129747575264247809\"). Required when creative_id is set."
                    },
                    "creative_id": {
                        "title": "Creative ID",
                        "type": "string",
                        "description": "Direct creative lookup (e.g. \"CR12965115384414863361\"). Requires advertiser_id."
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "NL",
                            "DE",
                            "BE",
                            "FR",
                            "GB",
                            "US",
                            "ES",
                            "IT",
                            "AT",
                            "CH",
                            "PL",
                            "SE",
                            "DK",
                            "NO",
                            "FI",
                            "PT",
                            "IE",
                            "CZ",
                            "RO",
                            "HU",
                            "GR",
                            "BG",
                            "HR",
                            "SK",
                            "SI",
                            "LT",
                            "LV",
                            "EE",
                            "LU",
                            "MT",
                            "CY",
                            "AU",
                            "CA",
                            "NZ",
                            "JP",
                            "KR",
                            "BR",
                            "MX",
                            "IN",
                            "TR",
                            "ZA",
                            "AR",
                            "CL",
                            "CO",
                            "EG",
                            "SA",
                            "AE",
                            "IL",
                            "SG",
                            "MY",
                            "TH",
                            "PH",
                            "ID",
                            "VN",
                            "TW",
                            "HK",
                            "RU",
                            "UA"
                        ],
                        "type": "string",
                        "description": "ISO country code for the region filter.",
                        "default": "NL"
                    },
                    "format": {
                        "title": "Ad format",
                        "enum": [
                            "",
                            "text",
                            "image",
                            "video"
                        ],
                        "type": "string",
                        "description": "Filter by ad format. Leave empty for all formats.",
                        "default": ""
                    },
                    "start_date": {
                        "title": "Start date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Lower bound of the ad's last-shown date (YYYY-MM-DD)."
                    },
                    "end_date": {
                        "title": "End date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Upper bound of the ad's last-shown date (YYYY-MM-DD)."
                    },
                    "ads_count": {
                        "title": "Number of ads",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many ad creatives to return (1-100).",
                        "default": 40
                    },
                    "detail": {
                        "title": "Include per-ad detail",
                        "type": "boolean",
                        "description": "Fetch impressions, regions, platforms, variations, and spend for every returned creative. Slower but richer.",
                        "default": false
                    },
                    "political": {
                        "title": "Political ads only",
                        "type": "boolean",
                        "description": "Filter to political / election ads (these include spend ranges where available).",
                        "default": false
                    },
                    "page_token": {
                        "title": "Page token",
                        "type": "string",
                        "description": "Pagination token from a previous run's `_next_page_token` field. Leave empty for the first page."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
