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

Scrape Google Ads Transparency Center creatives by advertiser name, AR ID, domain or URL: ad text (headline/description), images, YouTube videos, regions, impression ranges, platforms and first/last shown dates. Monitoring mode detects new and stopped ads. Fast HTTP, no browser.

- **URL**: https://apify.com/adyg/google-ads-transparency-scraper.md
- **Developed by:** [Adyanth Ganesh](https://apify.com/adyg) (community)
- **Categories:** Marketing, SEO tools, Lead generation
- **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 results

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 Monitor

**Scrape the Google Ads Transparency Center (adstransparency.google.com) for any advertiser, AR advertiser ID, website domain or Transparency Center URL.** For each ad creative you get the **ad text (headline, description, display URL, call to action, sitelinks)**, **image and YouTube video URLs**, **first and last shown dates**, **regions**, **platforms** (Google Search, YouTube, Shopping, Maps, Play), **impression ranges and targeting** (EU/EEA disclosures), the advertiser's **verification status** and a link back to the ad in the Transparency Center.

Turn on **monitoring mode** to see which ads your competitors **launched or stopped since the last run**. Every run also adds a free **summary row per advertiser** with active ads, new ads, and the mix of formats, platforms and regions.

- ✅ **Real ad text, not only screenshots**: Google archives most Search text ads only as images. This Actor reads the text from them (OCR) and from the ad preview data, so you get `headline`, `description` and `displayUrl` as text you can search and analyze.
- ✅ **Competitor ad monitoring**: schedule the Actor daily or weekly and get only the `NEW` and `STOPPED` ads, plus per-advertiser change counts.
- ✅ **Flexible input**: advertiser names (e.g. `Nike`), IDs (`AR...`), domains (`booking.com`) or any Transparency Center URL (advertiser, creative or domain search, with its region/format/platform/date filters).
- ✅ **Filters**: region (any country), date range or "last N days", format (text, image, video) and platform (Search, YouTube, Shopping, Maps, Play).
- ✅ **Fast and cheap**: plain HTTP requests to the Transparency Center's own data endpoints, no browser. Hundreds of ads per minute.
- ✅ **Pay only for ads**: summary rows, error rows, retries and failed requests are free.

### What data can you get?

| Group | Fields |
|---|---|
| Advertiser | `advertiserName`, `advertiserId` (AR...), `advertiserVerified`, `advertiserCountry`, `advertiserLegalName` |
| Creative | `creativeId` (CR...), `format` (TEXT / IMAGE / VIDEO), `adUrl` (Transparency Center link), `previewImageUrl`, `variationsCount` |
| Ad text | `headline`, `description`, `longHeadline`, `callToAction`, `displayUrl`, `businessName`, `sitelinks`, `productTitle`, `merchant`, `textSource` (`preview` or `ocr`), `ocrConfidence` |
| Media & landing page | `imageUrls`, `videoId`, `videoUrl`, `videoThumbnailUrl`, `youtubeChannel`, `landingUrl`, `landingDomain` |
| Dates | `firstShown`, `lastShown`, `daysShown`, `isActive` |
| Reach | `regionCodes`, `regions` (per country: first/last shown, impression range, platforms), `impressionsMin`, `impressionsMax`, `platforms`, `topic`, `targeting` |
| Monitoring | `changeType` (`NEW` / `STOPPED`) |
| Summary rows (`type: summary`) | `adsInThisRun`, `activeAdCount`, `newThisRun`, `stoppedThisRun`, `totalAdsMin` / `totalAdsMax`, `formatsMix`, `platformsMix`, `topRegions`, `newestAdFirstShown`, `latestShown`, `adsWithText` |

Google only publishes **impressions, per-platform data and targeting for ads shown in the EU/EEA** (Digital Services Act). For other regions, these fields are empty.

### How to use

1. Add **targets**: advertiser names, `AR...` advertiser IDs, website domains or Transparency Center URLs. You can mix them.
2. Optionally pick a **region**, a **date range** (or **last N days**), **formats** and **platforms**.
3. Set **max ads per target** (default 50). Ads are returned newest first (by last shown date).
4. For competitor monitoring, turn on **Monitoring mode** and schedule the Actor. The first run saves a baseline. Later runs return only new and stopped ads.
5. Click **Start** and download the results as JSON, CSV or Excel, or use the API.

### Input example

```json
{
    "targets": ["Nike", "booking.com", "AR09597646619583447041",
                "https://adstransparency.google.com/?region=DE&domain=zalando.de&format=IMAGE"],
    "maxAdsPerTarget": 100,
    "region": "US",
    "lastDays": 30,
    "formats": ["TEXT", "VIDEO"],
    "platforms": ["SEARCH", "YOUTUBE"],
    "monitorMode": false
}
```

### Output example

```json
{
    "type": "ad",
    "advertiserName": "The Coca-Cola Company",
    "advertiserId": "AR09597646619583447041",
    "advertiserVerified": true,
    "advertiserCountry": "US",
    "creativeId": "CR15474841625041043457",
    "format": "TEXT",
    "headline": "Single-Serve 14oz Bottle - fairlife 14oz - fairlife® 14oz On The Go",
    "description": "fairlife® Ultra-Filtered Milk 14oz Has 50% More Protein Than Regular Milk. Delicious Flavors Of fairlife® Ultra-Filtered...",
    "displayUrl": "www.fairlife.com/",
    "businessName": "Fairlife",
    "sitelinks": ["14oz Bottles To Take On The Go", "Where To Buy", "Find The Nearest Store Now"],
    "textSource": "ocr",
    "landingDomain": "fairlife.com",
    "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/13015767299354987170",
    "firstShown": "2024-06-28T22:31:59Z",
    "lastShown": "2026-10-08T14:44:32Z",
    "daysShown": 787,
    "isActive": true,
    "regionCodes": ["US"],
    "platforms": ["GOOGLE_SEARCH"],
    "adUrl": "https://adstransparency.google.com/advertiser/AR09597646619583447041/creative/CR15474841625041043457?region=anywhere"
}
```

A summary row:

```json
{
    "type": "summary",
    "advertiserName": "The Coca-Cola Company",
    "advertiserId": "AR09597646619583447041",
    "adsInThisRun": 25, "activeAdCount": 25, "newThisRun": 3, "stoppedThisRun": 1,
    "formatsMix": {"TEXT": 25}, "platformsMix": {"GOOGLE_SEARCH": 25}, "topRegions": {"US": 25}
}
```

### Competitor ad monitoring

With **Monitoring mode** on, the Actor stores the ads it saw for each target (and filter set) in a named key-value store (`monitorStoreName`, default `google-ads-transparency-monitor`). On the next run it compares the current ads with that state:

- `changeType: "NEW"`: an ad that wasn't there in the previous run.
- `changeType: "STOPPED"`: an ad that was active before but hasn't been shown in the last `activeWithinDays` days (default 7), or was removed from the Transparency Center.
- `changeType: "RESUMED"`: an ad that had stopped and is running again.

Unchanged ads are not returned and **not charged**, so daily monitoring of large advertisers stays cheap. The summary row per advertiser shows `newThisRun`, `stoppedThisRun` and the current `activeAdCount`. Use a different `monitorStoreName` for each independent watchlist. Set `emitBaselineOnFirstRun` to `false` if the first run should only save the baseline without returning ads.

### How it works

The Actor calls the same public JSON endpoints that the Transparency Center website uses (search, advertiser and creative lookups), without a browser. It reads ad text from the creative preview (responsive ads, video ads, Shopping ads) or, for text ads archived as images, with OCR. It uses Apify Proxy with session rotation, retries with backoff, falls back to residential IPs only if needed, and isolates errors per target and per ad. One bad input never stops the run.

**Measured on the Apify platform (October 2026)** with the default settings:

| Test | Result |
|---|---|
| Stress run: 20 advertisers of very different sizes (Nike, Temu, Shein, Booking.com, Airbnb, Canva, Duolingo, Salesforce, Shopify...), domains and URLs with region filters (DE, JP, BR, IN, FR, GB), up to 50 ads each | **20/20 targets, 1,000/1,000 ads with full details**, 94% of ads with extracted text (the rest are pure image banners) |
| Speed | ~1,000 ads with details and OCR in about 5 minutes (2 GB memory) |
| Monitoring (4 consecutive runs, 3 competitors) | baseline, then only changes (e.g. 1 new Zalando ad) |

### Pricing

This Actor uses **pay-per-event** pricing: you pay per ad returned, plus a small fee per run.

| Event | Price |
|---|---|
| Ad result (`ad-result`): one ad creative with details and extracted text | **$1.50 per 1,000 ads** ($0.0015 per ad) |
| Actor start (`actor-start`) | $0.001 per run |

Summary rows, error rows, retries and failed requests are **free**. In monitoring mode you pay only for `NEW` and `STOPPED` ads. Proxy and compute costs are included. Set **Maximum cost per run** in the run options to cap your spend. The Actor stops cleanly at the limit and keeps everything it scraped so far.

### Related tools

Competitor research: their ads, their keywords, their authority and traffic, and their AI search presence.

- [Keyword Search Volume (Google Keyword Planner)](https://apify.com/adyg/keyword-search-volume): search volume, CPC and keyword ideas in bulk
- [Domain Authority & Traffic Checker](https://apify.com/adyg/domain-authority-traffic-checker): bulk domain authority, backlinks and organic traffic
- [AI Search Visibility Tracker](https://apify.com/adyg/ai-search-visibility-tracker): check if ChatGPT, Perplexity, Gemini and AI Overviews mention your brand

All of these are maintained by the same developer and export flat JSON, CSV or Excel, so you can feed one tool's dataset into the next.

### FAQ

**What is the Google Ads Transparency Center?**
It is Google's public library of ads run on Google Search, YouTube, Shopping, Display, Maps and Play by verified advertisers. You can browse it at adstransparency.google.com. This Actor turns it into structured data.

**Is there an official Google Ads Transparency Center API?**
No, Google does not offer a public API for it. (Google publishes political ads in BigQuery, but not commercial ads.) This Actor works as an API: call it from the Apify API, Python/JS clients, Make, Zapier, n8n or the Apify MCP server.

**How do I find an advertiser ID?**
Open the advertiser in the Transparency Center. The URL contains `/advertiser/AR...`. You can also just enter the brand name or website domain. The Actor finds the advertiser and reports how it matched in `matchedBy`.

**Why do some text ads have `textSource: "ocr"`?**
Google archives most Search text ads only as images. The Actor reads them with OCR, which is very accurate for English and other Latin-script ads. `ocrConfidence` shows the confidence. The `previewImageUrl` always shows the original ad.

**Why are impressions and targeting empty for some ads?**
Google only publishes impression ranges, per-platform data and targeting for ads shown in the EU/EEA. Choose an EU region (e.g. Germany) to get them.

**Can I search by keyword?**
The Transparency Center itself can only be searched by advertiser or website, not by ad keyword. Use advertiser names or domains as targets, then filter the extracted ad text.

**How many ads can I get?**
As many as the Transparency Center lists for the advertiser. Large brands have tens of thousands. Use `maxAdsPerTarget`, region, date and format filters to focus on what you need.

**Is it legal to scrape the Google Ads Transparency Center?**
The Actor only collects ads and advertiser information that Google publishes for public transparency, without logging in. Google's Terms of Service restrict automated access to its services, and laws differ by country and use case. Make sure your use complies with them. If you're unsure, ask a lawyer.

### Acceptable use

- This Actor is an independent tool. It is not affiliated with, endorsed by or sponsored by Google or DataForSEO. DataForSEO is only used as an optional backup data source.
- Don't use the data to build a competing search engine, or otherwise to compete with or harm Google or the other search engines the data comes from.
- The Actor may not be used from, or for people or organizations in, Russia, Belarus, Cuba, Iran, Syria, Myanmar, North Korea, Crimea or the Russian-occupied territories of Ukraine.
- You are responsible for using the results lawfully, including privacy laws such as GDPR for any personal data they contain.

# Actor input Schema

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

One per line. Accepts: an <b>advertiser name</b> (<code>Nike</code>), an <b>advertiser ID</b> (<code>AR16735076323512287233</code>), a <b>website domain</b> (<code>grammarly.com</code> - returns every advertiser running ads for that site), or any <b>Ads Transparency Center URL</b> (advertiser page, single creative page, or a domain search; filters in the URL such as <code>region</code>, <code>platform</code>, <code>format</code> and dates are respected).

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

How many ad creatives to return for each target, newest (most recently shown) first. Big brands have thousands of ads.

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

Only ads shown in this country. <i>Anywhere</i> = all regions.

## `lastDays` (type: `integer`):

Only ads shown at least once in the last N days (e.g. <code>30</code>). Overrides the date range below.

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

Only ads shown on or after this date (YYYY-MM-DD). Data starts in 2018.

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

Only ads shown on or before this date (YYYY-MM-DD). Default: today.

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

Leave empty for all formats.

## `platforms` (type: `array`):

Leave empty for all platforms (this also includes Display-network ads, which have no separate filter in the Transparency Center).

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

Open each ad's detail record: every region it ran in with first/last shown dates, impression ranges and per-platform breakdown (impressions and platforms are published for EU/EEA regions), topic and targeting categories. Turn off for a faster list-only scrape.

## `extractAdText` (type: `boolean`):

Read headline, description, call to action, display/landing URL, YouTube video ID and image URLs from the ad previews.

## `ocrTextAds` (type: `boolean`):

Google archives most Search text ads only as a rendered image. With this on, the Actor reads the headline, description, display URL and sitelinks from that image with OCR (marked <code>textSource: "ocr"</code>).

## `ocrLanguage` (type: `string`):

Language model used to read text ads archived as images. Automatic picks the language of the selected region, of the countries the ad ran in, or of the domain (e.g. zalando.de -> German), and English otherwise. Latin-script models read English text too.

## `advertiserSummary` (type: `boolean`):

One extra row per advertiser (<code>type: "summary"</code>) with active ad count, total ads estimate, format and platform mix and top regions. Summary rows are free.

## `maxAdvertisersPerName` (type: `integer`):

A name can match several advertiser accounts (e.g. regional subsidiaries). How many of the best matches to scrape.

## `monitorMode` (type: `boolean`):

Compares each target with the previous run (state kept in a named key-value store) and outputs only ads that are <b>NEW</b> since the last run or have <b>STOPPED</b> running (<code>changeType</code> field). Schedule the Actor daily or weekly for competitor-ad alerts.

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

Named key-value store that keeps the last-seen ads per target. Use different names to keep independent watch lists.

## `activeWithinDays` (type: `integer`):

An ad whose last-shown date is older than this is treated as inactive (<code>isActive: false</code>) and, in monitoring mode, reported as STOPPED.

## `emitBaselineOnFirstRun` (type: `boolean`):

On the first run for a target there is nothing to compare with, so every current ad is reported as NEW. Turn off to silently store the baseline and only report changes from the second run on.

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

Apify Proxy is used by default (datacenter first, automatic residential fallback if Google throttles).

## `residentialFallback` (type: `boolean`):

If datacenter IPs are throttled, retry through Apify residential proxy automatically.

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

Parallel requests to the Transparency Center.

## `dataForSeoFallback` (type: `boolean`):

Only for self-hosted copies with DATAFORSEO_LOGIN / DATAFORSEO_PASSWORD environment variables: if the Transparency Center request fails, fetch the ad list from DataForSEO instead (list data only).

## Actor input object example

```json
{
  "targets": [
    "Nike"
  ],
  "maxAdsPerTarget": 5,
  "region": "anywhere",
  "includeDetails": true,
  "extractAdText": true,
  "ocrTextAds": true,
  "ocrLanguage": "auto",
  "advertiserSummary": true,
  "maxAdvertisersPerName": 1,
  "monitorMode": false,
  "monitorStoreName": "google-ads-transparency-monitor",
  "activeWithinDays": 7,
  "emitBaselineOnFirstRun": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "residentialFallback": true,
  "maxConcurrency": 8,
  "dataForSeoFallback": false
}
```

# Actor output Schema

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

No description

## `details` (type: `string`):

No description

## `summaries` (type: `string`):

No description

## `summary` (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"
    ],
    "maxAdsPerTarget": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("adyg/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"],
    "maxAdsPerTarget": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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