# Google Ads Transparency Scraper — Competitor Ad Spy (`tactful_anvil/google-ads-transparency-scraper`) Actor

Spy on any advertiser's Google ads — search, YouTube, display. Search by keyword, domain or advertiser ID. Ad creatives (text/image/video), first/last shown dates, days active, isNew flag, monitor mode. HTTP-only, no login. $0.64/1,000 ads.

- **URL**: https://apify.com/tactful\_anvil/google-ads-transparency-scraper.md
- **Developed by:** [Mr Zack](https://apify.com/tactful_anvil) (community)
- **Categories:** Lead generation, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.64 / 1,000 ad 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/actors/running/actors-in-store.md#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 Ad Spy at $0.64/1,000 ads

See **every Google ad any advertiser is running** — search, YouTube, display — straight from the [Google Ads Transparency Center](https://adstransparency.google.com). Search by **brand keyword**, **domain** or **advertiser ID**, filter by country and format, and get clean JSON with dates, days-active and an `isNew` flag.

**The cheapest ad-spy on Apify: $0.64 per 1,000 ads + $0.001 per start.** No login, no API key, no browser, no proxy add-ons. Filtered and duplicate rows are **never charged**.

### Who uses this

- **Media buyers & dropshippers** — see which creatives competitors keep running (long `daysActive` = winning ad), and which they just launched (`isNew`).
- **Affiliate & offer researchers** — track advertisers in a niche daily; monitor mode only outputs (and only charges) ads you haven't seen before.
- **Agencies** — automated competitor ad reports per client, per country.
- **AI agents** — structured, predictable ad intelligence for autonomous marketing research (see below).

### What you get per ad

| Field | Example | Notes |
|---|---|---|
| `advertiserId` | `AR0781…` | stable Transparency Center ID |
| `advertiserName` | `Temu` | |
| `advertiserVerified` | `true` | |
| `creativeId` | `CR0946…` | stable — safe dedupe key |
| `format` | `text` / `image` / `video` | |
| `firstShown` / `lastShown` | ISO dates | campaign lifetime |
| `daysActive` | `211` | long-running = proven ad |
| `isNew` | `true` | first shown within `newWithinDays` (default 7) |
| `imageUrl` / `videoUrl` / `previewUrl` | | creative media |
| `adUrl` | | destination URL, best effort (mostly text ads) |
| `transparencyUrl` | | one-click open in Transparency Center |
| `sourceQuery` | `temu.com` | which of your inputs found it |

### Input modes (combine freely)

```json
{
  "keywords": ["hello fresh"],
  "domains": ["temu.com"],
  "advertiserIds": ["AR07816964328396947457"],
  "region": "US",
  "maxAdsPerQuery": 200,
  "onlyNew": false
}
```

- **keywords** — resolved via Transparency Center suggestions; top 3 advertisers with active ads are scraped per keyword.
- **domains** — all ads whose verified advertiser matches the domain.
- **advertiserIds** — most precise; grab IDs from any previous run.
- **region** — ISO alpha-2 (`US`, `GB`, `DE`, `ID`, …) or `anywhere`.

### Monitor mode — pay only for new ads

Set `"onlyNew": true`. The Actor remembers every `creativeId` it has already output (key-value store) and skips them next run — **skipped rows are never charged.** Combined with a daily schedule this gives you a live feed of every new ad your competitors launch.

### How to schedule this Actor (recommended)

1. Open the Actor → **Schedules** tab (or Console → Schedules → Create new).
2. Cron `0 6 * * *` (daily, 6 AM).
3. Input: your advertisers/domains + `"onlyNew": true`.
4. Add an integration (Slack/email/webhook) on new dataset items — you'll only be notified when competitors launch something new.

Daily monitoring of 10 advertisers typically costs **a few cents per month** because monitor mode only charges new creatives.

### For AI agents & MCP

This Actor is built to be called by AI agents via the [Apify MCP server](https://apify.com/apify/actors-mcp-server) or API:

- **Minimal input that just works:** `{"keywords": ["<brand>"]}` — everything else has sane defaults.
- **Predictable cost:** exactly `$0.00064 × ads` + `$0.001` per run; `maxAdsPerQuery` is a hard cost cap.
- **Stable schema:** every field above is always present (nullable, never missing); `creativeId` is a stable dedupe key across runs.
- **Recommended agent loop:** resolve brand → `advertiserIds` from first run → schedule with `onlyNew: true` → read only fresh competitor ads each day.

```bash
curl -s "https://api.apify.com/v2/acts/tactful_anvil~google-ads-transparency-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST -H 'Content-Type: application/json' \
  -d '{"domains":["temu.com"],"region":"US","maxAdsPerQuery":50}'
```

### Related Actors

- **[Brand Ads Spy — Google + LinkedIn Ads in One Feed](https://apify.com/tactful_anvil/brand-ads-cross-network-spy)** — this actor's big brother: the same Google feed **plus LinkedIn Ad Library** in one normalized dataset, with cross-network monitor mode.
- **[Google Play Reviews Scraper](https://apify.com/tactful_anvil/google-play-reviews-scraper)** & **[App Store Reviews Scraper](https://apify.com/tactful_anvil/app-store-reviews-scraper-multi-country-deep-history)** — mine competitor app reviews for the pain points their ads target.
- **[Contact Details Scraper](https://apify.com/tactful_anvil/contact-details-scraper)** → **[Bulk Email Verifier](https://apify.com/tactful_anvil/bulk-email-verifier)** — turn advertiser domains into verified outreach lists.

### Fair use & data source

Only public data from the Google Ads Transparency Center (published by Google for transparency purposes). Reasonable rate limits. No login, no personal data.

# Actor input Schema

## `keywords` (type: `array`):

Brand or advertiser names, e.g. "nike", "hello fresh". Resolved via Transparency Center suggestions; up to 3 advertisers with active ads are scraped per keyword.

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

Domains whose ads you want, e.g. "nike.com". One search per domain.

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

Exact Ads Transparency advertiser IDs (start with AR…). Most precise mode; get them from a previous run or the Transparency Center URL.

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

ISO alpha-2 country code (US, GB, DE, ID…) to filter where ads were shown, or "anywhere".

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

Hard cap per advertiser/domain — this caps your cost ($0.64 per 1,000 ads).

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

Only charge for these formats: text, image, video. Empty = all. Filtered rows are never charged.

## `newWithinDays` (type: `integer`):

Ads first shown within this many days get isNew=true — spot fresh campaigns instantly.

## `onlyNew` (type: `boolean`):

Skip creatives already output by previous runs of this Actor (state kept in key-value store). Perfect for scheduled daily monitoring — you only pay for genuinely new ads.

## `enrichDetails` (type: `boolean`):

Extra per-ad detail call (better media URLs, adUrl fallback). Slower; same price.

## Actor input object example

```json
{
  "keywords": [
    "temu"
  ],
  "domains": [],
  "advertiserIds": [],
  "region": "anywhere",
  "maxAdsPerQuery": 100,
  "formats": [],
  "newWithinDays": 7,
  "onlyNew": false,
  "enrichDetails": false
}
```

# Actor output Schema

## `ads` (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 = {
    "keywords": [
        "temu"
    ],
    "domains": [],
    "advertiserIds": [],
    "formats": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("tactful_anvil/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 = {
    "keywords": ["temu"],
    "domains": [],
    "advertiserIds": [],
    "formats": [],
}

# Run the Actor and wait for it to finish
run = client.actor("tactful_anvil/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 '{
  "keywords": [
    "temu"
  ],
  "domains": [],
  "advertiserIds": [],
  "formats": []
}' |
apify call tactful_anvil/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tactful_anvil/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/dpja5ZsrVOwH1H4mE/builds/5iABN7AkxQEJs6IzL/openapi.json