# Google Ads Transparency Scraper | Google Ads Library & Ad Spy (`automatic/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center (Google Ads Library) by brand, domain or advertiser ID: every ad with format, dates, creatives, platforms and regions. Filter by country, date, format and YouTube/Search/Shopping. Only-new-ads mode for scheduled ad alerts.

- **URL**: https://apify.com/automatic/google-ads-transparency-scraper.md
- **Developed by:** [Philip Kirkbride](https://apify.com/automatic) (community)
- **Categories:** Marketing, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.

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

See every ad a competitor runs on Google. This Google Ads Transparency Scraper reads the Google Ads Transparency Center (the public Google Ads Library) and turns it into a clean spreadsheet: one row per ad with its format, the days it was first and last shown, the image or video creative, a direct link to the ad, and the advertiser's country and verified legal name.

Type a brand name (Nike), a website (nike.com), an advertiser ID or paste a Transparency Center link, press Start, and get hundreds of ads in a minute. Filter by country, date range, format and Google platform (Search, YouTube, Shopping, Maps, Play). Put it on a schedule with **Only new ads** and it becomes an ad spy alert feed: each run returns just the ads that appeared since the previous one. No Google account needed.

### Use cases

- **Competitor ad research**: everything a competitor runs on Google Search, YouTube, Shopping, Maps and Play, with formats, creatives and how long each ad has been live.
- **New-ad alerts for agencies**: schedule your competitor list daily or weekly with `onlyNewSinceLastRun` and get only the fresh creatives, ready for Slack, email or a sheet.
- **Creative libraries and swipe files**: collect the images and video ads a brand tests and see which ones survive for months.
- **YouTube and Shopping ad tracking**: use `platforms` to keep only the ads a brand runs on YouTube, or only its Shopping ads.
- **Market and region analysis**: see where an advertiser advertises, with per-country dates and impression ranges.
- **Lead generation and due diligence**: find the verified advertiser accounts behind a website, with their legal name and country.

### Also available

The Google data suite: pick the job.

| Actor | Use when |
|---|---|
| **Google Ads Transparency (this Actor)** | Ads an advertiser runs, by region |
| [Facebook Ads Library](https://apify.com/automatic/facebook-ads-library-scraper) | Meta ads by keyword or advertiser |
| [Google Search Results](https://apify.com/automatic/google-search-results-scraper) | Rankings, snippets and AI Overviews per query |
| [Google Shopping](https://apify.com/automatic/google-shopping-scraper) | Product offers and prices across stores |
| [Google Trends](https://apify.com/automatic/google-trends-scraper) | Search interest over time and by region |

### Quick Start

```json
{
  "advertisers": ["nike.com"],
  "maxAdsPerAdvertiser": 50
}
```

Only YouTube ads shown in the US, with per-country details:

```json
{
  "advertisers": ["AR16735076323512287233"],
  "region": "US",
  "platforms": ["youtube"],
  "maxAdsPerAdvertiser": 20,
  "includeDetails": true
}
```

A daily new-ad feed for two competitors:

```json
{
  "advertisers": ["nike.com", "adidas.com"],
  "maxAdsPerAdvertiser": 30,
  "onlyNewSinceLastRun": true,
  "monitorName": "sportswear-daily"
}
```

### Input

| Input | Type | Default | Meaning |
| --- | --- | --- | --- |
| `advertisers` | array | — | Advertiser names, domains or advertiser IDs. Links copied from the Transparency Center also work: an advertiser page, an ad's page or a domain search (`?domain=nike.com`). Each entry lists that advertiser's ads. |
| `region` | string | `all` | Only ads shown in this country, as a two-letter code (`US`, `GB`, `DE`...), or `all`. |
| `dateRange` | object | empty | Optional `{"from": "YYYY-MM-DD", "to": "YYYY-MM-DD"}`: only ads served in that window, both days included. Leave a side empty for an open range. |
| `format` | string | `all` | `all`, `text`, `image` or `video`. |
| `platforms` | array | all | Optional: only ads shown on these Google platforms: `search`, `youtube`, `shopping`, `maps`, `play`. |
| `maxAdsPerAdvertiser` | integer | `50` | Stop each advertiser account after this many ads (up to 5,000). A domain can match several accounts (for example, `nike.com` matches five), and the limit applies to each one. |
| `maxAdvertisersPerName` | integer | `1` | How many advertiser accounts a name lists: the exact match first, then the closest matches (up to 20). |
| `includeDetails` | boolean | `false` | Add each ad's detail page: the countries it was shown in with their own dates and impression ranges, the landing page, who paid, the platforms and the published targeting. |
| `onlyNewSinceLastRun` | boolean | `false` | Return only ads this Actor has not delivered to you before, so a schedule becomes an alert feed. |
| `monitorName` | string | empty | Optional name for an alert feed (for example `competitors-us`), so separate schedules keep separate histories. |

A run without the `advertisers` field runs a small built-in example (a well-known brand, five ads per advertiser) and says so in the run status, so you can see the output before a bigger run. An explicit empty list (`"advertisers": []`) ends the run with no rows and says which field to fill in, so a pipeline that sends no advertisers is never charged for the example.

#### Names, domains and IDs

- **A name** (`Nike`, `Nike, Inc.`) is searched in the Transparency Center and the best match is listed (or several, with `maxAdvertisersPerName`). The run summary shows which advertiser each name resolved to.
- **A domain** (`nike.com`) lists every advertiser that put that domain on its ads, up to five, each with its own limit. This is usually what you want for a brand: large brands advertise from several registered accounts.
- **An advertiser ID** (`AR06641858037806006273`, or an advertiser or ad link) is used directly. Filters come from the form, not from a pasted link.

### Example queries

- `{"advertisers": ["temu.com"], "region": "GB", "maxAdsPerAdvertiser": 200}`: the ads Temu's accounts show in the UK.
- `{"advertisers": ["Nike"], "maxAdvertisersPerName": 3, "format": "video"}`: video ads of the three closest "Nike" advertisers.
- `{"advertisers": ["hellofresh.com"], "platforms": ["youtube"], "dateRange": {"from": "2026-10-01"}}`: HelloFresh's YouTube ads since October.
- `{"advertisers": ["nike.com", "adidas.com"], "onlyNewSinceLastRun": true}`: on a daily schedule, only the ads that are new since yesterday.

### What it returns

The dataset contains one row per ad:

| Field | Meaning |
| --- | --- |
| `kind` | `ad` for every dataset row. |
| `advertiserId`, `advertiserName` | The advertiser in the Transparency Center. |
| `advertiserCountry`, `advertiserLegalName`, `advertiserVerified` | The advertiser's country, verified legal name and whether it completed Google's advertiser verification. |
| `adId` | The ad's creative ID. |
| `format` | `text`, `image` or `video`. |
| `firstShown`, `lastShown` | First and last day the ad was shown, `YYYY-MM-DD`. |
| `regions` | Countries the ad was shown in, as codes (with `includeDetails`). |
| `regionShownDates` | With details: per country, its own first and last day, the impression range and, when published, impressions per platform. |
| `platforms` | With details, when published: the Google platforms the ad was shown on. |
| `targeting` | With details, when published: whether demographics, geography, contextual signals, topics of interest and customer lists were used, plus included and excluded regions. |
| `text` | Ad copy, when the Transparency Center publishes it as text; most ads are published as the creative itself (see `imageUrls`, `previewHtml`). |
| `imageUrls` | Image links in the ad's creative. |
| `videoUrls` | Direct video links; video ads are served as a player, so use `previewUrl` for those. |
| `previewUrl` | The ad's own player or preview link, for video and interactive ads. |
| `previewHtml` | The small HTML snippet the Transparency Center renders for the ad. |
| `landingUrl` | The ad's landing page, when published (with details). |
| `transparencyUrl` | Link to the ad in the Google Ads Transparency Center. |
| `advertiserUnverified` | Whether the ad list marks the advertiser as unverified. |
| `servedDays` | How many days the ad was served. |
| `matchedDomain` | The domain that matched, when the advertiser was found through a domain. |
| `impressionsLowerBound`, `impressionsUpperBound` | Published impression range, when the ad has one (with details). |
| `endPayerName` | Who paid for the ad, when published (with details). |
| `containsSyntheticMedia` | Whether the ad is flagged as containing AI-generated media (with details). |
| `variantCount` | How many versions of the creative exist (with details). |
| `searchInput` | The advertisers entry this row came from. |
| `scrapedAt` | Collection time (UTC). |

The run summary (`OUTPUT`) lists each advertiser with the number of ads and pages returned and how it ended:

| Field | Meaning |
| --- | --- |
| `ads` | Ads this advertiser delivered. |
| `pages` | Result pages read. |
| `duplicates` | Ads already delivered in this run. |
| `alreadySeen` | With `onlyNewSinceLastRun`: ads skipped (and not charged) because an earlier run delivered them. |
| `availableAds` | How many ads the Transparency Center says the advertiser has, when it says. |
| `complete` | `true` only when the Actor reached the end of the advertiser's ads, so nothing is missing. |
| `stopReason` | `null` when `complete`; otherwise `maxAdsPerAdvertiser` (your limit), `chargeLimit` (your maximum charge), `noNewAds` (with `onlyNewSinceLastRun`, the rest was already there at the previous run), `timeout` (the run deadline), `safetyStop` or `error`. |
| `error` | `NO_RESULTS` (nothing matched), `NO_NEW_ADS` (nothing new since the last run), `SAFETY_STOP`, or the source's error code. |

`OUTPUT.advertisersComplete` and `OUTPUT.advertisersIncomplete` count the advertisers read to the end and those stopped by a limit or a failure. `OUTPUT.advertiserErrors` lists every advertiser that failed or stopped early with the ads it delivered. `OUTPUT.notFound` counts names or domains that matched no advertiser.

### Output example

```json
{
  "kind": "ad",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "adId": "CR01820856573459693569",
  "format": "text",
  "firstShown": "2023-11-17",
  "lastShown": "2026-11-09",
  "regions": ["US"],
  "regionShownDates": [
    {
      "region": "US",
      "firstShown": null,
      "lastShown": "2026-11-09",
      "impressionsLowerBound": null,
      "impressionsUpperBound": null
    }
  ],
  "text": null,
  "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/2991038131184986142"],
  "videoUrls": [],
  "previewUrl": null,
  "previewHtml": "<img src=\"https://tpc.googlesyndication.com/archive/simgad/2991038131184986142\" height=\"223\" width=\"348\">",
  "landingUrl": null,
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR01820856573459693569",
  "advertiserUnverified": null,
  "servedDays": 901,
  "matchedDomain": null,
  "impressionsLowerBound": null,
  "impressionsUpperBound": null,
  "endPayerName": "Nike, Inc.",
  "containsSyntheticMedia": null,
  "variantCount": 4,
  "advertiserCountry": "US",
  "advertiserLegalName": "Nike, Inc.",
  "advertiserVerified": true,
  "platforms": null,
  "targeting": null,
  "searchInput": "AR16735076323512287233",
  "scrapedAt": "2026-11-09T19:35:35+00:00"
}
```

### Pricing

**$1.50 per 1,000 ads** ($0.0015 per ad) plus **$0.005 per run start** at the default 1 GB of memory. Ads with details cost the same per ad. Ads skipped by **Only new ads**, advertisers that match nothing and the run summary are free. Set a maximum charge per run to cap any run.

### Good to know

- **Alert feeds**: with `onlyNewSinceLastRun`, ads you already received are skipped even while they keep running, and the Actor reads on until it reaches ads that were already there at your previous run. The first run of a feed delivers the current ads up to your limit; later runs deliver what is new. The history is kept per advertiser in your own Apify storage; use `monitorName` to keep separate feeds apart.
- **Ad copy**: the Transparency Center publishes most ads as the creative that ran (an image, or a player for video and interactive ads), so `text` is usually empty and the creative is in `imageUrls`, `previewHtml` and `previewUrl`.
- **Regions, platforms and targeting need details**: they come from each ad's detail page, so `includeDetails` adds one request per ad and roughly doubles the run time. Platform breakdowns and targeting appear only where Google publishes them (mostly ads shown in the EU and political ads).
- **Date ranges cover about the last year**: Google filters by served date within roughly the past 12 months.
- Totals are approximate: Google publishes a range (for example "1,000–2,000 ads"), and `availableAds` gives the upper bound.
- Ads already returned in the same run are not repeated, even when a name and a domain resolve to the same advertiser.
- An advertiser that fails is reported in the run summary and the rest of the run continues. A run that ends with no ads because nothing matched finishes with `OUTPUT.status` `no_results` and says so; only when the source refuses the requests and nothing can be read does the run fail with a clear status message. An `advertisers` entry that is not an advertiser ID, domain, name or Transparency Center link is skipped into `OUTPUT.skippedSearches` while the others still run.
- Media links can expire; download the ones you want to keep soon after the run.
- The Transparency Center is a public source published under advertising-transparency rules. Use this Actor only where you have a lawful basis for the data you collect.

# Actor input Schema

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

Advertiser names (Nike), domains (nike.com) or advertiser IDs (AR06641858037806006273). Links copied from the Google Ads Transparency Center also work: an advertiser page, an ad's page or a domain search. Each entry lists that advertiser's ads.

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

Only ads shown in this country, as a two-letter country code (US, GB, DE...), or all for every country.

## `dateRange` (type: `object`):

Optional: only ads served between these days. Leave a side empty for an open range. Dates are YYYY-MM-DD.

## `format` (type: `string`):

Limit results to one ad format.

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

Optional: only ads shown on these Google platforms. Leave empty for every platform.

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

Stop each advertiser account after this many ads. A domain or name can match several accounts (nike.com matches five), and the limit applies to each one.

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

How many matching advertiser accounts a name (Nike) lists: the exact match first, then the closest matches. Leave empty for the single best match.

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

Fetch each ad's detail page for the countries it was shown in with their own dates, landing page and impressions. This costs one extra request per ad, so the run is slower.

## `onlyNewSinceLastRun` (type: `boolean`):

Return only ads this actor has not delivered before. Run the same input on a schedule and each run returns just the new ads, which makes the Actor an alert feed of new creatives.

## `monitorName` (type: `string`):

Optional, with Only new ads: a name for this watch (for example competitors-us), so separate schedules keep separate histories. Leave empty to share one history per advertiser.

## Actor input object example

```json
{
  "advertisers": [
    "nike.com"
  ],
  "region": "all",
  "format": "all",
  "maxAdsPerAdvertiser": 50,
  "includeDetails": false,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

# 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.com"
    ],
    "region": "all",
    "format": "all",
    "maxAdsPerAdvertiser": 50,
    "includeDetails": false,
    "onlyNewSinceLastRun": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automatic/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.com"],
    "region": "all",
    "format": "all",
    "maxAdsPerAdvertiser": 50,
    "includeDetails": False,
    "onlyNewSinceLastRun": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automatic/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.com"
  ],
  "region": "all",
  "format": "all",
  "maxAdsPerAdvertiser": 50,
  "includeDetails": false,
  "onlyNewSinceLastRun": false
}' |
apify call automatic/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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