# Google Ads Transparency Scraper: Ad Copy, Videos & Spend (`sholkany_the_goat/google-ads-transparency-scraper`) Actor

Scrape every ad a company runs on Google Search, YouTube, Shopping, Maps and Play from the Google Ads Transparency Center. Search by brand, domain or advertiser ID. Get ad copy, CTAs, landing URLs, YouTube video IDs, run dates, countries and political ad spend. Monitor competitors for new ads.

- **URL**: https://apify.com/sholkany_the_goat/google-ads-transparency-scraper.md
- **Developed by:** [Ak THe goat](https://apify.com/sholkany_the_goat) (community)
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 & Spend

Get every ad a company runs on **Google Search, YouTube, Shopping, Maps and Play** from the public [Google Ads Transparency Center](https://adstransparency.google.com), with the ad copy, call to action, landing page, images, YouTube video ID, run dates, the countries it ran in and, for election ads, spend and impressions.

Type a brand (`Nike`), a website (`shopify.com`) or an advertiser ID and get clean rows you can export to CSV, Excel or JSON, send to Google Sheets, or pull from the API. No browser and no Google account needed.

### What can this Google Ads scraper do?

- 🔎 **Search by brand, domain or ID.** `Nike` finds the advertiser for you. `nike.com` returns ads from *every* advertiser sending traffic to that site (agencies, resellers, affiliates). Advertiser IDs and Transparency Center URLs work too.
- ✍️ **Ad copy, not just screenshots.** Headlines and descriptions, call-to-action button, display URL and landing URLs are decoded from each ad's preview. The Transparency Center itself only shows a picture.
- 🎬 **YouTube video IDs** for video ads, with a ready `youtubeUrl`.
- 🌍 **Countries and dates.** First shown, last shown, number of days shown, and (optionally) every country the ad ran in with the last date per country.
- 🗳️ **Political ad spend.** Spend range, currency, impressions range and targeted regions for election ads.
- 🔔 **Monitor competitors.** Turn on *Only new ads* and schedule the Actor: each run returns only creatives you have not seen before, and you only pay for those.
- 🧰 **Filters that match the site:** format (text, image, video), platform (Search, YouTube, Shopping, Maps, Play), countries, and date range.

### Who uses it

- **Marketers and agencies:** see what competitors are running right now, how long each creative has been live (long-running ads are usually the winners), and which landing pages they push.
- **Creative strategists:** build a swipe file of real headlines, CTAs and video ads in your niche.
- **E-commerce and app marketers:** track Shopping and app-install campaigns, including Play Store listings.
- **Brand protection:** find every advertiser sending traffic to your domain.
- **Researchers and journalists:** export political ad spend by country.

### How to use it

1. Add one or more lines to **Advertisers, domains or URLs**, for example `Nike`, `shopify.com` or `AR16735076323512287233`.
2. Set **Max ads per search** (ads come newest-shown first).
3. Optionally pick a format, platforms, countries and a date range.
4. Click **Start**, then open the **Output** tab or export the dataset.

#### Input examples

Latest 200 YouTube video ads from two competitors in the US and UK:

```json
{
  "searchTerms": ["Nike", "Adidas"],
  "maxAdsPerSearch": 200,
  "format": "VIDEO",
  "platforms": ["YOUTUBE"],
  "regions": ["US", "GB"]
}
```

Every advertiser promoting a domain in the last 30 days, with the countries each ad ran in:

```json
{
  "searchTerms": ["shopify.com"],
  "startDate": "30 days",
  "includeAdDetails": true
}
```

Weekly competitor monitor that only returns new creatives (schedule it in Apify):

```json
{
  "searchTerms": ["hubspot.com", "salesforce.com"],
  "maxAdsPerSearch": 500,
  "onlyNewAds": true,
  "monitorKey": "crm-competitors"
}
```

UK election ads with spend:

```json
{
  "searchTerms": ["labour.org.uk"],
  "politicalAdsOnly": true,
  "regions": ["GB"]
}
```

### Output

One row per ad. Example (a YouTube video ad):

```json
{
  "searchTerm": "Nike",
  "searchType": "name",
  "creativeId": "CR02029141914422345729",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserLegalName": "Nike, Inc.",
  "advertiserCountry": "US",
  "format": "VIDEO",
  "firstShown": "2026-07-07T14:19:50Z",
  "lastShown": "2026-09-30T20:49:33Z",
  "daysShown": 70,
  "adText": "Nike Clearance Store | San Leandro | Gear Up for Your Run In-Store | Explore the latest running footwear and apparel at your local Nike® Factory Store. | OPEN | 10 AM–8 PM",
  "adTextLines": ["Nike Clearance Store", "San Leandro", "Gear Up for Your Run In-Store", "..."],
  "callToAction": "Learn More",
  "landingUrls": ["https://www.nike.com/retail/"],
  "adImageUrls": ["https://tpc.googlesyndication.com/simgad/6916328398620481038"],
  "videoId": "vXMxDt7mYlw",
  "youtubeUrl": "https://www.youtube.com/watch?v=vXMxDt7mYlw",
  "previewImageUrl": "https://tpc.googlesyndication.com/simgad/6916328398620481038",
  "regions": [{ "countryCode": "US", "geoId": 2840, "lastShown": "2026-09-30" }],
  "variationsCount": 6,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR02029141914422345729?region=anywhere",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233?region=anywhere",
  "scrapedAt": "2026-10-01T01:34:20Z"
}
```

| Field | What it is |
|---|---|
| `creativeId`, `advertiserId` | Google's IDs for the ad and the advertiser |
| `advertiserName`, `advertiserLegalName`, `advertiserCountry` | Who runs the ad |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `firstShown`, `lastShown`, `daysShown` | When the ad ran (UTC) and how many days Google reports it was shown |
| `adText`, `adTextLines` | The ad copy, joined and as separate lines |
| `callToAction`, `displayUrl`, `landingUrls` | CTA button, display URL and landing pages found in the ad |
| `adImageUrls`, `previewImageUrl` | Image assets, and a preview image for every row |
| `videoId`, `youtubeUrl` | YouTube video for video ads |
| `landingDomain` | The domain the ad links to (domain searches) |
| `regions`, `variationsCount` | Countries the ad ran in and number of variations (with *Include countries*) |
| `spendMin`, `spendMax`, `spendCurrency`, `impressionsMin`, `impressionsMax`, `politicalRegions` | Election ads only |
| `adUrl`, `advertiserUrl` | Links back to the Transparency Center |

Rows always have the same columns, so CSV and Excel exports line up. A run summary (ads saved, skipped, failed searches) is stored in the run's key-value store as `RUN_SUMMARY`.

### Pricing

Pay only for results:

| Event | When you pay |
|---|---|
| **Ad** | Each ad saved to the dataset |
| **Ad copy & media** | Each ad where copy, a video ID or images were extracted (on by default; turn off *Extract ad copy* to skip) |
| **Ad countries & variations** | Each ad looked up with *Include countries where each ad ran* (off by default) |

The exact prices are shown on the Pricing tab. Set a **maximum cost per run** in the run options and the Actor stops cleanly when it is reached.

### Tips and limits

- **Ads come newest-shown first,** so a small *Max ads per search* gives you what is running now.
- **Names pick the biggest matching advertiser.** `Nike` resolves to *Nike, Inc.* (thousands of ads), not a small shop called Nike. Raise *Advertisers per name search* to include regional entities, or paste the advertiser ID to be exact.
- **Domains find everyone.** `nike.com` returns ads from Nike and from agencies or retailers linking to nike.com.
- **Text ads are published as screenshots.** Their copy is extracted when Google also provides a rendered version; turn on *Include countries* to check more variations. The screenshot is always in `previewImageUrl`.
- **Platform filter** only covers ads shown since 4 September 2023, the same as on the website.
- **Date filters behave like the site's date picker.** Some past windows return few or no ads for an advertiser even though the ads exist; Google's own page shows the same.
- **Political ads** are published per country, so set *Countries* when you use *Political ads only*.
- **Monitoring** stores the IDs it has already returned in a named key-value store (`google-ads-transparency-monitor`) in your Apify account. Use a different *Monitor key* per watchlist.

### FAQ

**Is it legal to scrape the Google Ads Transparency Center?** The Actor only reads data Google publishes for anyone to see, without logging in. As always, check that your use of the data complies with the laws that apply to you.

**Do I need a proxy?** The default Apify datacenter proxy is enough. Google limits requests per IP, and the Actor rotates IPs and retries automatically.

**Can I use it from my own code or tools?** Yes: through the Apify API, the Python and JavaScript clients, Make, Zapier, n8n, Google Sheets, or as a tool for AI agents over Apify's MCP server.

**Something missing or broken?** Open an issue on the Issues tab with the input you used and the run link.

# Actor input Schema

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

What to look up. Each line can be an advertiser name (<code>Nike</code>), a website domain (<code>nike.com</code> finds every advertiser sending traffic there), an advertiser ID (<code>AR16735076323512287233</code>), or any Transparency Center URL (advertiser page, single ad, or <code>?domain=</code> search).

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

Maximum number of ads to save for each line above. When a name matches several advertisers (see below), the limit applies to each advertiser. Ads come newest-shown first.

## `maxAdvertisersPerSearch` (type: `integer`):

When a line is a name, how many matching advertisers to scrape. The biggest advertiser (most ads) whose name contains your words is picked first. Raise it to include regional subsidiaries, e.g. 'Nike, Inc.' and 'Nike Retail BV'.

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

Only return ads of this format.

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

Only return ads shown on these Google platforms. Leave empty for all. Google only records the platform for ads shown since 4 September 2023.

## `regions` (type: `array`):

Only return ads shown in these countries. Use two-letter ISO codes such as US, GB, DE, MY. Leave empty for anywhere.

## `startDate` (type: `string`):

Only ads shown on or after this date. A date (2026-01-01) or a relative value such as '30 days' (meaning 30 days ago).

## `endDate` (type: `string`):

Only ads shown on or before this date. Leave empty for today.

## `politicalAdsOnly` (type: `boolean`):

Return only election ads. These include Google's spend range, impressions range and targeted regions. Political ads are published for a limited set of countries, so set Countries too.

## `extractAdContent` (type: `boolean`):

Decode each ad's preview to get its text, call to action, display URL, landing URLs, image URLs and YouTube video ID. Charged as an extra 'ad content' event only when content is found. Ads that Google publishes only as a screenshot have no extractable text unless you also turn on details.

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

Fetch each ad's detail page: the list of countries it was shown in (with last-shown date per country) and the number of variations. Also recovers copy for many text ads. Charged as an extra 'ad details' event.

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

Skip ads already returned by earlier runs with the same monitor key. Schedule the Actor daily or weekly to get only new creatives, and pay only for those.

## `monitorKey` (type: `string`):

Name for the list of ads already seen. Runs with the same key share the list. Leave empty to derive it from the search terms and filters.

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

Google limits requests per IP address, so the Actor rotates proxy IPs. The default datacenter proxy works well.

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

How many requests to Google run in parallel.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com"
  ],
  "maxAdsPerSearch": 100,
  "maxAdvertisersPerSearch": 1,
  "format": "ALL",
  "platforms": [],
  "regions": [],
  "politicalAdsOnly": false,
  "extractAdContent": true,
  "includeAdDetails": false,
  "onlyNewAds": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5
}
```

# Actor output Schema

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("sholkany_the_goat/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"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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