# Google Ads Transparency Scraper: Competitor Ads, Text & Images (`mitp1997/google-ads-transparency-scraper`) Actor

Scrape every ad a company runs on Google Search, Display and YouTube from the Google Ads Transparency Center. Search by domain, advertiser name or ID, any country, date range or format. Get ad text, headlines, images, videos, first/last shown dates and regions.

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

## Pricing

from $1.50 / 1,000 ad 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 ads, ad text, images & videos

Get **every ad a company runs on Google** (Search, Display/Image and YouTube) from the official [Google Ads Transparency Center](https://adstransparency.google.com/). Search by **website domain**, **advertiser name** or **advertiser ID**, in any country, for any date range, and get the ad copy, headline, landing page, images, YouTube video, first/last shown dates and the countries each ad ran in.

**Price: $1.50 per 1,000 ads** (pay per result) + $0.005 per run, platform usage included. Queries that find nothing are free.

### What you can do with it

- **Competitor ad research**: see every Search, Display and YouTube ad your competitors run, with the exact copy.
- **Ad copy inspiration**: collect headlines and descriptions across a whole niche.
- **Monitor new campaigns**: run it on a schedule with a date range and catch new ads as soon as they appear.
- **Agency and brand-safety audits**: find every advertiser account (including agencies and resellers) running ads for a domain.
- **Market research by country**: compare what a brand advertises in the US, India, Germany or any other country.

### Input

| Field | Description |
|---|---|
| **Advertiser domains** | Websites, e.g. `nike.com`. Returns ads from every advertiser account whose ads point to the domain. |
| **Advertiser names** | e.g. `Flipkart`. The matching advertiser with the most ads is used (set *Advertiser name matching* to `all` to include every match). |
| **Advertiser IDs or URLs** | `AR16735076323512287233` or a Transparency Center link such as `https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US`. |
| **Region** | 2-letter country code (`US`, `GB`, `IN`, `DE`, ...) or `anywhere`. |
| **Ad format** | All, Text (Search), Image (Display) or Video (YouTube). |
| **Shown from / until** | Optional date range (YYYY-MM-DD). |
| **Max ads per domain / advertiser** | Ads come newest first. Default 100. |
| **Max ads in total** | Optional overall limit. |
| **Include ad text, images & landing pages** | On by default. Opens each ad's preview and extracts its content. Turn off for a faster list with dates only. |
| **Include regions & impressions** | On by default. Countries where each ad ran, per-country first/last shown dates and impression ranges (Google publishes impressions for EU countries only). |

Example input:

```json
{
    "domains": ["nike.com"],
    "advertiserNames": ["Flipkart"],
    "advertiserIds": ["AR16735076323512287233"],
    "region": "US",
    "format": "any",
    "dateFrom": "2026-09-01",
    "maxAdsPerQuery": 100
}
```

### Output

One dataset item per unique ad. Example (shortened):

```json
{
    "status": "ok",
    "query": "nike.com",
    "queryType": "domain",
    "advertiserId": "AR16735076323512287233",
    "advertiserName": "Nike, Inc.",
    "adId": "CR10000000000000000000",
    "format": "text",
    "firstShown": "2026-08-02T14:11:05.000Z",
    "lastShown": "2026-10-23T18:40:12.000Z",
    "daysShown": 82,
    "advertiserDomain": "nike.com",
    "headline": "Shop Nike Running Shoes",
    "description": "Nike® shoes are available in a wide range of silhouettes to fit your running form.",
    "displayUrl": "nike.com",
    "destinationUrl": null,
    "adText": "Nike | nike.com | Shop Nike Running Shoes | ...",
    "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/..."],
    "youtubeVideoId": null,
    "regions": ["US"],
    "regionStats": [{ "region": "US", "firstShown": "2026-08-02", "lastShown": "2026-10-23", "impressionsMin": null, "impressionsMax": null }],
    "variationCount": 5,
    "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR10000000000000000000?region=US",
    "searchRegion": "US",
    "scrapedAt": "2026-10-24T10:00:00.000Z"
}
```

| Field | Notes |
|---|---|
| `advertiserId`, `advertiserName`, `adId` | Google's advertiser (AR...) and creative (CR...) IDs. |
| `format` | `text`, `image` or `video`. |
| `firstShown`, `lastShown`, `daysShown` | When the ad ran, as reported by Google. |
| `headline`, `description`, `displayUrl` | Extracted from the ad preview where Google renders it as text. |
| `destinationUrl` | Landing page. Available for many Display and YouTube ads; Google does not expose it for Search ads. |
| `adText`, `adTextLines`, `sitelinks` | Every visible line of the ad. |
| `imageUrls`, `previewImageUrl` | Ad images and Google's archived screenshot of the ad. |
| `youtubeVideoId`, `videoUrl` | For YouTube ads. |
| `regions`, `regionStats`, `impressionsMin/Max` | Countries, per-country dates and impression ranges (EU only). |
| `transparencyUrl` | The ad's page in the Transparency Center. |

Queries with no results produce one **free** row with `status` = `not_found` (unknown advertiser name), `no_ads` or `error`, plus a `message`. A run summary (ads per query, Google's approximate total, matched advertisers) is saved to the key-value store as `RUN_SUMMARY`.

The dataset has ready-made views: **Ads**, **Ad text & landing pages**, **Images & videos**, **Regions & impressions**.

### Good to know

- **Ad text coverage.** Google renders most ads as an interactive preview, and the Actor extracts the text from it. For some older or archived ads, Google only keeps a screenshot. Those ads come with `previewImageUrl`/`imageUrls` but no text.
- **Dynamic Search Ads.** Google generates the headline from the landing page at serving time, so `headline` is empty and the description is returned.
- **Domain search** returns all advertiser accounts whose ads link to the domain, including agencies and resellers. Use the advertiser ID to get only one account.
- **Ordering.** Ads come newest first, exactly as in the Transparency Center. The same ad is never returned twice in one run.
- No login, cookies or proxy needed.

### Pricing

**$1.50 per 1,000 ads** ($0.0015 per ad) plus **$0.005 per run start**. Platform usage is included, so you don't pay for compute or proxies. Example: a 100-ad competitor check costs $0.155. You only pay for ads returned; "not found" and error rows are free. Set *Max ads per domain / advertiser* or the run's maximum cost to cap spend.

### More data Actors

- [Google Trends Scraper](https://apify.com/mitp1997/google-trends-scraper-reliable): interest over time, by region, related queries and topics.
- [Keyword Ideas from Google Autocomplete](https://apify.com/mitp1997/keyword-ideas-autocomplete): long-tail and question keywords from Google, YouTube, Bing and Amazon autocomplete.
- [Google Jobs Scraper](https://apify.com/mitp1997/google-jobs-scraper): job listings with salaries and direct apply links.
- [Telegram Channel Scraper](https://apify.com/mitp1997/telegram-channel-scraper): posts, views, reactions, media and exact subscriber counts from public Telegram channels, no login.

### Disclaimer

This Actor collects publicly available data from the Google Ads Transparency Center. It is not affiliated with Google. Make sure your use complies with applicable laws and Google's terms.

# Actor input Schema

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

Websites whose ads you want, e.g. nike.com. Returns ads from every advertiser account (including agencies) whose ads point to that domain.

## `advertiserNames` (type: `array`):

Company names as shown in the Transparency Center, e.g. "Flipkart". The best-matching advertiser (most ads) is used; switch 'Advertiser name matching' to 'all' to include every match.

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

Google advertiser IDs (AR followed by digits) or Transparency Center advertiser URLs, e.g. https://adstransparency.google.com/advertiser/AR16735076323512287233.

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

Country where the ads were shown, as a 2-letter code (US, GB, IN, DE, ...) or "anywhere" for all countries.

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

Only return ads of this format.

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

Only ads shown on or after this date (YYYY-MM-DD).

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

Only ads shown on or before this date (YYYY-MM-DD).

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

Maximum number of ads to return for each domain, name or ID. Ads are returned newest first.

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

Stop after this many ads across all queries. Leave empty for no limit (the run's max cost still applies).

## `includeAdDetails` (type: `boolean`):

Open each ad's preview to extract headline, description, all visible text, landing page, image URLs and YouTube video. Turn off for a faster list of ads with dates only.

## `includeRegions` (type: `boolean`):

Fetch the countries where each ad ran, with first/last shown per country and impression ranges (impressions are published for EU countries only).

## `advertiserNameMatch` (type: `string`):

'best' uses the matching advertiser with the most ads; 'all' scrapes every advertiser whose name matches.

## `maxConcurrency` (type: `integer`):

Parallel requests to Google.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed request to Google.

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

Not needed normally. Enable Apify Proxy only if you see rate-limit errors.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "format": "any",
  "maxAdsPerQuery": 20,
  "includeAdDetails": true,
  "includeRegions": true,
  "advertiserNameMatch": "best",
  "maxConcurrency": 10,
  "maxRequestRetries": 4,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Advertiser, format, headline, text, dates, regions and Transparency Center link.

## `text` (type: `string`):

No description

## `media` (type: `string`):

No description

## `regions` (type: `string`):

No description

## `runSummary` (type: `string`):

Ads per query, approximate totals, matched advertisers, request stats and stop reason.

# 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 = {
    "domains": [
        "nike.com"
    ],
    "region": "US",
    "maxAdsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("mitp1997/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 = {
    "domains": ["nike.com"],
    "region": "US",
    "maxAdsPerQuery": 20,
}

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

```

## MCP server setup

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