# Google Ads Transparency Scraper - Ad Library & Creatives (`s-r/google-ads-transparency`) Actor

Scrape any advertiser's live ads from the Google Ads Transparency Center — text, image, and video creatives across 50+ countries.

- **URL**: https://apify.com/s-r/google-ads-transparency.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Marketing, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 954 total users, 166 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Ad Creatives

Hosted google ads transparency that returns structured JSON without the captcha-solving, proxy-rotation, and site-update maintenance you'd otherwise own. Run it from the Apify Store with one click, or call it from your own service via the Apify API. Pay only for what you scrape, no monthly subscription.

### How the google ads transparency center works

The Google Ads Transparency Center is Google's public record of every ad an advertiser is running across Search, Display, YouTube, and Shopping. It is a goldmine for competitor research, but the web interface is built for browsing one advertiser at a time, not for pulling data at scale. This Actor turns the Google Ads Transparency Center into a structured feed, you give it a domain or advertiser, and it returns the live ads with their creative text, images, formats, regions, and the dates each ad has been running.

That makes a few jobs much faster. You can watch which creatives a competitor is scaling and which they quietly dropped, spot the landing pages behind their paid traffic, and see which regions they are actually targeting. Because the ads come back as JSON and you pay per result, you can monitor a whole set of competitors on a schedule and diff the output week over week instead of clicking through the transparency center by hand.

### What you get

- **Structured JSON output**, every google ads transparency run returns clean, parseable records ready for analytics or downstream pipelines.
- **Hosted on Apify**, no servers, no proxies, no anti-bot maintenance. Click Run.
- **Pay only for what you scrape**, pricing scales with usage; no monthly subscription minimum.
- **Multi-country support** via the `region` parameter, 58 regions plus Anywhere. Anywhere is the default on purpose: a region filter is a hard narrowing, and pinning a global advertiser to one country often returns nothing.

### Why use this google ads transparency

Most google ads transparency solutions fall into one of two camps: free open-source libraries that break every few months when the upstream site changes, or expensive SaaS tools that charge $99-$399/month for the data layer plus a dashboard UI you may not need.

This Apify Actor sits in the middle: same structured data the SaaS tools ship, but priced per run instead of per month, with a hosted infrastructure that handles proxies, retries, and captcha solving so you don't have to.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domain` | string |, | Advertiser domain to look up (e.g. "redable.nl"). One of domain, search, or advertiser_id is required. |
| `search` | string |, | Brand or advertiser name to search (e.g. "Nike"). Use instead of domain when you don't know the exact domain. |
| `advertiser_id` | string |, | Direct advertiser lookup (e.g. "AR10129747575264247809"). Required when creative_id is set. |
| `creative_id` | string |, | Direct creative lookup (e.g. "CR12965115384414863361"). Requires advertiser_id. |
| `region` | string | ``| ISO country code, or empty for Anywhere. Advertisers often pin few or no ads to one region, so an empty value can return more ads than a pinned one. |
| `platform` | string |`` | Keep only ads seen on Google Search, Shopping, Maps, Play or YouTube. Applied after fetching because Google's search API has no platform criterion, so it forces `detail` on. |
| `max_advertisers` | integer | `1` | With `search`, how many matching advertisers to pull from, biggest first. Large brands run one ad account per country. |
| `format` | string | \`\` | Filter by ad format. Leave empty for all formats. |
| `start_date` | string |, | Lower bound of the ad's last-shown date (YYYY-MM-DD). |
| `end_date` | string |, | Upper bound of the ad's last-shown date (YYYY-MM-DD). |
| `ads_count` | integer | `40` | How many ad creatives to return, up to 1000. Google serves 100 per page and this Actor walks the pages for you. |
| `detail` | boolean | `False` | Fetch impressions, regions, platforms, variations, and spend for every returned creative. Slower but richer. |
| `political` | boolean | `False` | Filter to political / election ads (these include spend ranges where available). |
| `page_token` | string |, | Pagination token from a previous run's `_next_page_token` field. Leave empty for the first page. |

#### Going past one page

Google's Transparency Center hands out 100 creatives at a time behind a page
token. Set `ads_count` above 100 and this Actor follows those tokens until it
has what you asked for, the advertiser runs out, or the run's time budget is
spent. `_next_page_token` is still returned on every row, so an integration
that prefers to chain runs itself keeps working exactly as before.

### Output

Every run pushes results to the Apify dataset as JSON records. Each record contains the structured fields surfaced by the google ads transparency, fields, IDs, timestamps, and any nested objects. You can:

- **Download** the dataset as JSON, JSONL, CSV, or Excel from the Apify console
- **Stream** results via the Apify API for use in your own application
- **Pipe** results to webhooks, S3, BigQuery, or any of Apify's 30+ integrations
- **Diff** today's run against yesterday's to detect changes (new entries, removed entries, modified fields)

### Use cases for the google ads transparency

#### Competitor ad intelligence

Pull every active ad your top 5 competitors are running via the google ads transparency. Map their messaging angles, creative formats, and regional spend allocation.

#### Ad-creative inspiration

Browse high-spending campaigns by category to copy proven creative formats, saves weeks of A/B testing from scratch.

#### Compliance auditing

Verify your own brand's compliance with platform ad policies by pulling all your live ads via the google ads transparency weekly.

#### Market research

Aggregate google ads transparency data across an entire vertical (e.g. all DTC mattress brands) to size paid-media spend and identify rising challengers.

### How it compares

Other tools that rank for "google ads transparency scraper" range from key-gated SERP APIs to other Apify actors. Here is where this Actor sits.

| | This Actor | SerpApi | NoCodeSERPApi | Other Apify ad scrapers |
|---|---|---|---|---|
| Run without your own API key | Yes, runs from the Apify Store | No, needs a SerpApi key | No, needs an account key | Yes, run from Apify |
| Hosted (proxies + captcha handled) | Yes | Yes | Yes | Varies |
| Structured JSON output | Yes | Yes | Excel/spreadsheet focus | Varies |
| Creative detail (impressions, regions, platforms, spend) | Yes, with `detail` on | Varies by endpoint | Limited | Varies |

#### Output fields

Every row carries `advertiser_id`, `creative_id`, `advertiser_name`, `format`,
`first_shown`, `last_shown`, `days_shown`, `target_domain` and `deeplink`, plus
`scraped_at` and the `searched_*` fields that say which input produced it.

Where the creative provides them you also get `image_url`, `title`, `ad_text`,
`display_url` (the URL printed under a text ad, e.g.
`www.trivago.com/hotel/comparison`), `keyword` (the dynamic-keyword-insertion
value), `preview_url`, `ad_group_id` and `customer_id`. Searching by brand name
adds `advertiser_country`, `advertiser_ad_count_low/high` and `advertiser_url`.

With `detail` on, each row gains a nested `detail` object holding per-region and
per-platform impression ranges, variation creatives, `platform_targeting` with
shown-versus-targeted per surface and geo includes and excludes, and for
political ads `spend`, `funding_entities` and `payer`.

Google prints no seller, star rating or landing-page copy in this data, so this
Actor does not invent them.
| Pay per result, no monthly quota | Yes | Monthly search credits | Monthly plan | Varies |

If you already run other jobs on Apify, this Actor keeps ad transparency data in the same account, dataset format, and billing. No extra vendor signup.

### FAQ

#### Is this google ads transparency free?

The Actor itself is hosted on Apify with pay-per-event pricing, you only pay for what you actually scrape. There's no monthly subscription and no minimum spend. The first few runs typically cost less than a coffee. For long-running daily jobs, your monthly bill scales with the volume of data you pull.

#### How does this google ads transparency compare to existing tools?

Most off-the-shelf google ads transparency alternatives are either fragile open-source scripts that break every few months, or expensive SaaS subscriptions starting at $99-$399/month. This Actor sits in between: hosted infrastructure that handles proxy rotation and retries, but priced per run.

#### What input does the google ads transparency accept?

The full input schema is rendered as a form on the Apify Store page, you can run a job by filling out a few fields with no code. The schema also accepts raw JSON if you're calling the Actor via the Apify API from your own service. See the **Input** section above for the field list.

#### How accurate is the google ads transparency data?

The Actor scrapes data directly from the source, so accuracy matches what a human user would see on the page. There's no third-party cache or middleware, every run returns the live state. If the upstream site throttles requests, the Actor handles retries and proxy rotation transparently and surfaces a structured error in the dataset's `errors` field rather than failing silently.

#### Can I run this google ads transparency on a schedule?

Yes, Apify has built-in scheduling. You can set the Actor to run hourly, daily, or weekly, and pipe results to webhooks, S3, or your data warehouse via the Apify integrations. Most teams schedule the google ads transparency as a daily task and incrementally diff against the previous run to detect changes.

### Pricing

This google ads transparency uses Apify's pay-per-event pricing, every successful record costs a small fixed amount, so your bill scales linearly with usage. There's no monthly subscription and no minimum spend. See the Apify Store page for the current per-event price; expect typical workloads to cost a few dollars per run.

# Actor input Schema

## `domain` (type: `string`):

Advertiser domain to look up (e.g. "redable.nl"). One of domain, search, or advertiser_id is required.

## `search` (type: `string`):

Brand or advertiser name when you do not know the exact domain. Only one lookup term is ever used: domain wins, then this, then advertiser_id, so filling in Domain as well means this box is ignored. The winner is sent to Google's advertiser-suggestion endpoint and the advertisers it returns are the ones whose ads get fetched.

## `advertiser_id` (type: `string`):

Direct advertiser lookup. Used as the lookup term only when both Domain and Free-text search are empty, because domain and search take priority over it. With Creative ID also filled in the run takes a different path altogether: one detail request, one row, and region, format, dates and Number of ads are all ignored.

## `creative_id` (type: `string`):

Fetch one named creative and nothing else. Advertiser ID must be set as well, the run rejects the input without it. On this path no search or paging happens and the other filters do not apply: Region only ends up in the deeplink, format, dates and Number of ads are not used at all.

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

Restrict to one region, or leave on Anywhere. A region filter is a hard narrowing: measured 2026-09-07, nike.com returned 0 ads pinned to US and 20 with no region set.

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

Filter by ad format. Leave empty for all formats.

## `start_date` (type: `string`):

Lower bound of the ad's last-shown date, written YYYY-MM-DD. It is converted to a timestamp and sent inside Google's own SearchCreatives request, so Google narrows the result set before any page is walked and the bound really does shorten the run. It applies to the domain and advertiser searches only; a single Creative ID lookup ignores it.

## `end_date` (type: `string`):

Upper bound of the ad's last-shown date, written YYYY-MM-DD. Like the lower bound it travels inside Google's own SearchCreatives request rather than being applied to the rows afterwards, and it too is ignored on a single Creative ID lookup. Leave both bounds empty and Google applies no date window.

## `ads_count` (type: `integer`):

How many ad creatives to return. Google serves 100 per page, so higher values walk more pages and take longer.

## `detail` (type: `boolean`):

Fetch impressions, regions, platforms, variations, and spend for every returned creative. Slower but richer.

## `political` (type: `boolean`):

Filter to political / election ads (these include spend ranges where available).

## `page_token` (type: `string`):

Continue a previous run from the `_next_page_token` value it wrote on its rows. It only works together with Domain: a run carrying a token skips the advertiser-suggestion step entirely, so a token combined with a brand-name or advertiser-ID search returns nothing. The Actor already walks the pages itself up to Number of ads, so this is only for going past where an earlier run stopped. Leave empty for the first page.

## `max_advertisers` (type: `integer`):

When searching by brand name, how many matching advertisers to pull ads from, biggest first. Large brands run one ad account per country, so 1 silently drops the rest.

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

Keep only ads that ran on this surface. Google's search API has no platform criterion, so this is applied after the fact and forces detail lookups on, which makes the run slower and costlier per ad.

## Actor input object example

```json
{
  "domain": "redable.nl",
  "search": "Nike",
  "advertiser_id": "AR10129747575264247809",
  "creative_id": "CR12965115384414863361",
  "region": "",
  "format": "",
  "start_date": "2026-01-01",
  "end_date": "2026-09-01",
  "ads_count": 40,
  "detail": false,
  "political": false,
  "page_token": "PASTE_NEXT_PAGE_TOKEN_HERE",
  "max_advertisers": 1,
  "platform": ""
}
```

# Actor output Schema

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

One item per Google ad creative.

## `output` (type: `string`):

OUTPUT record with the run's counts and status flags.

## `errors` (type: `string`):

Failures with a code and a redacted message. Absent when the run had none.

# 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 = {
    "domain": "nike.com",
    "region": "",
    "ads_count": 40,
    "max_advertisers": 1,
    "platform": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/google-ads-transparency").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 = {
    "domain": "nike.com",
    "region": "",
    "ads_count": 40,
    "max_advertisers": 1,
    "platform": "",
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/google-ads-transparency").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 '{
  "domain": "nike.com",
  "region": "",
  "ads_count": 40,
  "max_advertisers": 1,
  "platform": ""
}' |
apify call s-r/google-ads-transparency --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/google-ads-transparency"
        }
    }
}
```

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/qf6rFH7ei0b1440JM/builds/NeEqynBMplYneW1TF/openapi.json