# Google Ads Transparency Scraper & API: Competitor Ads (`brainfoods_studio/google-ads-transparency-scraper`) Actor

Every ad a competitor runs on Google Search, YouTube and Display, by brand name, advertiser ID or domain: format, dates, countries, headline and text, plus which ads are likely working. No login. $1 per 1,000 ads, less on paid plans.

- **URL**: https://apify.com/brainfoods_studio/google-ads-transparency-scraper.md
- **Developed by:** [Brainfoods Studio](https://apify.com/brainfoods_studio) (community)
- **Categories:** AI, Lead generation, Integrations
- **Security:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

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

> **Late, but we brought receipts.** Every ad comes with when it started, where it ran and what it said. The ones that have run for years are flagged too, because an ad that keeps running is usually an ad that works.

**Google Ads Transparency Scraper** is an API for the Google Ads Transparency Center, built for competitor research. Get **every ad a brand ran on Google Search, YouTube and Display**, by advertiser name, advertiser ID or website, in any country, with dates, countries, ad text and a preview, as JSON, CSV or Excel.

**No login · No API key · $1 per 1,000 ads, less on paid plans · Independent tool, not affiliated with Google**

### What does Google Ads Transparency Scraper do?

- **Finds the right advertiser by name.** Type "nike" and you get Nike, Inc., not one of the small accounts with a similar name.
- **Lists every ad** for an advertiser or a website: format (text, image or video), first and last shown, preview image and link.
- **Adds details on request**: every country an ad ran in, with the last date in each, and how many variants it has.
- **Reads the ad text**: headline and description, straight from Google's own preview.
- **Premium intelligence**: days live, whether it's running now, and a 0–100 "likely working" score for each ad.
- **A free summary per source**: ads delivered, Google's approximate total, the format mix and the date span.

### Who is it for?

- **Marketers and media buyers** studying what competitors run, where, and for how long.
- **Agencies** building competitor decks and pitch research in minutes instead of days.
- **Sales and lead-gen teams** finding companies that actively spend on Google Ads.
- **Researchers and journalists** tracking brand or category advertising across countries.

### Use cases

| You want to | What to set |
| --- | --- |
| See every ad a competitor's website runs | `domains`, with `maxAdsPerSource` raised |
| Find the ads that are probably working | `includeIntelligence` and the free `winner` rows |
| Compare two brands' video ads in one country | Two `domains`, `region`, and `formats` set to `video` |
| Collect headlines for copy research | `includeAdText` |
| Check which companies in a list advertise on Google | A list of `domains`, then read the free `summary` rows |
| Get an alert when a competitor launches new ads | `monitorKey` and `deliveryWebhookUrl`, on a schedule |

### Find the right advertiser by name

Advertiser names on Google are messy. Type "nike" and there are many accounts called something like Nike. The actor picks the advertiser with the most ads among those whose name contains what you typed, and if none does, the advertiser with the most ads overall. The other candidates are listed in a free advertiser row, so you can switch to an exact ID.

The choice is shown in a free `advertiser` row with its ID, country, ad count and verification status, plus up to 5 alternatives. If it picked the wrong one, copy the right ID from `alternatives` into your next run.

### What each ad gives you

- **Format:** text, image or video.
- **First and last shown** dates.
- **A preview image** and the link to the ad on Google's Transparency Center.
- With `includeDetails`: **the countries where it ran**, with the last-shown date in each, and how many variants it has.
- With `includeAdText`: **the headline and description**, read from the ad's preview. For example, one Nike text ad gives "Shop Nike® Clearance" and "Save with Nike® clearance. Shop shoes, apparel and accessories on sale." Image and video ads often have no text to read.

Every source also gets a free `summary` row: ads delivered, Google's approximate total, the mix of formats, and the date span.

### What we measured

Live runs on Apify Proxy, 1 November 2026:

| Check | Result |
| --- | --- |
| Name lookup "nike" | Nike, Inc. (US, 9,000 to 10,000 ads), with the other candidates listed in the free advertiser row |
| Domain nike.com, 50 ads with details | every ad came with the countries it ran in, and the last-shown date for each |
| Ad text, same 50 ads | headline and description for 27 of 38 text ads and 8 of 11 image ads |
| Domain nike.com, region GB, video only | 13 video ads in 23 seconds |

Ad text is read from Google's own ad preview. When a preview has no readable text, the ad still arrives at the plain ad price.

### Built to finish the run

- Every request runs in a warmed-up session with its own cookies and proxy address, and requests are paced.
- Rate limits and block pages get up to 4 attempts, with a growing pause. A session that stops working is replaced.
- On Apify Proxy, datacenter addresses are used first. After repeated rate limits, the actor moves to residential addresses if your plan has them.
- **A failed lookup never fails the run.** It gets an error row, and every other advertiser still finishes.
- If details or text can't be fetched for one ad, the ad still arrives with `detailsError` or `textError` set, at the plain ad price.

### How to use the Google Ads Transparency scraper

1. Click **Try for free**.
2. Enter **advertisers** (names or IDs like `AR16735076323512287233`) or **domains** (like `nike.com`), up to 50 of each.
3. Pick a **region**, or leave it as `anywhere`.
4. Choose the **formats** you want and how many ads per source.
5. Click **Start**, then download the dataset as JSON, CSV or Excel, or run the actor from the [Apify API](https://docs.apify.com/api/v2) or on a schedule.

#### Input example

```json
{
  "advertisers": ["nike"],
  "region": "US",
  "formats": ["text", "image", "video"],
  "maxAdsPerSource": 200,
  "includeDetails": true,
  "includeAdText": true
}
```

#### More ready-to-run inputs

| Use case | Input |
| --- | --- |
| Every ad for a website | `{"domains": ["nike.com"], "maxAdsPerSource": 1000}` |
| Competitors' video ads in the UK | `{"domains": ["nike.com", "adidas.com"], "region": "GB", "formats": ["video"]}` |
| One advertiser by ID, with ad text | `{"advertisers": ["AR16735076323512287233"], "includeAdText": true, "maxAdsPerSource": 100}` |

Domains are cleaned for you: `https://www.nike.com/us` becomes `nike.com`.

#### Use it from an AI agent

Add the actor to any MCP client (Claude, Cursor, VS Code and others) through Apify's hosted MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=brainfoods_studio/google-ads-transparency-scraper"
    }
  }
}
```

Then ask in plain words: *"Show me the text ads Nike ran on Google in the US this month, with their headlines."* See [Apify's MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Integrations

Everything runs on Apify, so it plugs into the tools you already use:

- **Apify API and SDKs** (JavaScript, Python) to start runs and read results from your own code.
- **Schedules** to check competitors daily or weekly. Monitor mode then returns only new ads.
- **Make, Zapier and n8n** to send ads to Google Sheets, a CRM or a database without writing code.
- **Webhooks and Slack** to get a message when a competitor launches something new.
- **MCP** for Claude, Cursor and other AI agents, as shown above.

See [Apify integrations](https://docs.apify.com/platform/integrations).

### What you get

| Row type | One row per | Main columns |
| --- | --- | --- |
| `ad` | ad | `advertiserName`, `creativeId`, `format`, `firstShown`, `lastShown`, `previewImageUrl`, `adUrl`, `headline`, `description`, `displayUrl`, `regions`, `regionsLastShown`, `variantCount` |
| `advertiser` | name lookup (free) | `advertiserId`, `name`, `country`, `adCountMin`, `adCountMax`, `verified`, `alternatives` |
| `summary` | advertiser or domain (free) | `ads`, `approxTotal`, `formats`, `firstShown`, `lastShown`, `stoppedAt` |
| `error` | failed step | `stage`, `source`, `errorKind`, `message`, `attempts` |

One `ad` row, without details or text:

```json
{
  "type": "ad",
  "source": "nike",
  "sourceType": "advertiser",
  "region": "US",
  "rank": 1,
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR05757739320572116993",
  "format": "text",
  "firstShown": "2023-11-17",
  "lastShown": "2026-11-01",
  "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/4471758449974537828",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR05757739320572116993?region=US"
}
```

Every ad row has the same columns. Fields you didn't ask for are empty, so the dataset opens cleanly in a spreadsheet.

### Premium features

#### Intelligence: which ads are working?

Set `includeIntelligence: true` (it switches on details) and every ad gets `daysLive` and `activeNow`. Each advertiser or website also gets up to 10 free `winner` rows: the ads most likely to be working, scored 0–100 from how long they ran, how many variants they have and how many countries they ran in. Long-running ads are the usual sign of an ad that performs. The summary row lists the top 5.

On nike.com (1 November 2026), the top-ranked ads had run for 1,100+ days, in 5 variants, across 96 to 118 countries.

#### Monitor mode: only what's new

Set `monitorKey` to any name and run the actor on a schedule. Each run remembers what it returned, and the next run with the same name returns only ads you haven't seen yet, so you pay only for new results. Add `deliveryWebhookUrl` (a Slack incoming-webhook URL or any HTTPS endpoint) and a short alert with a link to the results is posted whenever something new turns up. The first run only builds the memory and never alerts. Use one `monitorKey` per schedule.

### Pricing

You pay per ad delivered. Advertiser rows, summary rows and error rows are free.

| Result | Free plan | Bronze | Silver | Gold and up |
| --- | --- | --- | --- | --- |
| Ad | $0.001 | $0.0008 | $0.0006 | $0.0005 |
| Ad with details, text or intelligence | $0.0025 | $0.002 | $0.0017 | $0.0015 |
| Monitor alert, per alert sent | $0.01 | $0.01 | $0.01 | $0.01 |

- **Charged only after your results are saved.** Never for error rows, advertiser rows or summaries.
- **Never past your spending limit.** When the limit is reached, the actor stops fetching new pages, and the run still succeeds.
- **No extra start fee.** Only Apify's standard run start charge of $0.00005 applies.
- If details or text fail for an ad, it's charged at the plain ad price.
- Ads you filter out by format are never charged.

What typical runs cost, before the start charge:

| Run | Free plan | Bronze |
| --- | --- | --- |
| 1 advertiser, 100 ads | $0.10 | $0.08 |
| 1 advertiser, 100 ads with details and text | $0.20 | $0.16 |
| 1 large advertiser, 8,000 ads | $8.00 | $6.40 |

### FAQ

#### Do I need a Google account or an API key?

No. You only need an Apify account. Click **Try for free**, enter a website or brand and start.

#### Is this data public?

Yes. Google publishes it in the Ads Transparency Center so anyone can see who advertises and what they show. This actor reads the same public pages.

#### How many ads can I get?

Up to 10,000 per advertiser or domain per run. The free `summary` row shows Google's approximate total, so you know how much is there before you raise the limit.

#### Why is `headline` empty for some ads?

Ad text is read from the ad's preview. Text ads usually have it; image and video ads often don't. Those ads arrive with `headline` empty.

#### Which regions can I search?

Any country, by its 2-letter code, or `anywhere`. With `includeDetails`, each ad also lists every country where it ran.

### Legal note

This actor reads public transparency data that Google publishes on purpose. It does not solve captchas and does not try to get around anti-bot checks. It respects Google's rate limits by waiting and backing off. Use the data in line with Google's terms, advertisers' rights and the laws where you live.

### More from Brainfoods Studio

- [Google Trends Scraper](https://apify.com/brainfoods_studio/google-trends-scraper): interest over time for up to 100 keywords on one 0–100 scale, plus regions, related queries and trending now.
- [Google News Scraper](https://apify.com/brainfoods_studio/google-news-scraper): articles by search, topic or top stories, past the 100-article cap, with real publisher URLs.
- [Google Play Scraper](https://apify.com/brainfoods_studio/google-play-scraper): app details and reviews, plus an App health report that shows which release hurt the rating.

### Support

We're the new kids on this Store, so every issue gets an answer from the people who wrote the code. Found a problem, or need a field we don't return yet? Open an issue in the **Issues** tab. And if this actor saved you an afternoon, a review helps the next person find it.

Built and maintained by Brainfoods Studio.

# Changelog

This Actor's version history is a separate document: https://apify.com/brainfoods_studio/google-ads-transparency-scraper/changelog.md

# Actor input Schema

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

Advertiser names to look up (the best match is used) or advertiser IDs such as AR16735076323512287233. Up to 50. Give advertisers, domains or both.

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

Websites whose ads you want, such as nike.com. A full address like https://www.nike.com/us is cut down to nike.com. Up to 50.

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

anywhere, or a two-letter country code (US, GB, IN) to keep only ads shown in that country.

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

Which ad formats to keep: text, image, video. Leave empty for all. Ads of other formats are skipped and never charged.

## `maxAdsPerSource` (type: `integer`):

Stop each advertiser or domain after this many ads, 1 to 10000.

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

Adds the countries where each ad was shown (with the last date in each), the number of variants and all image links. One extra request per ad; charged at the higher with-details rate.

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

Adds the ad headline and description when Google exposes them (best effort; image-only ads have none). One extra request per ad; charged at the higher with-details rate.

## `includeIntelligence` (type: `boolean`):

Adds days live, whether the ad is active now, and a likely-winner score and rank within each advertiser or website, based on how long each ad ran, its variants and the countries it ran in. Turns on details. Charged at the ad-with-details price.

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

Parallel sessions, 1 to 8. The default of 2 is the safest; higher is faster but more likely to be rate-limited by Google.

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

Apify Proxy is strongly recommended. Datacenter is tried first; residential is used automatically after repeated 429s if your plan has it.

## `monitorKey` (type: `string`):

Turns on monitor mode. Results are remembered under this name, and later runs with the same name return only what is new. Use one name per schedule.

## `deliveryWebhookUrl` (type: `string`):

Optional. A Slack incoming-webhook URL or any HTTPS endpoint. When a monitored run finds something new, it posts a short alert with a link to the results. Charged as one alert per run that sends one. Stored encrypted and hidden from logs, because a webhook URL works like a password.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "anywhere",
  "formats": [
    "text",
    "image",
    "video"
  ],
  "maxAdsPerSource": 20,
  "includeDetails": false,
  "includeAdText": false,
  "includeIntelligence": false,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All rows: ads, advertiser lookups, one summary per source, and error rows for anything that failed.

## `stats` (type: `string`):

Requests, successes, rate limits, retries, session changes and a summary of rows and charges for this run.

# 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 = {
    "domains": [
        "nike.com"
    ],
    "maxAdsPerSource": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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