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

Scrape Google Ads Transparency Center. Extract ad creatives, headlines, sitelinks, seller ratings by keyword or domain. No browser, pure API.

- **URL**: https://apify.com/apivault\_labs/google-ads-transparency-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 ad creatives

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

Spy on competitor ads at scale. This actor extracts ad creatives, headlines, advertiser details, and targeting data from the [Google Ads Transparency Center](https://adstransparency.google.com/) — no browser needed, pure API.

Use it as a **Google ads spy tool** to monitor competitor campaigns, build ad intelligence reports, or track advertiser activity across regions.

### Why This Actor

| Feature | This Actor | solidcode | devilscrapes | memo23 |
|---------|-----------|-----------|--------------|--------|
| Keyword/domain search | ✅ | ❌ ID only | ❌ ID only | ❌ ID only |
| Headline & description decode | ✅ protobuf | ❌ | ❌ | ✅ Puppeteer (slow) |
| Sitelinks extraction | ✅ | ❌ | ❌ | ❌ |
| Seller rating & app extension | ✅ | ❌ | ❌ | ❌ |
| DUNS business number | ✅ | ❌ | ❌ | ❌ |
| EU verified identity | ✅ | ❌ | ❌ | ❌ |
| Ad Group ID / Customer ID | ✅ | ❌ | ❌ | ❌ |
| Region filter | ✅ | ❌ | ❌ | ❌ |
| Price per creative | $0.025 | unstable | $0.02 + $5 base | $4/1K |
| Browser required | No | Yes | Yes | Yes |

### Features

- **Keyword & domain search** — find competitor ads by product name, brand, or domain without knowing their advertiser ID
- **Full ad creative extraction** — headlines, descriptions, sitelinks decoded directly from protobuf (no slow browser rendering)
- **31 structured fields** per creative including format, dates, dimensions, and preview URLs
- **Advertiser intelligence** — verified entity name, DUNS number, country of registration, total ad count
- **Ad extensions** — seller ratings, app extensions with ratings and review counts
- **Internal IDs** — ad group ID and Google Ads customer ID for cross-referencing with other tools
- **Region filtering** — get ads shown in specific countries using ISO codes
- **Fast and cheap** — pure HTTP requests + protobuf decode, no Puppeteer overhead

### Input Parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `searchQuery` | string | Keyword or domain to search (e.g. `vpn`, `nike.com`, `insurance quotes`) |
| `advertiserIds` | string\[] | Direct advertiser IDs in AR-format (e.g. `AR18091944865498coursenull`) |
| `domains` | string\[] | Domains to find ads for (e.g. `nike.com`, `adidas.com`) |
| `region` | string | ISO country code filter (e.g. `US`, `GB`, `DE`). Empty = worldwide |

Provide at least one of: `searchQuery`, `advertiserIds`, or `domains`.

### Usage Examples

#### Search by keyword

```json
{
    "searchQuery": "vpn",
    "region": "US"
}
```

#### Search by competitor domain

```json
{
    "domains": ["nike.com", "adidas.com"],
    "region": "GB"
}
```

#### Direct advertiser lookup

```json
{
    "advertiserIds": ["AR18091944865498coursenull"]
}
```

### Output Fields

Each result contains up to 31 fields:

| Field | Description |
|-------|-------------|
| `creativeId` | Unique creative ID (CR format) |
| `advertiserId` | Advertiser ID (AR format) |
| `advertiserName` | Company/brand name |
| `advertiserCountry` | ISO country of registration |
| `verifiedName` | EU-verified legal entity name (TFAAR) |
| `isVerified` | Boolean verification status |
| `dunsNumber` | Dun & Bradstreet business identifier |
| `format` | `image`, `video`, or `text` |
| `firstShown` | ISO timestamp — when ad first appeared |
| `lastShown` | ISO timestamp — last appearance |
| `totalDaysShown` | Number of days the ad has been running |
| `previewUrl` | Main preview URL |
| `imageUrl` | Direct CDN URL for image ads |
| `imageWidth` / `imageHeight` | Image dimensions in pixels |
| `sourceUrl` | Link to view in Google Ads Transparency Center |
| `headline` | Ad headline (text ads, decoded from protobuf) |
| `description` | Ad body text (full unicode) |
| `visibleUrl` | Display URL shown in the ad |
| `targetDomain` | Destination domain |
| `sitelinks` | Array of RSA sitelink headlines |
| `sellerRating` | Object: `{rating, reviewCount, domain, country}` |
| `appExtension` | Object: `{callToAction, appTitle, appDeveloper, appIconUrl, appRating, appReviews, currency}` |
| `adGroupId` | Google Ads ad group ID |
| `googleAdsCustomerId` | Google Ads account ID (obfuscated) |
| `previewUrls` | Array of all preview variant URLs |
| `variations` | Array with image dimensions per variant |
| `region` | Region filter used |
| `scrapedAt` | Timestamp of scraping |
| `advertiserTotalAds` | Total active ads for this advertiser |
| `advertiserAdStats` | Object: `{total, video, image}` breakdown |

### Sample Output

```json
{
    "creativeId": "CR12345678901234567",
    "advertiserId": "AR18091944865498coursenull",
    "advertiserName": "Example Corp",
    "advertiserCountry": "US",
    "verifiedName": "Example Corporation LLC",
    "isVerified": true,
    "dunsNumber": "123456789",
    "format": "text",
    "firstShown": "2024-01-15T00:00:00.000Z",
    "lastShown": "2024-03-20T00:00:00.000Z",
    "totalDaysShown": 65,
    "headline": "Best VPN Service 2024 - Try Free for 30 Days",
    "description": "Protect your privacy online with military-grade encryption. 5000+ servers worldwide.",
    "visibleUrl": "example.com/vpn",
    "targetDomain": "example.com",
    "sitelinks": ["Pricing Plans", "Download Now", "Business VPN", "24/7 Support"],
    "sellerRating": { "rating": 4.6, "reviewCount": 12847, "domain": "example.com", "country": "US" },
    "region": "US",
    "scrapedAt": "2024-03-21T14:30:00.000Z",
    "advertiserTotalAds": 342,
    "advertiserAdStats": { "total": 342, "video": 28, "image": 214 }
}
```

### Pricing

Pay per result: **$0.025 per creative**. No monthly fees, no base charges.

| Creatives | Cost |
|-----------|------|
| 100 | $2.50 |
| 1,000 | $25 |
| 10,000 | $250 |

Platform compute costs apply separately (minimal — no browser used).

### How It Works

1. Queries the Google Ads Transparency Center reverse-engineered API
2. Decodes protobuf responses to extract full ad creative data
3. Resolves advertiser identity, verification status, and DUNS mapping
4. Returns structured JSON with all 31 fields per creative

No Puppeteer, no Playwright, no browser. This means faster execution, lower compute costs, and higher reliability compared to browser-based alternatives.

### Use Cases

- **Ad intelligence** — monitor what ads competitors are running and for how long
- **Creative research** — collect ad copy, headlines, and sitelinks for inspiration
- **Compliance monitoring** — track advertiser verification status and identity data
- **Market analysis** — see ad format distribution and regional targeting patterns
- **Brand protection** — find unauthorized ads using your brand name or domain

### FAQ

**Can I search by keyword?**
Yes. Use `searchQuery` with any keyword, brand name, or domain. This is unique to this actor — most alternatives require you to already know the advertiser ID.

**Does it need a browser or proxy?**
No browser, but a residential proxy is required. Google blocks datacenter IPs on the Transparency Center with a captcha, so the actor defaults to Apify Residential proxy. Datacenter proxy returns zero results.

**What regions are supported?**
All regions available in Google Ads Transparency Center. Use standard ISO country codes (US, GB, DE, FR, JP, etc.).

**How fresh is the data?**
Real-time. Each run queries the live Google Ads Transparency Center API.

**What's the difference between searchQuery and domains?**
`searchQuery` searches across advertiser names and ad content. `domains` specifically finds advertisers whose ads point to those destination domains.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more keywords, brand names, or domains to search. Runs all queries in one job. Examples: 'nike', 'vpn', 'nike.com'. For each query, the top advertiser by ad count is scraped.

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

List of domains to find ads for (e.g. 'nike.com', 'adidas.com'). The scraper finds all advertisers running ads pointing to these domains.

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

Direct advertiser IDs in AR-format (e.g. 'AR16735076323512287233'). Use when you already know the advertiser. Find IDs via adstransparency.google.com.

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

ISO country code to filter ads by region shown (e.g. 'US', 'GB', 'DE', 'FR', 'JP'). Leave empty for worldwide results.

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

Maximum number of ad creatives to scrape per run. Default 100, max 10000.

## `includeAdDetails` (type: `boolean`):

Fetch full creative details (headline, description, sitelinks, seller rating, app extension, variations). Adds one request per creative but returns much richer data.

## `includeAdvertiserInfo` (type: `boolean`):

Enrich each creative with advertiser name, country, and verified identity.

## `includeDunsNumber` (type: `boolean`):

Add the advertiser's DUNS number (EU compliance). Downloads the full advertiser→DUNS table (~3900 rows) once per run. Niche field — leave off unless you need it.

## `outputFields` (type: `array`):

Select which fields to include in the output. Leave EMPTY to return ALL fields. Pick specific fields to get a leaner dataset.

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

Proxy settings. RESIDENTIAL proxy is REQUIRED — Google blocks datacenter IPs on the Transparency Center with a captcha, returning zero results. Keep the default residential group.

## Actor input object example

```json
{
  "searchQueries": [
    "nike"
  ],
  "domains": [],
  "advertiserIds": [],
  "maxItems": 100,
  "includeAdDetails": true,
  "includeAdvertiserInfo": true,
  "includeDunsNumber": false,
  "outputFields": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "nike"
    ],
    "domains": [],
    "advertiserIds": [],
    "region": "",
    "maxItems": 100,
    "outputFields": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/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 = {
    "searchQueries": ["nike"],
    "domains": [],
    "advertiserIds": [],
    "region": "",
    "maxItems": 100,
    "outputFields": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/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 '{
  "searchQueries": [
    "nike"
  ],
  "domains": [],
  "advertiserIds": [],
  "region": "",
  "maxItems": 100,
  "outputFields": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call apivault_labs/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/RtWF57ncDP1x48I9Z/builds/msaPn74zo8mTKaAHk/openapi.json