# Google Ads Transparency Scraper — Cheap Ad Library Export (`fabrikit/google-ads-transparency-scraper`) Actor

Google Ads Transparency Scraper: export ads from Google's Ads Transparency Center by advertiser name, advertiser ID, domain or URL. Creative ID, format (text/image/video), first/last shown dates, regions, image and preview URLs. No login. Pay per result, no subscription.

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

## Pricing

from $1.00 / 1,000 ad scrapeds

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

## Google Ads Transparency Scraper — Cheap Ad Library Export

Export ads from the **Google Ads Transparency Center** without a login, browser or API key. Give it advertiser names, advertiser IDs (`AR...`), domains or Transparency Center URLs and get one clean row per ad creative: format, first and last shown dates, image URL, preview URL, optional regions and a direct link to the ad.

Pay per ad exported. Plain HTTP, no browser: 300 ads take about 20 seconds.

### What you get

- Look up advertisers by **name**, **ID**, **domain** (ads whose landing domain matches) or a **Transparency Center URL**.
- Filter by **region** (any country or "anywhere"), **date range** and **format** (text, image, video).
- Each ad: `advertiserId`, `advertiserName`, `creativeId`, `format`, `firstShown`, `lastShown`, `imageUrl`, `previewUrl`, `adUrl`.
- Optional **creative details**: every region the ad ran in (with last-seen date), number of variations and all image URLs.
- Pagination handled for you, deduplicated by creative ID, exact `maxItems` limit.

### Who it is for

- **Marketers and media buyers** who want to see every Google ad a competitor is running, how long each creative has been live and where it ran.
- **Agencies** preparing pitches and creative audits for a prospect's brand and its rivals.
- **Brand-protection and legal teams** checking who advertises on their brand or trademark-like domains.
- **Sales teams** building lists of companies that are actively spending on Google Ads in a niche or country.
- **Researchers and journalists** studying advertising activity by advertiser, format and region.

### How to scrape the Google Ads Transparency Center

1. Add one or more entries to **Advertisers, domains or URLs**: a brand name (`Coca-Cola`), an advertiser ID (`AR16735076323512287233`), a domain (`nike.com`) or a Transparency Center link.
2. Optionally pick a **region**, **formats** and a **date window**.
3. Set **Max ads** (total) and, if you query several advertisers, **Max ads per query** so one big advertiser does not use the whole budget.
4. Turn on **creative details** if you need the list of regions, last-seen dates per region and the number of variations.
5. Run it and download the dataset as JSON, CSV or Excel.

### Input example

```json
{
    "queries": ["nike.com", "Coca-Cola", "AR16735076323512287233"],
    "maxItems": 200,
    "maxItemsPerQuery": 100,
    "region": "US",
    "formats": ["image"],
    "startDate": "2026-01-01",
    "includeDetails": false
}
```

| Field | Meaning |
| --- | --- |
| `queries` | Advertiser names, `AR...` IDs, domains or Transparency Center URLs. Names resolve to the closest advertiser with the most ads (switch `advertiserMatch` to `all` to scrape every suggestion). |
| `maxItems` / `maxItemsPerQuery` | Total cap (default 50) and optional cap per advertiser/domain. |
| `region` | ISO country code (`US`, `GB`, `DE`, `BR`...) or `anywhere`. |
| `formats` | `text`, `image`, `video`. Empty = all. |
| `startDate` / `endDate` | `YYYY-MM-DD` window in which the ad was shown. |
| `includeDetails` | Adds regions, variations and all image URLs (extra event, see pricing). |
| `advertiserMatch` / `maxAdvertisersPerName` | `best` (default) or `all` suggested advertisers for a name; with `all`, up to 5 advertisers per name by default (max 10). |
| `proxyConfiguration` | Starts on datacenter proxy and falls back to residential automatically if Google blocks. |

#### More input examples

A competitor's ads anywhere in the world (the "See a competitor's Google ads" example task):

```json
{ "queries": ["nike.com"], "region": "anywhere", "maxItems": 50 }
```

Ads shown in Argentina for one domain (the "Google ads shown in Argentina" task):

```json
{ "queries": ["mercadolibre.com.ar"], "region": "AR", "maxItems": 50 }
```

Video ads from every advertiser that matches a name, with region details:

```json
{
    "queries": ["Spotify"],
    "advertiserMatch": "all",
    "maxAdvertisersPerName": 3,
    "formats": ["video"],
    "includeDetails": true,
    "maxItems": 100
}
```

### Output example

```json
{
    "advertiserId": "AR16735076323512287233",
    "advertiserName": "Nike, Inc.",
    "advertiserCountry": "US",
    "creativeId": "CR13600979056295149569",
    "format": "image",
    "firstShown": "2022-12-30T14:51:36.000Z",
    "lastShown": "2026-10-13T11:46:33.000Z",
    "regions": ["US"],
    "regionsLastSeen": { "US": "2026-09-01" },
    "variationCount": 3,
    "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/5409490591553474264",
    "imageWidth": 348,
    "imageHeight": 295,
    "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/5409490591553474264"],
    "previewUrl": null,
    "landingDomain": null,
    "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR13600979056295149569?region=anywhere",
    "searchQuery": "Nike",
    "searchRegion": "anywhere",
    "scrapedAt": "2026-10-13T12:00:00.000Z"
}
```

`regions`, `regionsLastSeen`, `variationCount` and `imageUrls` are `null` unless `includeDetails` is on. `imageUrl` is set for image ads; text and video ads carry a `previewUrl` (Google's renderer link). `landingDomain` is filled when you search by domain.

#### Output fields

| Field | Description |
| --- | --- |
| `advertiserId` | Transparency Center advertiser ID (`AR...`). |
| `advertiserName` | Verified advertiser name. |
| `advertiserCountry` | Advertiser's country, when shown. |
| `creativeId` | Creative ID (`CR...`), unique per ad. |
| `format` | `text`, `image` or `video`. |
| `firstShown` / `lastShown` | First and last time Google showed the ad (ISO 8601). |
| `regions` | Countries where the ad ran (details only). |
| `regionsLastSeen` | Last-seen date per region (details only). |
| `variationCount` | Number of variations of the creative (details only). |
| `imageUrl`, `imageWidth`, `imageHeight` | Main image of an image ad and its size. |
| `imageUrls` | All image URLs of the creative (details only). |
| `previewUrl` | Google's preview renderer link for text and video ads. |
| `landingDomain` | The domain you searched for, when the query was a domain. |
| `adUrl` | Direct link to the ad in the Transparency Center. |
| `searchQuery` / `searchRegion` | The query and region that produced the row. |
| `scrapedAt` | When the row was collected. |

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

| Event | When it is charged |
| --- | --- |
| `apify-actor-start` | Once per run (a fraction of a cent) |
| `ad-result` | Per ad saved |
| `ad-details` | Per ad whose details were fetched, only when `includeDetails` is on |

From 30 October 2026, 1,000 ads cost US$2 on the Apify Free plan; paid Apify plans pay less per ad — see the **Pricing** tab. Creative details add US$1 per 1,000 ads on every plan, and are only charged for ads whose details were actually retrieved.

### FAQ

**Do I need a Google account or API key?** No. Only public Transparency Center data is read.

**Can I get the text of text ads or the video file?** Google renders those in a script-driven preview. You get the `previewUrl` and `adUrl`; the text and video asset themselves are not exposed as plain data.

**Why did my name search pick a different advertiser?** Names resolve to the best match with the most ads. Use the advertiser ID or `advertiserMatch: all` for exact control.

**Does it only return my country?** `region: anywhere` returns ads shown anywhere. Pick a country to restrict.

**Are individuals included?** The Transparency Center lists legal advertisers. Use the tool for company research and respect applicable data-protection rules.

**Why did I get 0 ads?** The advertiser may not run ads in the chosen region or date window, or the name matched a different advertiser. The run still succeeds and logs a warning; try `region: anywhere`, remove date filters, or use the advertiser ID. If Google blocks every proxy tier, the run fails with a clear error instead of returning an empty dataset.

**How do I monitor a competitor's new ads?** Save the input as a task with a recent `startDate` and schedule it weekly. Compare `creativeId` and `firstShown` with the previous run to spot new creatives.

**Can I filter by more than one format?** Yes. With one format the filter is applied by Google; with several, the actor filters the results itself.

### Use cases

Competitor ad monitoring, creative research and swipe files, agency pitches, brand-safety and trademark checks, lead lists of active advertisers in a niche, regional campaign audits.

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

Google publishes the Ads Transparency Center so that anyone can see who is advertising, and this actor only collects what the site shows publicly without logging in. Advertisers are verified businesses or organisations, but some can be individuals, so names may count as personal data under laws such as the EU GDPR, Chile's Ley 21.719 or the California CCPA; make sure your purpose is lawful and keep only what you need. Ad images and texts are the advertisers' creative work, so do not republish them as your own. You are also responsible for respecting Google's terms of service. This is general information, not legal advice.

### Integrations

Run the Google Ads Transparency Scraper from the Apify API or the JavaScript and Python clients, send results onward with webhooks, or schedule weekly competitor checks in Apify Console. It works with n8n, Make and Zapier, and with LangChain and LlamaIndex through their Apify integrations. AI agents in Claude, ChatGPT, Cursor and other MCP clients can find and run it through Apify's MCP server. Download results as JSON, CSV or Excel, or read them from the dataset API.

### Use with AI agents

Use this actor to list the Google ads an advertiser (by name, `AR...` ID or domain) has shown, with format, first/last shown dates, image or preview links and optional regions.

```json
{ "queries": ["nike.com"], "region": "US", "maxItems": 20 }
```

Main output fields: `advertiserName`, `advertiserId`, `creativeId`, `format`, `firstShown`, `lastShown`, `imageUrl`, `previewUrl`, `adUrl`, and with details `regions` and `variationCount`. It is pay-per-event: an agent pays a small start fee plus a fixed price per ad saved, not for compute time.

### Related actors

- [Google Maps Scraper](https://apify.com/fabrikit/google-maps-places-scraper) — find local businesses in a niche, then check which of them advertise.
- [Google Trends Scraper](https://apify.com/fabrikit/google-trends-scraper) — search interest for the products an advertiser promotes.
- [Google News Scraper](https://apify.com/fabrikit/google-news-scraper) — press coverage of a competitor's campaigns.
- [YouTube Scraper](https://apify.com/fabrikit/youtube-videos-scraper) — a brand's YouTube channel and videos.

#### Ready-made examples

- [See a competitor's Google ads](https://apify.com/fabrikit/google-ads-transparency-scraper/examples/competitor-google-ads)
- [Google ads shown in Argentina](https://apify.com/fabrikit/google-ads-transparency-scraper/examples/google-ads-argentina)

### Changelog

- **2026-10-16** — README expanded: how-to, more input examples, output field table, FAQ, legal notes, integrations and example tasks.
- **2026-10-15** — Tiered pricing announced, effective 2026-10-30 (lower per-ad price on paid Apify plans).
- **2026-10-13** — Builds 0.1.1–0.1.2: initial release. Search by advertiser name, ID, domain or URL; region, format and date filters; optional creative details; automatic fallback to residential proxy if Google blocks.

### En español

Exporta anuncios del Centro de Transparencia de Anuncios de Google por nombre de anunciante, ID (`AR...`), dominio o URL, con formato, fechas de primera y última emisión, regiones, imagen y enlace al anuncio. Sin login. Se cobra por anuncio exportado; el precio vigente para tu plan está en la pestaña Pricing.

# Actor input Schema

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

What to look up. Each entry can be an advertiser name (`Nike`), an advertiser ID (`AR16735076323512287233`), a domain (`nike.com`) or a Google Ads Transparency Center URL (`https://adstransparency.google.com/advertiser/AR...` or `...?domain=nike.com`). Names resolve to the advertiser with the most ads unless you switch matching to `all`.

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

Stop after this many ads across all queries.

## `maxItemsPerQuery` (type: `integer`):

Optional cap per advertiser/domain so one big advertiser does not use the whole budget. 0 = no per-query cap.

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

Only ads shown in this country. `anywhere` = all regions.

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

Limit to some formats. Leave empty for text, image and video.

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

Only ads shown on or after this date. Leave empty for no start limit.

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

Only ads shown on or before this date. Leave empty for no end limit.

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

Fetch one extra record per ad to add the list of regions with last-seen dates, the number of variations and all image URLs. Billed as a separate `ad-details` event.

## `advertiserMatch` (type: `string`):

How advertiser NAMES are resolved. `best` picks the closest advertiser with the most ads; `all` scrapes every suggested advertiser.

## `maxAdvertisersPerName` (type: `integer`):

Only used when name matching is `all`.

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

Starts on Apify datacenter proxy and switches to residential automatically if Google blocks the requests.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "maxItems": 50,
  "maxItemsPerQuery": 0,
  "region": "anywhere",
  "formats": [],
  "startDate": "",
  "endDate": "",
  "includeDetails": false,
  "advertiserMatch": "best",
  "maxAdvertisersPerName": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All ads collected during the 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 = {
    "queries": [
        "nike.com"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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