# Google Ads Transparency Scraper | Ad Text, Regions, New Ads (`akatra/google-ads-transparency-scraper`) Actor

See every ad a company runs on Google Search, YouTube, Shopping, Maps and Play. Search the Google Ads Transparency Center by website, advertiser name or ID and get ad text, images, video links, dates, regions and EU impression ranges. Monitor competitors with 'Only new ads'.

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

## Pricing

from $1.26 / 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: ad text, regions, impressions, new ads

See every ad a company runs on Google: Search, YouTube, Shopping, Maps and Play. This scraper reads the public **Google Ads Transparency Center** and returns, for each ad, the advertiser, format, first and last shown dates, how many days it ran, the ad's visible text, image and video links, every region it was shown in and, where Google publishes them, impression ranges per region and platform.

Search by **website domain**, **advertiser name**, **advertiser ID** or a Transparency Center URL. Run it on a schedule with **Only new ads** turned on and you get only the ads that appeared since your last run.

**Pay per result** · **No login, no API key** · **Public data only** · **Tested daily** · **LLM-ready JSON for AI agents (MCP)**

### 🛠️ What does Google Ads Transparency Scraper do?

- 🔎 **Search by website domain, advertiser name, advertiser ID** or a Transparency Center URL.
- 🧾 **Ad text, image and video links, format, first and last shown dates** and how many days each ad ran.
- 🌍 **Every region an ad was shown in**, with impression ranges per region and platform where Google publishes them.
- 🆕 **Only new ads mode.** Schedule it and get just the ads that appeared since your last run.
- 🛡️ **Built to get through blocking.** Requests go out with a real browser fingerprint through rotating proxies, and a blocked request is retried from a fresh IP. A result that could not be completed is never charged.

#### What people use it for

- **Competitor ad monitoring.** See which ads a competitor launched this week, on which platform and in which countries.
- **Creative research.** Collect headlines, descriptions, images and YouTube videos of the ads in your market, and see which ones ran the longest.
- **Market entry signals.** Spot when a brand starts advertising in a new country.
- **Agency reporting.** Export a client's or a prospect's full ad history in one run.
- **EU reach analysis.** Use the impression ranges Google publishes for ads shown in the EU.

### 📊 What data can you extract?

Every result is one JSON object (one row in CSV or Excel) with these fields:

| Field | Meaning |
|---|---|
| `adId`, `adUrl` | Google's ID for the ad and a link to it in the Transparency Center |
| `advertiserId`, `advertiserName`, `advertiserLegalName` | The advertiser as verified and published by Google |
| `domain` | The website the ad promotes (filled when you search by domain) |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `firstShownAt`, `lastShownAt`, `daysShown` | When the ad first and last ran, and on how many days |
| `adText` | The visible text of the ad: headline, description, displayed URL. Empty when Google stores the ad only as a picture |
| `imageUrl` | The ad as an image, when Google provides one |
| `videoUrl` | The YouTube link of a video ad |
| `previewUrl` | Google's preview script for ads that are not stored as an image |
| `variations`, `variationCount` | All versions of the ad |
| `regions`, `regionCount` | Every country the ad was shown in, with first and last shown dates |
| `regions[].impressionsMin`, `impressionsMax`, `platforms` | How often the ad was shown, as a range, in total and per platform. Google publishes these only for some regions, mainly the EU |

### 🚀 How to use Google Ads Transparency Scraper

1. Create a free [Apify](https://apify.com) account and open this Actor.
2. Add one or more **advertisers**, one per line: a domain such as `nike.com`, an advertiser name, an advertiser ID (`AR...`) or a Transparency Center URL.
3. Optionally pick a **region**, an **ad format** (text, image, video), a **platform** and a date range.
4. Set **Max ads per advertiser**. The most recently shown ads come first.
5. Keep **Include regions and variations** and **Include ad text and video link** on for the full record, or turn them off for a faster run with the basic fields.
6. Turn on **Only new ads** and add a schedule to watch a competitor.
7. Run it and download the results as JSON, CSV, Excel, or connect them through the API.

### 📥 Input example (JSON)

```json
{
  "queries": ["nike.com", "AR16735076323512287233"],
  "region": "DE",
  "format": "",
  "platform": "",
  "maxItemsPerQuery": 200,
  "includeDetails": true,
  "includeAdText": true,
  "onlyNew": false
}
```

### 📤 Sample output (JSON)

![Sample output table of Google Ads Transparency Scraper](https://api.apify.com/v2/key-value-stores/GkJnrNz6YWKHQYnZr/records/google-ads-transparency-scraper-output.png)

```json
{
  "adId": "CR16839929171130974209",
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "advertiserLegalName": "Nike Retail BV",
  "domain": "nike.com",
  "format": "TEXT",
  "firstShownAt": "2025-09-19T13:07:13+00:00",
  "lastShownAt": "2026-10-01T23:10:03+00:00",
  "daysShown": 378,
  "adText": "Sponsored nike.com The Official Nike Site · Discover Nike Shoes Online At Nike.com. Shop The Official Nike Site.",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/13158258397673946674",
  "previewUrl": null,
  "videoUrl": null,
  "variationCount": 3,
  "variations": [
    { "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/13158258397673946674", "previewUrl": null }
  ],
  "regionCount": 12,
  "regions": [
    {
      "regionCode": "DE",
      "region": "Germany",
      "firstShown": "2025-09-19",
      "lastShown": "2026-09-28",
      "impressionsMin": 0,
      "impressionsMax": 1000,
      "platforms": [
        { "platform": "Google Search", "impressionsMin": 0, "impressionsMax": 1000 }
      ]
    }
  ],
  "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR16839929171130974209",
  "search": "nike.com",
  "scrapedAt": "2026-10-01T23:28:57+00:00"
}
```

### 🤖 Use it with AI agents, MCP and the API

The output is clean JSON with stable field names, ready for LLM pipelines, RAG and agent tools without extra parsing.

- **AI agents and MCP (Claude, ChatGPT, Cursor and others).** Add the Apify MCP server with this Actor as a tool: `https://mcp.apify.com?tools=akatra/google-ads-transparency-scraper`. The agent can then run it and read the results by itself.
- **API.** Start a run and get the results in a single call:

```bash
curl -X POST "https://api.apify.com/v2/acts/akatra~google-ads-transparency-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["nike.com", "AR16735076323512287233"], "region": "DE", "format": "", "platform": "", "maxItemsPerQuery": 200, "includeDetails": true, "includeAdText": true, "onlyNew": false}'
```

- **No-code tools and SDKs.** Works with Make, n8n, Zapier and LangChain through Apify's integrations, and with the Apify clients for Python and JavaScript. Schedule it and send the results to a webhook, Google Sheets or your own database.

### 💰 Pricing: pay per result

You pay per ad, nothing for empty runs beyond a tiny start fee. See the price on the Pricing tab. Regions, variations, ad text and video links are included at no extra charge. There is no subscription or rental fee. New to Apify? The free plan includes $5 of platform credit every month, enough for about 2,700 ads with this Actor, and no credit card is needed.

### 🚦 Run status and error messages

Every run ends with a plain status message, so automated workflows (API, Make, n8n, AI agents) can tell what happened without reading the log:

| Situation | What you get |
|---|---|
| Finished normally | `Saved N ads.` |
| Nothing matched | The run succeeds with `No ads saved. Check the domain or advertiser, widen the filters, or turn off 'Only new ads'.` You pay only the start fee. |
| Missing or unsupported input | The run fails at once and the log names the field to fix. Nothing is scraped. |
| The site kept blocking some pages | `Some pages stayed blocked, so the results are incomplete; run again to get the rest.` |
| Details of some ads stayed blocked | `Skipped N ads whose details stayed blocked (not charged).` |
| Your maximum charge is reached | Stops cleanly with `Stopped at your maximum charge limit.` Everything saved so far stays in the dataset. |

### ℹ️ Good to know

- A **domain** search returns ads from every advertiser that promotes that website, including resellers and agencies. Use an **advertiser ID** for one specific company. An **advertiser name** is matched to the closest advertiser; the run log tells you which one was used.
- Google keeps text ads either as a picture or as a live preview. The scraper reads the text from the preview when there is one; picture-only ads come with `imageUrl` and an empty `adText`.
- Dynamic keyword placeholders in ad text are replaced with their default text, as a searcher would see them.
- An ad is delivered once per run, even when it matches several of your lines. If you set a maximum charge for a run, the scraper stops as soon as that limit is reached.
- You never pay for an incomplete record: with details on, an ad whose details cannot be loaded is skipped and picked up on a later run. The run's status message tells you when something was skipped or a search could not be finished.
- **Only new ads** remembers what it delivered per advertiser and filter set. The first run is your baseline. From the second run on you get ads whose first shown date is after the previous run (with a three-day margin, because Google lists new ads with a delay). Google sorts ads by when they were last shown, so the scraper checks every ad shown since your previous run, up to the 20,000 most recently shown ads per advertiser. Changing the region, format, platform or dates starts a fresh memory.
- Advertiser names come from Google's public transparency registry. The scraper collects no other personal data.

### 📝 Changelog

- **2026-10-02** 'Only new ads' now also scans the most recently shown ads and treats unfinished searches as not done. README restructured: data table, API and MCP examples, run status messages.
- **2026-10-02** Ads whose details cannot be loaded are skipped and not charged; sturdier parsing, after two independent audits.
- **2026-10-02** First release: domain and advertiser search, regions and impression ranges, ad text and video links, only-new mode.

### ⚖️ Legal and privacy

This scraper is an independent tool and is not affiliated with, endorsed by, or sponsored by Google. "Google", "Google Ads" and "YouTube" are trademarks of their owner and are used here only to show which website the tool works with. It reads only data that Google publishes in its public Ads Transparency Center. Ads and their content belong to their advertisers. Use the data in line with the laws that apply to you and the source site's terms.

The source site's name and logo are trademarks of their owner and appear here only to identify the website this tool works with. The Actor reads only pages that are public without logging in. How you store and use the data is your responsibility: follow the laws that apply to you, such as GDPR and CCPA.

### 🔗 More scrapers from Akatra

- [Indeed Jobs Scraper](https://apify.com/akatra/indeed-jobs-scraper): 💼 job ads from Indeed in 30 countries, with yearly salary and only-new mode.
- [Google News Scraper](https://apify.com/akatra/google-news-scraper): 📰 news by keyword or topic in 50 editions, with the real article URLs.
- [Google Trends Scraper](https://apify.com/akatra/google-trends-scraper): 📈 interest over time, by region, and rising related queries.
- [YouTube Transcript Scraper](https://apify.com/akatra/youtube-transcript-scraper): 🎬 video transcripts as clean text and timestamped lines.

### 💬 Support

Found a bug or need a field that is missing? Open an issue on the Issues tab and we usually reply within a day.

# Actor input Schema

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

One per line: a website domain (nike.com), an advertiser name (Nike, Inc.), an advertiser ID (AR16735076323512287233) or a Google Ads Transparency Center URL. A domain returns the ads of every advertiser that promotes that website.

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

Only ads shown in this country. Leave on 'Anywhere' for all regions.

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

Only ads of this format.

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

Only ads shown on this Google platform.

## `dateFrom` (type: `string`):

Optional. Only ads shown on or after this date.

## `dateTo` (type: `string`):

Optional. Only ads shown on or before this date.

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

Stop after this many ads for each line in 'Advertisers'. The most recently shown ads come first.

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

Open each ad to add the list of regions with first and last shown dates, impression ranges where Google publishes them (mainly the EU), the advertiser's legal name and all variations of the ad. Turn off for a faster run with the basic fields only.

## `includeAdText` (type: `boolean`):

Read the ad's visible text (headline, description, displayed URL) and, for video ads, the YouTube link. Needs 'Include regions and variations'.

## `onlyNew` (type: `boolean`):

The first run is your baseline. Later runs with the same advertiser and filters return only ads that started running since your previous run. Ideal for a daily or weekly competitor watch.

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

Apify Proxy is recommended. The scraper spreads requests over several IPs automatically.

## Actor input object example

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

# Actor output Schema

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

All scraped ads, shown in the overview table.

## `adsFull` (type: `string`):

All scraped ads with every field, including regions and variations.

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

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

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

```

## MCP server setup

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