# Google Ads Transparency Scraper (`lergassy/google-ads-transparency-scraper`) Actor

\[$1/1K ads] Every ad an advertiser runs, from the Google Ads Transparency Center: creative ID, format (text, image, video), first and last shown, preview and image URLs, shopping product title, regions. Search by name, ID or domain; filter by country and format. No fee per run, no browser.

- **URL**: https://apify.com/lergassy/google-ads-transparency-scraper.md
- **Developed by:** [Matvey](https://apify.com/lergassy) (community)
- **Categories:** Marketing, Lead generation, Agents
- **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

Every ad an advertiser runs on Google — search, display, shopping and YouTube — as rows from the Google Ads Transparency Center. Give it advertiser names, IDs or domains and get creative ID, format, first and last shown dates, preview and image URLs, shopping product titles, and, with details on, every country the ad ran in. **$1 per 1,000 ads, no fee per run, no fee per advertiser, error rows free.**

### What is Google Ads Transparency Scraper?

The [Ads Transparency Center](https://adstransparency.google.com/) is where Google publishes the ads of every verified advertiser: what they look like, when they ran, and where. It has no export and no API. This Actor reads the Center's own data endpoints — no browser, no login, no captcha — and returns the ads as a flat table you can download as JSON, CSV or Excel or pull through the API. One advertiser or five hundred in a run; each is billed only for the ads it returns.

It is built for the people who look at competitors' ads for a living: performance-marketing agencies, brand and competitive-intelligence teams, ad-creative researchers, and anyone building a dataset of what a market advertises.

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

| Field | What it holds |
|---|---|
| `advertiserId`, `advertiserName`, `advertiserCountry`, `advertiserUrl` | The verified advertiser, its ID (AR…), verification country and page in the Center |
| `creativeId`, `adUrl` | The ad's ID (CR…) and its page in the Center |
| `format` | `TEXT` (search ads), `IMAGE` (display and shopping), `VIDEO` (YouTube) |
| `firstShown`, `lastShown` | First and most recent time Google served the ad |
| `imageUrl` | Direct image of the creative when Google serves one (text ads come as rendered screenshots) |
| `previewUrl` | Google's rendered preview of the creative — embeddable, opens in a browser |
| `productTitle`, `productBrand`, `productImageUrl` | Shopping ads: the product behind the ad |
| `regions` ($) | With details: every country the ad was shown in, each with its last-shown date |
| `variantCount`, `variants` ($) | With details: how many variants of the creative exist and their previews |
| `query`, `scrapedAt` | What you asked for and when the row was taken |

Every row carries `type: "ad"`. A query that cannot be served — unknown advertiser, no ads in the chosen region — produces one `type: "error"` row that says what to try instead; error rows cost nothing.

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

Two events, both per ad: **$0.001 per ad** on the free plan (down to $0.0006 on the highest plans), and an optional **$0.002 per ad** for details (regions with dates and all variants — one extra request per ad). No fee per run, no fee per advertiser, no fee per page, no proxy charge.

| Plan | Per ad | Per ad with details | Ads per $1 |
|---|---|---|---|
| Free | $0.001 | $0.003 | 1,000 |
| Bronze | $0.0009 | $0.0027 | 1,111 |
| Silver | $0.0008 | $0.0024 | 1,250 |
| Gold | $0.0007 | $0.0021 | 1,428 |
| Platinum, Diamond | $0.0006 | $0.0018 | 1,666 |

The $5 of free monthly credit on Apify's free plan buys 5,000 ads. Nike's complete library of 10,000 ads costs $10.

#### Bulk export: what 50,000 ads actually cost

This Actor is built for volume — a list of every advertiser in a category, run weekly. Because there is no fee per run and no fee per advertiser, the bill is the number of ads you keep and nothing else.

| Job | This Actor | Most-used Actor in this category |
|---|---|---|
| 50,000 ads across 100 runs | **$50** | $75 |

Checked on the Apify Store on 23 September 2026 against the Actor with the most monthly users for "google ads transparency"; its per-run fee is counted in, as ours would be if we charged one. Some Actors here ask less per row — this table compares against the one buyers actually use most.

### How to scrape Google ads of any advertiser

1. Type the advertiser as you would in the Center: a name (`Nike`), the ID from an advertiser page URL (`AR16735076323512287233`) or a domain (`nike.com`).
2. Set **Ads per advertiser** — 40 is one page, 10,000 is the ceiling per advertiser per run.
3. Optionally pick a **Region** (`US`, `GB`, `ID`…) and **formats**, and switch on **details** for the country list.
4. Press **Start**. Download the table, or read it through the API.

A name picks the single best match: among advertisers whose name starts with what you typed, the one with the most ads. Switch on **Take every advertiser that matches** to get all legal entities of a brand.

### ⬇️ Input

#### The newest 25 ads of Nike and Adidas (the form's default — runs in about 10 seconds)

```json
{
  "advertisers": ["Nike", "Adidas"],
  "maxAdsPerAdvertiser": 25
}
```

#### Every video ad Booking.com runs in Germany, with the country list

```json
{
  "advertisers": ["booking.com"],
  "region": "DE",
  "formats": ["VIDEO"],
  "maxAdsPerAdvertiser": 2000,
  "includeDetails": true
}
```

#### A competitor set by advertiser ID, weekly

```json
{
  "advertisers": ["AR16735076323512287233", "AR18378488041124659201", "AR01437837420136497153"],
  "maxAdsPerAdvertiser": 500
}
```

### ⬆️ Output

```json
{
  "type": "ad",
  "query": "Nike",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserCountry": "US",
  "creativeId": "CR12805937033067364353",
  "format": "IMAGE",
  "firstShown": "2026-05-05T16:29:29.000Z",
  "lastShown": "2026-09-22T22:50:14.000Z",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR12805937033067364353?region=anywhere",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=anywhere",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&…",
  "imageUrl": null,
  "productTitle": "Nike Men's G.T. Cut Basketball Shoes in Pink, Size: 18 | CZ0175-600",
  "productBrand": "Nike",
  "productImageUrl": "https://encrypted-tbn0.gstatic.com/shopping?q=tbn:ANd9GcRl5wmLXmbGRqiLuOjmJ-eA-78vLK6J2RgxvxakYKNVjj4-e4Ib",
  "regions": [{ "region": "US", "lastShown": "2026-09-01" }],
  "variantCount": 3,
  "scrapedAt": "2026-09-23T06:02:11.000Z"
}
```

Export as JSON, CSV, Excel, XML or RSS from the **Dataset** tab, or fetch the same rows with one API call.

### Use cases for Google Ads Transparency data

#### Competitive intelligence

Pull a competitor's whole library once, then weekly: new creatives, dropped creatives, which formats they lean on, how long their winners run (`firstShown` → `lastShown`).

#### Agency prospecting

Which advertisers in a domain list are active, in which countries, with what — a first look at a prospect's Google spend before the call.

#### Creative research

Thousands of live ad previews and product titles by vertical, as data rather than screenshots.

#### Market and regulatory research

Where an advertiser runs, and since when — the public record, in bulk.

### Integrations and Google Ads Transparency API

Run the Actor from your own code with the [Apify API](https://docs.apify.com/api/v2) or the Python and JavaScript clients, from n8n, Make and Zapier through the Apify nodes, straight into Google Sheets, or on a schedule with a webhook when the run finishes:

```
https://api.apify.com/v2/acts/lergassy~google-ads-transparency-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN
```

#### Use it from Claude, Cursor or any MCP agent

Every Apify Actor is available as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Add the server and an agent can ask "what is Adidas advertising in Germany right now" and get rows back.

### 🤖 For AI Agents & LLM Apps

- One row type, flat fields; `regions` and `variants` are the only arrays and appear only with details on.
- `format` is one of three constants; dates are ISO.
- `adUrl` opens the human view of the same ad for verification.
- Error rows carry `type: "error"` with a plain-English `error` string and cost nothing.

### Troubleshooting

- **Error row "No advertiser with this name"** — the Center only knows verified advertisers by their legal name. Open adstransparency.google.com, search, and use the name or ID it shows, or the advertiser's domain.
- **Fewer ads than the Center shows** — the region or format filter narrowed the set; try `anywhere` and no formats.
- **`imageUrl` empty** — image and video creatives come as a rendered preview (`previewUrl`), which opens in a browser; text ads come as a screenshot in `imageUrl`. Switch on details to get all variants.

### ❓ FAQ

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

The Center is a public disclosure Google publishes for exactly this purpose — anyone can look at any advertiser's ads without logging in, and the Actor reads only that. The data is about companies and their ads, not private individuals. How you use it is subject to the laws of your country.

#### Does Google have an Ads Transparency API?

No public one. There is a downloadable political-ads report and nothing for commercial advertisers. This Actor is the practical alternative.

#### How far back does it go?

As far as the Center keeps the ad — `firstShown` on many creatives goes back to 2021.

#### Can I search by keyword or topic?

The Center indexes advertisers, not ad text. Use names, IDs or domains; a domain returns ads from every advertiser that uses it.

#### Do I need proxies?

No. Apify datacenter proxies are included and enough; the Center answers them without a captcha.

#### What happens on an error?

You get an error row that explains the problem in plain words. Error rows are never billed.

### Your feedback

If a field is missing or an advertiser does not resolve, open an issue on the Actor page with the query — it is usually fixed within a day. If the Actor saved you time, a review on the Store helps other buyers find it.

### You might also like

| Actor | What it does |
|---|---|
| [Meta Ad Library Scraper](https://apify.com/lergassy/meta-ad-library-scraper) | Ads from the Meta Ad Library: Facebook and Instagram |
| [Website Tech Gap Scanner](https://apify.com/lergassy/website-tech-gap-scanner) | What a website runs and what it is missing — tracking, analytics, ads pixels |
| [Website Contacts API](https://apify.com/lergassy/website-contacts-api) | E-mails, phones and social profiles from any website |
| [Shopify Store Intel](https://apify.com/lergassy/shopify-store-intel) | Products, prices, apps and traffic signals of any Shopify store |
| [Threads Scraper](https://apify.com/lergassy/threads-scraper) | Posts, profiles and replies from Threads |

# Actor input Schema

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

One per line: an advertiser name as shown in the Ads Transparency Center (<code>Nike</code>), an advertiser ID (<code>AR16735076323512287233</code>) or a domain (<code>nike.com</code> — returns ads from every advertiser using that domain). Hundreds per run are fine; each is billed only for the ads it returns.

## `maxAdsPerAdvertiser` (type: `integer`):

How many ads to take from each advertiser, newest first. Google serves 40 per page; up to 10,000 per advertiser per run.

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

<code>anywhere</code> for all countries, or a two-letter country code to keep only ads shown there: <code>US</code>, <code>GB</code>, <code>DE</code>, <code>ID</code>, <code>AU</code>…

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

Keep only these formats. Empty = all.

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

One extra request per ad: every country the ad was shown in with the last-shown date there, and all preview variants of the creative. Billed as a separate event.

## `matchAll` (type: `boolean`):

By default a name picks the single best match (the advertiser with the most ads whose name starts with what you typed). Turn on to scrape every advertiser Google suggests for the name — useful for brands with many legal entities.

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

Apify datacenter proxies by default; the Transparency Center answers them without a captcha. Residential is not needed.

## Actor input object example

```json
{
  "advertisers": [
    "Nike",
    "Adidas"
  ],
  "maxAdsPerAdvertiser": 25,
  "region": "anywhere",
  "includeDetails": false,
  "matchAll": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One flat row per ad: advertiser ID and name, creative ID, format, first and last shown, link to the ad in the Transparency Center, preview URL, direct image URL, shopping product title and image, and with details on: regions with last-shown dates and preview variants.

# 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",
        "Adidas"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lergassy/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",
        "Adidas",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lergassy/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",
    "Adidas"
  ]
}' |
apify call lergassy/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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