# Google Ads Transparency API: Competitor Ads by Domain or Brand (`sauliusautomatesit/google-ads-transparency-api`) Actor

Every ad a competitor runs on Google Search, YouTube, Display, Maps and Play, from Google's Ads Transparency Center. Search by website domain, brand name or advertiser ID. Get format, first and last shown dates, image links, YouTube video links and optional per-country reach. $1 per 1,000 ads.

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

## Pricing

from $0.85 / 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 API: Competitor Ads by Domain or Brand

See every ad a competitor runs on Google: Search, YouTube, Display, Maps, Play and Shopping. This Actor reads Google's public [Ads Transparency Center](https://adstransparency.google.com/) and returns the ads as clean JSON, CSV or Excel. No Google account, no login, no cookies.

Give it a website domain (`hubspot.com`), a brand name (`HubSpot`), an advertiser ID (`AR10072600183532683265`) or any Transparency Center URL. For each ad you get:

- **Advertiser**: Google-verified legal name and advertiser ID.
- **Format**: text, image or video.
- **Dates**: when Google first and last showed the ad, and on how many days it ran. Long-running ads are the ones that work.
- **Creative**: the ad image (text ads are archived by Google as images too), the live preview link, and for video ads the **YouTube video ID and URL**.
- **Optional detail**: every country the ad ran in with first and last shown dates, impression ranges where Google publishes them (EU countries), and all creative variations.

### Why use it

- **$1 per 1,000 ads.** The Store's best-known Google Ads Transparency scrapers charge $1.48 to $2 per 1,000 on the free plan, plus extra for details. Paid Apify plans get the usual discounts on top.
- **Domain search finds every advertiser.** Agencies, resellers and regional entities that point ads to the same website all come back in one query.
- **Filters that matter.** Country, format (text, image, video) and a date range, so a weekly run only returns ads shown that week.
- **YouTube links included.** Video ads come with the YouTube URL at no extra cost, ready for our [YouTube Transcript Scraper](https://apify.com/sauliusautomatesit/youtube-transcript-scraper) if you want the script of every competitor video ad.
- **Built for bulk and schedules.** Each request goes out on a fresh proxy IP, so large brands with tens of thousands of ads finish without rate-limit failures. Empty queries cost nothing.

### What it's used for

- **Competitor ad monitoring**: a weekly scheduled run per competitor domain, filtered to the last 7 days, shows every new creative.
- **Creative research**: find a brand's longest-running ads (`daysShown`) to see which messages and formats they keep paying for.
- **Agency prospecting**: list every business advertising in a country and format, then check how active they are.
- **Brand protection**: catch advertisers using your brand or domain.
- **Ad intelligence for AI agents**: an agent can pull a competitor's ads and summarise their positioning.

### Input

| Field | What it does | Default |
|---|---|---|
| `queries` | Domains, brand names, advertiser IDs or Transparency Center URLs, one per line | |
| `mode` | `ads`, or `advertisers` to look up advertiser names and IDs only | `ads` |
| `region` | Two-letter country code (`US`, `GB`, `DE`...) or `anywhere` | `anywhere` |
| `format` | `all`, `text`, `image` or `video` | `all` |
| `dateFrom`, `dateTo` | Only ads shown in this window (`YYYY-MM-DD`) | all time |
| `maxAdsPerQuery` | Cap per query line, newest ads first | `100` |
| `includeDetails` | Add per-country dates, EU impression ranges and all variations | `false` |
| `includeVideoIds` | Add YouTube video ID and URL to video ads (free) | `true` |
| `maxAdvertisersPerName` | For brand names: how many matching advertisers to scrape, most ads first | `1` |

Example:

```json
{
  "queries": ["hubspot.com", "salesforce.com"],
  "region": "US",
  "dateFrom": "2026-09-01",
  "maxAdsPerQuery": 500
}
```

**Domain or brand name?** A domain is the most complete: it returns ads from every advertiser that sends traffic to that site. A brand name is matched against Google's verified advertiser names (`HubSpot` finds "Hubspot, Inc."). Names that are common words can match the wrong company, so use the domain or the advertiser ID when it matters. Run `mode: "advertisers"` first to see which advertisers a name matches.

### Output

One item per ad:

```json
{
  "type": "ad",
  "query": "hubspot.com",
  "region": "US",
  "advertiserId": "AR10072600183532683265",
  "advertiserName": "Hubspot, Inc.",
  "creativeId": "CR02085961376810926081",
  "format": "video",
  "firstShown": "2026-06-29T21:00:29.000Z",
  "lastShown": "2026-10-03T11:59:19.000Z",
  "daysShown": 97,
  "spanDays": 97,
  "domain": "hubspot.com",
  "imageUrl": null,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...",
  "videoId": "yiG2lE3wqrY",
  "videoUrl": "https://www.youtube.com/watch?v=yiG2lE3wqrY",
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR02085961376810926081?region=US",
  "scrapedAt": "2026-10-03T13:06:00.404Z"
}
```

Image and text ads carry `imageUrl` (with `imageWidth` and `imageHeight`). With `includeDetails` on, each ad also has:

```json
{
  "regionCount": 9,
  "regions": [
    { "countryCode": "FR", "country": "France", "firstShown": "2025-05-30", "lastShown": "2026-09-21", "impressionsMin": 1000 }
  ],
  "euImpressionsMin": 1000,
  "variationCount": 3,
  "variations": [{ "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/...", "width": 348, "height": 269 }]
}
```

`daysShown` is Google's count of days the ad was shown; `spanDays` is the calendar span from first to last shown. In `advertisers` mode each item is an advertiser: `advertiserName`, `advertiserId`, `country`, `adCountMin`, `adCountMax`, `advertiserUrl` and related domains.

The run summary (ads delivered, queries without results, failures) is saved as `OUTPUT` in the run's key-value store.

### Pricing

Pay per result, no subscription:

| Event | Price |
|---|---|
| Ad | $0.001 per ad ($1.00 per 1,000) |
| Ad details (only with `includeDetails`) | $0.001 per ad |
| Advertiser record (`advertisers` mode) | $0.0005 per advertiser |
| Actor start | $0.00005 per run |

Queries that find nothing are free. Set **Maximum cost per run** in the run options and the run stops cleanly when it is reached.

### Tutorial: Python, schedules and AI agents

You need an Apify API token (Apify Console > Settings > API & Integrations). Apify's free plan includes $5 of monthly credit, about 5,000 ads.

#### 1. Python: every ad a competitor ran this month

```bash
pip install apify-client
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("sauliusautomatesit/google-ads-transparency-api").call(run_input={
    "queries": ["hubspot.com"],
    "region": "US",
    "dateFrom": "2026-09-01",
    "maxAdsPerQuery": 1000,
})

ads = list(client.dataset(run.default_dataset_id).iterate_items())
longest = sorted(ads, key=lambda a: a["daysShown"] or 0, reverse=True)[:10]
for ad in longest:
    print(ad["format"], ad["daysShown"], "days", ad["videoUrl"] or ad["imageUrl"])
```

`run.default_dataset_id` is for `apify-client` 3.x; on 2.x write `run["defaultDatasetId"]`. Pass `max_total_charge_usd=1` to `.call()` to cap a run at $1.

#### 2. Weekly competitor monitoring

Save an input like this as a Task and give it a weekly schedule. Each run returns only ads shown in the last 7 days; connect the Task to Slack, Google Sheets or a webhook in the Integrations tab.

```json
{
  "queries": ["competitor-one.com", "competitor-two.com", "competitor-three.com"],
  "region": "US",
  "dateFrom": "2026-09-26",
  "maxAdsPerQuery": 2000
}
```

#### 3. AI agents: one MCP URL, one tool

This URL gives any MCP client exactly one tool, this Actor:

```
https://mcp.apify.com/?tools=sauliusautomatesit/google-ads-transparency-api
```

Claude Code:

```bash
claude mcp add --transport http google-ads-transparency "https://mcp.apify.com/?tools=sauliusautomatesit/google-ads-transparency-api"
```

Cursor, Claude Desktop, VS Code and other clients that take JSON:

```json
{
    "mcpServers": {
        "google-ads-transparency": {
            "url": "https://mcp.apify.com/?tools=sauliusautomatesit/google-ads-transparency-api",
            "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
        }
    }
}
```

Then ask: *"Which video ads has Salesforce run in the UK since August, and which ran longest?"*

### Related Actors

- [Google Trends API](https://apify.com/sauliusautomatesit/google-trends-api): search interest over time for the keywords and brands your competitors advertise on.
- [YouTube Transcript Scraper](https://apify.com/sauliusautomatesit/youtube-transcript-scraper): the full script of every competitor video ad, from the YouTube links this Actor returns.
- [Google Hotels API](https://apify.com/sauliusautomatesit/google-hotels-api): hotel prices by destination, for travel and hospitality advertisers.

### Limits and notes

- Data comes from Google's public Ads Transparency Center. Google lists ads from verified advertisers; it does not publish spend, clicks or keywords (except for political ads), and it publishes impression ranges only for EU countries.
- Text ads are archived by Google as images, so their wording is in `imageUrl`, not as text.
- A platform filter (Search only, YouTube only) is not offered yet.
- Not affiliated with Google.

# Actor input Schema

## `queries` (type: `array`):

One per line. A website domain (`nike.com`) returns every advertiser that runs ads pointing to it, which is the most complete option. A brand name (`HubSpot`) is matched to Google's verified advertiser names. An advertiser ID (`AR16735076323512287233`) or a Transparency Center URL (advertiser, creative or domain page) is used as is.

## `mode` (type: `string`):

`ads` = the ad creatives. `advertisers` = look up advertiser names and IDs only (verified name, country, number of ads), for example to find the right ID before a large run.

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

Two-letter country code (`US`, `GB`, `DE`, `IN` ...) to get only ads shown in that country, or `anywhere` for all countries.

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

Only ads of this format.

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

Only ads shown on or after this date (YYYY-MM-DD). Leave empty for all time.

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

Only ads shown on or before this date (YYYY-MM-DD). Leave empty for today.

## `maxAdsPerQuery` (type: `integer`):

Stop after this many ads for each line in `queries`. Newest ads come first. Big brands run tens of thousands of ads; set a cap to control cost.

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

Fetch each ad's detail page: every country it ran in with first and last shown dates, impression ranges where Google publishes them (EU countries), and all creative variations. Charged as a separate `ad-details` event.

## `includeVideoIds` (type: `boolean`):

For video ads, read the ad preview to get the YouTube video ID and URL. Free.

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

A brand name can match several verified advertisers (for example one per country). Scrape up to this many, those with the most ads first. Ignored for domains and IDs.

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

How many queries run at the same time.

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

Apify datacenter proxy is enough. Each request uses a fresh IP to stay clear of Google's rate limit.

## Actor input object example

```json
{
  "queries": [
    "hubspot.com"
  ],
  "mode": "ads",
  "region": "anywhere",
  "format": "all",
  "maxAdsPerQuery": 100,
  "includeDetails": false,
  "includeVideoIds": true,
  "maxAdvertisersPerName": 1,
  "concurrency": 4,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per ad creative (or advertiser). Download as JSON, CSV or Excel, or read it from this API endpoint.

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

Queries, ads delivered, queries without results and failures.

# 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 = {
    "queries": [
        "hubspot.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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

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/umJYfVDWSQuk1hjBl/builds/nGyNA7lUsz4iWwzTR/openapi.json