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

See every ad a competitor runs on Google Search, YouTube and Display from the Google Ads Transparency Center: ad format, first and last shown dates, days running, image and preview links. Search by website domain, advertiser name or ID, filter by country.

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

## Pricing

from $1.13 / 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

See **every ad a competitor runs on Google** (Search, YouTube, Shopping, Maps and Play) from the public **Google Ads Transparency Center**. Search by **website domain, advertiser name, advertiser ID or a Transparency Center link**. Get the **advertiser, format, first and last shown dates, days running, landing domain, image or preview link** and the ad's Transparency Center page, or one summary row per advertiser. Turn on the **competitor ad watch** to get only the ads that appeared since the last run. For marketers, PPC agencies and competitor researchers.

**Price: $1.50 per 1,000 results.** Duplicates and failed searches are free. Apify's free plan ($5 monthly credit) covers about 3,300 results a month.

[![New Google ads from a competitor since last week: real output preview (Competitor ad watch: only ads not seen in earlier runs)](https://raw.githubusercontent.com/TikTop-Data/apify-store-assets/main/images/google-ads-transparency-scraper-output.png)](https://apify.com/redfoxscout/google-ads-transparency-scraper)

### Questions it answers

- Which ads is my competitor running on Google right now?
- Which new ads did a competitor launch since last week?
- How long has each ad been running (a long-running ad is usually a winning ad)?
- Does this brand advertise on YouTube, Shopping or Play, and which video ads?
- Which advertisers run ads on a domain, and are they verified?

### Who uses this

- 📣 **Performance marketers:** study competitors' long-running ads before writing your own.
- 🏢 **Agencies:** competitor ad audits for pitches and client reports, and weekly new-ad alerts.
- 🎬 **Creative teams:** collect image and video ad examples by brand.
- 📊 **Market researchers:** track which brands advertise, where, and on which Google surfaces.

### Why this Google Ads Transparency Scraper

- 🔔 **New-ad watch:** schedule a run with "Only new ads since the last run" and get just the ads launched since the last time.
- 🔎 **Search any way you know the brand:** a name, a domain, an advertiser ID or a link copied from the Transparency Center.
- 📺 **Where the ads run:** filter by Google Search, YouTube, Shopping, Maps or Play, and by country and format.
- ✅ **Ad check:** one row per advertiser with its verification status, country and approximate ad count.
- 📅 **Days running** for every ad, so winners are easy to sort.
- 🔒 **No login, no cookies:** the public Transparency Center data only.

### How to use the Google Ads Transparency Scraper

1. Click **Try for free** (a free Apify account is enough).
2. Enter competitors' website domains (`shopify.com`), advertiser names or advertiser IDs, one per line.
3. Optional: pick a country, Google surfaces, ad formats and a date range.
4. Click **Start**, then sort by `daysRunning` and download as JSON, CSV or Excel.

### Input

| Field | Default | What it does |
|---|---|---|
| `advertisers` | – | Website domains, advertiser names or IDs (AR...), one per line. |
| `advertiserIds` | – | Advertiser IDs (AR...), one per line. Same as putting them in `advertisers`. |
| `startUrls` | – | Transparency Center links: an advertiser page, an ad page (searches its advertiser) or a domain search. |
| `region` | `anywhere` | Only ads shown in this country. |
| `formats` | all | Any of `text`, `image`, `video`. |
| `platforms` | all | Any of `search`, `youtube`, `shopping`, `maps`, `play`. Several run one after another; an ad on two surfaces appears once. |
| `dateFrom` / `dateTo` | – | Keep ads that ran at any point between these dates (`YYYY-MM-DD`). |
| `resultType` | `ads` | `ads`: one row per ad. `advertisers`: one row per advertiser (ad check). |
| `allMatchingAdvertisers` | `false` | For names: include every advertiser account with that exact name. |
| `maxItems` | 100 | Ads checked per search, newest shown first (max 5,000). In advertiser mode: rows per search. |
| `includeDetails` | `false` | Add each ad's A/B variations and the countries it ran in. One extra request per ad. |
| `onlyNewAds` | `false` | Competitor ad watch: return only ads not seen in earlier runs with the same monitor name. |
| `monitorName` | – | Name of the watch, e.g. `Nike weekly`. Needed with `onlyNewAds`. |
| `maxConcurrency` | 3 | How many searches run at once. |
| `proxyConfiguration` | off | Your own proxy, if Google starts blocking requests (HTTP 429). |

Example (the input behind the table above):

```json
{ "advertisers": ["shopify.com"], "region": "US", "maxItems": 100 }
```

### Output

In ad mode, each ad creative is one dataset item:

```json
{
  "resultType": "ad",
  "advertiserId": "AR01625195283841286145",
  "advertiserName": "Shopify Inc.",
  "creativeId": "CR12194632834589130753",
  "format": "text",
  "firstShown": "2024-06-14",
  "lastShown": "2026-10-08",
  "daysRunning": 847,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/2489843581007849881",
  "previewUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR01625195283841286145/creative/CR12194632834589130753",
  "landingDomain": "shopify.com",
  "matchedAdvertiser": null,
  "region": "anywhere",
  "isNew": null,
  "variationCount": null,
  "variationUrls": null,
  "regionsShown": null,
  "searchQuery": "shopify.com"
}
```

Text ads come back as the image Google renders for them (`imageUrl`). Video ads come with a `previewUrl` (Google's ad preview). `landingDomain` comes with domain searches; advertiser-ID searches leave it empty.

With "Add variations and countries" on, `variationCount`, `variationUrls` and `regionsShown` are filled, for example:

```json
"regionsShown": [
  { "regionId": 2724, "countryCode": "ES", "firstShown": "2023-03-22", "lastShown": "2026-09-28" },
  { "regionId": 2826, "countryCode": "GB", "firstShown": null, "lastShown": "2026-10-08" }
]
```

`countryCode` is filled for the countries this Actor knows; other countries keep Google's numeric `regionId`.

In advertiser mode (`resultType: advertisers`), each row is one advertiser:

```json
{
  "resultType": "advertiser",
  "advertiserId": "AR17567291692413878273",
  "advertiserName": "Nike Klara",
  "legalName": "Nike Klara",
  "countryCode": "US",
  "verified": true,
  "approxAdCountLow": 11,
  "approxAdCountHigh": 11,
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR17567291692413878273",
  "region": "anywhere",
  "searchQuery": "Nike Klara"
}
```

`verified` is true when the advertiser has verified its identity on its Transparency Center page. The approximate ad count is Google's own range, shown for name and ID searches (null for domain searches).

### Example tasks

Ready-made inputs you can open, change and run:

- [New Google ads from a competitor since last week](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/new-google-ads-from-competitor-weekly)
- [See all Google ads a competitor runs (by website)](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/competitor-google-ads-by-domain)
- [Research a brand's Google ads in the United States](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/google-ads-us-competitor-research)
- [Find a competitor's YouTube video ads](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/youtube-video-ads-of-competitor)
- [Download a competitor's Google display image ads](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/google-display-image-ads)
- [Get a competitor's Google Search text ads](https://apify.com/redfoxscout/google-ads-transparency-scraper/examples/google-search-text-ads-competitor)

### Competitor ad watch: only new ads

Set a **monitor name** (for example `Nike weekly`) and turn on **Only new ads since the last run**, then schedule the run daily or weekly.

- The first run returns the current ads (up to `maxItems`) and remembers them. Each later run returns only ads that were not seen before under that name.
- Memory is kept in a named key-value store in your Apify account, one record per monitor name, so different watches never mix.
- Each run checks the newest `maxItems` ads of each search (newest shown first). Raise `maxItems` for very large advertisers.
- Keep the country, formats, surfaces and date filters the same across runs: they decide which ads count.
- A monitor remembers up to 15,000 ads per advertiser; the oldest are forgotten after that.
- Without "Only new ads", a monitor name still records ads, and each row shows `isNew`.

### What this Actor does not do

It does not log in, use cookies or a Google account, or read personal data about people. It does not show ad spend, clicks or impression counts, because Google does not publish them for commercial ads.

### How much does it cost?

$1.50 per 1,000 results. Each ad row is one result, and so is each advertiser row.

- 100 results: about $0.15
- 10,000 results: about $15
- Duplicates, ads skipped by the new-ads watch, and failed searches: free

Apify's free plan gives $5 of credit every month, enough for about 3,300 results.

### FAQ

**Is this legal?** The Google Ads Transparency Center is a public library Google publishes so anyone can see who advertises and what. This Actor reads the same public data. No login and no personal data.

**Why does a name find the wrong advertiser?** Many companies have several advertiser accounts. Search by website domain for the most precise results, or turn on "All advertisers with that name".

**Why does a domain search show other companies?** A domain search returns every ad that points to that website, including ads by agencies, resellers and partners. Use the advertiser name or ID column to tell them apart, or search by advertiser ID.

**Why are some landing domains empty?** Google returns the landing domain in domain searches. Advertiser-ID and name searches leave it empty. Use a domain search to get it for every ad.

**Can I run the watch every day?** Yes. Schedule the Actor in Apify with the same monitor name and filters each time.

### Related Actors

- [Tech Stack Detector](https://apify.com/redfoxscout/tech-stack-detector): which ad pixels and tools a competitor's site runs.
- [SEO Meta Tag & Schema Checker](https://apify.com/redfoxscout/seo-meta-checker): titles, descriptions and schema of a competitor's landing pages.

# Actor input Schema

## `advertisers` (type: `array`):

Website domains (nike.com), advertiser names (Shopify Inc.) or advertiser IDs (AR...), one per line.

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

Google advertiser IDs starting with AR, one per line. Same as putting them in Advertisers. Find one in an advertiser's Transparency Center page address.

## `startUrls` (type: `array`):

Links copied from adstransparency.google.com: an advertiser page, an ad page (searches its advertiser) or a domain search. Other filters still come from the fields below.

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

Only ads shown in this country. Default: anywhere.

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

Leave empty for all formats.

## `platforms` (type: `array`):

Only ads shown on these surfaces. Leave empty for all. Several surfaces run one after another.

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

Keep ads that were shown on or after this date (YYYY-MM-DD). Empty: no start limit.

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

Keep ads that were first shown on or before this date (YYYY-MM-DD). Empty: no end limit.

## `resultType` (type: `string`):

Ads: one row per ad creative. Advertisers: one summary row per advertiser with its verification status, country and approximate ad count.

## `allMatchingAdvertisers` (type: `boolean`):

For a name search, include every advertiser account with that exact name (e.g. one per country), not only the largest.

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

Ads checked per search (the newest by last shown date come first). For advertiser rows: rows per search.

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

Also fetch each ad's A/B variations and the countries it ran in. One extra request per ad, so runs are slower.

## `onlyNewAds` (type: `boolean`):

Competitor ad watch: output only ads not seen in earlier runs with the same monitor name. Needs a monitor name. Schedule the run to get new ads each day or week.

## `monitorName` (type: `string`):

Name of this watch, e.g. "Nike weekly". Ads are remembered per name, so keep the name and filters the same across runs. Empty: nothing is remembered.

## `maxConcurrency` (type: `integer`):

How many searches run at once.

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

Off by default. Turn on if Google starts blocking requests (HTTP 429).

## Actor input object example

```json
{
  "advertisers": [
    "shopify.com"
  ],
  "region": "anywhere",
  "resultType": "ads",
  "allMatchingAdvertisers": false,
  "maxItems": 20,
  "includeDetails": false,
  "onlyNewAds": false,
  "monitorName": "",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "advertisers": [
        "shopify.com"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("redfoxscout/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 = {
    "advertisers": ["shopify.com"],
    "maxItems": 20,
}

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

```

## MCP server setup

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