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

Google Ads Transparency Center scraper, no API key. See every ad a brand or domain runs on Google: text, image and video creatives, first and last shown dates, variations, impressions and regions. Only-new mode to track competitors. $1.99 per 1,000 ads.

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

## Pricing

from $1.99 / 1,000 ads

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?

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

See every ad a brand or domain runs on Google — text, image and video — straight from Google's Ads Transparency Center. No API key, no login. Search by brand name, domain, advertiser ID or Transparency Center URL, filter by country, format and date, and get first and last shown dates, every creative variation, impressions and a per-country breakdown.

**$1.99 per 1,000 ads.** Details add $1.00 per 1,000.

***

### Why this one

**It keeps going when Google pushes back.** Google shows a captcha to an IP after a few dozen requests. Each page and each retry here goes out on a fresh residential IP, so a large domain does not stop halfway.

**It shows where an ad ran, not just that it ran.** With details on, each ad gets a `regions` list: every country it ran in, with an impressions range and the first and last day it was shown there — sorted by reach.

**It can watch competitors for you.** Turn on **Only new ads** and put the Actor on a Schedule: each run returns only creatives that were not in the previous runs.

***

### Quick start

```json
{
  "queries": ["nike.com"],
  "region": "US",
  "adFormat": "ALL",
  "maxAdsPerSearch": 200
}
```

Other ways in:

```json
{ "queries": ["Nike"], "maxAdvertisersPerQuery": 3 }
{ "advertiserIds": ["AR18378488041124659201"] }
{ "startUrls": ["https://adstransparency.google.com/?region=US&domain=nike.com"] }
```

A brand name is matched to advertiser accounts (a big brand often has several — per country or per agency); the best matches come first. Anything that looks like a domain is searched as a domain.

### Output

| Field | Notes |
|---|---|
| `advertiser_id` | Starts with `AR` |
| `advertiser_name` | |
| `creative_id` | Starts with `CR` |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `first_shown` / `last_shown` | ISO 8601, UTC |
| `domain` | The domain the ad points to |
| `image_url` | Snapshot of the ad (Google also stores text ads as images) |
| `preview_url` | Google's own preview renderer for the ad |
| `ad_url` | The ad's page in the Transparency Center |

With **Include details** on:

| Field | Notes |
|---|---|
| `variation_count`, `variations` | Every version of the creative (A/B variants) |
| `impressions_min`, `impressions_max` | Google's impressions range for the ad (published for ads shown in the EU) |
| `region_count`, `regions` | Per country: `region`, `impressions_min`, `impressions_max`, `first_shown`, `last_shown` — largest first |

#### Sample row

```json
{
  "advertiser_id": "AR18378488041124659201",
  "advertiser_name": "Nike Retail BV",
  "creative_id": "CR04918732594763268097",
  "format": "TEXT",
  "first_shown": "2025-10-24T10:57:39Z",
  "last_shown": "2026-09-24T06:29:44Z",
  "domain": "nike.com",
  "image_url": "https://tpc.googlesyndication.com/archive/simgad/4025281590245195688",
  "ad_url": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR04918732594763268097?region=anywhere",
  "impressions_min": 300000,
  "impressions_max": 350000,
  "region_count": 17,
  "regions": [{ "region": "PL", "impressions_min": 300000, "impressions_max": 350000, "first_shown": "2025-10-24", "last_shown": "2026-09-23" }]
}
```

### Use it from code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("reportable_broth/google-ads-transparency-scraper").call(run_input={
    "queries": ["competitor.com"],
    "region": "US",
    "onlyNewAds": True,
})
for ad in client.dataset(run.default_dataset_id).iterate_items():
    print(ad["format"], ad["last_shown"], ad["ad_url"])
```

Works the same from JavaScript, n8n, Make, Zapier, or an AI agent through Apify's MCP server. Export as JSON, CSV or Excel from the dataset tab.

### FAQ

**Do I need a Google Ads account or API key?**
No. The Transparency Center is public.

**Why does a brand name return several advertisers?**
Large brands run ads through several accounts — per country, per agency. Raise **Max advertiser accounts per brand name** to cover more of them, or search the domain instead to get all of them at once.

**How does the date filter work?**
An ad is kept if it was running at any point in the range: last shown on or after the start date, and first shown on or before the end date.

**Are impressions exact?**
No — Google publishes ranges, and so do we.

**Why are impressions empty for some ads?**
Google only publishes impressions for ads shown in the European Union (a Digital Services Act requirement). An ad that ran only in the US has regions and dates but no impressions — that is Google's data, not a failed request. In a 120-ad sample for nike.com in the US, 10 had impressions.

### Our other Actors

- **[YouTube Transcript Scraper](https://apify.com/reportable_broth/youtube-transcript-scraper)** — transcripts by URL, playlist, channel or keyword; SRT/VTT; 55-language translation.
- **[YouTube Monitor](https://apify.com/reportable_broth/youtube-scraper-monitor)** — new videos only, by keyword or channel.
- **[Threads Scraper](https://apify.com/reportable_broth/threads-scraper-monitor)** — Threads posts by keyword, #hashtag or profile. No login.

### Disclaimer

This Actor collects publicly available information from Google's Ads Transparency Center. You are responsible for how you use it, including compliance with Google's terms and applicable law.

# Actor input Schema

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

Brand names (e.g. Nike) are matched to advertiser accounts; anything that looks like a domain (e.g. nike.com) is searched as a domain.

## `domains` (type: `array`):

Exact domains. Returns ads from every advertiser whose ads point to that domain.

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

IDs that start with AR, from the advertiser's Transparency Center page URL.

## `startUrls` (type: `array`):

Advertiser pages, creative pages or domain search pages from adstransparency.google.com.

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

Two-letter country code such as US, GB, DE, JP, TW, or ANYWHERE for all regions.

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

Only return one creative format.

## `startDate` (type: `string`):

Only ads that were running on or after this date (YYYY-MM-DD).

## `endDate` (type: `string`):

Only ads that were running on or before this date (YYYY-MM-DD).

## `maxAdsPerSearch` (type: `integer`):

Stops paging after this many ads for each target.

## `maxAdvertisersPerQuery` (type: `integer`):

A brand name can match several advertiser accounts (per country or agency). The best matches come first.

## `includeDetails` (type: `boolean`):

One extra request per ad for every creative variation, the impressions range, and a per-region breakdown (impressions and first/last shown in each country).

## `onlyNewAds` (type: `boolean`):

Remembers ads returned in earlier runs with the same targets and filters, and only returns ones you have not seen. Use with a Schedule to watch competitors.

## `monitorStoreName` (type: `string`):

Named key-value store that holds seen ads for Only-new mode. Leave empty for the default.

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

Google shows a captcha to an IP after a few dozen requests. Residential proxy is the default: every retry and every page uses a fresh IP.

## `concurrency` (type: `integer`):

Parallel detail requests.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "domains": [],
  "advertiserIds": [],
  "startUrls": [],
  "region": "ANYWHERE",
  "adFormat": "ALL",
  "maxAdsPerSearch": 100,
  "maxAdvertisersPerQuery": 3,
  "includeDetails": false,
  "onlyNewAds": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "concurrency": 5
}
```

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

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

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

```

## MCP server setup

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