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

Scrape every ad a company runs on Google Search, YouTube, Shopping, Maps and Play from the public Ads Transparency Center. Search by domain, brand name or advertiser ID. Get creative previews, first and last shown dates and days running. No login.

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

## Pricing

$0.80 / 1,000 ad creatives

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 is Google Ads Transparency Scraper?

> This actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google LLC. All trademarks are the property of their respective owners. "Google Ads Transparency Center" is named only to describe the public website this actor reads.

**Google Ads Transparency Scraper** lets you extract every ad a company is running across Google Search, YouTube, Google Shopping, Google Maps and Google Play, straight from Google's public Ads Transparency Center, helping you see a competitor's live creative, work out which messages they keep paying to run, and check whether a whole list of companies buys Google Ads at all.

- 🎯 **See a competitor's entire ad library:** point it at a domain like `nike.com` and get back every creative Google has on file for it, image, text and video, with the exact first and last shown dates.
- ⏱ **Find the ads that actually work:** every row carries `shownForDays`, so the creative an advertiser has kept live for 900 days is one sort away.
- 🧭 **Qualify accounts in bulk:** ad-check mode returns one row per advertiser with Google's own approximate ad count, which tells you in a single cheap pass which companies on your prospect list are already spending.
- 🧩 **Reconstruct campaign structure:** Google's internal ad account and ad group ids come back on every preview-backed ad, so ads from one campaign cluster without guessing.
- 🌍 **Compare markets:** the Transparency Center is region-scoped, and this scraper runs any of 58 countries, so you can see what a brand runs in Germany that it does not run in the US.
- 🔓 **No login, no cookies, no Google account.** The Transparency Center is public and this actor never asks you for a session.

Google's own Transparency Center gives you an infinite scroll and no export. There is no official API. This actor gives you the same data as a dataset you can sort, filter and push into a spreadsheet, at **$0.80 per 1,000 ads**, which is well under half what the other Transparency Center scrapers on the Store charge.

### What data does Google Ads Transparency Scraper extract?

- 🆔 Creative ID and advertiser ID (`creativeId`, `advertiserId`)
- 🏢 Advertiser display name and the landing domain (`advertiserName`, `domain`)
- 🖼 Ad format: `IMAGE`, `TEXT` or `VIDEO`
- 📅 First shown and last shown, as full ISO timestamps (`firstShown`, `lastShown`)
- ⏳ How many days the ad has been running (`shownForDays`)
- 📸 Direct CDN image URL, with width and height, for ads Google archived as a picture
- 🔗 Google-hosted preview URL for text, video and rich-media ads (`previewUrl`)
- ✍️ Ad headline, read out of the rendered preview (`headline`, opt-in, best effort)
- 🧾 Google ad account ID, ad group ID and internal creative ID (`googleCustomerId`, `adGroupId`, `googleCreativeId`)
- 🎞 Every A/B variation of a creative (`variations`, opt-in)
- 🔍 The Transparency Center page for that exact ad (`adUrl`)
- 🌐 The region the ads were pulled for (`region`)

In ad-check mode each row is an advertiser instead: name, advertiser ID, country, verified badge, and the low and high bound of Google's approximate ad count.

### How to use Google Ads Transparency Scraper

1. Click **Try for free** and open the actor in Apify Console.
2. Put one or more websites into **Domains**, for example `nike.com`. A domain is the most reliable input because a single company often runs several advertiser accounts.
3. Pick the **Region** whose ads you want, and set **Maximum ads** to cap the run.
4. Click **Start** and watch the rows stream into the dataset.
5. **Export** as JSON, CSV, Excel or XML, or pull the results from the [Apify API](https://docs.apify.com/api/v2).

### Input

Target ads four ways and mix them freely.

```json
{
  "domains": ["nike.com", "hellofresh.com"],
  "advertiserNames": ["Squarespace"],
  "advertiserIds": ["AR16735076323512287233"],
  "startUrls": ["https://adstransparency.google.com/advertiser/AR16735076323512287233?region=GB"],
  "resultType": "ads",
  "region": "US",
  "adFormat": "ANY",
  "platforms": ["GOOGLE_SEARCH", "YOUTUBE"],
  "maxItems": 500,
  "extractAdCopy": false,
  "includeVariations": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

- **`domains`** exact landing domains. Scheme, `www.` and paths are stripped for you.
- **`advertiserNames`** brand names, resolved through the Transparency Center's own advertiser directory. Matching is a prefix match on the registered legal name, so `Nike` finds `Nike, Inc.` but `nike.com` does not.
- **`advertiserIds`** the `AR...` id from an advertiser page URL.
- **`startUrls`** advertiser or domain-search URLs pasted from the site. The region in the URL wins for that target.
- **`resultType`** `ads` for creatives, `advertisers` for one summary row per advertiser.
- **`adFormat`** `ANY`, `IMAGE`, `TEXT` or `VIDEO`.
- **`platforms`** any of `GOOGLE_SEARCH`, `YOUTUBE`, `GOOGLE_SHOPPING`, `GOOGLE_MAPS`, `GOOGLE_PLAY`.
- **`maxItems`** `0` means everything Google will serve, which for a large brand is tens of thousands of ads.
- **`extractAdCopy`** fetches each ad's rendered preview and reads the headline out of it.
- **`includeVariations`** attaches every A/B variation Google holds for the ad.

### Output

One ad per row.

```json
{
  "creativeId": "CR06029231865573933057",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "domain": "nike.com",
  "format": "IMAGE",
  "firstShown": "2023-04-25T20:04:55.635Z",
  "lastShown": "2026-09-16T00:37:16.475Z",
  "shownForDays": 1098,
  "previewType": "image",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/3520373571186011087",
  "previewUrl": null,
  "width": 348,
  "height": 229,
  "headline": null,
  "googleCustomerId": null,
  "adGroupId": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR06029231865573933057?region=US",
  "region": "US"
}
```

The dataset ships with three table views: **Ads** for the creative list, **Ad account & campaign** for the Google-internal ids, and **Advertisers** for ad-check runs.

### How much does it cost to scrape the Google Ads Transparency Center?

One flat price per ad, **$0.0008**, which is **$0.80 per 1,000 ads**. No platform usage on top, no per-run start fee.

| Ads | Cost |
|---|---|
| 1,000 | $0.80 |
| 10,000 | $8.00 |
| 100,000 | $80.00 |

Advertiser summary rows in ad-check mode are charged at the same flat rate, so screening 1,000 companies for whether they run Google Ads costs $0.80.

The other Google Ads Transparency scrapers on the Apify Store charge between $2.00 and $3.00 per 1,000 ads, and some add a per-run start fee on top.

### Measured coverage

Measured 2026-09-16 against live data through the Apify datacenter proxy, on a 2,000 ad platform run plus a 560 ad sample spread across seven large advertisers.

| Field | Coverage |
|---|---|
| `creativeId`, `advertiserId`, `advertiserName`, `domain` | 100% |
| `format`, `firstShown`, `lastShown`, `shownForDays` | 100% |
| `adUrl`, `region` | 100% |
| An image URL or a preview URL | 100% |
| `imageUrl` (image-archived ads) | 72% of all ads |
| `previewUrl` (text, video and rich media) | 28% of all ads |
| `headline` with `extractAdCopy` on | roughly 55% of preview-backed ads |

Format mix across the 560 ad multi advertiser sample: 73% image, 16% text, 11% video. A single advertiser can sit far from that average, so filter by format rather than assuming a mix.

Throughput on the platform: 2,000 ads in 89 seconds at 1 GB, all 2,000 unique, no proxy rotation needed.

### Limits

- **There is no date filter.** Google's endpoint does not expose one to the public client, so filter on `firstShown` and `lastShown` after the run instead.
- **A platform filter hides old ads.** Google only recorded the serving surface from 2023-09-04 onwards, and says so in its own interface, so selecting any platform drops everything older.
- **Ad counts are ranges.** Google publishes "roughly 8,000 to 9,000 ads", never an exact number, and this actor passes that through as `approxAdCountLow` and `approxAdCountHigh` rather than inventing a figure.
- **Ad copy is best effort.** Only text, video and rich-media ads carry a readable preview, and the headline comes back on roughly half of those. The field is null rather than wrong when the markup cannot be read.
- **Political ads are a separate archive.** This actor reads the main Transparency Center, not the political ads library.
- **The region matters.** An advertiser with 8,000 ads in the US may have 500 in India. Pick the region you actually care about.

### FAQ

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

The Ads Transparency Center is a public archive Google publishes deliberately, under its own ad transparency commitments. This actor reads only that public page, uses no login or cookie, and collects no personal data. You are responsible for using the results in line with Google's terms and with the law where you operate, particularly if you republish creative assets that belong to somebody else.

#### Do I need a Google account or cookies?

No. There is nothing to log in to and the actor never asks you for a session.

#### Can I use Google Ads Transparency Scraper as an API?

Yes. Every actor on Apify is an API. Start a run, poll it and read the dataset with the [Apify API](https://docs.apify.com/api/v2), or use the synchronous run-and-get-dataset endpoint for small jobs.

#### Can I use this in Python?

Yes, with `apify-client`:

```python
from apify_client import ApifyClient
client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("cirkit/google-ads-transparency-scraper").call(run_input={"domains": ["nike.com"], "maxItems": 100})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["advertiserName"], ad["format"], ad["shownForDays"])
```

#### Can I integrate it with other apps?

Yes. Apify connects to Zapier, Make, n8n, Slack, Google Sheets, Google Drive and Airtable, and can POST results to any webhook when a run finishes.

#### How do I schedule it to run automatically?

Use Apify **Schedules**. A daily or weekly run against the same domains, with results appended to a named dataset, gives you a change log of what a competitor launches and retires.

#### How do I find an advertiser ID?

Open the advertiser's page on adstransparency.google.com and copy the `AR...` segment from the URL. Or skip it: paste the page URL into **Transparency Center URLs**, or just use the domain.

#### Why did I get fewer ads than Google's page says?

Google's headline number is a rounded range, not a count. A platform filter also removes everything shown before 2023-09-04, and a format filter narrows the set further. Drop the filters and raise **Maximum ads** to see the full library.

#### Why are some ads missing a headline?

Only text, video and rich-media ads have a readable preview, and `extractAdCopy` has to be switched on. Image ads are archived as flat pictures with no text layer to read, so `headline` is null for them by design.

#### Can I get a field that is not listed?

If the Transparency Center shows it, it can usually be added. Open an issue on the actor and say which field and which ad you saw it on.

### You might also like

- [Google Maps Business Scraper](https://apify.com/cirkit/google-maps-business-scraper)
- [Google Shopping Scraper](https://apify.com/cirkit/google-shopping-scraper)
- [Google News Scraper](https://apify.com/cirkit/google-news-scraper)
- [Google Trends Scraper](https://apify.com/cirkit/google-trends-scraper)
- [YouTube Video Search Scraper](https://apify.com/cirkit/youtube-video-search-scraper)

### Changelog

**0.1** (2026-09-16) First release. Domain, advertiser name, advertiser ID and pasted URL input, 58 regions, format and platform filters, ad-check mode, opt-in ad copy extraction and A/B variations.

# Actor input Schema

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

Website domains the ads link to, for example nike.com. This is the most reliable way to find a company's ads because it catches every advertiser account the company uses. Scheme, www and paths are stripped for you.

## `advertiserNames` (type: `array`):

Brand names to look up in the Transparency Center's own advertiser directory, for example Nike. Matching is a prefix match on the advertiser's registered legal name, so a domain works better when you know it.

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

Transparency Center advertiser IDs, which start with AR and appear in the advertiser page URL, for example AR16735076323512287233.

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

Advertiser or domain-search URLs copied straight from adstransparency.google.com. The advertiser ID, the domain and the region are read out of each URL.

## `resultType` (type: `string`):

ads returns one row per ad creative. advertisers returns one summary row per matching advertiser with Google's approximate ad count, which is the cheap way to check whether a list of companies runs Google Ads at all. advertisers only reads the Advertiser names field.

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

Two-letter country code for the country the ads were shown in. The Transparency Center is region-scoped, so the same advertiser returns a different set of ads in every country.

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

Keep only one format. TEXT covers Search and Shopping ads and is the format that carries ad copy. IMAGE covers display banners. VIDEO covers YouTube ads.

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

Keep only ads served on these Google surfaces. Leave empty for all of them. Google only records the surface for ads shown on or after 2023-09-04, so any selection here hides everything older.

## `maxItems` (type: `integer`):

Stop after this many rows across all targets. Set 0 for everything the Transparency Center will serve, which for a large advertiser can be tens of thousands of ads.

## `extractAdCopy` (type: `boolean`):

Fetch each ad's rendered preview and read the headline out of it. Only text, video and rich-media ads have a preview to read, and the headline comes back on roughly half of those, so expect nulls elsewhere. Adds about 1.5 seconds per ad.

## `includeVariations` (type: `boolean`):

Fetch every A/B variation Google holds for each ad and attach them to the row. Adds one request per ad.

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

Google rate-limits by IP, so the actor rotates the exit node whenever it is throttled. The Apify datacenter pool is enough; residential proxies are not needed for this target.

## Actor input object example

```json
{
  "domains": [
    "nike.com",
    "hellofresh.com"
  ],
  "advertiserNames": [
    "Nike"
  ],
  "advertiserIds": [
    "AR16735076323512287233"
  ],
  "startUrls": [
    "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US"
  ],
  "resultType": "ads",
  "region": "US",
  "adFormat": "ANY",
  "platforms": [],
  "maxItems": 50,
  "extractAdCopy": false,
  "includeVariations": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Everything this run collected as the Ads table: advertiser, domain, format, ad headline, first and last shown, days running, creative image and the link back to the ad's Transparency Center page.

## `campaigns` (type: `string`):

The same ads grouped by Google's internal ids: ad account, ad group and creative id, so ads from one campaign can be clustered without guessing.

## `advertisers` (type: `string`):

Ad-check output: one row per advertiser with the country, the verification badge and Google's approximate ad count range.

## `adsCsv` (type: `string`):

The full result set as CSV, ready for a spreadsheet, a swipe file or a BI tool.

## `consoleRun` (type: `string`):

The Apify Console page for this run, including the live log.

# 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"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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