# Google Ads Transparency Monitor — Competitor Ad Tracking (`jp-data-engine/google-ads-transparency-monitor`) Actor

Track which ads your competitors are running on Google. Returns every creative in the Ads Transparency Center for a domain, with first/last shown dates, creative previews and region — built for daily monitoring.

- **URL**: https://apify.com/jp-data-engine/google-ads-transparency-monitor.md
- **Developed by:** [Shota Tatara](https://apify.com/jp-data-engine) (community)
- **Categories:** Marketing, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 ad creatives

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Google Ads Transparency Monitor** tells you **which ads your competitors are running on Google right now**. Give it a domain and it returns every ad creative that domain has in the [Google Ads Transparency Center](https://adstransparency.google.com/) — with the **first and last date each ad was shown**, how many days it has been running, the creative preview, and the region. Press Start with the defaults and you will see real ad data in about fifteen seconds.

The Transparency Center is Google's own public disclosure database, but its interface is built for looking at one advertiser at a time in a browser. This Actor turns it into a structured feed you can schedule, diff and pipe into a spreadsheet, a warehouse or an AI agent. On Apify you also get a REST API, webhooks, and integrations with Zapier, Make, Slack and n8n — so a daily "what did my competitors launch yesterday?" report becomes a five-minute setup.

### Why use Google Ads Transparency Monitor?

- **Track competitor campaigns continuously.** Ads appear and disappear. A daily run tells you what launched, what is still running after 90 days (usually a winner), and what quietly stopped.
- **Find the creatives worth copying.** `daysRunning` is the cheapest proxy for ad performance available anywhere: advertisers do not keep paying for ads that lose money.
- **Ad intelligence without a subscription.** Competitive ad tools charge hundreds a month for a view of this same public data.
- **Market entry and regional research.** Query the same advertiser across `US`, `GB`, `DE`, `JP` and see how the creative strategy changes by market.
- **Agencies and pitch prep.** Pull a prospect's entire ad footprint before the call.
- **AI agents and MCP.** Every Apify Actor is callable as an MCP tool, so an agent can answer "is this company advertising, and since when?" against the primary source.

### How to use Google Ads Transparency Monitor

1. Click **Try for free** / **Start** — the defaults track `nike.com` in the US so you can see the shape of the data immediately.
2. Put your own competitors in **Advertiser domains**, one per line. `nike.com`, `www.nike.com` and `https://nike.com/` all work.
3. Pick a **Region** — an ISO country code such as `US`, `GB`, `DE`, `JP`, or `ALL` for every region at once.
4. Set **Max ads in total**. This is the only thing that determines the cost of the run.
5. Run it, then download the dataset as JSON, CSV, Excel or XML — or send it to a webhook.
6. For continuous monitoring, open the **Schedule** tab, run it daily, and set **Only ads first shown on or after** to yesterday's date. You then receive only newly launched creatives.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `domains` | array | Advertiser websites to track, one per line. Default: `nike.com`. |
| `region` | string | ISO 3166-1 alpha-2 country code (`US`, `GB`, `DE`, `JP`, …) or `ALL`. Default `US`. |
| `maxItems` | integer | Hard cap on ads returned across all advertisers. Default `1000`. |
| `maxItemsPerAdvertiser` | integer | Per-advertiser cap so one large advertiser cannot consume the whole budget. Default `100`. |
| `firstShownAfter` | string | `YYYY-MM-DD`. Keep only ads first shown on or after this date — **this is the daily-monitoring filter**. |
| `lastShownAfter` | string | `YYYY-MM-DD`. Keep only ads still shown recently. |
| `maxPagesPerAdvertiser` | integer | Search-depth safety limit, 40 creatives per page. Default `25`. |
| `requestDelayMs` | integer | Minimum pause between requests. Floored at 1000 ms. |

```json
{
    "domains": ["nike.com", "adidas.com"],
    "region": "US",
    "firstShownAfter": "2026-08-01",
    "maxItems": 500
}
```

### Output

```json
{
    "creativeId": "CR01627280765341401089",
    "advertiserId": "AR18378488041124659201",
    "advertiserName": "Nike Retail BV",
    "advertiserDomain": "nike.com",
    "regionCode": "US",
    "creativeType": "image",
    "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/1647651078873472722",
    "previewRenderUrl": null,
    "firstShownAt": "2025-10-27",
    "lastShownAt": "2026-08-14",
    "daysRunning": 291,
    "transparencyUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR01627280765341401089?region=US",
    "scrapedAt": "2026-08-14T09:13:32.342Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Data fields

| Field | Description |
| --- | --- |
| `creativeId`, `advertiserId` | Google's identifiers. `creativeId` is stable, so you can diff runs to find new ads. |
| `advertiserName` | The verified advertiser name Google displays — often a legal entity, which is useful on its own. |
| `advertiserDomain` | The advertiser's website. |
| `regionCode` | The region the search was run for. |
| `creativeType` | `image` when Google exposes a static creative, `rendered` when the ad is an HTML/video unit shown through a preview renderer. |
| `previewImageUrl` | Direct URL of the creative image, when there is one. Images are linked, never re-hosted. |
| `previewRenderUrl` | Google's rendered-preview URL for non-static creatives. |
| `firstShownAt`, `lastShownAt` | ISO dates. The pair is the campaign's visible lifespan. |
| `daysRunning` | Days between first and last shown — the closest thing to a performance signal in public data. |
| `formatCode` | Google's internal format number. Included raw and deliberately not relabelled: Google does not publish what the codes mean, and guessing would be worse than saying so. |
| `matchedTotalLowerBound`, `matchedTotalUpperBound` | Google's own coarse estimate of how many creatives match the query. These are heavily bucketed (100/200, 9,000/10,000, 3,200,000/3,300,000) — treat them as an order of magnitude, not a count. |
| `transparencyUrl` | Deep link to the ad on Google's site, so any row can be verified in one click. |

### How much does it cost to track competitor ads?

Cost scales with **Max ads in total**, not with runtime. One request returns 40 creatives, so a typical competitor pull is a handful of requests. Measured on real runs: 100 ads in about 12 seconds; 5 advertisers at 100 ads each in roughly a minute.

A daily monitor over ten competitors with `firstShownAfter` set to yesterday usually returns a few dozen rows a day.

The Apify free tier is enough to try the Actor and to run a small daily monitor.

### Tips

- **For daily monitoring**, set `firstShownAfter` to yesterday. You pay only for genuinely new creatives instead of re-collecting the whole history.
- **`daysRunning` is your ranking column.** Sort descending and the top of the list is your competitor's proven creative.
- **Compare regions** by running the same domain with `US`, then `GB`, then `DE`.
- **Date filters are applied to results in the order Google returns them**, so a very narrow date range on a very large advertiser may hit the page limit before filling your item budget. The run warns you when that happens — raise `maxPagesPerAdvertiser` to search deeper.
- **A proxy is available in Advanced settings but is normally unnecessary.** The Transparency Center is public and has no anti-bot challenge. It does rate-limit, and the Actor already backs off and retries automatically.

### FAQ

**Where does the data come from?**
Google's own Ads Transparency Center, which Google publishes for advertising-transparency compliance. No login is involved, and the site publishes no `robots.txt` restricting automated access.

**Is this legal?**
The Actor reads a public disclosure database and collects no personal data — advertisers here are companies, and the fields are advertiser name, domain, dates and creative previews. Creative images stay on Google's servers and are only linked, never copied.

**Why is there no ad spend or impression data?**
Google only publishes spend and impression figures for political ads and for ads shown in the EEA. This Actor returns what the Transparency Center exposes for all advertisers. If you specifically need EEA spend data, Google's public BigQuery dataset is the right source for that.

**Does an ad disappearing mean the campaign stopped?**
Not necessarily. Coverage and retention are Google's choice. Treat disappearance as a signal, not proof.

**Why does `matchedTotalLowerBound` look strange?**
Because Google reports it in coarse buckets. It is passed through unmodified rather than dressed up as an exact number.

**Something broke, or you need a different ad source?**
Open the **Issues** tab on this Actor. Google changes its interfaces from time to time, and issues reported there get fixed. Custom variants can be built on request.

***

*Disclaimer: this Actor reproduces publicly disclosed advertising data for research and competitive-analysis purposes. Not affiliated with, or endorsed by, Google.*

# Actor input Schema

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

Advertiser websites to track, one per line. `nike.com`, `www.nike.com` and `https://nike.com/` all work. Leave empty to run the built-in demo.

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

ISO 3166-1 alpha-2 country code the ads were shown in, e.g. `US`, `GB`, `DE`, `JP`. Use `ALL` for every region at once.

## `maxItemsPerAdvertiser` (type: `integer`):

Caps how many creatives are collected for each advertiser, so one large advertiser cannot consume the whole budget.

## `maxItems` (type: `integer`):

Hard cap across all advertisers. This is what determines the cost of the run.

## `firstShownAfter` (type: `string`):

`YYYY-MM-DD`. This is the filter to use for daily monitoring: set it to yesterday and you get only newly launched creatives.

## `lastShownAfter` (type: `string`):

`YYYY-MM-DD`. Use it to keep only campaigns that are still running recently.

## `maxPagesPerAdvertiser` (type: `integer`):

Safety limit on how deep to search. Date filters are applied to results in the order the source returns them, so a narrow date range on a large advertiser can page for a long time. Each page holds 40 creatives.

## `requestDelayMs` (type: `integer`):

Minimum pause between two requests. The default is deliberately slow: the Transparency Center rate-limits bursts, and going faster mostly buys you 429s and retries. Values below 1000 ms are ignored.

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

Apify Proxy is on by default. The Transparency Center rate-limits per IP and shared datacenter addresses are often already throttled, so a rotating IP is what keeps runs reliable. Set useApifyProxy to false to run from the bare container.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "maxItemsPerAdvertiser": 100,
  "maxItems": 1000,
  "firstShownAfter": "2026-08-01",
  "lastShownAfter": "2026-08-01",
  "maxPagesPerAdvertiser": 25,
  "requestDelayMs": 2000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "domains": [
        "nike.com"
    ],
    "region": "US",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jp-data-engine/google-ads-transparency-monitor").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 = {
    "domains": ["nike.com"],
    "region": "US",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("jp-data-engine/google-ads-transparency-monitor").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 '{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call jp-data-engine/google-ads-transparency-monitor --silent --output-dataset

```

## MCP server setup

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

```

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/AC3md1jbhXCEaF5wJ/builds/V7J0WMq4AqDClEBRj/openapi.json