# Google Ads Transparency Center Scraper - Ads by Brand (`dottti/google-ads-transparency`) Actor

Ads from the Google Ads Transparency Center by advertiser name, domain or id: format, first and last shown, regions, impressions where Google shows them, preview, image, video and ad text. Region, date, format and platform filters. New-ad alerts. No login.

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

## Pricing

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

Get the ads any company runs on Google from the public [Google Ads Transparency Center](https://adstransparency.google.com/). Type a brand name, a website domain or a Google advertiser id. You get one clean row per ad: format, first and last shown dates, the countries it ran in, impression ranges where Google publishes them, the ad page link, the image or preview, and optionally the ad text and YouTube video link.

No login, no cookies, no browser.

### Who it is for

- **Marketers and agencies** who track what competitors advertise, where and for how long.
- **Brand and compliance teams** who watch for new ads that use their name or domain.
- **Researchers and journalists** who build archives of an advertiser's ads by country and date.
- **Sales teams** who want to know which companies run Google Ads right now.

### What you can search

| Input | Example | What happens |
|---|---|---|
| Domain or website link | `noon.com`, `https://www.nike.com/sa/` | All advertisers whose ads point to that domain. |
| Advertiser id | `AR16735076323512287233` | That advertiser account only. |
| Transparency Center link | `https://adstransparency.google.com/advertiser/AR16735076323512287233` | Same as the id. |
| Advertiser name | `Nike` | Matched to Google's advertiser list. You get the closest match with the most ads (Nike, Inc.). Raise **Advertisers per name** to add regional accounts. |

Filters: **region** (any country code such as US, GB, SA, AE, EG, or anywhere), **dates shown**, **format** (text, image, video) and **Google platform** (Search, YouTube, Shopping, Maps, Play).

Empty input runs a short demo: the 10 latest ads that point to nike.com.

### Output

One row per ad. Example from a real run (2026-11-04):

```json
{
  "type": "ad",
  "input": "nike.com",
  "matchedBy": "domain",
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "creativeId": "CR11185976386646966273",
  "format": "TEXT",
  "targetDomain": "nike.com",
  "firstShown": "2026-02-02T11:26:29.371Z",
  "lastShown": "2026-11-04T09:44:18.183Z",
  "daysShown": 240,
  "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR11185976386646966273",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/7766845036078850100",
  "regions": ["FR", "AT", "SI", "IT"],
  "regionCount": 4,
  "impressionsMin": 3000,
  "impressionsMax": 4000,
  "impressionPlatforms": [
    { "platform": "SEARCH", "impressionsMin": 3000, "impressionsMax": 4000 },
    { "platform": "SHOPPING", "impressionsMin": 0, "impressionsMax": 1000 }
  ],
  "regionStats": [
    { "region": "FR", "firstShown": "2026-02-03", "lastShown": "2026-10-11", "impressionsMin": 0, "impressionsMax": 1000,
      "platforms": [{ "platform": "SEARCH", "impressionsMin": 0, "impressionsMax": 1000 }] },
    { "region": "IT", "firstShown": "2026-02-02", "lastShown": "2026-11-04", "impressionsMin": 3000, "impressionsMax": 4000,
      "platforms": [{ "platform": "SHOPPING", "impressionsMin": 0, "impressionsMax": 1000 }, { "platform": "SEARCH", "impressionsMin": 3000, "impressionsMax": 4000 }] }
  ],
  "variationCount": 2,
  "videoUrl": null,
  "adText": null
}
```

With **Include ad text and video link** on, a search ad also gets its text:

```json
{
  "adText": "Nike | www.nike.com/shop/running-shoes | Nike® Official Site - Shop Women's Running Shoes | Put a spring in your step with latest Nike® Downshifter running shoes, now at Nike®. Shop... | Nike® Downshifter Shoes",
  "textSnippets": ["Nike", "www.nike.com/shop/running-shoes", "Nike® Official Site - Shop Women's Running Shoes", "..."]
}
```

and a video ad gets `"videoUrl": "https://www.youtube.com/watch?v=RZ1MLoOdWcc"`.

Field notes:

- `format` is TEXT, IMAGE or VIDEO, as Google labels it. Many text ads are stored by Google as an image of the ad; for those `imageUrl` shows the ad and there is no text to read.
- `impressionsMin` / `impressionsMax` are Google's published ranges. Google publishes them for the EU and a few other regions only. Elsewhere they are empty.
- `regions` lists the countries Google shows for the ad. `regionStats` has dates and impressions per country.
- `previewUrl` is Google's own preview script for the ad.

#### Status rows

Every input that returns no ads gets a free row with `"type": "status"` and a `status` of `no_ads`, `no_match`, `invalid_input`, `blocked`, `api_error` or `skipped_cost_limit`, plus a plain-English `error`. A name with no match lists Google's suggestions so you can pick the right one. Status rows are never charged. The run summary (key-value store record `RUN_SUMMARY`) lists every input, the advertiser accounts a name matched, the number of ads Google says are available, and the requests used.

### Alerts for new ads

Turn on **Only new ads (alert mode)** and schedule the actor (for example daily). The first run delivers the current ads and saves them. Each later run delivers only ads that were not delivered before for the same advertiser and filters. Give each schedule its own **Alert list name** so lists stay separate. You pay only for new ads.

To schedule: open the actor in Apify Console, save your input as a task, then add a schedule under **Schedules**. Connect a webhook, email, Slack or Google Sheets integration to get the new rows.

### Pricing

Pay per ad delivered. Platform usage is included in the price. Regions, impressions, variations and ad text are included at no extra charge. Status rows are free. You can set a maximum cost per run in Apify Console; the actor stops cleanly at that limit.

### Speed and limits

- About 1 ad per second with regions and impressions on, faster with them off. Turning on ad text adds one larger download per ad.
- Google lists an advertiser's ads by last shown date, newest first. **Max ads per advertiser** takes the newest ones.
- The actor sends one request at a time with a pause between requests. If Google rate-limits the connection, it waits, retries and moves to Apify datacenter, then residential proxy.
- Data is what the public Transparency Center shows. Google does not publish spend (except for political ads), targeting for most ads, or click data.
- Political ads with spend data are not covered by this version.
- Google keeps some text ads only as an archived image. Those rows have `imageUrl` set and `adText` empty.

# Actor input Schema

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

One per line. A domain (nike.com, https://www.noon.com), an advertiser id (AR16735076323512287233) or Transparency Center link, or an advertiser name (Nike). Names are matched to Google's advertiser list; see 'Advertisers per name'. Empty input runs a 10-ad demo for nike.com.

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

Country where the ads were shown, as a 2-letter code (US, GB, SA, AE, EG, DE) or 'anywhere' for all countries.

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

Optional. Only ads shown on or after this date: 2026-10-01, or a relative time such as 30 days, 4 weeks, 3 months.

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

Optional. Only ads shown on or before this date (2026-10-31 or a relative time).

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

Only ads of this format.

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

Only ads shown on this Google platform.

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

Newest ads to fetch for each advertiser or domain (Google lists ads by last shown date). Large brands have thousands.

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

When you type a name, how many matching advertiser accounts to scrape. 1 = the closest match with the most ads (for 'Nike' that is Nike, Inc.). Raise it to include regional accounts such as Nike Retail BV.

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

One extra request per ad for the list of countries with first and last shown dates, impression ranges where Google publishes them (EU and some other regions), and the number of variations. Turn off for a faster, lighter run.

## `includeAdText` (type: `boolean`):

Opens each ad's preview to read the headline and description text, the YouTube video link of video ads and the product image of Shopping ads. Slower: one extra download of about 100 to 400 kB per ad. Text ads that Google stores only as an image have no text to read.

## `onlyNew` (type: `boolean`):

Remembers the ads each advertiser returned last time (per filter set) and delivers only new ones on the next run. Schedule the actor for alerts. The first run delivers everything and saves the baseline. You pay only for new ads.

## `stateName` (type: `string`):

Name for the saved only-new list, so several schedules (for example 'competitors-ksa' and 'brand-us') keep separate memories.

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

Optional. Leave empty: the actor starts without a proxy and moves to Apify datacenter, then residential proxy only if Google rate-limits it. Set your own proxy here to use only that.

## `autoProxyFallback` (type: `boolean`):

Move to Apify Proxy when Google rate-limits the direct connection.

## `allowResidentialFallback` (type: `boolean`):

Let the fallback use residential proxy as the last step. Residential traffic is included in the price.

## `maxRetries` (type: `integer`):

Retries for each request on rate limits, server errors or network errors, with growing waits.

## Actor input object example

```json
{
  "advertisers": [
    "nike.com"
  ],
  "region": "anywhere",
  "format": "ALL",
  "platform": "ALL",
  "maxAdsPerAdvertiser": 20,
  "maxAdvertisersPerName": 1,
  "includeDetails": true,
  "includeAdText": false,
  "onlyNew": false,
  "stateName": "default",
  "autoProxyFallback": true,
  "allowResidentialFallback": true,
  "maxRetries": 4
}
```

# Actor output Schema

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

All rows. Filter by the type field.

## `runSummary` (type: `string`):

Status per input, matched advertisers, ads available, requests, bytes and proxy tier used.

# 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"
    ],
    "maxAdsPerAdvertiser": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("dottti/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 = {
    "advertisers": ["nike.com"],
    "maxAdsPerAdvertiser": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("dottti/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 '{
  "advertisers": [
    "nike.com"
  ],
  "maxAdsPerAdvertiser": 20
}' |
apify call dottti/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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