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

Scrape Google Ads Transparency Center: every Search, YouTube, Maps, Play and Shopping ad of a brand, domain or advertiser, with dates, formats, images, per-country stats, EU impressions and new-ad monitoring. Fast, no browser.

- **URL**: https://apify.com/rakish_bobby_gwr/google-ads-transparency-scraper.md
- **Developed by:** [mustafa kılıç](https://apify.com/rakish_bobby_gwr) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ad scrapeds

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

Get every Google ad a brand, website or advertiser runs, straight from the [Google Ads Transparency Center](https://adstransparency.google.com): text, image and video ads on Google Search, YouTube, Maps, Play and Shopping, with first and last shown dates, ad images, YouTube links, ad copy, the countries each ad ran in and the impression ranges Google publishes for the EU.

It talks to the Transparency Center's own data endpoints instead of driving a browser, so it is fast and cheap to run: in our tests 200 ads came back in under 3 seconds, and about 4 ads per second with per-country details and ad copy turned on.

### What can you do with it?

- **Competitor ad research**: see every ad a competitor runs, which formats they use, how long each ad has been live and where it is shown.
- **New ad alerts**: schedule a daily run with *Only new ads* and get just the ads launched since the previous run.
- **Agency prospecting**: find which companies advertise on a domain or in a country, and how many ads they run.
- **Creative inspiration**: collect ad images, YouTube creatives and ad copy for a niche.
- **Compliance and brand protection**: check who runs ads that point to your domain.

### How to use it

1. Enter one or more queries, one per line:
   - a **domain** such as `nike.com`: every ad that points to that website, from any advertiser account;
   - a **brand name** such as `HelloFresh`: the matching advertiser accounts (largest first) and their ads;
   - an **advertiser ID** such as `AR17410177287600472065`, or an **Ads Transparency Center URL** copied from your browser.
2. Optionally filter by region, platform, ad format and date range.
3. Click **Start**. Results appear in the dataset as they are scraped; download them as JSON, CSV, Excel or HTML, or read them through the API.

#### Input example

```json
{
    "queries": ["nike.com", "HelloFresh"],
    "region": "DE",
    "platform": "YOUTUBE",
    "adFormat": "VIDEO",
    "startDate": "30 days",
    "maxAdsPerQuery": 200,
    "includeDetails": true,
    "includeAdContent": true
}
```

#### Output example

One row per ad. The fields under *details* and *ad content* are added only when those options are on.

```json
{
    "query": "nike.com",
    "queryType": "domain",
    "advertiserId": "AR18378488041124659201",
    "advertiserName": "Nike Retail BV",
    "creativeId": "CR15051374359509729281",
    "format": "TEXT",
    "firstShown": "2025-10-24T11:40:34+00:00",
    "lastShown": "2026-11-01T09:00:59+00:00",
    "daysShown": 314,
    "domain": "nike.com",
    "imageUrl": null,
    "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&...",
    "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR15051374359509729281?region=anywhere",
    "variationCount": 1,
    "regionCount": 8,
    "regions": [
        {
            "countryCode": "AT",
            "countryName": "Austria",
            "firstShown": "2025-10-24",
            "lastShown": "2026-11-01",
            "impressionsMin": 10000,
            "impressionsMax": 15000,
            "platforms": [
                { "platform": "MAPS", "impressionsMin": 0, "impressionsMax": 1000 },
                { "platform": "SEARCH", "impressionsMin": 10000, "impressionsMax": 15000 }
            ]
        }
    ],
    "euImpressionsMin": 15000,
    "euImpressionsMax": 20000,
    "euFirstShown": "2025-10-24",
    "euLastShown": "2026-11-01",
    "adTexts": [
        "{KeyWord:Nike Trainers}",
        "Discover {KeyWord:Nike Shoes} Online At Nike.com. Shop The Official Nike Site.",
        "nike.com",
        "Designer-Outlet-Straße 1"
    ],
    "scrapedAt": "2026-11-01T09:20:51+00:00"
}
```

Video ads with *ad content* also get `"youtubeUrl": "https://www.youtube.com/watch?v=5kbRYm0TFIo"`. Text like `{KeyWord:Nike Shoes}` is the advertiser's own keyword insertion placeholder, exactly as Google publishes it.

| Field | Description |
| --- | --- |
| `advertiserId`, `advertiserName` | The verified advertiser account behind the ad. |
| `creativeId`, `adUrl` | The ad's ID and its page in the Transparency Center. |
| `format` | `TEXT`, `IMAGE` or `VIDEO`. |
| `firstShown`, `lastShown`, `daysShown` | When the ad ran (UTC) and on how many days. |
| `domain` | The website the ad points to, when Google publishes it. |
| `imageUrl` | Image of image ads. Google archives text ads as images too. |
| `previewUrl` | Script that renders text and video ads in the Transparency Center. |
| `variations`, `variationCount` | Every creative variation (*details*). |
| `regions`, `regionCount` | Each country the ad ran in with its dates; for EU countries also the impression range and per-platform impressions (*details*). |
| `euImpressionsMin`, `euImpressionsMax` | Total EU impressions range (*details*). |
| `youtubeVideoId`, `youtubeUrl` | The YouTube video of video ads (*ad content*). |
| `adTexts` | Text shown in the ad: headline, description, display URL, sitelinks, product titles (*ad content*). |

With **What to return: Advertisers** you get advertiser accounts instead of ads: for a brand name the matching accounts with their country and approximate number of ads, for a domain the accounts running ads that point to it, with how many of the scanned ads each ran.

### Monitoring new ads

Turn on **Only new ads** and [schedule](https://docs.apify.com/platform/schedules) the Actor (for example daily). The first run returns ads as usual and starts monitoring. Each later run checks the most recently shown ads (up to *Max ads per query*) and returns only ads first shown after monitoring started that were not returned before. Each query and filter combination is tracked separately in a named key-value store, so you can run several monitors side by side by giving them different storage names. Connect the run to Slack, email, Google Sheets or a webhook through [integrations](https://docs.apify.com/platform/integrations) to get alerts.

### Pricing

You pay per result, nothing for failed queries:

| Event | Price |
| --- | --- |
| Ad | $1.00 per 1,000 ads |
| Per-country details (optional) | $1.50 per 1,000 ads |
| Ad copy and video link (optional, charged only when found) | $1.00 per 1,000 ads |
| Advertiser (advertisers mode) | $2.00 per 1,000 advertisers |

Example: the 200 most recent ads of a brand with details cost $0.50.

### Tips and limits

- **Large advertisers** run tens of thousands of ads. Set *Max ads per query* to what you need; results come newest first (by last shown date).
- **Impression numbers** exist only for ads shown in the EU, because the Digital Services Act requires Google to publish them. Elsewhere you get the countries and dates.
- **Ad copy** is extracted on a best-effort basis from the preview Google renders. Some video ads do not reveal their YouTube video. You are charged for ad content only when something is found.
- **Rate limits**: Google limits requests per IP address. The Actor uses residential proxies by default and retries from a new IP when it is rate-limited.
- **Region codes** are two-letter country codes (`US`, `DE`, `TR`). Use `anywhere` for all countries.

### Is it legal?

The Ads Transparency Center is a public database that Google publishes so anyone can see who is advertising and where; the EU Digital Services Act requires this data to be public. The Actor collects only that public ad data, no personal data. Make sure your use of the data complies with Google's terms and the laws that apply to you.

### Use it through the API or with AI agents

Every run can be started through the [Apify API](https://docs.apify.com/api/v2) or the Python and JavaScript clients, and the Actor is available to AI agents through the [Apify MCP server](https://mcp.apify.com).

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<USERNAME>/google-ads-transparency-scraper").call(run_input={"queries": ["nike.com"], "maxAdsPerQuery": 100})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["advertiserName"], ad["format"], ad["lastShown"])
```

### Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google. It only collects publicly available data; make sure your use complies with the applicable terms and laws.

### Feedback

Found a bug or need a field that is missing? Open an issue in the **Issues** tab and it will be looked at quickly.

# Actor input Schema

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

One per line. A brand name ("HelloFresh") is matched to the advertiser accounts with that name. A domain ("nike.com") returns every ad that points to that website, from any advertiser. An advertiser ID ("AR17410177287600472065") or a Transparency Center URL returns that advertiser's ads.

## `resultType` (type: `string`):

"Ads" returns one row per ad creative. "Advertisers" returns advertiser accounts instead of ads: for a brand name the matching accounts with their country and approximate number of ads, for a domain the accounts that run ads pointing to it (from up to "Max ads per query" recent ads).

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

Only ads shown in this country. "Anywhere" returns ads from all countries.

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

Only ads shown on this Google surface.

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

Only ads of this format.

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

Only ads shown on or after this date. Use YYYY-MM-DD or a relative value such as "30 days".

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

Only ads shown on or before this date (YYYY-MM-DD). Leave empty for today.

## `maxAdsPerQuery` (type: `integer`):

Stop after this many ads for each brand, domain or advertiser. 0 means all ads (large advertisers have tens of thousands).

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

A brand name can match several advertiser accounts (for example one per country). The best matches are used, up to this number.

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

One extra request per ad adds every country the ad ran in with its first and last shown date, the impression ranges Google publishes for EU countries, per-platform impressions and all creative variations. Charged as an extra event per ad.

## `includeAdContent` (type: `boolean`):

Adds the YouTube video link of video ads and the text shown in text ads (headline, description, display URL, sitelinks) on a best-effort basis. Image ads already include the image URL. Charged as an extra event per ad.

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

The first run returns ads as usual and starts monitoring. Later runs check the most recently shown ads (up to "Max ads per query") and return only those first shown after monitoring started and not returned before. Each query and filter combination is tracked separately.

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

Name of the key-value store that remembers which ads were already returned. Use different names to keep independent monitors.

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

How many queries are processed in parallel.

## `maxRequestRetries` (type: `integer`):

How many times a request is retried from a new IP address when Google rate-limits it.

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

Google rate-limits the Transparency Center per IP address. Residential proxies are recommended.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "resultType": "ads",
  "region": "anywhere",
  "platform": "",
  "adFormat": "",
  "maxAdsPerQuery": 20,
  "maxAdvertisersPerQuery": 3,
  "includeDetails": false,
  "includeAdContent": false,
  "onlyNewAds": false,
  "monitorStoreName": "ads-transparency-monitor",
  "maxConcurrency": 3,
  "maxRequestRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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"
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rakish_bobby_gwr/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"],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

```

## MCP server setup

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