# Google Ads Transparency Scraper API — Competitor Ads, $0.50/1K (`sherwood/google-ads-transparency-scraper`) Actor

Scrape every ad a company runs on Google (Search, YouTube, Shopping, Maps, Play) from the Ads Transparency Center, by domain, brand or advertiser ID: format, first/last shown, days active, previews; optional countries, impressions, variations and ad text. $0.50 per 1,000 ads, no login.

- **URL**: https://apify.com/sherwood/google-ads-transparency-scraper.md
- **Developed by:** [Sherwood](https://apify.com/sherwood) (community)
- **Categories:** Lead generation, Marketing
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 ad scrapeds

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 API — every ad a company runs on Google

Returns **every ad a company runs on Google** (Search, YouTube, Shopping, Maps, Play) from the [Google Ads Transparency Center](https://adstransparency.google.com/), as one dataset item per ad creative, for **$0.50 per 1,000 ads**. Look up a website (`nike.com`), a brand name (`Nike`), an advertiser ID (`AR…`) or a Transparency Center URL. No login, no API key, no browser.

Built for AI agents and workflows (MCP clients, n8n, Make, Python): the default input runs alone in a few seconds, nothing is required, every list also accepts a plain string, and failures are never charged.

### What you get

One item per ad creative (a real run on `decathlon.fr`, region `FR`, with `includeDetails`):

```json
{
  "creativeId": "CR03939502093047431169",
  "advertiserId": "AR15666691663760195585",
  "advertiserName": "Decathlon France SASU",
  "domain": "decathlon.fr",
  "format": "IMAGE",
  "firstShown": "2026-01-21T15:02:11Z",
  "lastShown": "2026-11-08T09:17:03Z",
  "shownForDays": 283,
  "region": "FR",
  "adUrl": "https://adstransparency.google.com/advertiser/AR15666691663760195585/creative/CR03939502093047431169?region=FR",
  "previewType": "rendered",
  "imageUrl": null,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&…",
  "width": null,
  "height": null,
  "query": "decathlon.fr",
  "queryAdsMin": 20000,
  "queryAdsMax": 30000,
  "status": "ok",
  "error": null,

  "advertiserLegalName": "Decathlon France SASU",
  "variationCount": 3,
  "variations": [{"previewType": "rendered", "previewUrl": "https://…content.js?…", "imageUrl": null, "width": null, "height": null}],
  "regionsShown": [
    {"region": "FR", "firstShownDate": "2026-01-21", "lastShownDate": "2026-11-08", "firstShownOnOrBefore": "2026-01-21",
     "impressionsMin": 2250000, "impressionsMax": 2500000,
     "platformImpressions": [{"platformCode": 3, "platform": "SEARCH", "impressionsMin": 2250000, "impressionsMax": 2500000},
                             {"platformCode": 4, "platform": "SHOPPING", "impressionsMin": 2000, "impressionsMax": 3000}]}
  ],
  "impressionsMin": 2250000,
  "impressionsMax": 2500000,
  "platformCodes": [3, 4, 5],
  "platforms": ["SEARCH", "SHOPPING", "YOUTUBE"],
  "audienceSelection": {"demographicInfo": null, "geographicLocations": "included and excluded", "contextualSignals": "included and excluded", "topicsOfInterest": null, "customerLists": null},
  "adText": "GARMIN - Compteur vélo gps Garmin Edge Explore 2 - compteur gps vélo - velo tout chemin randonnee - Decathlon",
  "adHeadline": "GARMIN - Compteur vélo gps Garmin Edge Explore 2 - compteur gps vélo - velo tout chemin randonnee - Decathlon",
  "adDescription": null,
  "headlines": ["GARMIN - Compteur vélo gps Garmin Edge Explore 2 - compteur gps vélo - velo tout chemin randonnee - Decathlon"],
  "displayUrl": "Decathlon.fr",
  "landingPage": null,
  "videoId": null,
  "detailError": null
}
```

| Field | Always | Meaning |
|---|---|---|
| `creativeId`, `advertiserId` | yes | Google's stable ids (`CR…`, `AR…`). Items are de-duplicated by `creativeId` across queries. |
| `advertiserName`, `domain` | yes | Advertiser account name; destination domain (known for domain searches, `null` when you search by advertiser ID or brand). |
| `format` | yes | `TEXT`, `IMAGE` or `VIDEO`, as Google classifies the creative. |
| `firstShown`, `lastShown`, `shownForDays` | yes | ISO 8601 UTC; `shownForDays` is Google's count of days the ad was shown (longevity signal). |
| `region`, `adUrl` | yes | The region you asked for; the public ad page. |
| `previewType`, `imageUrl`, `width`, `height`, `previewUrl` | yes | `image`: a direct CDN image. `rendered`: Google's preview bundle (text, video and rich ads). |
| `queryAdsMin`, `queryAdsMax` | yes | Google's estimate of how many ads the query has in total, e.g. 20,000 to 30,000 for `decathlon.fr`. |
| `status`, `error` | yes | `ok`; `skipped` with a message when a query has no ad; `error` when Google refused or the input was wrong. |
| `advertiserLegalName`, `variationCount`, `variations` | details | Legal name of the paying advertiser; every A/B variation with its preview. |
| `regionsShown`, `impressionsMin`, `impressionsMax`, `platformCodes`, `platforms`, `audienceSelection` | details | Every country the ad ran in, with first and last dates, Google's "times shown" range and its split by platform; totals are the sums over countries. Google publishes impressions, platforms and audience criteria only for ads shown in the EU (Digital Services Act); elsewhere these fields are `null`. |
| `adText`, `adHeadline`, `adDescription`, `headlines`, `displayUrl`, `landingPage`, `videoId` | details | Read from the preview bundle without a browser: the visible text lines, the display URL, the landing page when the bundle carries it, the YouTube video id of video ads. Plain image ads have no text. |

Advertiser mode (`resultType: advertisers`) returns one item per advertiser account instead: `advertiserName`, `advertiserId`, `advertiserCountry`, `adsMin`, `adsMax`, `advertiserVerified`, `domain`, `runsGoogleAds`.

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `queries` | array of strings | `["nike.com"]` | Websites, brand names, advertiser IDs (`AR` + 20 digits) or `adstransparency.google.com` URLs (advertiser or creative page). Aliases: `query` (string, comma or newline separated), `domains`, `advertiserIds`, `startUrls`. Everything is merged. A brand name is resolved to its largest advertiser accounts (5 at most). |
| `region` | string | `ANYWHERE` | Two-letter country code (`US`, `FR`), English country name, or `ANYWHERE`. |
| `adFormat` | `ALL` / `TEXT` / `IMAGE` / `VIDEO` | `ALL` | |
| `platforms` | array of `SEARCH`, `YOUTUBE`, `MAPS`, `PLAY`, `SHOPPING` | all | Google's own platform filter, sent to Google (not applied after the fact). |
| `startDate`, `endDate` | `YYYY-MM-DD` | none | Ads whose shown period overlaps the window. Google keeps the last 12 months of dates. One bound alone is completed (today / 12 months before). |
| `maxAdsPerQuery` | integer | `100` | 40 ads per page. Big advertisers have tens of thousands (we read 4,800 Nike ads in one go while measuring). |
| `maxAds` | integer | `1000` | Cap for the whole run. |
| `includeDetails` | boolean | `false` | One extra request per ad (see the table above). |
| `resultType` | `ads` / `advertisers` | `ads` | `advertisers`: does this company run Google Ads? One cheap request per query. |
| `proxyConfiguration` | object | Apify datacenter proxies | Sessions are rotated and paced; a residential IP is tried once when Google refuses. |

Minimal calls:

```json
{"queries": ["nike.com", "adidas.com"], "region": "US", "maxAdsPerQuery": 200}
{"query": "Decathlon", "region": "FR", "platforms": ["YOUTUBE"], "startDate": "2026-10-01"}
{"queries": ["https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR01855627099679752193?region=FR"], "includeDetails": true}
{"queries": ["qonto.com", "Allianz", "my-prospect.com"], "resultType": "advertisers"}
```

### Pricing

Pay per event, nothing up front:

| Event | Price | When |
|---|---|---|
| Ad scraped (`result`) | **$0.0005** ($0.50 per 1,000) | One ad creative delivered, or one advertiser row in advertiser mode. |
| Ad detail (`ad-detail`) | **$0.0005** ($0.50 per 1,000) | One ad enriched with `includeDetails`, only when Google answered. |
| Actor start | $0.00005 | Per run. |

Duplicates, errors and queries with no ad are never charged. 1,000 fully detailed ads cost $1; the same data costs $2 to $7 per 1,000 on the most used alternatives. The run uses 256 MB of memory, so platform usage is a few cents per 10,000 ads.

### Accuracy, measured

- 16-case panel (12 sectors, 9 countries, 3 languages; domains, brands, advertiser IDs, creative URLs, format and date filters, advertiser mode), every run green, 521 ads, every field at 100 % coverage except what depends on the ad (`imageUrl` for image ads, text for rendered ads, impressions for EU ads).
- Same inputs as the most used alternative (`scrapesage/google-ads-transparency-scraper`, 3 searches × 40 ads): 100 % agreement on advertiser name, format, first and last shown dates, days shown and image URL on every common ad (91 of 91).
- Dates and ids come straight from Google's own data; `format`, `shownForDays` and the impressions ranges are Google's values, not estimates.

### How to run it

**API**

```bash
curl -X POST "https://api.apify.com/v2/acts/sherwood~google-ads-transparency-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["nike.com"], "region": "US", "maxAdsPerQuery": 100}'
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("APIFY_TOKEN")
run = client.actor("sherwood/google-ads-transparency-scraper").call(run_input={"queries": ["decathlon.fr"], "region": "FR", "includeDetails": True})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["format"], ad["shownForDays"], ad.get("adHeadline"), ad["adUrl"])
```

**n8n / Make**: the official Apify node, Actor `sherwood/google-ads-transparency-scraper`, input as above. **MCP**: any client connected to the Apify MCP server can call it by name; the input schema tells the agent what to pass.

**Schedules**: pair it with [Apify Schedules](https://docs.apify.com/platform/schedules) and `startDate` to watch a competitor's new ads every week.

### Use it from an AI coding agent

Install the task skill for Claude Code, Codex, Cursor, Gemini CLI or any agent that reads the Agent Skills format:

```bash
npx skills add maxouf/sherwood-skills --skill google-ads-transparency-scraper
```

The skill compares this Actor with the other tools for the task, estimates the cost before running, caps the spend and hands back the result as a file. The pipeline skill `apify-competitor-watch` chains it with the other Actors of the use case. Source: [github.com/maxouf/sherwood-skills](https://github.com/maxouf/sherwood-skills).

### Limits, honestly

- **Source**: the Transparency Center's own interface data, read by HTTP. Google can change it; the Actor is tested every day on its default input.
- **Platforms**: the five surfaces are Google Search, YouTube, Google Maps, Google Play and Google Shopping; the Display Network is not part of the Transparency Center. Platform data exists for ads shown on or after 2023-09-04.
- **Impressions, platform split and audience criteria** exist only for ads shown in the EU. Outside the EU you get them on ads that also ran in an EU country (common for global brands).
- **Dates**: Google keeps 12 months of shown dates. A window that ends earlier returns nothing.
- **Ad text**: plain image ads carry no text. Shopping ads are assembled by feed vendors, whose host can appear before the advertiser's link; `landingPage` prefers a host matching the ad's domain.
- **Speed**: Google slows down an IP after a burst, so each proxy session is paced at one request every two seconds and the Actor runs several in parallel. 100 ads take a few seconds; 400 ads with details, a few minutes.
- **Advertiser name vs domain**: searching by advertiser ID or brand gives no `domain` (Google does not return it on those searches).

### Related Actors by Sherwood

- [Google Maps Scraper API](https://apify.com/sherwood/google-maps-scraper): places, leads and AI verdicts, $0.50 per 1,000 on the free plan, from $1 on paid plans.
- [Review Analyzer API](https://apify.com/sherwood/review-analyzer): sentiment, topics and complaints from any review dataset.
- [Trade Show Exhibitors & Attendees Finder](https://apify.com/sherwood/trade-show-people-finder).

### FAQ

**Is there an official Google Ads Transparency API?** No. The Center is a public website; this Actor reads the same data its pages load, with no login.

**Can I get all ads of a big brand?** Yes: raise `maxAdsPerQuery` and `maxAds`. Pagination has no fixed cap (4,800 Nike ads were read in one measurement).

**Does it work for political ads?** It returns them like any other ad; the political-ads surface with spend ranges is not covered yet.

**Which countries have impressions?** EU member states, under the Digital Services Act. Use an EU `region` to get them on nearly every ad.

# Actor input Schema

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

What to look up in the Google Ads Transparency Center: a website (nike.com), a brand or company name (Nike), an advertiser ID (AR + 20 digits) or an adstransparency.google.com URL (advertiser page or creative page). Several per run. A single string may hold several entries separated by commas or new lines; a brand name is resolved to its advertisers first.

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

Where the ads were shown: a two-letter country code (US, FR, DE), an English country name (France), or ANYWHERE for every country. Countries in the EU also expose impressions and platform data on ad details.

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

Keep only text, image or video ads.

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

Keep only ads shown on these Google surfaces. Empty = all platforms. Google applies platform data to ads shown on or after 2023-09-04.

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

YYYY-MM-DD. Keeps the ads whose shown period overlaps the window \[startDate, endDate]. Google only keeps the last 12 months of shown dates, so an earlier date starts there. On its own, the window runs to today.

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

YYYY-MM-DD. On its own, the window covers the 12 months up to this date.

## `maxAdsPerQuery` (type: `integer`):

Ads collected for each domain, brand or advertiser (40 per page). Large advertisers have tens of thousands.

## `maxAds` (type: `integer`):

Hard cap for the whole run, across every query, after de-duplication by creative ID.

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

One extra request per ad: every country the ad ran in with first and last shown dates, impressions range and platform split (published by Google for EU countries), every variation with its preview, the advertiser's legal name, the audience criteria selected, and the ad text, landing page and display domain read from the preview. Charged $0.50 per 1,000 detailed ads on top of the ad itself; never charged when the detail cannot be read.

## `resultType` (type: `string`):

"ads" lists the ads. "advertisers" answers 'does this company advertise on Google?' with one item per advertiser account matching each query: name, advertiser ID, country, approximate number of ads, verified badge. Cheap lead qualification: one request per query.

## `query` (type: `string`):

Alias of queries: one or several entries separated by commas or new lines. Other accepted aliases: domains, domain, advertiserIds, startUrls, urls, searchTerms.

## `domains` (type: `array`):

Alias of queries.

## `advertiserIds` (type: `array`):

Alias of queries: advertiser IDs (AR + 20 digits).

## `startUrls` (type: `array`):

Alias of queries: adstransparency.google.com URLs.

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

Apify datacenter proxies by default: Google slows an IP down after about ten pages, so the Actor rotates sessions. A residential IP is tried automatically if Google refuses.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "region": "ANYWHERE",
  "adFormat": "ALL",
  "platforms": [],
  "maxAdsPerQuery": 100,
  "maxAds": 1000,
  "includeDetails": false,
  "resultType": "ads",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One item per ad creative (or per advertiser in advertiser mode), with status ok, skipped or error.

# 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"
    ],
    "region": "ANYWHERE",
    "maxAdsPerQuery": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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