# Google Ads Transparency Scraper — Competitor Ads Library (`flash_scraper/google-ads-transparency-scraper`) Actor

Google Ads Transparency scraper: see every ad a competitor runs on Google. Domains, brand terms or advertiser IDs in - advertiser, format, preview, first/last shown dates and days active out. Only-new-creatives mode turns a schedule into a competitor-ad alert.

- **URL**: https://apify.com/flash\_scraper/google-ads-transparency-scraper.md
- **Developed by:** [Flash Scrape](https://apify.com/flash_scraper) (community)
- **Categories:** Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job results

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 Scraper — Competitor Ads Library

See **every ad a competitor runs on Google** — Search, Display and YouTube — straight from Google's own [Ads Transparency Center](https://adstransparency.google.com), the public accountability tool where every advertiser's creatives are listed. Give it a domain (`nike.com`), a brand term (`nike` — auto-resolved to its top advertiser domain) or an advertiser ID (`AR…`), and get one clean row per ad: advertiser, format, preview, **first-shown and last-shown dates**, and days active.

No API key, no login, no browser — the actor calls the same keyless endpoint the Transparency Center's own page uses, so the data is exactly what Google publishes, at the moment you run it.

> Watching competitors on Facebook/Meta instead? The Ad Library niche is well covered on the Store — this actor is for the Google side, where fresh, honest tooling is scarce.

### What you get

One row per ad creative. Measured on `nike.com` (100 rows, 2026-08-15):

| column | fill | notes |
|---|---|---|
| `advertiser_id`, `advertiser_name` | 100% | e.g. `AR18378488041124659201`, "Nike Retail BV" — ads run by resellers/agencies for the same domain show up under their own advertiser |
| `domain` | 100% | the advertiser's verified domain |
| `creative_id` | 100% | Google's `CR…` id — stable, deduplicated |
| `format` | 100% | `text` / `image` / `video` |
| `preview_url` | 100% | archived screenshot for text ads, render URL for display/video |
| `first_shown`, `last_shown` | 100% | real dates — the sample's `last_shown` was the run date itself |
| `days_active` | 100% | how long the creative has been running — long-running ads are the ones making money |
| `transparency_url` | 100% | the ad's own public page on Google's Transparency Center |
| `query` | 100% | which of your targets produced the row |

Example row (real):

```json
{
  "advertiser_id": "AR18378488041124659201",
  "advertiser_name": "Nike Retail BV",
  "domain": "nike.com",
  "creative_id": "CR16074515335549550593",
  "format": "image",
  "preview_url": "https://tpc.googlesyndication.com/archive/simgad/3436141099225117854",
  "first_shown": "2025-07-01",
  "last_shown": "2026-08-15",
  "days_active": 410,
  "transparency_url": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR16074515335549550593",
  "query": "nike.com",
  "source": "google-ads-transparency"
}
```

### Quick start

Run it with no input at all — you get up to 100 of Nike's current Google ads. Then point it at your own market:

```json
{
  "queries": ["asics.com", "on-running.com", "hoka.com"],
  "activeWithinDays": 30,
  "maxItems": 300
}
```

`activeWithinDays: 30` is the filter that matters: it keeps only ads **last shown in the past month** — a competitor's *currently running* campaigns instead of a year of history. Long `days_active` + recent `last_shown` = the proven winners they keep paying for.

### Input reference

| field | default | what it does |
|---|---|---|
| `queries` | 1-domain sample | Domains (exact) or brand terms (auto-resolved via Google's own suggestions). Your list replaces the sample entirely. |
| `advertiserIds` | `[]` | `AR…` ids — grab them from any run's rows to watch specific advertisers precisely. |
| `format` | `any` | Keep only `text`, `image` or `video` ads. Applied before billing. |
| `activeWithinDays` | `0` (off) | Keep only ads last shown within N days. Undated ads are kept, never guessed away. |
| `onlyNewCreatives` | `false` | Competitor-ad alert mode — see below. |
| `maxItems` | `100` | Total cap across all targets, split round-robin. Your cost ceiling. |
| `proxy` | Apify Proxy | Google rate-limits this endpoint per IP (measured: ~15 rapid requests → 429). The default automatic proxy rotates to a fresh session on every rate-limit; your own proxy URLs are honored. |

Every filter runs **before billing** — a filtered ad is never charged.

### 🔔 Competitor-ad alerts: `onlyNewCreatives` + a schedule

Schedule the actor (daily or weekly) with `onlyNewCreatives: true` and the same targets:

- the **first run is the baseline** — it delivers everything and says so;
- every later run delivers **only creatives not seen before** — i.e. the competitor's *new* ads;
- a quiet run delivers nothing, **bills nothing**, and says "Nothing new" plainly.

A competitor launching new creatives is a competitor testing a new offer, product or angle — this is the cheapest way to hear about it first. Watch memory lives in a named key-value store (`google-ads-monitor`) in your own account, pruned automatically (90 days / 50k keys).

### Use it from your code

```javascript
// JavaScript — apify-client
const { ApifyClient } = require('apify-client');
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('flash_scraper/google-ads-transparency-scraper').call({
  queries: ['nike.com'], activeWithinDays: 30, maxItems: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
## Python — apify-client
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("flash_scraper/google-ads-transparency-scraper").call(run_input={
    "queries": ["nike.com"], "activeWithinDays": 30, "maxItems": 200})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

```bash
## curl — run synchronously and get the dataset back
curl -X POST "https://api.apify.com/v2/acts/flash_scraper~google-ads-transparency-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["nike.com"], "maxItems": 50}'
```

### n8n / Make / Zapier

All three have a native Apify node/module: pick **Run actor** → `flash_scraper/google-ads-transparency-scraper`, pass the JSON input above, and read the default dataset when the run finishes. `onlyNewCreatives` + a schedule trigger pipes every new competitor ad into Slack, a sheet or your CRM — and quiet days cost nothing.

### Honest limits

- **Google's data, Google's rules.** The Transparency Center keeps roughly the last year of ads and doesn't expose spend or impressions per creative — nobody scraping it can. What you get is what Google publishes: the creatives, who ran them, and when they ran.
- **No region filter yet.** Results are worldwide for the advertiser; `first_shown`/`last_shown`/`days_active` still tell you what's actively running.
- **Ad text for text ads** ships as an archived screenshot URL (`preview_url`), not extracted copy — that is how Google serves them.
- Brand-term resolution is best-effort (it uses Google's own suggestion service); the exact domain is always the reliable input.
- The endpoint rate-limits per IP; the default proxy handles it. Very large pulls simply take longer — pacing is deliberate.

### Related actors

- [Multi Job Board Scraper — LinkedIn, Indeed, Glassdoor + 9 more](https://apify.com/flash_scraper/multi-jobboard-scraper)
- [Workday Jobs Scraper — company careers, no API key](https://apify.com/flash_scraper/workday-jobs-scraper)
- [Local Business Leads — any category, any city, MX-verified emails](https://apify.com/flash_scraper/local-business-leads)

# Actor input Schema

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

One per line: a domain like 'nike.com' (exact) or a brand term like 'nike' (auto-resolved to the top matching advertiser domain). Supplying your own list replaces the sample entirely.

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

Google advertiser IDs starting with 'AR' (every delivered row carries its advertiser\_id, so grab them from a first run and watch specific advertisers precisely).

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

Only keep ads of one format. 'any' keeps everything.

## `activeWithinDays` (type: `integer`):

Only keep ads LAST SHOWN within the last N days - the honest way to see a competitor's currently running campaigns instead of a year of history. 0 = no filter. Ads whose last-shown date Google doesn't state are kept, never guessed away.

## `onlyNewCreatives` (type: `boolean`):

The first run is the baseline (delivers everything and says so). Every later run with the same targets + filters delivers ONLY creatives not seen before; a run where nothing is new delivers nothing, bills nothing, and says 'Nothing new' plainly. Memory lives in a named key-value store ('google-ads-monitor') in your own account.

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

Total cap across ALL targets in the run, split round-robin so one giant advertiser cannot eat the whole budget. Your cost ceiling.

## `proxy` (type: `object`):

Google rate-limits this endpoint per IP (measured: ~15 rapid requests earn a 429), so the default Apify Proxy with automatic fresh-session rotation is recommended. Your own proxy URLs are honored.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "advertiserIds": [],
  "format": "any",
  "activeWithinDays": 30,
  "onlyNewCreatives": false,
  "maxItems": 50,
  "proxy": {
    "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 = {
    "queries": [
        "nike.com"
    ],
    "activeWithinDays": 30,
    "maxItems": 50,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("flash_scraper/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 = {
    "queries": ["nike.com"],
    "activeWithinDays": 30,
    "maxItems": 50,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("flash_scraper/google-ads-transparency-scraper").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": [
    "nike.com"
  ],
  "activeWithinDays": 30,
  "maxItems": 50,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call flash_scraper/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/ftny0CjDe3lHbRXVS/builds/YxHC9nEFyvwohPaex/openapi.json