# Google Ads Transparency Scraper & Competitor Ad Monitor (`earlytern/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center by website, brand or advertiser ID. Get every ad with dates, formats, countries and ad text, and get alerts for new and stopped competitor ads. No login.

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

## Pricing

from $0.80 / 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.
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

Google Ads Transparency Scraper collects the ads any company runs on Google Search, YouTube, Shopping, Maps and Google
Play from the public [Google Ads Transparency Center](https://adstransparency.google.com/). Search by website, brand
name or advertiser ID, get every ad with its dates, format, countries and ad text, and turn on the competitor monitor to
see only the ads that are new or have stopped since your last run. No Google account or login needed.

### What does Google Ads Transparency Scraper do?

- Finds all ads of an advertiser by **website** (`nike.com`), **brand name** (`Booking.com`), **advertiser ID**
  (`AR16735076323512287233`) or a **Transparency Center link**. It works out which one you typed.
- Returns for each ad: advertiser name and country, ad format (text, image, video), first and last day shown, number
  of days shown, an image of the ad and a link to it in the Transparency Center.
- **Ad details** (optional): the countries the ad was shown in, dates per country, every version of the ad, and for ads
  shown in the EU also the impression ranges per country and the Google platforms it ran on.
- **Ad text** (optional): headline, description and display link of text ads, and the YouTube link of video ads.
- **Competitor monitor**: give the run a monitor name and schedule it. Each run then returns only ads that are **NEW**
  or have **STOPPED** showing since the previous run.
- **Advertisers** result type: one row per advertiser, telling you whether a website or brand is running Google ads
  right now and about how many ads it has. Useful for checking a list of leads.
- Filters: country, platform, ad format, last N days or a date range.

### Who is it for?

- **Advertising agencies and marketers**: study competitors' ads, offers and wording; collect ideas for new ads.
- **Sales teams**: find companies that spend on Google Ads, or check a list of websites ("which of these run ads?").
- **Market researchers and analysts**: track how often a brand changes its ads and where it advertises.
- **AI agents**: call the Actor through the Apify API or MCP to answer "what ads is this company running?".

### How to use it

1. Click **Try for free**.
2. Under **Websites, brand names or advertiser IDs**, add one or more searches, for example `nike.com`.
3. Choose **Ads** or **Advertisers** as the result type, and set the filters and the maximum number of ads you want.
4. Turn on **Add ad details** or **Add ad text** if you need them (they cost extra, see below).
5. Click **Start**. Download the results as JSON, CSV or Excel, or use them through the API.

To monitor competitors, enter a **Monitor name** (for example `my-rivals`) and create a schedule for the Actor with the
same input, for example every day. The first run returns all ads as NEW; later runs return only changes.

### Use with AI agents (MCP)

AI assistants and AI agents can call this Actor through Apify's MCP server at [mcp.apify.com](https://mcp.apify.com)
or through the Apify API. Questions it answers well:

- "Is example.com running Google ads right now?" Use the **Advertisers** result type: one short row per advertiser.
- "What new YouTube ads has example.com started in the last 30 days?" Use **Ads** with the YouTube platform and
  `lastDays: 30`.
- "Which of these 50 websites advertise on Google?" Use **Advertisers** with the list of websites.

Only `queries` is required. Keep **Maximum ads per search** low (the default is 100) so answers stay short.

### Input example

```json
{
  "queries": ["nike.com", "Booking.com", "AR16735076323512287233"],
  "mode": "ads",
  "region": "US",
  "lastDays": 30,
  "maxAdsPerQuery": 200,
  "includeAdText": true,
  "monitorName": "my-rivals"
}
```

The full list of fields with explanations is on the **Input** tab.

### Output example

One ad with details and text, from a real run (shortened):

```json
{
  "query": "nike.com",
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "advertiserCountry": "NL",
  "creativeId": "CR10301054218470948865",
  "format": "TEXT",
  "platforms": ["SEARCH", "MAPS", "SHOPPING"],
  "firstShown": "2025-10-22",
  "lastShown": "2026-11-02",
  "daysActive": 376,
  "regionsShown": ["DE", "BE", "CH", "FR", "LU", "IT", "ES", "NL"],
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/3290858767449404677",
  "videoUrl": null,
  "adText": {
    "headline": "Le confort Air Max",
    "description": "Découvre {Keyword:chaussures Nike} sur Nike.com. Commande sur le site officiel Nike.",
    "displayUrl": "nike.com",
    "productTitle": null
  },
  "details": {
    "perCountry": [
      { "region": "DE", "firstShown": "2025-10-25", "lastShown": "2026-10-29", "impressionsMin": 0, "impressionsMax": 1000 },
      { "region": "BE", "firstShown": "2025-10-23", "lastShown": "2026-11-01", "impressionsMin": 0, "impressionsMax": 1000 }
    ]
  },
  "monitorStatus": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR10301054218470948865?region=anywhere",
  "scrapedAt": "2026-11-02T05:09:00.744Z"
}
```

With the **Advertisers** result type, each row looks like this (a search for `nike.com` gives one row per advertiser
that runs ads for the website):

```json
{
  "query": "nike.com",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserCountry": "US",
  "isRunningAds": true,
  "approxAdCount": 8000,
  "lastAdShown": "2026-11-02",
  "matchedVia": "website",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=anywhere",
  "scrapedAt": "2026-11-02T05:12:06.424Z"
}
```

A website that runs no Google ads gives one row with `isRunningAds: false`. A summary of every search (what was found,
how many ads Google lists, and why a search was skipped) is saved in the **OUTPUT** record of the run.

### How much does it cost?

You pay only for the rows you get; there is no fee to start a run. Prices per 1,000, by Apify plan:

| What | Free | Bronze | Silver | Gold and higher |
|---|---|---|---|---|
| Ads | $1.50 | $1.20 | $1.00 | $0.80 |
| Ad details (extra, per ad) | $2.00 | $1.80 | $1.50 | $1.20 |
| Ad text (extra, only when text is found) | $1.00 | $0.80 | $0.70 | $0.50 |
| Advertiser rows | $2.00 | $1.80 | $1.50 | $1.20 |

Examples on the Free plan: 1,000 ads cost $1.50; with ad text $2.50; with details $3.50. On the Gold plan the same
1,000 ads cost $0.80, $1.30 and $2.00. Checking whether 500 websites run Google ads costs $1.00 on the Free plan. The
same search typed twice in one run (for example `nike.com` and `https://www.nike.com`) is done and charged once. You
can set a **maximum cost per run**; the Actor stops
cleanly when it is reached, and a monitor remembers what it did not deliver, so nothing is lost. Searches that Google
blocks are not charged.

### Tips and limits

- Up to 10,000 ads per search and 50,000 per run. Google shows an estimated total for large advertisers (for example
  about 50,000 ads for nike.com); use filters to get the part you need.
- The platform filter only works for ads shown since September 2023 (a Google limit).
- Impressions are ranges published by Google, not exact numbers. Google publishes impressions and platforms only for
  ads shown in the EU; for other ads these fields are empty.
- The Actor asks Google politely (one or two requests per second) and never solves captchas. If Google
  blocks a search, the search is skipped and listed in OUTPUT; try again later.
- The Actor uses Apify's residential proxy by default, because Google often blocks datacenter connections. You can
  pick another proxy group under **Proxy**; the price per result stays the same.
- Schedule runs and send results to Google Sheets, Slack, Make, Zapier or n8n with Apify integrations.

### FAQ

**Is it legal to scrape the Google Ads Transparency Center?** The Actor reads only information that Google publishes
for everyone about ads and advertisers. It does not log in and does not get around blocks or captchas. You are
responsible for how you use the data and for following the laws that apply to you.

**Does it collect personal data?** No. It collects ad and advertiser information as Google publishes it. Some small
advertisers are registered under a person's name; Google shows that name as the advertiser, and the Actor returns it
like any other advertiser name. It collects no emails, phone numbers or private profiles.

**Why are some text ads only an image?** Google stores many text ads as pictures. Turn on **Add ad text** to read the
headline and description; you pay for ad text only when it was found.

**Which ads count as NEW?** Ads the monitor has not seen before that Google first showed since the previous run. An
older ad that only now appears in the results (for example after you raise the maximum) is remembered quietly and
not returned or charged.

**How does the monitor decide that an ad stopped?** An ad counts as stopped when it has not been shown for two days,
or when it no longer appears in a full list of the advertiser's ads.

**Can I change the input of a monitor?** Yes. Adding searches, raising the maximum or turning on ad text keeps the
history. Changing the country, platforms, ad format or dates of a search starts a new history for it (its next run
returns all ads as NEW). "Shown in the last … days" keeps its history from day to day.

### Questions and feedback

Open an issue on the **Issues** tab with the run link, and we will look into it.

# Actor input Schema

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

One per line: a website (nike.com), a brand or company name (Booking.com B.V.), an advertiser ID (AR…) or a link copied from the Google Ads Transparency Center.

## `mode` (type: `string`):

Ads: one row per ad. Advertisers: one row per advertiser, with whether it is running ads and roughly how many, to check lead lists.

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

Only ads shown in this country.

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

Only ads shown on these platforms. Leave empty for all. Google records platforms for ads shown since September 2023.

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

Text, image or video ads.

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

Only ads shown in this many days up to today. Overrides the start and end dates.

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

Only ads shown on or after this date.

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

Only ads shown on or before this date.

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

The run stops collecting ads for a search after this many.

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

A brand name can match several advertiser accounts (for example one per country). The ones with the closest name and the most ads are used.

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

All versions of each ad, first and last date per country, platforms, and impression ranges (published for ads shown in the EU). Costs extra per ad and takes about one second more per ad.

## `includeAdText` (type: `boolean`):

Headline, description and display link of text ads, and the headline and YouTube link of video ads. Charged only for ads where text is found. Text inside images is not read.

## `monitorName` (type: `string`):

Give your monitor a name and schedule this task. Each run then returns only ads that are new since the last run, and ads that stopped showing. The first run returns every ad as new.

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

Connection used to reach Google. The default (residential) works best; Google often blocks datacenter connections.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "mode": "ads",
  "region": "anywhere",
  "platforms": [],
  "adFormat": "ALL",
  "maxAdsPerQuery": 20,
  "maxAdvertisersPerQuery": 3,
  "includeDetails": false,
  "includeAdText": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

## `advertisers` (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 = {
    "queries": [
        "nike.com"
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("earlytern/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("earlytern/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 earlytern/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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