# Google Ads Transparency Scraper: Competitor Ads by Domain (`api-co/google-ads-transparency-scraper`) Actor

Get every Google ad a competitor runs from the Google Ads Transparency Center: search by domain, advertiser name or ID; filter by country, format (text, image, video) and date. First/last shown, days running, image and YouTube video URLs. $1 per 1,000 ads.

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

## Pricing

from $0.80 / 1,000 ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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: Competitor Ads by Domain

See **every Google ad a competitor runs**, straight from the public **Google Ads Transparency Center** (adstransparency.google.com). Search by **website domain**, **advertiser name** or **advertiser ID**, filter by **country**, **format** (text/Search, image/Display, video/YouTube) and **date**, and export each ad with first and last shown dates, days running, preview image, preview URL and, for many video ads, the YouTube video URL.

### How to use

1. Enter one or more **domains** (`nike.com`), **advertiser names** (`Nike`) or **advertiser IDs** (`AR16735076323512287233`). Transparency Center URLs work too.
2. Optionally pick a **country** (`US`, `GB`, `DE`, `MX`...), an **ad format** and a **date range**.
3. Click **Start** and export JSON, CSV or Excel, or send the ads to Google Sheets, Airtable, Slack, Zapier, Make or n8n.

### Why this Actor

| | This Actor |
|---|---|
| Search by domain, advertiser name, advertiser ID or URL | **Yes**, mixed in one run |
| Country, format and date filters (same as the Transparency Center UI) | **Yes** |
| First shown, last shown and days running | **Yes** |
| Preview image for text and image ads, YouTube URL for video ads (when Google exposes it) | **Yes** |
| Optional details: all ad variations and the countries where each ad ran | **Yes** |
| Price | **$1 / 1,000 ads** + $0.005 per run |

### Input example

```json
{
  "searchTerms": ["nike.com", "Adidas", "AR16735076323512287233"],
  "region": "US",
  "format": "video",
  "dateFrom": "2026-09-01",
  "includeDetails": true,
  "maxAdsPerSearch": 200,
  "maxItems": 600
}
```

### Output (one item per ad)

```json
{
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserDomain": "nike.com",
  "creativeId": "CR09321311378696306689",
  "format": "TEXT",
  "firstShown": "2022-11-30T14:51:06.000Z",
  "lastShown": "2026-10-23T22:38:10.000Z",
  "daysRunning": 1424,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/15795779259366162468",
  "previewUrl": null,
  "youtubeVideoId": null,
  "videoUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR09321311378696306689?region=US",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US",
  "searchTerm": "nike.com",
  "regionFilter": "US",
  "variationCount": 5,
  "variationUrls": ["https://tpc.googlesyndication.com/archive/simgad/15795779259366162468", "..."],
  "regionsShown": [{ "countryCode": "US", "lastShown": "2026-10-23" }],
  "scrapedAt": "2026-10-24T05:45:00.000Z"
}
```

`variationCount`, `variationUrls` and `regionsShown` appear when *Include ad details* is on.

### How much does it cost?

Pay per event: **$0.005 per run + $0.001 per ad** ($1 per 1,000). No compute charges.

| You get | You pay (Starter/Bronze plan) |
|---|---|
| 100 ads | $0.105 |
| 1,000 ads | $1.005 |
| 10,000 ads | $10.005 |

Apify's **free plan includes $5 of usage every month**, and free-plan users pay **half price**, so that covers about **9,000 ads**. Paid plans get volume discounts (Silver -10%, Gold and above -20%). Set a *maximum cost per run* and the Actor stops cleanly at your limit.

### Use cases

- **PPC agencies and media buyers**: audit a prospect's or competitor's Google Search, Display and YouTube ads before a pitch.
- **Ecommerce and DTC brands**: find long-running (winning) ads by sorting on `daysRunning`.
- **Creative strategists**: build swipe files of image and video ads by niche and country.
- **Lead generation**: find businesses that actively advertise on Google (they have budget) and enrich them.
- **Brand protection**: spot advertisers bidding on or imitating your brand.

### Run it from code (API, Python, JavaScript)

```bash
curl -X POST "https://api.apify.com/v2/acts/api-co~google-ads-transparency-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" -d '{"searchTerms": ["nike.com"], "region": "US", "maxItems": 100}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("api-co/google-ads-transparency-scraper").call(run_input={"searchTerms": ["nike.com"], "region": "US", "maxItems": 100})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["format"], ad["daysRunning"], ad["adUrl"])
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('api-co/google-ads-transparency-scraper').call({ searchTerms: ['nike.com'], region: 'US', maxItems: 100 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### FAQ

**Why does a domain search include ads from other advertisers?**
Searching a domain returns every ad Google links to that website, the same as the Transparency Center. That includes agencies, resellers or partners whose ads point to it (e.g. landing pages hosted on hubspot.com). To get one company only, enter its advertiser name or its advertiser ID (`AR...`), which the output gives you in `advertiserId`.

**How do the date filters work?**
An ad is kept if it was shown at any time between `dateFrom` and `dateTo` (its first-shown to last-shown period overlaps the window).

**Does it show the ad text and landing page?**
Google renders text ads as preview images, so you get the preview image (`imageUrl`) and the Transparency Center link (`adUrl`), not separate headline fields. Keyword data, impressions and spend are not published by Google for commercial ads.

**Why don't all video ads have a YouTube URL?**
Some video previews expose the YouTube video ID and some are rendered dynamically by Google. When the ID is in the preview, `videoUrl` is filled; otherwise use `previewUrl` or `adUrl`.

**Name search found the wrong advertiser?**
Big brands have several advertiser accounts. Raise *Advertisers per name*, search by domain, or paste the advertiser ID from the Transparency Center URL.

**How many ads can I get?**
As many as Google lists for the advertiser. Results come 40 per page, newest first; *Max ads per domain/advertiser* caps each search.

**Is it legal?**
It reads ads that Google publishes publicly in its Ads Transparency Center, at a polite rate and without logging in. Ads are commercial information about advertisers. Use the data responsibly and follow applicable laws.

### Related Actors

- [Tech Stack Detector](https://apify.com/api-co/tech-stack-detector): see which ad pixels and tools a website uses.
- [SEO Site Auditor](https://apify.com/api-co/seo-site-auditor): audit a competitor's landing pages.

# Actor input Schema

## `searchTerms` (type: `array`):

One per line: a website domain (nike.com), an advertiser name (Nike), an advertiser ID (AR16735076323512287233) or any adstransparency.google.com advertiser/creative URL.

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

2-letter country code such as US, GB, CA, AU, DE, FR, ES, MX, BR, IN, or 'anywhere' for all countries.

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

Only ads of this format.

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

Optional. Only ads shown on or after this date.

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

Optional. Only ads shown on or before this date.

## `advertisersPerName` (type: `integer`):

When you search by name, how many matching advertiser accounts to include (big brands often have several, e.g. one per country).

## `includeVideoUrls` (type: `boolean`):

Open each video ad's preview to find its YouTube video ID and URL.

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

Add every variation of the ad (image/preview URLs) and the countries where it was shown with last-shown dates. One extra request per ad.

## `maxAdsPerSearch` (type: `integer`):

Stop after this many ads for each search term (newest first).

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

Stop after this many ads in total. You are only charged per ad returned.

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

Used only if Google rate-limits the run's IP (HTTP 429). The default Apify datacenter proxy is included in all Apify plans.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com"
  ],
  "region": "anywhere",
  "format": "any",
  "advertisersPerName": 1,
  "includeVideoUrls": true,
  "includeDetails": false,
  "maxAdsPerSearch": 100,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Results dataset.

# 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 = {
    "searchTerms": [
        "nike.com"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-co/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 = {
    "searchTerms": ["nike.com"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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