# Google Ads Transparency Scraper — Domain & Advertiser Ads (`genial_candlestand/google-ads-transparency-scraper`) Actor

Get the ads of any domain or advertiser from the Google Ads Transparency Center: advertiser name, format, first and last shown dates, days shown, image or preview, political spend and impressions. Many queries per run, $1 per 1,000 ads.

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

## Pricing

from $0.70 / 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 domain, advertiser or political

This actor returns the ads that a domain or an advertiser runs on Google, taken from the public Google Ads Transparency Center. Each row is one ad with its `advertiserName`, `format` (text, image or video), `firstShown`, `lastShown`, `daysShown`, an archived `imageUrl` or a `previewUrl`, and the Google Ads ids. Political ads add `spendMin`, `spendMax` and `impressionsMin`/`impressionsMax` ranges. No login and no browser are needed.

### What does it do?

You give the actor a list of domains, advertiser ids, Transparency Center URLs or advertiser names, in any mix. It finds the ads of each one on adstransparency.google.com and returns one flat row per ad. You can filter by country, platform (Search, YouTube, Shopping, Maps, Play), format and dates. It can also list all political ads shown in a country. It suits marketers, agencies, ad-intelligence tools, journalists and AI agents.

### How to use

1. Open the actor in Apify Console and enter one or more values in **Domains, advertisers or Transparency Center URLs**.
2. Optionally set country, platform, format, dates and **Max ads per query**.
3. Switch on **Include details** for variations, per-country reach and the advertiser's country.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API. AI agents can call the actor through the Apify API or MCP with the same JSON input.

### Pricing

The actor uses pay-per-event pricing: **$0.001 per ad** (one `ad` event per saved ad), which is **$1.00 per 1,000 ads**. Details are included at no extra charge. There is no start fee, and queries with no ads cost nothing. An ad found by two queries in the same run is saved and charged once. Higher Apify subscription tiers get a discount (down to $0.0007 per ad). Example: 500 ads cost $0.50.

### Input

| Field | Meaning |
|---|---|
| `queries` | Domains, advertiser ids (`AR` + 20 digits), Transparency Center advertiser/search URLs or advertiser names |
| `political` | Political ads only; needs `country`; with queries use advertisers, not domains |
| `country` | Two-letter ISO code (`UK` is accepted as `GB`); empty = anywhere |
| `platform` | `ALL`, `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY` |
| `format` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `startDate`, `endDate` | `YYYY-MM-DD` range of when the ads were shown |
| `maxItemsPerQuery` | Ads per query, default 100, no upper cap |
| `maxItems` | Optional cap on the whole run |
| `includeDetails` | Adds variations, countries, per-country reach, advertiser country |
| `proxyConfiguration` | Apify datacenter proxy by default |

```json
{
  "queries": ["nike.com", "adidas.com"],
  "country": "DE",
  "platform": "YOUTUBE",
  "maxItemsPerQuery": 200
}
```

### Output

One row is one ad. Main fields:

| Field | Description |
|---|---|
| `creativeId`, `advertiserId` | Transparency Center ids of the ad and the advertiser |
| `advertiserName` | Verified advertiser name |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `firstShown`, `lastShown`, `daysShown` | When and for how long the ad was shown |
| `imageUrl`, `previewUrl` | Archived image or Google preview script |
| `spendMin`, `spendMax`, `currency`, `regions` | Political ads only |
| `impressionsMin`, `impressionsMax` | Political ads, and EU-served ads with details |
| `variations`, `countries`, `regionStats`, `advertiserCountry`, `advertiserLegalName` | With `includeDetails` |

Example item (shortened):

```json
{
  "url": "https://adstransparency.google.com/advertiser/AR09595561223982678017/creative/CR09949182245287755777?region=anywhere",
  "creativeId": "CR09949182245287755777",
  "advertiserId": "AR09595561223982678017",
  "advertiserName": "M Media Group Pty Ltd",
  "query": "nike.com",
  "queryType": "domain",
  "political": false,
  "country": null,
  "domain": "nike.com",
  "format": "VIDEO",
  "firstShown": "2026-10-04T23:20:32.000Z",
  "lastShown": "2026-10-23T17:06:21.000Z",
  "daysShown": 20,
  "imageUrl": null,
  "googleCreativeId": "826665934501",
  "googleCustomerId": "7268451689",
  "adGroupId": "204454935567",
  "scrapedAt": "2026-10-23T17:30:09.830Z"
}
```

### Use cases

- **Competitor ad research:** all YouTube or Search ads of several domains in one country.
- **Advertiser library:** every ad of given advertiser ids or URLs.
- **EU reach analysis:** with details, impression ranges per EU country and platform.
- **Political ads monitoring:** political ads in a country since a date, with spend and impression ranges.
- **Brand lookup by name:** resolve an advertiser by exact name and list its video ads.

### Limitations

- Advertiser names are resolved on a best-effort basis (exact name first, then a matching domain). If nothing matches, the query returns no ads and a warning lists candidates.
- Spend and impression ranges exist only for political ads and, with details, for EU regions; elsewhere they are empty. `impressionsMax` is empty when only a lower bound is published.
- Google keeps date-filterable data for about the last 365 days. An `endDate` older than that, a future `startDate`, or an `endDate` before `startDate` fails the run.
- Single-ad (creative) URLs are not supported; use the advertiser URL or id.
- With `political`, domains are not accepted, and a country is required.
- `imageUrl` or `previewUrl` can be empty for some ads. Details make runs slower, as they need one extra request per ad.
- Subdomains are searched as given; try the parent domain if you get no ads.

### FAQ

**Is it legal to scrape the Ads Transparency Center?** The data is public and published by Google for transparency. The actor reads only what the site shows, with no login. You are responsible for how you use it and for following applicable laws and Google's terms.

**Do I need a login or cookies?** No.

**How many ads can I get?** There is no cap on `maxItemsPerQuery`; the actor follows pages until the ads end or your limit is reached.

**What about a residential proxy?** Not needed; the default Apify datacenter proxy is used.

**How does it differ from the official BigQuery dataset?** This actor needs no Google Cloud project, billing or SQL, and takes domains, ids or URLs directly.

### Other actors

Other public data actors from the same author:

- [Google Trends Scraper](https://apify.com/genial_candlestand/google-trends-scraper) — interest over time, by region and related queries for search terms.
- [Apple App Store Reviews API](https://apify.com/genial_candlestand/apple-app-store-reviews-api) — public App Store reviews and ratings as JSON.
- [Firefox Add-ons Reviews Parser](https://apify.com/genial_candlestand/firefox-addons-reviews-parser) — public Firefox add-on ratings and reviews.

# Actor input Schema

## `queries` (type: `array`):

One per line, mixed freely: a domain (nike.com), an advertiser id (AR + 20 digits), a Transparency Center advertiser URL, or an advertiser name (exact match first). Single-ad URLs are not supported. Leave empty only with 'Political ads only' and a country.

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

Return election (political) ads with spend and impression ranges. Needs a Country. Without queries: all political ads shown in that country; with queries: political ads of those advertisers (advertiser ids, names or advertiser URLs — not domains).

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

Two-letter ISO country code (US, DE, GB…) to get only ads shown in that country. Empty = anywhere. Required with 'Political ads only'.

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

Only ads shown on this Google platform. Works with every country, format and date range.

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

Only ads of this format. Text ads come as an archived image of the ad.

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

Only ads shown on or after this date (YYYY-MM-DD). Must not be in the future. Google keeps date-filterable data for about the last 365 days; an earlier date works but adds nothing.

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

Only ads shown on or before this date (YYYY-MM-DD, inclusive). Must be on or after 'Shown from' and within the last ~365 days.

## `maxItemsPerQuery` (type: `integer`):

Stop each query after this many ads. 100 ads need one request; there is no upper cap.

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

Optional cap on all ads of the run, across all queries. Empty = no total cap.

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

Add each ad's variations, the countries it ran in with first/last dates, impression ranges per country and platform (EU countries and political ads), and the advertiser's country and legal name. No extra charge; one extra request per ad, so runs are slower.

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

Apify datacenter proxy works (default). Residential is not needed.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "political": false,
  "platform": "ALL",
  "format": "ALL",
  "maxItemsPerQuery": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with all ads

## `overview` (type: `string`):

Ads table in the Overview 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 = {
    "queries": [
        "nike.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("genial_candlestand/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 = { "queries": ["nike.com"] }

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

```

## MCP server setup

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