# Google Ads Transparency Center API (`deepmine/google-ads-transparency`) Actor

Google Ads Transparency Center scraper: every Google ad of an advertiser, website or ad link, with image or video, ad text and landing page where shown, countries, dates, EU reach and targeting. Or list advertisers with ad counts. Filter by country, format, platform, dates; only new ads. No login.

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

## Pricing

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

## Google Ads Transparency Center API

Google Ads Transparency scraper and API: type an advertiser name, a website, an advertiser ID or an ad link and get every Google ad they run, with the image or YouTube video, countries and dates, plus headline and ad text where Google shows them.

| Advertiser | Headline | Ad Text | Format | Countries | First Shown | Days Shown |
|---|---|---|---|---|---|---|
| Nike, Inc. | Shop Women's Running Shoes | Put a spring in your step with latest Nike® runnin… | Text | United States | 2023-11-16 | 900 |
| Canva, Pty Ltd | Install now | Canva - Photo Editor with AI - Free AI video generator | Produce more video content with Canva Pro. Remove… | Video | Australia | 2026-06-01 | 122 |
| Nike Retail BV | Nike NOCTA S.S.C. Cap CS - Black - Polyester - Size: L/XL | – | Image | Spain, Poland, United Kingdom +1 | 2021-10-25 | 1,801 | <sub>Collected 2026-09-29 with the prefilled input (`nike.com` and `Canva`, 50 ads each, with ad details).</sub>

**$0.80 per 1,000 ads** on Starter ($0.95 Free, $0.60 Scale, $0.50 Business); with ad details $1.30 per 1,000 ($1.45 Free, $1.10 Scale, $1.00 Business). The prefilled run (100 ads with details) costs about $0.13.

### What you get

For each ad in the [Google Ads Transparency Center](https://adstransparency.google.com/):

- **Who**: the verified advertiser, its ID and a link to all its ads.
- **The ad itself** (with ad details, on by default): the headline, ad text and display URL of search ads, the picture of image ads, the product and photo of Shopping ads, and the YouTube link and thumbnail of video ads.
- **Where and when**: the countries where it was shown, when it was first and last shown, and on how many days.
- **Reach and targeting in the EU** (with ad details): for ads shown in the EU/EEA, Google publishes impressions per country and per platform (Search, YouTube, Shopping, Maps, Play) and which targeting the advertiser used; you get them as `impressionsMin`/`impressionsMax`, one `regionStats` line per country, and `targeting`. Outside the EU Google publishes only the last-shown date per country, which is in `regionStats` too.
- **Links**: the ad's own page in the Transparency Center, and for display, video and app ads the landing page the ad leads to (`clickUrl`: a page of the site, an App Store or Google Play link). Google doesn't publish the landing page of Search text and Shopping ads, so it's empty there.
- **Advertisers instead of ads** (Get: Advertisers): the advertiser accounts behind a name, a website or an ID, with country, whether Google verified them and how many ads each runs.

Use it to study competitors' Google ads, collect ad copy and creatives for inspiration, get alerted to a competitor's new ads (Only new ads on a schedule), see how many people an ad reached in the EU, check who advertises on your brand's domain, or find every advertiser in a niche.

### How to use it

1. Put advertisers or websites in **Advertisers or websites**, one per line. Each can be:
   - an advertiser name, as it shows in the Transparency Center (`Nike`, `Canva`): the run picks the advertiser account with the most ads by that name and logs the others (set **Advertiser accounts per name** under Advanced to get the ads of several);
   - a website domain or URL (`nike.com`): every ad that leads to that site, whoever runs it (a brand's resellers and agencies too);
   - an advertiser ID (`AR16735076323512287233`) or a link copied from adstransparency.google.com: an advertiser page, a website search or a single ad (its region, format, platform and date filters are used).
2. Optionally pick a **Country**, and in **Filters** an ad format, a Google platform (Search, YouTube, Shopping, Maps, Play) or dates.
3. Set **Max ads per search** and run. Rows come in Google's order (most recently shown first) and each has its `rank`.
4. To track competitors, turn on **Only new ads** and schedule the run (daily, say): each run delivers only the ads earlier runs haven't, and skipped ads cost nothing. The first run delivers everything as the baseline.
5. To find advertisers rather than ads, set **Get** to **Advertisers**: a name lists every advertiser Google finds for it (all of a brand's accounts, or all advertisers named "dentist"), a website lists the advertisers whose ads lead to it, and an ID or ad link gives that advertiser. Most ads first; Max ads per search caps the advertisers per search, and Only new ads skips advertisers earlier runs listed. Give an advertiser's ID back to the Actor to get its ads.

No login and no Google account: the Actor reads the same public pages you see in your browser.

### Output

One row per ad. A sample row (text ad, with ad details):

```json
{
  "image": "https://tpc.googlesyndication.com/archive/simgad/12960423100325740031",
  "advertiserName": "Nike Retail BV",
  "headline": "Men's Nike ACG Shoes",
  "description": "Shop Men's ACG Shoes.",
  "descriptionSnippet": "Shop Men's ACG Shoes.",
  "displayUrl": "nike.com",
  "clickUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR01931161727441829889?region=anywhere",
  "videoUrl": null,
  "format": "Text",
  "category": null,
  "regions": ["Spain", "United Kingdom", "France"],
  "regionStats": [
    "Spain: under 1,000 impressions (Search under 1,000), 2025-09-19 to 2026-09-30",
    "United Kingdom: last shown 2026-09-30",
    "France: under 1,000 impressions (Search under 1,000), 2025-12-21 to 2026-09-30"
  ],
  "impressionsMin": 0,
  "impressionsMax": 1000,
  "targeting": ["Demographic info: included", "Geographic locations: included", "Contextual signals: included"],
  "firstShownAt": "2025-09-19T14:02:31Z",
  "lastShownAt": "2026-09-30T20:01:08Z",
  "daysShown": 355,
  "rank": 4,
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201?region=anywhere",
  "detailsStatus": "OK",
  "advertiserId": "AR18378488041124659201",
  "creativeId": "CR01931161727441829889",
  "searchInput": "nike.com",
  "scrapedAt": "2026-09-30T20:27:10Z"
}
```

(The United Kingdom isn't in the EU/EEA, so Google publishes only its last-shown date. A Search text ad has no published landing page, so `clickUrl` is null.)

| Field | What it is |
|---|---|
| `image` | The ad's picture: the image of an image ad, the YouTube thumbnail of a video ad, the product photo of a Shopping ad, or Google's preview of a text ad. |
| `advertiserName` | The verified advertiser that paid for the ad. |
| `headline` | With ad details: the headline of a text ad, or the product title of a Shopping ad. |
| `description` | With ad details: the ad text in full. |
| `descriptionSnippet` | The first 50 characters of the ad text. |
| `displayUrl` | With ad details: the website shown in the ad. |
| `clickUrl` | With ad details: the landing page of a display, video or app ad (a page of the site, an App Store or Google Play link); null for Search text and Shopping ads, whose landing page Google doesn't publish. |
| `adUrl` | The ad in the Google Ads Transparency Center. |
| `videoUrl` | With ad details: the video ad on YouTube. |
| `format` | Text, Image or Video. |
| `category` | With ad details: the ad's category when Google names it (`Furniture`). |
| `regions` | With ad details: the countries where the ad was shown. |
| `regionStats` | With ad details: one line per country. EU/EEA: `Germany: 45,000–50,000 impressions (Search 40,000–45,000; Shopping under 1,000; YouTube under 1,000), 2023-10-18 to 2026-09-30`; elsewhere: `United States: last shown 2026-09-01`. |
| `impressionsMin`, `impressionsMax` | With ad details: the ad's total EU/EEA impressions as Google's range (null for ads not shown there). |
| `targeting` | With ad details, EU/EEA ads: the targeting kinds used, e.g. `Geographic locations: included and excluded`, `Contextual signals: included`. |
| `firstShownAt`, `lastShownAt` | When the ad was first and last shown (UTC). A recent last-shown time means it's still running. |
| `daysShown` | On how many days the ad was shown. |
| `rank` | The ad's place in its search, in Google's order. |
| `advertiserUrl` | All of the advertiser's ads in the Transparency Center. |
| `detailsStatus` | With ad details: `OK`; `Failed` (that row has no copy or countries and is charged as a plain ad); or `Skipped` (the run reached its timeout before reading them; also charged as a plain ad). |
| `advertiserId`, `creativeId` | Google's advertiser and ad IDs. |
| `searchInput` | The advertiser, website or link that found the ad. |
| `scrapedAt` | When the run started (UTC). |

The dataset has three views: **📊 Overview**, **🎨 Creatives** (picture, headline, full ad text, landing page, video) and **🇪🇺 EU Reach & Targeting** (impressions, per-country lines, targeting). A run summary (`OUTPUT` in the key-value store) lists each search with Google's own ad count for it.

**Advertisers mode** puts one row per advertiser account in the **🏢 Advertisers** dataset (the Ads dataset stays empty):

```json
{
  "advertiserName": "Nike, Inc.",
  "country": "United States",
  "verified": true,
  "adsMin": 9000,
  "adsMax": 10000,
  "rank": 1,
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=anywhere",
  "advertiserId": "AR16735076323512287233",
  "searchInput": "Nike",
  "scrapedAt": "2026-09-30T21:10:04Z"
}
```

`adsMin` and `adsMax` are Google's count of the advertiser's ads, which it rounds to a range for big advertisers; `country` is where the advertiser's account is billed; an advertiser found by two of your searches is listed once, under the first.

Good to know:

- Ad details always add the countries where the ad was shown. The words come only where Google keeps the ad as text: some text ads exist in the Transparency Center only as a picture of the ad, and those rows have the picture and no headline or text. Dynamic search ads have no fixed headline (Google writes it from the landing page), so `headline` is empty for them.
- Image links (`tpc.googlesyndication.com`, `i.ytimg.com`) are stable. Shopping photos (`encrypted-tbn*.gstatic.com`) are Google's thumbnails.
- An ad found by two of your searches is delivered once, under the first.

### Pricing

Pay per ad (per advertiser in Advertisers mode); no monthly fee and no minimum.

| Per 1,000 | Free | Starter | Scale | Business |
|---|---|---|---|---|
| Ad | $0.95 | $0.80 | $0.60 | $0.50 |
| Ad with details | $1.45 | $1.30 | $1.10 | $1.00 |
| Advertiser (Advertisers mode) | $0.50 | $0.50 | $0.50 | $0.50 |

Ad details are on by default; turn them off for a cheaper, faster list of ads (advertiser, format, dates and a preview picture). Set a maximum cost per run in the run options and the Actor stops at or before it.

### Speed

About 30 seconds per 1,000 ads without details, and about 7 minutes per 1,000 with details (each ad's details are one lookup plus its preview). A run stops 2 minutes before its timeout and keeps every ad it found, so the default 1-hour timeout fits about 8,000 ads with details; raise the timeout in the run options for more.

Google limits requests per IP; the Actor spreads them over Apify datacenter proxies and switches to residential proxies by itself when Google refuses datacenter IPs. If Google refuses a search on every IP tried, or gives no ads even for a big advertiser it checks against, the run fails with a clear message instead of returning an empty result.

### Related Actors

- [Meta Ad Library API](https://apify.com/deepmine/meta-ad-library): the same for Facebook and Instagram ads.

### Feedback

Found a problem or missing a field? Open an issue in the Issues tab and we'll look at it within 48 hours. If the data helped you, a short review on the Store helps others find it.

# Actor input Schema

## `searchTerms` (type: `array`):

One per line: an advertiser name (Nike, Canva), a website domain or URL (nike.com), an advertiser ID (AR14188379519798214657) or a link copied from adstransparency.google.com: an advertiser page, a website search or a single ad. A domain gets every ad that leads to that site, whoever runs it.

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

Ads (default): the ads themselves. Advertisers: the advertiser accounts instead, with country, verification and how many ads each runs, in the Advertisers dataset: every advertiser Google finds for a name (e.g. all "Canva" accounts, or advertisers named "dentist"), the advertisers whose ads lead to a website, or an ID's account. Charged per advertiser (see Pricing).

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

Two-letter country code where the ads were shown (US, GB, DE, ...), or anywhere for every country.

## `maxAdsPerSearch` (type: `integer`):

Stop each advertiser or website after this many ads (in Advertisers mode: this many advertisers per search). You pay per ad, so this caps the cost of each search. Ads come in Google's order, most recently shown first. About 30 seconds per 1,000 ads, or 7 minutes with ad details: above about 8,000 ads with details, raise the run timeout.

## `includeAdDetails` (type: `boolean`):

Read each ad's details: the headline, ad text and display URL of text ads, the image or YouTube video of display and video ads, the product of Shopping ads, and the countries where it was shown (always; the words only where Google keeps the ad as text). An ad with details costs more than a plain ad (see Pricing); without them a row has the advertiser, format, dates and a preview image. An ad whose details fail is charged as a plain ad. For ads shown in the EU/EEA, details also give impressions per country and platform, and the targeting used.

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

Monitor mode: skip the ads an earlier run already delivered for the same advertiser or website and filters, so a scheduled run gives only ads that are new since the last one. Skipped ads aren't read or charged. The first run delivers everything (it's the baseline). Max ads per search still sets how far down Google's list each run looks. In Advertisers mode: only advertisers an earlier run didn't list.

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

Only text, image or video ads.

## `platform` (type: `string`):

Only ads shown on this Google platform. Google records platforms for ads shown since September 2023.

## `dateFrom` (type: `string`):

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

## `dateTo` (type: `string`):

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

## `advertisersPerName` (type: `integer`):

An advertiser name can match several accounts (Canva US, Canva Pty Ltd, ...). Ads: get the ads of this many of them, the ones with the most ads first (default 1: the biggest account). Each account is its own search, with its own max ads. Websites and IDs aren't affected.

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

Apify datacenter proxies are the default. When Google refuses datacenter IP after IP, the run goes on through Apify residential proxies by itself.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com",
    "Canva"
  ],
  "resultType": "ads",
  "region": "anywhere",
  "maxAdsPerSearch": 50,
  "includeAdDetails": true,
  "onlyNewAds": false,
  "format": "all",
  "platform": "all",
  "advertisersPerName": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `advertisers` (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 = {
    "searchTerms": [
        "nike.com",
        "Canva"
    ],
    "maxAdsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/google-ads-transparency").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 = {
    "searchTerms": [
        "nike.com",
        "Canva",
    ],
    "maxAdsPerSearch": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/google-ads-transparency"
        }
    }
}
```

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/FCHYeBjKfLxrT2zfk/builds/prNbQaINbeNkbQgz8/openapi.json