# Google Ads Transparency Center Scraper (`datatrilha/google-ads-transparency`) Actor

Collect ads from Google's Ads Transparency Center by brand, domain or advertiser ID: ad text, landing pages, YouTube videos, run dates, regions, EU impressions and targeting.

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

## Pricing

from $1.50 / 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 Center Scraper

Collect ads from Google's public [Ads Transparency Center](https://adstransparency.google.com) for any brand, website or advertiser account. Each ad comes with its text and links where Google shows them, its YouTube video, run dates, the countries it ran in and, for ads shown in the EU, its impressions and targeting.

No Google account or login needed. You pay only for the ads you get.

### What you can do with it

- **Watch competitors**: see every ad a brand runs on Search, YouTube, Shopping, Maps and Play, and when each started and stopped.
- **Research creatives**: headlines, descriptions, landing pages and videos across a whole market.
- **Find leads**: check which companies in a list of domains advertise on Google, and how much.
- **Monitor**: schedule the Actor with a date filter to get only ads shown recently.

### Input

Give any mix of:

| Field | Example | What it does |
|---|---|---|
| Brands or advertiser names | `nike` | Finds the advertiser accounts with that name and collects from them in turn, most ads first, until the term has its ads (up to 5 accounts), then the brand's own domain (nike.com) if more are needed. Domain results include agencies and resellers advertising for that site; `searchKey` (`advertiser:…` or `domain:…`) shows where each ad came from. |
| Domains | `nike.com` | Every ad that points to that website, from any advertiser, including agencies and resellers. |
| Advertiser IDs | `AR16735076323512287233` | One advertiser account. The most precise option. |
| Transparency Center URLs | `https://adstransparency.google.com/advertiser/AR16735076323512287233?region=BR` | Advertiser, domain or single-ad pages copied from the site. |

Filters: **region** (two-letter country code or `anywhere`), **format** (text, image, video), **date range**, and **max ads per search**.

```json
{
  "searchTerms": ["nike"],
  "domains": ["adidas.com"],
  "region": "BR",
  "format": "ALL",
  "maxAdsPerSearch": 200
}
```

### Output

One row per ad. An example, shortened:

```json
{
  "creativeId": "CR01307164191206932481",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "format": "TEXT",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR01307164191206932481",
  "firstShown": "2023-11-17T00:41:25.000Z",
  "lastShown": "2026-10-31T18:23:04.000Z",
  "numServedDays": 913,
  "landingDomain": "nike.com",
  "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/2294605507521620571",
  "headline": "Browse Kids Soccer Cleats",
  "description": "Shop best selection of Nike® soccer cleats for men, women, and kids.",
  "displayUrl": "nike.com",
  "variationCount": 4,
  "regions": ["US"],
  "regionStats": [{ "region": "US", "lastShown": "2026-10-31" }]
}
```

`title` is the one field to read for every ad: the headline, or the product title for Shopping and product ads. Video ads add `youtubeVideoId`, `youtubeUrl` and `callToAction`. Shopping and product ads add `productTitle`, `price`, `merchant` and `productImageUrl`. Ads shown in the EU add `euImpressions` (impressions range for the EU as a whole, with dates), impressions per country in `regionStats`, and `targeting`:

```json
"targeting": {
  "demographics": { "targeted": true, "excluded": false },
  "location": { "targeted": true, "excluded": true },
  "contextual": { "targeted": true, "excluded": false }
}
```

The dataset has three views: **Ads** (the main fields with a preview image), **Regions & EU data**, and **Media**. Export as JSON, CSV, Excel or through the API.

### Pricing

**$1.50 per 1,000 ads**, with the ad text, links, details, regions and EU data included. There are no extra charges per feature. An ad found by two of your searches is charged once. Set a maximum cost per run in the run options and the Actor stops there.

### Good to know

- **Ad text.** Google shows many text ads only as a rendered image. For those, `previewImageUrl` is the ad, and `headline`/`description` stay empty. Image, video, Shopping and location ads usually have readable text.
- **Impressions and targeting** are published by Google only for ads shown in the EU. For other countries you get the dates and countries, but not the reach.
- **Brand names** are matched against the advertiser's registered name, not the brand. "magalu" finds MAGALU CLOUD LTDA but not Magazine Luiza, whose account is under another name. The log shows which accounts were picked. For retail brands a domain (`magazineluiza.com.br`) or an advertiser ID is more reliable.
- **Blocking.** Google blocks an IP after many quick requests. The Actor switches to a new proxy IP when that happens, so keep the default residential proxy.
- **Limits.** Google returns about 12 months of history for most queries, and age-restricted ads are not shown to anonymous visitors.

### Support

Found an ad that came out wrong, or need a field that is missing? Open an issue on the Actor's Issues tab with the run link and the ad URL. Issues get answered within a day or two.

This Actor is not affiliated with Google. It reads data that Google publishes publicly in the Ads Transparency Center.

# Actor input Schema

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

Brand or company names, for example "nike". Each term is matched to the advertisers with the most ads (see "Advertisers per term"). A term that looks like a domain (nike.com) is searched as a domain. If the brand's accounts don't fill "Max ads per search", its own domain is searched too; those results can include agencies and resellers. Each ad's searchKey (advertiser:… or domain:…) shows where it came from.

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

Ads that point to these websites, from any advertiser (including agencies and resellers), for example nike.com. Full URLs are accepted.

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

Google advertiser IDs (AR followed by digits), from the advertiser's Transparency Center URL. The most precise way to get one advertiser's ads.

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

Advertiser, domain or single-ad URLs copied from adstransparency.google.com. The region in each URL is used for that URL.

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

Two-letter country code where the ads were shown, for example US, BR or DE. "anywhere" means all countries.

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

Only ads of this format.

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

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

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

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

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

Stop each search after this many ads. A brand name counts as one search across all its accounts. You pay only for ads returned. Ads found by more than one search are returned and charged once.

## `maxAdvertisersPerTerm` (type: `integer`):

Big brands run ads from several accounts (e.g. Nike, Inc. and Nike Retail BV). The matching accounts are searched in turn, most ads first, until "Max ads per search" is reached for the term. This caps how many accounts are tried.

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

All variations, every country the ad ran in with dates, and for ads shown in the EU the impressions range and targeting. One extra request per ad.

## `includeAdContent` (type: `boolean`):

Read the ad preview for headline, description, display URL, landing page, YouTube video and image URLs. Included in the price. Text ads that Google only shows as an image have no readable text.

## `concurrency` (type: `integer`):

Ads fetched in parallel, each through its own proxy IP.

## `delaySecs` (type: `number`):

Pause after each request to Google, per parallel worker.

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

Google blocks an IP after a few dozen quick requests. The Actor switches IP on every block; residential proxies get blocked least.

## Actor input object example

```json
{
  "searchTerms": [
    "nike"
  ],
  "region": "anywhere",
  "format": "ALL",
  "maxAdsPerSearch": 100,
  "maxAdvertisersPerTerm": 5,
  "includeDetails": true,
  "includeAdContent": true,
  "concurrency": 4,
  "delaySecs": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All collected ads with full details.

## `overview` (type: `string`):

Main fields in a table.

## `regions` (type: `string`):

Countries, impressions and targeting per ad.

# 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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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