# Google Ads Transparency Scraper: Ads by Advertiser or Domain (`t3data/google-ads-transparency`) Actor

Every ad an advertiser or website runs on Google Search, YouTube, Shopping, Maps and Play, from the Ads Transparency Center: format, first/last shown, days running, image or YouTube video, ad text. Filter by country, platform, format and date. Pay only for ads you get.

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

## Pricing

from $0.80 / 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 Scraper: Ads by Advertiser or Domain

A **Google Ads Transparency Center API** alternative with no login, no cookies and no API key. Enter a brand name, a website or an advertiser ID and get **every ad they run on Google Search, YouTube, Shopping, Maps and Play**: format, first and last shown, days running, the ad image or YouTube video, and ad text where Google provides it, filtered by country, platform, format and date. **You only pay for ads you get**: advertisers without ads are free.

| | |
|---|---|
| 💲 **Price** | $2 per 1,000 ads. Preview details (text, video) are included. |
| ⚡ **Speed** | 300 ads with details in ~7 seconds; 31 brands and domains (600 ads) in ~25 seconds |
| 📥 **Input** | Brand names, domains (nike.com), advertiser IDs (AR…), or Ads Transparency Center links |
| 📤 **Output** | One row per ad: advertiser, format, dates, days shown, image or YouTube video, text (when available), Transparency Center link |
| 🌍 **Filters** | Country (all 243 regions Google lists, or anywhere), platform (Search, YouTube, Shopping, Maps, Play), format (text, image, video), date range |

### What people use it for

- **Competitor ad intelligence**: what a rival runs right now, in which format, and for how long
- **Creative research and swipe files**: collect image and video ads at scale for inspiration or analysis
- **Lead generation**: check which companies actively advertise on Google (and roughly how much)
- **Agency pitches**: show a prospect their competitors' live ads in minutes
- **Brand protection**: find who advertises with your brand name or domain
- **Long-running ads**: `daysShown` reveals the ads that keep running, usually the ones that convert

### How to use it

1. Add brand names, domains, advertiser IDs or Transparency Center links, one per line.
2. Pick a country (or anywhere), and optionally a format and date range.
3. Click **Start**, then download the results as JSON, CSV or Excel, or fetch them through the API.

### For AI agents and automations

- **One job:** get the ads a company or website runs on Google (Search, YouTube, Display), with dates, format, image or video and ad text. Minimal input: `{ "advertisers": ["nike.com"], "maxAdsPerAdvertiser": 50 }`
- **Fast enough for a single tool call:** one advertiser with 50–100 ads finishes in about 5–10 seconds; ~300 ads with details in ~10 seconds, which fits inside the Apify MCP server's default 30-second wait for small inputs. For big jobs, start the run asynchronously and read the dataset when it finishes.
- **Where the results are:** dataset items (fields below). A **run summary** is in the key-value store record `OUTPUT`: `status` (`SUCCEEDED`, `PARTIAL`, `STOPPED_AT_SPEND_LIMIT`, `ABORTED`, `NO_RESULTS`, `SOURCE_UNAVAILABLE`), `results`, `errorsByCode` and a plain-English `message`.
- **Predictable billing:** pay per event. Only successful ads are charged; error rows are free.
- **Respects "Max cost per run":** it never starts work your budget can't pay for, then stops cleanly with status `STOPPED_AT_SPEND_LIMIT`. Everything fetched up to that point is kept.
- **Graceful on abort and restarts:** partial results are always kept, and a platform restart resumes without duplicates or double charges.
- **Honest failures:** if the source blocks every request or changes its format, the run fails with a clear message and you pay $0, instead of quietly returning empty results.
- Works with the **Apify MCP server** (Claude, Cursor, other agents), agentic payments, and the API.

### Input examples

The newest 200 US ads of two brands:

```json
{ "advertisers": ["Nike, Inc.", "Adidas"], "region": "US", "maxAdsPerAdvertiser": 200 }
```

Every YouTube ad a website ran in the UK since July:

```json
{ "advertisers": ["hellofresh.co.uk"], "region": "GB", "platforms": ["YOUTUBE"], "dateFrom": "2026-07-01", "maxAdsPerAdvertiser": 1000 }
```

Quick check of which companies advertise (10 ads each, no preview details):

```json
{ "advertisers": ["canva.com", "notion.so", "monday.com", "AR16735076323512287233"], "maxAdsPerAdvertiser": 10, "includeAdDetails": false }
```

### Output

One item per ad. From a real run, a **video ad** with details:

```json
{
  "status": "ok",
  "input": "HelloFresh",
  "advertiserCountry": "DE",
  "advertiserVerified": false,
  "advertiserId": "AR17410177287600472065",
  "advertiserName": "HelloFresh SE",
  "creativeId": "CR01471839147210571777",
  "format": "VIDEO",
  "firstShown": "2024-01-31T12:59:47.000Z",
  "lastShown": "2026-01-15T16:05:56.000Z",
  "daysShown": 716,
  "imageUrl": null,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&...",
  "adUrl": "https://adstransparency.google.com/advertiser/AR17410177287600472065/creative/CR01471839147210571777?region=US",
  "region": "US",
  "headline": "Get mealtimes sorted.",
  "description": "Cook with fresh, pre-measured ingredients",
  "displayUrl": null,
  "adTexts": ["HelloFresh", "Get mealtimes sorted.", "HelloFresh SE", "Cook with fresh, pre-measured ingredients", "delivered to your door."],
  "landingUrl": "https://play.google.com/store/apps/details?id=com.hellofresh.androidapp",
  "videoId": "ScCF2Gs3HRo",
  "videoUrl": "https://www.youtube.com/watch?v=ScCF2Gs3HRo",
  "images": []
}
```

A **search text ad** (Google shows these as a rendered image):

```json
{
  "status": "ok",
  "input": "Booking.com",
  "domain": "booking.com",
  "advertiserId": "AR02934798844673654785",
  "advertiserName": "Booking.com",
  "creativeId": "CR17328202588306276353",
  "format": "TEXT",
  "firstShown": "2026-08-19T09:38:59.000Z",
  "lastShown": "2026-10-16T16:46:24.000Z",
  "daysShown": 59,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/13415141303128408515",
  "imageWidth": 348,
  "imageHeight": 180,
  "previewUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR02934798844673654785/creative/CR17328202588306276353?region=US",
  "region": "US"
}
```

| Field | Meaning |
|---|---|
| `advertiserName`, `advertiserId`, `advertiserCountry`, `advertiserVerified` | Who paid for the ad (verified = Google-verified identity) |
| `creativeId`, `adUrl` | The ad's ID and its page in the Ads Transparency Center |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `firstShown`, `lastShown`, `daysShown` | When the ad first and last ran, and on how many days |
| `imageUrl`, `imageWidth`, `imageHeight` | The ad image (for text ads, Google's rendering of the ad) |
| `videoId`, `videoUrl` | The YouTube video of a video ad (in our tests 50 of 57 video ads had one; the rest are Google-made animations with no YouTube video) |
| `headline`, `description`, `displayUrl`, `adTexts` | Ad text pulled from the preview (all visible text in `adTexts`). Only for ads Google shows as a live preview: in our tests about half of image ads, and few text ads (see FAQ) |
| `landingUrl` | Where the ad sends people. Google rarely includes it (under 1% of ads in our tests) |
| `images` | All images found in the preview |
| `domain`, `matchedBy` | For domain searches, the domain searched; for name searches, how the name was matched (`brandDomain`, `exactName`, `closestName`) |

### Cost examples

| Job | Ads | Cost |
|---|---|---|
| Latest 100 ads for 10 competitors | 1,000 | $2.00 |
| Every video ad of one big brand in a year | ~3,000 | ~$6.00 |
| Ad check for 500 companies (10 ads each) | ≤5,000 | ≤$10 |

Set **Max cost per run** to cap any run, and the actor stops cleanly at the limit.

### Integrations

- **API**: `client.actor("t3data/google-ads-transparency").call({ advertisers: [...] })` (JS), or `client.actor("t3data/google-ads-transparency").call(run_input={"advertisers": [...]})` (Python). Full snippets are on the **API** tab.
- **AI agents (MCP)**: available as a tool through the Apify MCP server.
- **No-code**: Make, Zapier, n8n, Google Sheets, Slack and webhooks, through Apify integrations. Use **Schedules** to watch competitors weekly.
- **Export**: JSON, CSV, Excel, XML, HTML or RSS.

### Error codes (never charged)

| Code | Meaning |
|---|---|
| `NO_ADS` | The advertiser or domain has no ads with these filters (try another region or "anywhere") |
| `ADVERTISER_NOT_FOUND` | No advertiser matches the name or ID |
| `INVALID_INPUT` | Not a name, domain, advertiser ID or Transparency Center link |
| `INVALID_REGION` / `INVALID_PLATFORM` | Unknown country code or platform name |
| `SOURCE_UNAVAILABLE` (run status) | Every request was blocked, or the source changed its format. The run fails with $0 charged; retry later |
| `BLOCKED` | Google kept refusing after every retry (rare; try again) |

### FAQ

**How does a brand name get matched?** In this order: the brand's own website (e.g. adidas.com for "Adidas", which covers every account that advertises that site), then an advertiser account with exactly that name (ignoring "Inc.", "LLC" and the like), then the closest name with the most ads. Each row's `matchedBy` says which one was used. For a precise result, use the domain or the advertiser ID from the Transparency Center link.

**Why do most text ads have no headline?** For most search text ads, Google's Transparency Center stores only a picture of the ad, not the text, so there is no text to extract; you get the picture (`imageUrl`), which shows the full ad. The row still has the advertiser, dates, days shown and link, which is what most people use it for. If you only want ads with text or video, set **Ad format** to Image or Video, or skip rows without `headline`. Each row is charged once either way, whether or not Google provides text.

**Why does Google say "7000–8000 ads"?** Google only reports a range. Set **Max ads per advertiser** as high as you need; newest ads come first.

**Can I filter by platform?** Yes: Search, YouTube, Shopping, Maps and Play, alone or combined, the same filter as on the Transparency Center website.

**Do I need a Google account, proxy or API key?** No. Proxies and retries are built in and included in the price.

**Is it legal?** The Ads Transparency Center is a public Google service built so anyone can see who advertises. This actor reads that public data.

**Something broke?** Open an issue on the **Issues** tab with your input. Fixes usually ship within a day.

### Limits

- Most search text ads come as images only (Google's limit).
- Landing pages are rarely available from Google.
- Google keeps detailed date filtering for roughly the last year.
- Brand-name matching is best effort; domains and advertiser IDs are exact.

### More from T3 Data

- [YouTube Transcripts](https://apify.com/t3data/youtube-transcripts): full transcripts, SRT and AI-ready chunks for videos, playlists and channels
- [YouTube Comments Scraper](https://apify.com/t3data/youtube-comments): comments and replies with likes, pinned and creator-hearted flags
- [YouTube Channel & Shorts Scraper](https://apify.com/t3data/youtube-channel): channel info plus every video and Short with exact views, likes and dates
- [Google News Scraper](https://apify.com/t3data/google-news): news by keyword, topic or location, with real article URLs and full text
- [Google Trends Scraper](https://apify.com/t3data/google-trends): interest over time, by region, related queries, and trending now
- [Google Hotels Scraper](https://apify.com/t3data/google-hotels): hotel prices, ratings and booking-site prices for any city and dates

***

*This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Google. It only accesses publicly available data from the Google Ads Transparency Center.*

# Actor input Schema

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

One per line: an advertiser name ("Nike, Inc."), a website domain (nike.com), an advertiser ID (AR…), or a link from adstransparency.google.com (advertiser, creative or domain page).

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

Only ads shown in this country: a two-letter code such as US, GB, DE, IN, BR (all 243 regions Google lists), or "anywhere" for all regions. A region in a pasted link wins over this.

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

Only ads of this format.

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

Only ads shown on these Google platforms. Empty = all platforms.

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

Only ads shown on or after this date (YYYY-MM-DD). Google keeps about the last year of date data.

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

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

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

Newest ads come first.

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

A name can match several advertiser accounts (e.g. a brand's country subsidiaries). Exact name matches come first, then the ones with the most ads.

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

Open each ad's live preview (when Google has one) to pull its headline, description, YouTube video and images. Most search text ads have no live preview, only a picture. Included in the price; turn off for a faster list.

## `maxConcurrency` (type: `integer`):

How many advertisers or domains to process at the same time.

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

Apify Proxy is used by default. If Google blocks an IP, the actor retries on fresh IPs and switches to residential IPs automatically. Proxy cost is included in the price.

## Actor input object example

```json
{
  "advertisers": [
    "Nike, Inc."
  ],
  "region": "anywhere",
  "format": "ALL",
  "maxAdsPerAdvertiser": 100,
  "maxAdvertisersPerName": 1,
  "includeAdDetails": true,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per ad, plus free error rows for advertisers or domains without ads.

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

One JSON object: status (SUCCEEDED, PARTIAL, STOPPED_AT_SPEND_LIMIT, ABORTED, NO_RESULTS, SOURCE_UNAVAILABLE), results count, failed inputs by error code, and a plain-English message.

# 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, Inc."
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("t3data/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, Inc."] }

# Run the Actor and wait for it to finish
run = client.actor("t3data/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, Inc."
  ]
}' |
apify call t3data/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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