# Google Ads Transparency Scraper: Competitor Ads & Ad Copy (`ragequit/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center by brand, website or advertiser: every ad with format, dates, days running, countries, EU reach and the ad copy Google exposes (headlines, Shopping products, YouTube videos). Fast and cheap, no login.

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

## Pricing

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

### What does Google Ads Transparency Scraper do?

**Google Ads Transparency Scraper** extracts ads from the [Google Ads Transparency Center](https://adstransparency.google.com) for any **brand, website or advertiser**: every ad's **format**, **first and last shown dates**, **how many days it has been running**, the **countries** it ran in, **reach (impressions) by country and platform** where Google publishes it, and the **ad copy Google exposes**: search ad headlines and descriptions, Shopping product titles and images, and YouTube video links.

It works as a **Google Ads Transparency Center API**: run it from Apify Console, schedule it, or call it through the Apify API. No Google account, login or API key needed.

### Why use this Google Ads scraper?

- 🔍 **Spy on competitor ads.** See every ad a competitor runs on Google Search, YouTube, Shopping, Maps and Play, and how long each one has been live. Ads running for hundreds of days are the ones that work.
- ✍️ **Get the ad copy, not just screenshots.** Where Google exposes it, you get the headline, description and display URL as text, Shopping product titles with images, and YouTube video links, ready for spreadsheets, swipe files or AI analysis.
- 📈 **Reach data.** For ads shown in the EU, Google publishes impression ranges per country and platform. They are included.
- 🔔 **Monitor new ads.** Switch on *Only new ads* and schedule the Actor: each run returns just the ads launched since the last run.
- ⚡ **Fast and cheap.** Direct calls to the Transparency Center's own data API, no browser: 40 ads with full details in about 20 seconds.
- 🧾 **Bulk.** Mix brand names, websites, advertiser IDs and pasted Transparency Center URLs in one run.

Typical uses: **competitive intelligence**, **ad creative research** and swipe files, **agency pitches** and audits, **brand-safety and compliance checks** (who runs ads pointing to your domain?), and **lead generation** (which companies advertise on Google, and how much?).

### What data can I extract from the Google Ads Transparency Center?

| Field | Description |
| --- | --- |
| `advertiserName`, `advertiserId` | The verified advertiser behind the ad |
| `format` | `text`, `image` or `video` |
| `firstShown`, `lastShown`, `daysShown` | When the ad started, when it was last seen, and for how many days it has run |
| `domain` | The website the ad points to |
| `headline`, `description`, `displayUrl` | Search ad copy, when Google exposes it |
| `productTitle`, `productImageUrl`, `merchant` | Shopping ad product, when exposed |
| `videoId`, `videoUrl` | YouTube video of a video ad, when exposed |
| `previewImageUrl`, `variations` | Images of the ad and all of its versions (A/B variants, sizes) |
| `regionsShown` | Every country the ad ran in, with first and last shown dates |
| `impressionsMin`, `impressionsMax`, `platformImpressions` | Reach ranges, published by Google for ads shown in the EU |
| `adUrl` | Link to the ad in the Transparency Center |

#### Which ads come with text?

Google stores many plain text search ads only as an **image** of the ad, so for those you get `previewImageUrl` instead of a `headline`. Ads with sitelinks or location extensions, **Shopping ads** and many **video ads** expose their content as data, and this Actor extracts it. The `hasAdContent` field tells you which is which. **Dynamic Search Ads** have no fixed headline (Google writes it from the landing page when serving the ad), so they come with `isDynamicAd: true` and just the description.

### How to scrape Google Ads Transparency Center

1. Click **Try for free** to open the Actor in Apify Console.
2. Add **brand names or websites**, for example `nike.com` or `HelloFresh`. You can also paste advertiser IDs or Transparency Center URLs.
3. Pick a **country** (or *anywhere*) and, optionally, **platforms**, an **ad format** and a **date range**.
4. Set how many ads you want per brand, website or advertiser.
5. Click **Start**. Results appear in the **Output** tab within seconds.
6. Download them as JSON, CSV, Excel or HTML, or fetch them through the API.

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

The Actor uses **pay-per-event** pricing, with platform usage and proxies included:

- **$1.00 per 1,000 ads**
- **+ $0.50 per 1,000 ads with details** (variations, countries, reach and ad copy), only when *Include ad details* is on

So **1,000 fully detailed ads cost $1.50**. Apify's free plan includes monthly credits, enough for a few thousand ads, and higher subscription tiers get lower prices.

### Input

See the **Input** tab for every option. The main ones:

- **Brands or websites**: `nike.com` returns every ad pointing to nike.com from any advertiser; `Nike` is matched to advertiser accounts, like the Transparency Center's search box. *Advertisers per brand name* controls how many accounts to include.
- **Advertiser IDs** and **Ads Transparency Center URLs**: for exact targeting. Pasted URLs keep their region, platform and format filters, and creative URLs return that single ad.
- **Country**, **Platforms**, **Ad format**, **Shown since / until**: the same filters as on the website. Google's date filter covers about the last 12 months.
- **Max ads per brand, domain or advertiser**: big brands run thousands of ads; `0` means all of them.
- **Include ad details and ad copy** and **Only new ads (monitoring)**.

Example input:

```json
{
    "searchQueries": ["nike.com", "HelloFresh"],
    "region": "US",
    "platforms": ["SEARCH", "YOUTUBE"],
    "maxAdsPerTarget": 200,
    "includeDetails": true
}
```

### Output

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**. The Output tab has an **Ads** view (one row per ad with its copy and preview) and a **Reach by country** view.

Example ad (arrays shortened):

```json
{
    "advertiserName": "Example Brand, Inc.",
    "advertiserId": "AR01234567890123456789",
    "creativeId": "CR01234567890123456789",
    "format": "text",
    "domain": "example.com",
    "firstShown": "2024-04-24T15:02:11.000Z",
    "lastShown": "2026-10-19T22:23:05.000Z",
    "daysShown": 899,
    "headline": "Browse Golf Shirts",
    "description": "Hit the links with the latest golf gear to chase your best this season. Shop now.",
    "displayUrl": "example.com",
    "isDynamicAd": false,
    "hasAdContent": true,
    "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/1234567890123456789",
    "variationCount": 4,
    "regionsShown": [
        { "region": "DE", "firstShown": "2025-11-26", "lastShown": "2026-09-29", "impressionsMin": null, "impressionsMax": 1000, "platformImpressions": [{ "platform": "SEARCH", "impressionsMin": null, "impressionsMax": 1000 }] },
        { "region": "US", "firstShown": null, "lastShown": "2026-10-19", "impressionsMin": null, "impressionsMax": null, "platformImpressions": [] }
    ],
    "impressionsMin": 2000,
    "impressionsMax": 3000,
    "region": "US",
    "target": "example.com",
    "targetType": "domain",
    "adUrl": "https://adstransparency.google.com/advertiser/AR01234567890123456789/creative/CR01234567890123456789?region=US",
    "scrapedAt": "2026-10-19T23:07:40.000Z"
}
```

### Tips for scraping the Google Ads Transparency Center

#### Website or brand name: which should I use?

A **website** (`nike.com`) finds every ad that points to it, even from resellers and agencies running ads for the brand. A **brand name** (`Nike`) finds the advertiser accounts with that name and returns all their ads, including ads pointing to other websites. Use **advertiser IDs** when you know exactly which account you want.

#### How do I monitor competitors for new ads?

Turn on **Only new ads (monitoring)** and create a **schedule** in Apify Console, for example every morning. The first run returns everything and remembers it; later runs return only newly launched ads. Connect the dataset to **Slack, Google Sheets, Make, Zapier or n8n** through Apify integrations to get alerts. Use a different *Monitoring store name* for each separate monitor.

#### How do I make runs cheaper or faster?

Switch off **Include ad details** if you only need the list of ads with dates and preview images: it skips two to three extra requests per ad. Lower *Max ads per brand* to stop early on big advertisers.

#### Why are impressions empty for most ads?

Google publishes reach (impression ranges) only for ads shown in the European Union, under the Digital Services Act. For other countries the Transparency Center lists only the dates.

### FAQ, disclaimers and support

#### Is it legal to scrape the Google Ads Transparency Center?

The Transparency Center is a public library that Google publishes so anyone can see who advertises and what they show. This Actor collects that public ad and advertiser information and does not log in or collect personal data. Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

This Actor is an independent tool and is not affiliated with or endorsed by Google.

#### A brand name returns the wrong advertiser. What can I do?

Brand names are matched the same way as in the Transparency Center's search box, so common words can match several companies. Use the brand's **website** instead, or copy the advertiser's page URL from the Transparency Center into **Ads Transparency Center URLs**.

#### How do I use it through the API?

Open the **API** tab for ready-to-use code in Python, JavaScript and cURL, or call it through the [Apify API](https://docs.apify.com/api/v2) with your token. It also works as a tool for AI agents through the Apify MCP server.

#### Something does not work. Where can I get help?

Open an issue in the **Issues** tab with a link to your run. Issues are usually answered within a day, and feature requests are welcome.

# Actor input Schema

## `searchQueries` (type: `array`):

Brand names (Nike, HelloFresh) or websites (nike.com). Websites return every ad that points to that domain; brand names are matched to advertiser accounts, like the search box of the Ads Transparency Center.

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

Optional. Domains to look up exactly as typed, for example shop.example.com.

## `advertiserIds` (type: `array`):

Optional. Advertiser IDs starting with AR, as in the URL of an advertiser page (adstransparency.google.com/advertiser/AR...).

## `startUrls` (type: `array`):

Optional. Paste advertiser, ad (creative) or domain search URLs from adstransparency.google.com. Region, platform and format in the URL are respected.

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

How many matching advertiser accounts to scrape for each brand name. Big brands often run ads from several accounts.

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

Only ads shown in this country: a two-letter code (US, GB, DE...) or an English country name. Use "anywhere" for all countries.

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

Only ads shown on these Google platforms. Leave empty for all. Google applies this filter to ads shown since September 2023.

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

Only ads of this format.

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

Only ads shown on or after this date (YYYY-MM-DD). Google supports roughly the last 12 months.

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

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

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

Stop after this many ads for each target. 0 means all of them (big brands have thousands).

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

Fetch each ad's detail page: all variations, every country it ran in with dates, reach (impressions) where Google publishes it (EU), and the ad text Google exposes (headline, description, display URL, Shopping product title, YouTube video). Slower, billed as a separate event.

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

Return only ads not seen in earlier runs. The first run returns everything and remembers it; later scheduled runs return just newly launched ads. Seen ads are kept in a named key-value store in your account.

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

Name of the key-value store that remembers seen ads. Use a different name for each separate monitor.

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

How many ad details to fetch at the same time.

## `maxRetries` (type: `integer`):

How many times to retry a request on a new IP address when Google rate-limits it.

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

Start on cheap datacenter IPs and move to Apify residential proxies for the rest of the run if Google rate-limits them. Only applies when you use Apify datacenter proxies.

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

The Ads Transparency Center rate-limits single IPs. Apify's datacenter proxies work well and are the cheapest option.

## Actor input object example

```json
{
  "searchQueries": [
    "nike.com"
  ],
  "maxAdvertisersPerQuery": 3,
  "region": "US",
  "platforms": [],
  "adFormat": "ALL",
  "maxAdsPerTarget": 100,
  "includeDetails": true,
  "onlyNewAds": false,
  "monitorStoreName": "ads-transparency-monitor",
  "maxConcurrency": 5,
  "maxRetries": 6,
  "residentialFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per ad creative

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

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

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

```

## MCP server setup

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