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

Get every Google ad of any advertiser or domain from the Google Ads Transparency Center: text, image and video ads with preview images, first and last shown dates, countries and variations. Filter by country, format and date. Monitor competitors with alerts for new ads only. Pay per ad.

- **URL**: https://apify.com/fguiraud/google-ads-transparency-scraper.md
- **Developed by:** [Fernando Guiraud](https://apify.com/fguiraud) (community)
- **Categories:** SEO tools, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

### What does Google Ads Transparency Scraper do?

**Google Ads Transparency Scraper** gets **every Google ad of any advertiser or website** from the [Google Ads Transparency Center](https://adstransparency.google.com): **text ads (Google Search), image ads (Display) and video ads (YouTube)**, with the **preview image**, **first and last date shown**, **how long each ad has been running**, and optionally **the countries where it ran and all its variations**.

Search by **advertiser name** ("Nike"), **advertiser ID** or **domain** ("nike.com"), and filter by **country**, **ad format** and **date range**. Turn on **Only new ads** and schedule it weekly to get **alerts when a competitor launches new ads**.

It runs on the Apify platform, so you also get an API, **scheduling**, integrations (Google Sheets, Make, Zapier, n8n, Slack) and access for **AI agents through the [Apify MCP server](https://mcp.apify.com)**.

### Why use it?

- 🕵️ **Competitor ad research**: see every ad a competitor runs on Google Search, Display and YouTube, and which ones have been running the longest (long-running ads are usually the ones that work).
- 🔔 **Competitor ad monitoring**: schedule a weekly run with **Only new ads** and receive only the ads launched since last week.
- ✍️ **Ad copy and creative inspiration**: collect hundreds of real ads in your niche in minutes, with preview images.
- 🌍 **Market entry**: see which advertisers run ads in a country and what they show there.
- 🛡️ **Brand protection**: search your own domain to find resellers and affiliates advertising with your brand.
- 🤖 **AI agents and dashboards**: one clean JSON record per ad, ready for spreadsheets, BI tools and LLMs.

### How to scrape the Google Ads Transparency Center

1. Click **Try for free**.
2. Enter **advertiser names** (e.g. `Nike`), advertiser IDs or links, and/or **domains** (e.g. `adidas.com`).
3. Optionally choose a **country** (`US`, `GB`, `DE`...), an **ad format** and a **date range**.
4. Click **Start**. 100 ads take a few seconds.
5. Download the results as JSON, CSV or Excel: the **Ads** view shows the preview image of each ad.

### Input

| Field | Description | Default |
|---|---|---|
| `advertisers` | Advertiser names, IDs (`AR...`) or Ads Transparency Center links | - |
| `domains` | Websites whose ads you want (`nike.com`) | - |
| `region` | 2-letter country code (`US`, `GB`, `MX`...) or empty for anywhere | anywhere |
| `adFormat` | `all`, `text`, `image` or `video` | `all` |
| `dateFrom`, `dateTo` | Only ads shown in this period (`YYYY-MM-DD`) | - |
| `maxAdsPerSearch` | Maximum ads per advertiser or domain | 100 |
| `includeDetails` | Countries where each ad ran and all its variations | `false` |
| `onlyNewAds` | Scheduled runs: only ads not returned by previous runs | `false` |
| `advertiserMatch` | `best` (the matching advertiser with the most ads for your filters) or `all` | `best` |

```json
{
  "advertisers": ["Nike"],
  "domains": ["adidas.com"],
  "region": "US",
  "adFormat": "all",
  "maxAdsPerSearch": 200
}
```

### Output

One record per ad. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR14430561696143638529",
  "format": "text",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/12286367498515173624",
  "firstShown": "2023-11-16T23:49:17Z",
  "lastShown": "2026-09-26T18:16:59Z",
  "daysRunning": 1045,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR14430561696143638529?region=US",
  "region": "US",
  "searchedBy": "advertiser: Nike",
  "variations": 4,
  "regionsShown": [{ "region": "US", "lastShown": "2026-09-01" }]
}
```

### Data fields

| Field | Description |
|---|---|
| `advertiserName`, `advertiserId` | Verified advertiser |
| `creativeId`, `adUrl` | The ad and its page on the Ads Transparency Center |
| `format` | `text` (Google Search), `image` (Display) or `video` (YouTube) |
| `imageUrl` | Archived preview image (text and most image ads); `previewUrl` for rich and video ads |
| `firstShown`, `lastShown`, `daysRunning` | When the ad started and last ran, and for how many days |
| `regionsShown` | With `includeDetails`: countries where the ad ran and the last date it was shown there |
| `variations`, `variationPreviews` | With `includeDetails`: how many versions of the ad exist, with their previews |
| `searchedBy` | The advertiser or domain search that found the ad |

### How much does it cost to scrape Google ads?

| Event | Price |
|---|---|
| Run start (per GB of memory, default 256 MB) | $0.001 |
| Ad scraped | **$0.0015** |
| Ad details (optional: countries and variations) | $0.001 |

**100 ads cost $0.15; 1,000 ads cost $1.50.** Failed searches are never billed, and with **Only new ads** you only pay for ads you have not received before. Set **Max cost per run** and the Actor stops cleanly at that limit.

### Use it with AI agents (MCP)

Add `https://mcp.apify.com?tools=fguiraud/google-ads-transparency-scraper` to Claude, Cursor or any MCP client and ask:

- *"What Google ads is Nike running in the US right now? Which have been running the longest?"*
- *"Show me the YouTube ads of hubspot.com from the last 30 days."*
- *"Compare the number of active Google ads of Notion and ClickUp in Germany."*

Smallest useful input for an agent: `{"advertisers": ["Notion"], "region": "US", "maxAdsPerSearch": 20}`.

### Tips

- **Sort by `daysRunning`**: ads that have been running for months are usually the advertiser's best performers.
- A name like "Nike" matches several advertisers (local subsidiaries, unrelated companies). The default picks the one with the most ads for your country, format and dates; use the **advertiser ID** or **link** from the Ads Transparency Center to be exact, or `advertiserMatch: all` to include every match.
- For big brands with one account per country, **domain search** (`puma.com`) is often the most complete option. It also finds resellers and affiliates: great for brand protection, noisier for competitor research.
- Ads are returned most recently shown first, so a small `maxAdsPerSearch` gives you the ads running now.
- Long runs are safe: if the platform restarts the run, ads already returned are skipped and never charged twice.

### FAQ and limitations

- **Text of text ads**: Google archives Search ads as images, so the headline and description are in `imageUrl`, not as separate text fields.
- **Platform (Search, YouTube, Maps, Play, Shopping)**: not available as a filter yet; use `adFormat` (`video` = YouTube ads).
- **Spend and impressions** are only published by Google for political ads in some regions, and are not part of this Actor.
- **Is it legal?** The Actor reads public data that Google publishes in the Ads Transparency Center for transparency purposes. It does not collect personal data.
- Found a problem or need a feature? Open an issue on the **Issues** tab. Replies within 48 hours.

### Related tools

- [Google Trends Scraper](https://apify.com/fguiraud/google-trends-scraper): is interest in a competitor's product growing, and where?
- [Google News Scraper + Full Article Text](https://apify.com/fguiraud/google-news-scraper): the news about a brand or market, with the full article as Markdown.

# Actor input Schema

## `advertisers` (type: `array`):

Advertiser names (e.g. 'Nike'), advertiser IDs (AR...) or Ads Transparency Center links (adstransparency.google.com/advertiser/AR...). A name is matched to the advertiser whose name contains it and that has the most ads for your country, format and dates; set 'Advertiser name matching' to 'all' to include every match.

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

Websites whose ads you want (e.g. 'nike.com'): returns the ads of every advertiser that points to the domain, including resellers and affiliates.

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

Only ads shown in this country: a 2-letter code (US, GB, DE, MX, BR...). Empty = anywhere.

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

Only text (Google Search), image (display) or video (YouTube) ads.

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

Only ads shown on or after this date (YYYY-MM-DD).

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

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

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

Stop after this many ads for each advertiser or domain (most recently shown first).

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

Also get the countries where each ad ran (with the last date shown there) and all its variations. One extra request and one extra charge per ad.

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

For scheduled runs: skip ads already returned by previous runs of the same search (remembered in a key-value store named 'google-ads-transparency-monitor' in your account), so you are alerted to, and pay for, new ads only.

## `advertiserMatch` (type: `string`):

'best': of the advertisers whose name contains your text, the one with the most ads for your filters. 'all': every advertiser whose name contains it (e.g. local subsidiaries).

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

How many advertisers or domains are searched at the same time.

## `failOnError` (type: `boolean`):

Mark the run as FAILED when a search fails or no ads are found. Useful for monitoring pipelines.

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

Apify Proxy spreads requests over several IPs, which avoids rate limits on large runs.

## Actor input object example

```json
{
  "advertisers": [
    "Nike"
  ],
  "region": "US",
  "adFormat": "all",
  "maxAdsPerSearch": 100,
  "includeDetails": false,
  "onlyNewAds": false,
  "advertiserMatch": "best",
  "maxConcurrency": 3,
  "failOnError": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "advertisers": [
        "Nike"
    ],
    "region": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fguiraud/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 = {
    "advertisers": ["Nike"],
    "region": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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