# Google Ads Transparency Scraper - Ads by Advertiser or Domain (`sweet_stickball/google-ads-transparency-scraper`) Actor

Google Ads Transparency Center scraper and ad library API alternative: every ad of an advertiser by name, domain or AR ID with format, first and last shown dates, countries, image, YouTube video and preview URLs. Competitor ad research, no login.

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

## Pricing

from $0.84 / 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 - Ads by Advertiser or Domain

Scrape the [Google Ads Transparency Center](https://adstransparency.google.com): every ad (creative) of an advertiser, found by advertiser name, website domain or advertiser ID, with its format, first and last shown dates, countries where it ran, image, YouTube video and preview URLs, and a link to the ad page. Filter by country, ad format and date range. One flat JSON record per ad.

### What it does

- Takes one main input, `advertiser`, in any of three forms:
  - a **domain** or URL (`nike.com`): ads that lead to this domain, from every advertiser that runs them;
  - an **advertiser ID** (`AR16735076323512287233`) or a Transparency Center advertiser URL: the most precise option;
  - an **advertiser name** (`Nike`): matched against Google's own advertiser suggestions, ignoring case, punctuation and legal suffixes (`Inc.`, `Ltd`, `GmbH`...); when several advertisers share the name, the one with the most ads is used and named in the run log.
- Reads the same JSON endpoints that the Transparency Center web page uses (search, advertiser lookup, ad details), over plain HTTP. No browser, no login, no Google account.
- Optional filters: `region` (country where the ad was shown), `format` (text, image, video) and `dateRange` (last 7, 30, 90 or 365 days).
- For each ad, by default, opens its detail record (countries where it ran, number of variations) and, for image and video ads that Google only shows through a preview script, reads that script to get the image URL and the YouTube video URL.
- Deduplicates ads by `creativeId` and stops at `maxItems`.

Typical uses: competitor ad research, creative monitoring, checking which countries and formats a brand advertises in, building a swipe file of ads with their run dates.

### Input

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `advertiser` | string | Yes | - | Advertiser name (`Nike`), website domain or URL (`nike.com`), or advertiser ID (`AR16735076323512287233`). |
| `region` | string | No | any region | Two-letter country code (`US`, `GB` or `UK`, `FR`, `DE`, `JP`...): only ads shown in that country. |
| `format` | string | No | `all` | `all`, `text`, `image` or `video`. |
| `dateRange` | string | No | `anytime` | `anytime`, `last_7_days`, `last_30_days`, `last_90_days` or `last_365_days` (ads shown at least once in the period, counted back from yesterday, UTC). |
| `maxItems` | integer | No | 20 | Maximum number of ads to return (1 to 5,000). |
| `includeDetails` | boolean | No | `true` | Fill `regions`, `regionCount` and `variationCount` (one extra request per ad). |
| `extractMediaUrls` | boolean | No | `true` | Fill `imageUrl` / `videoUrl` for image and video ads shown through a preview script (one extra download of about 200 KB per such ad). |

Example input:

```json
{
    "advertiser": "nike.com",
    "region": "US",
    "format": "video",
    "dateRange": "last_30_days",
    "maxItems": 50
}
```

### Output

One dataset item per ad. Real items from a run with `"advertiser": "nike.com"`:

```json
[
    {
        "advertiserId": "AR18378488041124659201",
        "advertiserName": "Nike Retail BV",
        "creativeId": "CR02488267518863474689",
        "format": "text",
        "firstShown": "2021-10-25T07:00:00+00:00",
        "lastShown": "2026-10-28T06:22:05+00:00",
        "daysShown": 1414,
        "landingDomain": "nike.com",
        "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/3129906315878413076",
        "previewUrl": "https://tpc.googlesyndication.com/archive/simgad/3129906315878413076",
        "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR02488267518863474689?region=anywhere",
        "advertiserCountry": "NL",
        "regions": "AT,BE,BG,BR,CY,CZ,DE,DK,EE,ES,FI,FR,GR,HR,HU,IE,IS,IT,LT,LV,MT,NL,NO,PL,PT,RO,SE,SK,TR",
        "regionCount": 29,
        "variationCount": 3,
        "videoUrl": null,
        "searchRegion": "anywhere",
        "query": "nike.com",
        "scrapedAt": "2026-10-28T06:46:10.552859+00:00"
    },
    {
        "advertiserId": "AR01266454498310619137",
        "advertiserName": "유한회사 나이키코리아",
        "creativeId": "CR03459814590374739969",
        "format": "video",
        "firstShown": "2026-10-01T02:16:21+00:00",
        "lastShown": "2026-10-28T06:19:51+00:00",
        "daysShown": 28,
        "landingDomain": "nike.com",
        "imageUrl": "https://i.ytimg.com/vi/6UWPFi97i9w/hqdefault.jpg",
        "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&...",
        "adUrl": "https://adstransparency.google.com/advertiser/AR01266454498310619137/creative/CR03459814590374739969?region=anywhere",
        "advertiserCountry": "KR",
        "regions": "KR",
        "regionCount": 1,
        "variationCount": 2,
        "videoUrl": "https://www.youtube.com/watch?v=6UWPFi97i9w",
        "searchRegion": "anywhere",
        "query": "nike.com",
        "scrapedAt": "2026-10-28T06:46:10.552859+00:00"
    }
]
```

| Field | Description |
|-------|-------------|
| `advertiserId`, `advertiserName` | Google advertiser ID (AR...) and name as shown in the Transparency Center. |
| `advertiserCountry` | Two-letter country code of the advertiser's location. |
| `creativeId` | Google ID of the ad (CR...), unique in the dataset. |
| `format` | `text`, `image` or `video`. |
| `firstShown`, `lastShown` | First and last time the ad was shown (ISO 8601, UTC). |
| `daysShown` | Number of days on which the ad was shown, as reported by the Transparency Center (at most the days between first and last shown). |
| `regions`, `regionCount` | Countries where the ad ran (comma-separated codes) and their number (`includeDetails`). |
| `variationCount` | Number of variations of the ad archived by Google (`includeDetails`). |
| `landingDomain` | Domain the ad leads to, when Google reports it (mostly in domain searches). |
| `imageUrl` | Archived image of the ad, product or display image, or YouTube thumbnail of a video ad. |
| `videoUrl` | YouTube URL of a video ad, when its preview references a YouTube video. |
| `previewUrl` | Google's preview of the ad: the archived image, or the preview script the Transparency Center uses to render it. |
| `adUrl` | Page of the ad in the Google Ads Transparency Center. |
| `searchRegion`, `query`, `scrapedAt` | Region filter and `advertiser` input of the run, collection time. |

Missing values are `null`. Export as JSON, CSV, Excel or through the Apify API.

### Pricing

Pay-per-event, **no start fee**: **$1.40 per 1,000 ads** on the Apify Free plan, with lower prices on paid plans. Each ad pushed to the dataset is one `AD` event; regions, variations and media URLs are included at no extra charge.

| Event | Free | Starter | Scale | Business | Enterprise |
|-------|------|---------|-------|----------|------------|
| Ad (`AD`) | $1.40 | $1.20 | $1.00 | $0.84 | $0.84 |

Prices in USD per 1,000 events.

#### Cost examples (Free plan)

| Scenario | Ads | Cost |
|----------|-----|------|
| Quick look | 10 | $0.014 |
| One advertiser, recent ads | 100 | $0.14 |
| Full creative library | 1,000 | $1.40 |

The run stops cleanly when the "maximum cost per run" set in the run options is reached.

### Limitations

- Only what the Ads Transparency Center publishes is available. Google does not publish impressions, spend or targeting for commercial ads; those exist only for political ads, which this Actor does not cover.
- Ad text is not extracted: Google archives most text (search) ads as an image of the ad, so the text is in `imageUrl`, not in a text field.
- `videoUrl` is filled only when the video ad's preview references a YouTube video (not all of them do); other video ads keep their thumbnail or preview script.
- Name search depends on Google's advertiser suggestions (10 per query). For an ambiguous or very short name, use the domain or the advertiser ID; the resolved advertiser is written in the run log.
- A domain search returns ads from every advertiser that points to that domain (resellers, regional entities), not only the brand owner.
- The date filter only goes back about one year: Google returns no ads for older periods.
- For long-running ads, `firstShown` can be the start of Google's archive rather than the real launch date (many older ads show October 2021).
- Google's ad counts are approximate ("about 9,000 ads"); `maxItems` caps the number of ads returned, up to 5,000 per run.

# Actor input Schema

## `advertiser` (type: `string`):

Whose ads to get. Accepted values: (1) a website domain or URL, e.g. 'nike.com' - returns ads that lead to this domain, from every advertiser that runs them; (2) an advertiser ID such as 'AR16735076323512287233' or a Transparency Center advertiser URL - the most precise option; (3) an advertiser name such as 'Nike' - matched against Google's advertiser suggestions (case, punctuation and legal suffixes like 'Inc.' are ignored) and, when several advertisers share the name, the one with the most ads is used. The resolved advertiser is written in the run log.

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

Only ads shown in this country: a two-letter ISO country code such as US, GB (or UK), FR, DE, JP. Leave empty for ads shown anywhere.

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

Only ads of this format: text (search ads, archived by Google as an image of the ad), image (display and shopping ads) or video (YouTube ads). 'all' returns every format.

## `dateRange` (type: `string`):

Only ads shown at least once in this period, counted back from yesterday (UTC). 'anytime' applies no date filter.

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

Maximum number of ads (dataset items) to return. Each returned ad is one billed AD event.

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

Opens each ad's detail record to fill 'regions' (countries where it ran), 'regionCount' and 'variationCount'. One extra request per ad; turn off for faster runs.

## `extractMediaUrls` (type: `boolean`):

For image and video ads that Google only shows through a preview script, reads that script to fill 'imageUrl' and, when the video is on YouTube, 'videoUrl'. One extra download (about 200 KB) per such ad.

## Actor input object example

```json
{
  "advertiser": "nike.com",
  "region": "US",
  "format": "all",
  "dateRange": "anytime",
  "maxItems": 10,
  "includeDetails": true,
  "extractMediaUrls": true
}
```

# Actor output Schema

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

Dataset items (one per ad) shown with the 'ads' view.

# 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 = {
    "advertiser": "nike.com",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("sweet_stickball/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 = {
    "advertiser": "nike.com",
    "maxItems": 10,
}

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

```

## MCP server setup

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