# Google Ads Transparency Scraper (`ninja.dev/google-ads-transparency-scraper`) Actor

Extract ad creatives from Google Ads Transparency Center by domain, advertiser, or keyword.

- **URL**: https://apify.com/ninja.dev/google-ads-transparency-scraper.md
- **Developed by:** [Matheus Coelho](https://apify.com/ninja.dev) (community)
- **Categories:** Developer tools, Lead generation, SEO tools
- **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 creative scrapes

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper — See Any Company's Google Ads

Ever wondered **what ads your competitors are running on Google**? This actor
extracts every ad creative a company runs from the **Google Ads Transparency
Center** — Google's public ads library — and can **flag the moment they launch
a new campaign**.

Think of it as the **Google equivalent of the Facebook Ad Library**, but
scriptable: give it a list of domains or advertiser names and get back
structured data — advertiser, ad format, last-shown date, and direct links to
every creative.

### Why this scraper

- **Campaign monitoring built in** — with **Detect new creatives** on (it is by
  default), every run remembers the ads it has already seen and flags brand-new
  ones with `isNew: true`, plus a count of new ads per domain. Run it on a
  daily schedule and you'll know the day a competitor launches something new.
  No other scraper on the Store tracks this across runs.
- **Fast & cheap** — talks to Google's data endpoint directly instead of
  loading pages in a browser, so runs finish in seconds and cost from
  **$3 per 1,000 ads**.
- **Rich data** — advertiser name and ID, ad format (image / text / video),
  last-shown date, and the creative asset URL for every ad.
- **Any country** — filter ads by region with a two-letter country code
  (`US`, `BR`, `DE`, ...).

### How to use it (30 seconds)

1. Enter one or more **domains** (e.g. `nike.com`) or advertiser names.
2. Pick a region (default `US`) and press **Start**.
3. Download the results as JSON, CSV, or Excel — or pipe them into Make,
   Zapier, n8n, or your own webhook via Apify integrations.

To monitor competitors automatically, save your input as a task and add a
**schedule** (e.g. daily). Each run reports how many ads are new since the
last one — perfect for a "competitor launched new ads" alert.

### Input

| Field | Type | Description |
|---|---|---|
| `domains` | array | Domains or advertisers to look up (e.g. `nike.com`). |
| `region` | string | Two-letter country code (default `US`). |
| `maxAdsPerDomain` | integer | Max ads to scrape per domain (default 50). |
| `includeDetails` | boolean | Fetch format/date/image per ad (default true). |
| `detectNewCreatives` | boolean | Flag new ads vs. last run (default true). |

### Output

One record per ad creative:

```json
{
  "domain": "nike.com",
  "region": "US",
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "creativeId": "CR13422600440197939201",
  "adUrl": "https://adstransparency.google.com/advertiser/.../creative/...",
  "isNew": true,
  "format": "image",
  "lastShown": "2026-07-17T18:06:56.000Z",
  "adLink": "https://tpc.googlesyndication.com/archive/simgad/..."
}
````

On top of the dataset, each run saves a compact summary (total ads and new ads
per domain) as the run's `OUTPUT` — handy when an integration only needs to
know *"did anything change?"* without reading the whole dataset.

### What people use it for

#### See every ad a competitor is running on Google

Enter a competitor's domain and get their full active creative inventory:
formats, copy angles, and how recently each ad was shown.

#### Get alerted when a competitor launches a new campaign

Schedule a daily run with **Detect new creatives** on. When `totalNewAds > 0`,
trigger a Slack/email alert through an Apify integration. You'll spot new
offers, promos, and product launches before they show up anywhere else.

#### Find companies actively spending on Google Ads (lead generation)

Agencies and SaaS vendors: a company with live Google ads has marketing budget.
Feed in a list of prospect domains and qualify them by advertising activity.

#### Monitor who advertises on your brand

Check which advertisers run ads connected to your brand or in your niche —
useful for brand protection and affiliate compliance.

#### Creative and copy research at scale

Pull hundreds of creatives from the leaders in your niche and study formats,
hooks, and messaging before spending your own ad budget.

### FAQ

#### Can I really see any company's Google ads?

Yes — the Google Ads Transparency Center is a public accountability tool where
Google discloses ads from verified advertisers. This actor reads that public
data and turns it into structured, exportable records.

#### How is this different from browsing the Transparency Center myself?

Manually, you can look at one advertiser at a time in a browser. The actor
checks dozens of domains in one run, exports everything to JSON/CSV, runs on a
schedule, and — the part the website can't do — remembers previous runs so it
can tell you **which ads are new**.

#### Is there a Google version of the Facebook Ad Library?

Yes — that's exactly what the Google Ads Transparency Center is, and this actor
is the scriptable way to use it: bulk lookups, exports, schedules, and
new-campaign detection.

#### How much does it cost? Can I try it for free?

Pricing is pay-per-result: **$3 per 1,000 ad creatives** — you only pay for
ads actually scraped. Apify's free plan includes $5 of monthly credit, enough
to scrape roughly 1,500 ads every month for free.

#### Do I need a Google account, API key, or proxies?

No. Everything runs inside the actor — no login, no API key, no proxy setup.

#### Which countries does it work for?

Any region the Transparency Center covers. Set the `region` input to a
two-letter country code (`US`, `BR`, `GB`, `DE`, ...) to filter ads shown in
that country.

#### Can it send alerts automatically?

Yes. Combine an Apify **schedule** (run daily) with an **integration**
(Slack, email, Make, Zapier, n8n, or webhook) that fires when the run summary
shows new ads.

### Support & feedback

Found a bug or missing a feature? Open a ticket in the **Issues** tab — I
usually respond within a few hours and actor updates ship fast.

If this actor saves you time, please leave a ⭐ **review** on the Store page.
It takes 10 seconds and genuinely helps other marketers find it — and tells me
what to build next.

### Legal & ethical use

This actor extracts only publicly available data from Google's Ads
Transparency Center, a public accountability tool — no logins, no private
data, no personal information. You are responsible for using the data in
compliance with applicable laws and the terms of service that apply to you.

# Actor input Schema

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

Domains (e.g. "nike.com") or advertiser names to look up in the Ads Transparency Center.

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

Two-letter country code to filter ads shown in that region (e.g. "US", "BR"). Default: US.

## `maxAdsPerDomain` (type: `integer`):

Maximum ad creatives to scrape per domain/advertiser.

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

Fetch format, last-shown date and image/preview URL for each ad (one extra request per ad). Turn off for a faster, cheaper ID-only listing.

## `detectNewCreatives` (type: `boolean`):

Remember ads seen in previous runs and flag brand-new ones with isNew=true, plus a summary of how many are new since last run. Ideal for monitoring when a competitor launches a new campaign. Uses a persistent named store.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "maxAdsPerDomain": 50,
  "includeDetails": true,
  "detectNewCreatives": true
}
```

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

// Run the Actor and wait for it to finish
const run = await client.actor("ninja.dev/google-ads-transparency-scraper").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"] }

# Run the Actor and wait for it to finish
run = client.actor("ninja.dev/google-ads-transparency-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ]
}' |
apify call ninja.dev/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ninja.dev/google-ads-transparency-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Transparency Scraper",
        "description": "Extract ad creatives from Google Ads Transparency Center by domain, advertiser, or keyword.",
        "version": "0.1",
        "x-build-id": "cW0ZjkekTrniX1aFp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ninja.dev~google-ads-transparency-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ninja.dev-google-ads-transparency-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ninja.dev~google-ads-transparency-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ninja.dev-google-ads-transparency-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ninja.dev~google-ads-transparency-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ninja.dev-google-ads-transparency-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains or advertisers",
                        "type": "array",
                        "description": "Domains (e.g. \"nike.com\") or advertiser names to look up in the Ads Transparency Center.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region",
                        "type": "string",
                        "description": "Two-letter country code to filter ads shown in that region (e.g. \"US\", \"BR\"). Default: US.",
                        "default": "US"
                    },
                    "maxAdsPerDomain": {
                        "title": "Max ads per domain",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum ad creatives to scrape per domain/advertiser.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include ad details",
                        "type": "boolean",
                        "description": "Fetch format, last-shown date and image/preview URL for each ad (one extra request per ad). Turn off for a faster, cheaper ID-only listing.",
                        "default": true
                    },
                    "detectNewCreatives": {
                        "title": "Detect new creatives (campaign monitoring)",
                        "type": "boolean",
                        "description": "Remember ads seen in previous runs and flag brand-new ones with isNew=true, plus a summary of how many are new since last run. Ideal for monitoring when a competitor launches a new campaign. Uses a persistent named store.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```