# Google Ads Transparency Scraper: Ad Copy, Videos, Landing Pages (`kuezi/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center: every ad an advertiser or website runs on Google Search, YouTube, Maps, Shopping and Play. Filter by country, format, platform and date. Optional ad text, landing pages and YouTube video links.

- **URL**: https://apify.com/kuezi/google-ads-transparency-scraper.md
- **Developed by:** [Ishema Hugues](https://apify.com/kuezi) (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 $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: ad copy, videos and landing pages

Scrape the **[Google Ads Transparency Center](https://adstransparency.google.com/)** for any advertiser or website and get every ad they run on **Google Search, YouTube, Google Maps, Google Shopping and Google Play**. You get it as clean JSON, CSV or Excel.

Each ad comes with:

- the advertiser and website;
- the format (text, image or video);
- when Google first and last showed it;
- a preview image and a direct link to the ad.

Turn on **ad details** to also get:

- the **visible ad text** (headline and description);
- the **landing page URLs**;
- the **YouTube video ID and link** for video ads;
- image URLs, the number of variations, and the countries where the ad ran.

**Why this one:**

- **Search three ways:** by advertiser name, by advertiser ID or Transparency Center URL, or by website (`nike.com` returns every advertiser running ads for that site).
- **All the Transparency Center filters:** any of 249 countries, format, platform, and date range (or "last N days").
- **Ad text and landing pages,** not just a screenshot link, so you can analyze the copy at scale.
- **Monitoring mode:** set `onlyNewAds` and schedule it daily to get only the ads a competitor launched since the last run.
- **Pay only for ads you get:** $1 per 1,000 ads, with nothing charged at start.
- Proxy handling is built in: every request uses a fresh IP, with an automatic switch to residential if Google throttles.

### What you can do with it

- **Competitor ad research:** see every Search, YouTube and Shopping ad a competitor runs in your country and how long each one has been live. An ad that has run for months is usually one that works.
- **Ad copy swipe file:** pull the headlines and descriptions of a whole category's ads into a spreadsheet.
- **Landing page discovery:** find the pages competitors send paid traffic to.
- **YouTube ad library:** collect the video IDs of a brand's YouTube ads.
- **Agency prospecting:** check whether a prospect advertises and on which platforms.
- **Brand protection and compliance:** watch who runs ads for your domain or brand name, with a daily schedule and `onlyNewAds`.

### Input

| Field | What it does |
|---|---|
| `searchTargets` | Advertiser names (`Nike, Inc.`), advertiser IDs or Transparency Center URLs (`AR16735076323512287233`), or websites (`nike.com`). One per line. |
| `country` | Only ads shown in this country (`US`, `GB`, `DE`, …), or `anywhere`. |
| `adFormat` | `all`, `text`, `image` or `video`. |
| `platform` | `all`, `google_search`, `youtube`, `google_maps`, `google_shopping` or `google_play`. |
| `lastDays` / `dateFrom` / `dateTo` | Only ads shown in this period. |
| `maxAdsPerTarget` | Maximum number of ads per advertiser or website (default 100). |
| `includeAdDetails` | Also extract the ad text, landing pages, YouTube link, images, variations and countries. |
| `onlyNewAds` | Monitoring: only output ads not returned by a previous run with the same target and filters. |
| `allExactNameMatches` | Brands often have several advertiser accounts with the same name. On: scrape them all. |

Example: a competitor's YouTube ads in the US over the last 90 days, with video links.

```json
{
  "searchTargets": ["nike.com"],
  "country": "US",
  "platform": "youtube",
  "lastDays": 90,
  "maxAdsPerTarget": 200,
  "includeAdDetails": true
}
```

### Output

One row per ad. With `includeAdDetails` on, a row looks like this (a real result from a test run on 2026-10-02):

```json
{
  "target": "nike.com",
  "targetType": "domain",
  "countryFilter": "US",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "domain": "nike.com",
  "creativeId": "CR11071274990039990273",
  "format": "VIDEO",
  "firstShown": "2026-09-11T07:00:00.000Z",
  "lastShown": "2026-10-02T09:57:07.000Z",
  "previewImageUrl": null,
  "previewScriptUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integri...",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR11071274990039990273?region=US",
  "variationsCount": 6,
  "shownInCountries": [{ "country": "US", "lastShownDate": "2026-10-02" }],
  "adTexts": ["Nike Factory Store -", "Citadel", "Engineered for Max Airflow", "Maximum breathability meets ultra-light", "comfort in new Nike Aero-FIT styles.", "Commerce", "10 AM–9 PM"],
  "landingPageUrls": ["https://www.nike.com/retail/"],
  "youtubeVideoId": "RZ1MLoOdWcc",
  "youtubeUrl": "https://www.youtube.com/watch?v=RZ1MLoOdWcc",
  "imageUrls": ["https://tpc.googlesyndication.com/simgad/3359047060733984341", "https://i1.ytimg.com/vi/RZ1MLoOdWcc/mqdefault.jpg"],
  "scrapedAt": "2026-10-02T11:41:13.531Z"
}
```

The `SUMMARY` record in the key-value store lists, for each target:

- the advertisers it resolved to;
- **Google's estimated number of ads** for your filters;
- how many ads were saved, and how many were new.

### Pricing (pay per event)

| Event | Price |
|---|---|
| Ad saved (`ad-result`) | **$0.001** ($1 per 1,000 ads) |
| Ad details: text, landing pages, video, countries (`ad-details`, optional) | $0.003 per ad |

Subscribers on higher Apify plans pay less per event. You're never charged for targets that fail. Set a maximum cost per run in Apify and the Actor stops cleanly when it's reached.

### Notes and limits

- **Text ads** are archived by Google as images. For them you get the preview image URL, and the ad text when Google includes it in the preview.
- Google reports the total number of ads as a range (for example "7000-8000"). The Actor pages through results 40 at a time until it reaches `maxAdsPerTarget`.
- Results come from Google's public Transparency Center, the same data anyone can see on adstransparency.google.com. No login or cookies are needed.
- **Political ads** live in a separate section of the Transparency Center and aren't covered yet.

### FAQ

**Is this legal?** The Ads Transparency Center is a public database Google publishes so that anyone can see who is advertising. This Actor reads the same public data the website shows. Use it in line with your local laws and Google's terms.

**Which name should I use for a brand?** The legal advertiser name usually works best (`Booking.com B.V.`, `Nike, Inc.`). If a name matches nothing exactly, the Actor uses the biggest matching advertiser and says so in `SUMMARY`. Searching by **website** is the most reliable option.

**How do I monitor a competitor?**

1. Turn on `onlyNewAds`.
2. Save the input as a task.
3. Schedule it daily.

Each run returns only ads the previous runs didn't. You can connect it to Slack, email or Google Sheets with Apify integrations.

### More from the same developer

- [Google Trends Scraper](https://apify.com/kuezi/google-trends-scraper): unlimited keywords on one scale, breakout queries and Trending Now.
- [Google Hotels Scraper](https://apify.com/kuezi/google-hotels-scraper): hotel prices plus every booking site's price.
- [Google Flights Scraper](https://apify.com/kuezi/google-flights-scraper): prices, cheapest day to fly and Google price insights.

# Actor input Schema

## `searchTargets` (type: `array`):

One per line. Accepts an advertiser name ("Nike, Inc."), an advertiser ID or Transparency Center URL (AR…), or a website domain ("nike.com"). A domain returns every advertiser that ran ads for that site.

## `country` (type: `string`):

Only ads shown in this country. "Anywhere" covers all countries.

## `adFormat` (type: `string`):

Text (Search), image/display/shopping, or video ads.

## `platform` (type: `string`):

Where the ad ran.

## `lastDays` (type: `integer`):

Only ads shown in the last N days. 0 = no date filter. Ignored when Date from is set.

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

Only ads shown on or after this date (YYYY-MM-DD).

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

Only ads shown on or before this date (YYYY-MM-DD). Defaults to today when Date from is set.

## `maxAdsPerTarget` (type: `integer`):

Stop after this many ads for each advertiser or website.

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

For each ad, also extract the visible ad text (headline, description), landing page URLs, YouTube video ID and link, image URLs, the number of variations and the countries it was shown in. Charged per ad as "ad details".

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

Remembers which ads each target already returned (per country, format and platform) and only outputs ads you haven't seen. Schedule the Actor daily to get a feed of competitors' new ads.

## `allExactNameMatches` (type: `boolean`):

Many brands run several advertiser accounts with the same name ("Booking.com B.V." has several). On: scrape all of them. Off: only the biggest one.

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

Parallel requests when fetching ad details.

## `maxRetries` (type: `integer`):

Each retry uses a new proxy IP.

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

Google limits requests per IP, so each request uses a new proxy session. Apify datacenter proxy is the default; the Actor switches to residential automatically if Google blocks it.

## Actor input object example

```json
{
  "searchTargets": [
    "nike.com",
    "Booking.com B.V."
  ],
  "country": "anywhere",
  "adFormat": "all",
  "platform": "all",
  "lastDays": 0,
  "maxAdsPerTarget": 100,
  "includeAdDetails": false,
  "onlyNewAds": false,
  "allExactNameMatches": true,
  "maxConcurrency": 5,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `ads` (type: `string`):

One row per ad: advertiser, website, format, first and last shown, ad text, landing pages, YouTube link, preview.

## `fullResults` (type: `string`):

Every field, including variations count, countries shown in and image URLs.

## `summary` (type: `string`):

Advertisers resolved for each name, Google's estimated ad count for your filters, ads saved and new ads.

# 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 = {
    "searchTargets": [
        "nike.com",
        "Booking.com B.V."
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kuezi/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 = {
    "searchTargets": [
        "nike.com",
        "Booking.com B.V.",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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