# Google Ads Transparency Scraper – Monitor New Competitor Ads (`leadsbrary/google-ads-transparency-advertiser-monitor`) Actor

Google Ads Transparency scraper that monitors competitor ads by domain or advertiser ID: returns new creatives with format, first/last shown dates, ad URL and preview. Export JSON, CSV, Excel. From $0.40 per 1,000 results.

- **URL**: https://apify.com/leadsbrary/google-ads-transparency-advertiser-monitor.md
- **Developed by:** [Alexandre Manguis](https://apify.com/leadsbrary) (community)
- **Categories:** SEO tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 – Monitor New Competitor Ads

### What does Google Ads Transparency Monitor do?

This **Google Ads Transparency scraper** looks up any advertiser by website domain or Google advertiser ID in the public [Google Ads Transparency Center](https://adstransparency.google.com/) and returns their ad creatives: format (text, image, video), first and last shown dates, a link to the ad page and a preview URL. Turn on **monitor mode** and every scheduled run returns only the creatives it has not seen before for that monitor — a simple "what did my competitors just launch?" feed. Export to JSON, CSV or Excel, or send results to Slack, Google Sheets or a webhook through Apify integrations.

It reads only public data, needs no login and no browser, and runs on Apify datacenter proxies.

### Use cases

- **Performance marketers and agencies** – watch competitors' new Google Ads creatives each week.
- **Brand and competitive-intelligence teams** – track who advertises in a country and in which formats (text, image, video).
- **E-commerce and SaaS founders** – get alerted to new campaigns of rival brands.
- **Researchers and journalists** – export ad archives per advertiser or per region and date range.

### Features

- Search by **domain** (e.g. `nike.com`) and/or **advertiser ID** (`AR…`) or full Transparency Center advertiser URL.
- **Monitor mode** (`onlyNewAds`): remembers seen creatives per `monitorName` and returns/bills only new ones. The first run returns everything it finds.
- Filters: region (`anywhere` or a country code), ad format (TEXT / IMAGE / VIDEO), date range (absolute or relative like `30 days`).
- Optional creative details: countries where the ad was shown and the creative asset URL (one extra request per ad, slower).
- Caps for cost control: ads scanned per advertiser and maximum results per run.
- Unknown domains/IDs produce a clear error row instead of failing the whole run.

### Input

#### Configuration

Provide at least one domain or advertiser ID; all other fields are optional.

| Field | Type | Description |
|---|---|---|
| `domains` | string\[] | Competitor domains. Protocol, `www` and path are stripped. |
| `advertiserIds` | string\[] | Advertiser IDs (`AR…`) or advertiser page URLs. Provide domains and/or IDs. |
| `region` | string | `anywhere` (default) or a country code such as `US`, `GB`, `DE`, `FR`. |
| `formats` | string\[] | `TEXT`, `IMAGE`, `VIDEO`. Empty = all. |
| `dateFrom` / `dateTo` | string | `YYYY-MM-DD` or relative (`30 days`). Empty = no bound. |
| `onlyNewAds` | boolean | Default `true`: only creatives not seen by this monitor before. Set `false` for a plain snapshot. |
| `monitorName` | string | Name of the remembered state (default `default`). Use one per competitor list. |
| `resetMonitor` | boolean | Forget seen ads before this run (re-baseline). |
| `includeCreativeDetails` | boolean | Adds `regionsShown` and `assetUrl`. Slower. |
| `maxResultsPerAdvertiser` | integer | Creatives scanned per advertiser, newest first (default 100). |
| `maxResults` | integer | Stop after this many delivered ads (default 200). Also caps spending. |
| `proxyConfiguration` | object | Apify datacenter proxy (default, recommended). |

#### Example input

```json
{
  "domains": ["nike.com"],
  "region": "US",
  "onlyNewAds": true,
  "monitorName": "my-competitors",
  "maxResultsPerAdvertiser": 30,
  "maxResults": 20
}
```

### Output

#### Example output

One dataset item per ad creative. Sample (nike.com, region US):

```json
{
  "creativeId": "CR02140587682869280769",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "domain": "nike.com",
  "format": "TEXT",
  "firstShown": "2023-11-16T22:23:39.000Z",
  "lastShown": "2026-10-04T09:56:25.000Z",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR02140587682869280769",
  "previewUrl": "https://tpc.googlesyndication.com/archive/simgad/13612398631290192720",
  "inputQuery": "nike.com",
  "regionFilter": "US",
  "regionsShown": null,
  "assetUrl": null,
  "isNew": true,
  "firstSeenByMonitor": "2026-10-04T10:35:46.538Z",
  "scrapedAt": "2026-10-04T10:35:46.688Z"
}
```

#### Output fields and fill rates

Measured on a production run of 45 ads (`TEST_REPORT.json`, medium run, details enabled for part of the input):

| Field | Fill rate | Notes |
|---|---|---|
| `creativeId`, `advertiserId`, `advertiserName`, `format`, `firstShown`, `lastShown`, `adUrl`, `previewUrl` | 100% | |
| `inputQuery`, `regionFilter`, `isNew`, `firstSeenByMonitor`, `scrapedAt` | 100% | |
| `domain` | 100% when searching by domain; empty when searching by advertiser ID | 0% in the advertiser-ID proof run |
| `regionsShown` | 100% in the medium run | Only filled when `includeCreativeDetails` is on (0% in runs without it) |
| `assetUrl` | 28.9% | Only with `includeCreativeDetails`; not every creative exposes a direct asset |

#### Modes proven on Apify

| Mode | Input | Result |
|---|---|---|
| Advertiser ID, video only | `advertiserIds`, `formats: ["VIDEO"]`, 30 max | 30 items, 0 error rows |
| Domain monitor, region US | `domains`, `onlyNewAds: true` | 15 items, all `isNew: true` on first run |
| Future `dateFrom` | date in the future | Run succeeds, 0 items |
| Unknown domain | `this-domain-does-not-exist-xyz123.com` | Run succeeds, 1 error row (not billed): "No advertiser or ads found for this input in the Google Ads Transparency Center." |
| Empty input | no domains or IDs | Run fails fast: "Provide at least one domain or advertiser ID." |

### Run via API

Replace `USERNAME` with the Actor's owner and `YOUR_TOKEN` with your Apify API token.

**curl**

```bash
curl -X POST "https://api.apify.com/v2/acts/USERNAME~google-ads-transparency-advertiser-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["nike.com"], "region": "US", "onlyNewAds": true, "monitorName": "my-competitors", "maxResults": 20}'
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('USERNAME/google-ads-transparency-advertiser-monitor').call({
    domains: ['nike.com'],
    region: 'US',
    onlyNewAds: true,
    monitorName: 'my-competitors',
    maxResults: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("USERNAME/google-ads-transparency-advertiser-monitor").call(run_input={
    "domains": ["nike.com"],
    "region": "US",
    "onlyNewAds": True,
    "monitorName": "my-competitors",
    "maxResults": 20,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Monitoring competitors on a schedule

Create an Apify **Schedule** (for example daily or weekly) that runs this Actor with the same `monitorName` and `onlyNewAds: true`. Each run returns only creatives not seen in earlier runs, so you pay only for new ads. Connect the dataset to Slack, Google Sheets or a webhook with Apify integrations.

### Pricing

#### Cost per result

Pay per result: one event per ad delivered. Error rows are not billed.

| Apify plan | Price per 1,000 results |
|---|---|
| Free | $0.60 |
| Bronze | $0.52 |
| Silver | $0.46 |
| Gold and above | $0.40 |

In monitor mode you are billed only for new ads. `maxResults` caps what a run can spend. Platform usage (compute and proxy) is billed separately by Apify; in the measured production runs it was well under $0.001 per run for 15–45 ads.

### Troubleshooting and limits

- **"Invalid input: Provide at least one domain or advertiser ID."** – add `domains` or `advertiserIds`.
- **Error row "No advertiser or ads found"** – the domain has no verified advertiser in the Transparency Center; check the spelling or use the advertiser ID from the advertiser page URL.
- **0 results in monitor mode** – nothing new since the last run with this `monitorName`. Set `resetMonitor: true` to re-baseline or `onlyNewAds: false` for a snapshot.
- **0 results with a date filter** – the range may contain no ads (a future `dateFrom` always returns nothing).
- **`regionsShown` / `assetUrl` empty** – enable `includeCreativeDetails`; `assetUrl` is not available for every creative.
- **`domain` empty** – expected when you search by advertiser ID.
- **Rate limiting (HTTP 429)** – keep Apify datacenter proxy enabled; running from a home IP gets throttled.

### FAQ

#### Common questions

##### Is it legal to scrape the Google Ads Transparency Center?

The Actor only reads publicly available pages that Google publishes for transparency, without login. You remain responsible for complying with Google's terms and applicable laws (including GDPR) for how you use the data.

##### Does it return the ad text or image?

It returns the ad URL, a preview URL and, with creative details, an asset URL when available. It does not download media files.

##### How does monitor mode know what is new?

It stores creative IDs in a key-value store named after your `monitorName`. Use a different name for each competitor list.

##### Can I search by company name?

Not directly; use the domain or the advertiser ID/URL.

##### Which regions are supported?

`anywhere` plus the country codes listed in the input field description.

### Keywords

google ads transparency scraper, google ads transparency center, competitor ads monitor, google ads spy, ad creatives export, advertiser ads lookup, new ads alert, competitor ad tracking, ads transparency API, google ads library

### Hashtags

\#googleads #adstransparency #competitoranalysis #adintelligence #adspy #marketingintelligence #ppc #scraper #apify

# Changelog

This Actor's version history is a separate document: https://apify.com/leadsbrary/google-ads-transparency-advertiser-monitor/changelog.md

# Actor input Schema

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

Competitor website domains (e.g. nike.com). Protocol, www and path are stripped. Provide domains and/or advertiser IDs.

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

Google advertiser IDs (AR…) or full Transparency Center advertiser page URLs.

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

"anywhere" or an ISO 3166-1 alpha-2 country code (US, GB, DE, FR, ES, IT, NL, CA, AU, BR, IN, JP, MX, PL, SE, TR, ZA, AR, BE, CH, AT, IE, PT, DK, NO, FI, NZ, SG, KR, CZ, RO, GR, CO, CL, ID, PH, TH, AE, SA, IL, NG, EG, UA, HU).

## `formats` (type: `array`):

Only these ad formats. Empty = all formats.

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

YYYY-MM-DD or relative like "30 days". Empty = no lower bound.

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

YYYY-MM-DD or relative like "7 days". Empty = no upper bound.

## `onlyNewAds` (type: `boolean`):

Return (and bill) only creatives not seen in previous runs with the same monitor name. The first run returns everything it finds. Disable for a plain snapshot export.

## `monitorName` (type: `string`):

Name of the remembered state (key-value store gatm-<name>). Lowercase letters, digits, dashes. Use different names for different competitor lists.

## `resetMonitor` (type: `boolean`):

Forget previously seen ads before this run (re-baseline).

## `includeCreativeDetails` (type: `boolean`):

One extra request per ad to add the countries where it was shown and the creative asset URL. Slower.

## `maxResultsPerAdvertiser` (type: `integer`):

Cap on creatives scanned per domain / advertiser, newest first.

## `maxResults` (type: `integer`):

Stop after this many delivered ads (also caps your spending).

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

Apify datacenter proxy is enough and recommended.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "onlyNewAds": true,
  "monitorName": "my-competitors",
  "resetMonitor": false,
  "includeCreativeDetails": false,
  "maxResultsPerAdvertiser": 30,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `summary` (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",
    "onlyNewAds": false,
    "monitorName": "my-competitors",
    "maxResultsPerAdvertiser": 30,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadsbrary/google-ads-transparency-advertiser-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",
    "onlyNewAds": False,
    "monitorName": "my-competitors",
    "maxResultsPerAdvertiser": 30,
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("leadsbrary/google-ads-transparency-advertiser-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",
  "onlyNewAds": false,
  "monitorName": "my-competitors",
  "maxResultsPerAdvertiser": 30,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call leadsbrary/google-ads-transparency-advertiser-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leadsbrary/google-ads-transparency-advertiser-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/jXy6x1qOeUazendnX/builds/rc2npkM3N9SDZwxv1/openapi.json