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

Scrape the Google Ads Transparency Center by domain or advertiser ID. Every ad creative a brand runs on Google Search, YouTube, Display, Maps and Shopping, with the advertiser behind it, the dates it ran, and a preview of the ad. No login and no API key.

- **URL**: https://apify.com/eiv/google-ads-transparency-scraper.md
- **Developed by:** [Eimantas V](https://apify.com/eiv) (community)
- **Stats:** 2 total users, 1 monthly users, 50.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ad scrapes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Ads Transparency Scraper — Competitor Ad Library

See every ad a brand is running on Google — Search, YouTube, Display, Maps and Shopping —
straight from Google's own Ads Transparency Center. Give it a domain; get back every
creative, who paid for it, and how long it has been running.

No login, no API key, no browser.

### What you get for every ad

| Field | Notes |
|---|---|
| `advertiserName` | Google's **verified** advertiser, e.g. `Nike, Inc.` |
| `advertiserDomain` | The domain the ad points at |
| `firstShownAt`, `lastShownAt` | ISO 8601, UTC |
| `daysShown` | Days the creative actually ran — not the window between those dates |
| `previewUrl` | Google's own endpoint that renders the ad |
| `url` | The creative's page in the Transparency Center |
| `creativeId`, `advertiserId`, `region` | |

**`daysShown` is the column to sort by.** An ad Nike has run for 1,646 days is a proven
performer; one at 5 days is a test. That distinction is the whole point of watching a
competitor's ad library, and it comes free with every row.

### One domain, every agency

`nike.com` does not return one advertiser. It returns **Nike, Inc.**, **Nike Japan**,
**Nike Global Trading**, and the media agencies buying on their behalf — **WPP Media
Management**, **Initiative Media B.V.**, **SLAM Media Inc.**

So pointing this at a competitor's domain tells you not just what they advertise, but who
runs their media. The summary row lists all of them.

### Pricing

Pay per result. You are charged for ads you actually receive.

| Event | Price |
|---|---|
| Ad scraped | **$1.50 per 1,000** |
| Target processed | $0.002 each |
| Actor start | $0.00005 |

A target that cannot be reached is **never charged** — results are written to your dataset
before any charge is raised.

### Example input

```json
{
  "targets": ["nike.com", "adidas.com", "AR16735076323512287233"],
  "region": "US",
  "maxAdsPerTarget": 500,
  "maxTotalAds": 5000
}
```

Targets accept a bare domain, an advertiser ID, or an `adstransparency.google.com`
advertiser URL. `region` takes an ISO code (`US`, `GB`, `DE`, `FR`…) or Google's numeric
geo-target ID directly.

### Example output

```json
{
  "creativeId": "CR12984801659073855489",
  "advertiserId": "AR06365026152670560257",
  "advertiserName": "WPP MEDIA MANAGEMENT",
  "advertiserDomain": "nike.com",
  "firstShownAt": "2022-01-28T21:52:24.000Z",
  "lastShownAt": "2026-09-21T04:42:06.000Z",
  "daysShown": 1646,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?…",
  "url": "https://adstransparency.google.com/advertiser/AR06365026152670560257/creative/CR12984801659073855489?region=2840",
  "region": "2840"
}
```

### Speed, and the one real limit

Google returns **40 creatives per request**, so 1,000 ads is about 25 requests. A measured
run pulled 200 ads in 5 requests in seven seconds.

**Google budgets these requests per IP address.** After enough of them it stops answering
and serves a block page. This Actor detects that, reports it plainly rather than as a
mystery, and stops instead of burning further addresses. If a large run gets cut short,
raise **Delay between requests**, or switch the proxy to the **RESIDENTIAL** group — both
are input fields, no rebuild needed.

### What isn't here

- **Ad text and headlines.** Google's listing response carries the creative as a render
  endpoint, not as text. `previewUrl` shows you the ad; it does not hand you a string.
- **Spend and impressions.** Google publishes these for political and issue ads only. They
  are not available for commercial advertisers at all.
- Two fields in Google's payload have no documented meaning. They are passed through as
  `rawFields` rather than given invented names.

### Integrations

Results land in a standard Apify dataset — export to JSON, CSV or Excel, or push onward
with Make, Zapier, Google Sheets, Slack, or the API.

### Support

Need a field that isn't here, or a region that isn't listed? Open an issue on this Actor's
page — that reaches the developer directly.

### Is this legal?

The Ads Transparency Center is a public disclosure service Google is legally required to
operate, and this Actor reads only what any visitor sees. It touches no private data and
no account of yours. What you do with the data is still your responsibility.

# Actor input Schema

## `targets` (type: `array`):

A domain like nike.com, an advertiser ID like AR12365610929977556993, or an adstransparency.google.com advertiser URL.

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

ISO code (US, GB, DE, FR...) or Google's numeric geo-target ID. The region is a numeric code internally; a wrong one returns nothing rather than an error.

## `maxAdsPerTarget` (type: `integer`):

Google returns up to 40 creatives per request.

## `maxTotalAds` (type: `integer`):

A ceiling across every target in the run.

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

Any of text, image, video. Leave empty for all formats.

## `requestDelayMs` (type: `integer`):

Google budgets these requests per IP address. Raising this makes a run last longer but burn fewer addresses.

## `proxyConfig` (type: `object`):

Strongly recommended. Google stops answering an address after a few dozen requests, so a run without rotation will stop early.

## Actor input object example

```json
{
  "targets": [
    "nike.com"
  ],
  "region": "US",
  "maxAdsPerTarget": 200,
  "maxTotalAds": 2000,
  "formats": [],
  "requestDelayMs": 1200,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `ads` (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 = {
    "targets": [
        "nike.com"
    ],
    "proxyConfig": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("eiv/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 = {
    "targets": ["nike.com"],
    "proxyConfig": { "useApifyProxy": True },
}

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

```

## MCP server setup

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