# Google Ads Transparency Scraper API: Ad Library (`egra_van/google-ads-transparency`) Actor

Google Ads Transparency scraper API: the Search, Display and YouTube ads of any domain, advertiser name or ID from the Google Ads Transparency Center, Google's public ad library. Format, countries, first and last shown dates, image or preview link. Competitor ads by country. $1.20 per 1,000 ads.

- **URL**: https://apify.com/egra_van/google-ads-transparency.md
- **Developed by:** [Argentin Vazdautan](https://apify.com/egra_van) (community)
- **Categories:** Marketing, SEO tools, E-commerce
- **Stats:** 2 total users, 1 monthly users, 81.3% 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 API: Ad Library

**Google Ads Transparency scraper API: see the ads a company runs on Google, in Search, Display, Shopping and YouTube.** Type a website (`nike.com`), an advertiser name (`Nike, Inc.`) or an advertiser ID, and get one row per ad from the public [Google Ads Transparency Center](https://adstransparency.google.com), Google's ad library: format, the countries where it was shown, the first and last day it was shown, the image or preview of the ad and a link to its page.

- **What you get:** advertiser, ad ID, format (`TEXT`, `IMAGE`, `VIDEO`), `firstShown`, `lastShown`, `regions` (country codes and names), `imageUrl` / `previewUrl` / `videoUrl`, `adUrl`, plus every version of the ad.
- **What it costs:** $1.20 per 1,000 ads stored (`$0.0012` each), countries and versions included. Lower on paid Apify plans (down to $0.70 per 1,000). Searches that find nothing cost only Apify's $0.00005 start fee.
- **Try it now:** the form is prefilled with `nike.com`, region `US` and 10 ads. Click **Start**; with the 2-second pause it needs at least about 25 seconds and costs about **$0.01**.

This is an unofficial tool, not affiliated with or endorsed by Google.

### Who it's for

- **Marketing agencies** checking what a client's competitors advertise, in which countries, and since when.
- **Advertisers** looking for ad ideas: which messages a competitor keeps running for months (a sign they work).
- **Researchers and journalists** studying who advertises what, where.

### What you can search

| You type | What you get |
|---|---|
| A domain: `nike.com`, `https://www.nike.com/shoes` | ads of **every advertiser** that sends people to this website (resellers and agencies included) |
| An advertiser name: `Nike, Inc.` | ads of the advertiser with **exactly this name** and the most ads. The log lists other advertisers with a similar name and their IDs. |
| An advertiser ID: `AR16735076323512287233`, or a Transparency Center link | ads of that one advertiser (most precise) |

Filters, all optional:

- **Region:** a 2-letter country code (`US`, `GB`, `DE`, `IN`...) or `anywhere`.
- **Period:** any time, last 7 / 30 / 90 days, or custom dates. Google keeps the day-by-day data for about the last 12 months; older periods return no ads.
- **Format:** text, image or video.
- **Max ads per domain / advertiser.**

### Quick start

```json
{
  "searchTerms": ["nike.com", "AR16735076323512287233"],
  "region": "US",
  "period": "last30days",
  "format": "all",
  "maxAdsPerQuery": 100
}
```

Run it from the API:

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

### Output

One ad of `nike.com` as read from the Transparency Center on 8 Oct 2026 (text ad, archived by Google as a picture):

```json
{
  "searchTerm": "nike.com",
  "advertiserName": "Nike, Inc.",
  "advertiserId": "AR16735076323512287233",
  "adId": "CR16080400334098268161",
  "format": "TEXT",
  "firstShown": "2023-11-16T23:49:45.279Z",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/12353189800749445678",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR16080400334098268161?region=US"
}
```

| Field | Meaning |
|---|---|
| `advertiserName`, `advertiserId` | the verified advertiser (one domain can have several) |
| `adId` | the ad's ID in the Transparency Center (`CR...`) |
| `format` | `TEXT` (Google Search), `IMAGE` (Display, Shopping), `VIDEO` (YouTube) |
| `firstShown`, `lastShown` | first and last time Google showed the ad (UTC). The Center counts from its own start of records, so very old ads start there. |
| `regions`, `regionNames`, `regionCount` | countries where the ad was shown (with **Add countries and all variants** on, the default) |
| `imageUrl` | picture of the ad. Google archives text ads as a picture of the ad, so the headline and text are in this image. |
| `previewUrl` | Google's preview script for image and video ads (opens the rendered ad) |
| `videoUrl` | YouTube link, when Google exposes it |
| `variants` | every version of the ad (images or previews) |
| `adUrl`, `advertiserUrl` | the ad and the advertiser in the Transparency Center |

The run summary (key-value store, record `OUTPUT`) lists, for each search, the advertiser found, how many ads Google reports for your filters, how many were stored, and any error.

### Pricing (pay per event)

| Apify plan | Per 1,000 ads |
|---|---|
| Free | $1.20 |
| Starter (Bronze) | $1.00 |
| Scale (Silver) | $0.85 |
| Business (Gold) | $0.70 |

Countries and all versions of each ad are included. You pay only for ads stored; you can set a maximum cost per run in Apify and the Actor stops there.

### Speed and Google's limits

The Actor reads only what the Transparency Center shows to any visitor, without logging in. It sends **one request at a time with a pause of 2 seconds** (you can make it longer). With countries on, that is at least 2 seconds per ad: 100 ads take at least 3–4 minutes, 1,000 ads at least 35 minutes. Turn **Add countries and all variants** off to go about 20 times faster (one request per 40 ads), without the country list.

If Google answers with its "unusual traffic" page, the Actor waits (30 s, 60 s, 120 s) and tries again **on the same IP**. It never solves captchas and never switches IP to get around a block. If Google still refuses, the run stops and keeps the ads already read. The Apify RESIDENTIAL and GOOGLE_SERP proxy groups are not available in this Actor; you can add your own proxy URLs.

### Limitations

- **Ad text:** Google stores text ads as a picture (`imageUrl`), not as text. The Actor does not read text out of pictures.
- **Dates:** only about the last 12 months can be filtered by period.
- **Names:** an advertiser name search picks one advertiser. Big brands have several (per country, per agency); use the domain to get them all, or the IDs from the log.
- **Counts** reported by Google are rounded ranges (e.g. 8,000–9,000).
- Political ads have their own section in the Transparency Center and are not covered.

### FAQ

**Is this legal?** The Transparency Center is a public page Google publishes so anyone can see who advertises what (and, in the EU, because the Digital Services Act requires an ad repository). The Actor reads only public data, slowly, without an account, and does not get around Google's rate limits or captchas. Google's Terms of Service still apply to the Transparency Center, and the Actor is not approved by Google. Check your own use case with your lawyer.

**Why does a domain return ads from other companies?** Google lists every verified advertiser whose ads send people to that domain: resellers, affiliates and agencies too. Use the advertiser ID to get one company only.

**Why fewer ads than Google reports?** You reached **Max ads per domain / advertiser**, or your maximum cost per run. Raise either.

# Actor input Schema

## `searchTerms` (type: `array`):

One per line. A website domain ("nike.com": every advertiser that sends traffic to it), an advertiser name ("Nike, Inc.": the advertiser with this exact name and the most ads is picked; the log lists similar names), an advertiser ID ("AR16735076323512287233") or a Transparency Center advertiser link. Domains and IDs are the most precise.

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

2-letter country code such as US, GB, DE, FR, IN, or "anywhere" for all countries.

## `period` (type: `string`):

Only ads shown in this period. Google keeps the day-by-day data for about the last 12 months; for older periods it returns no ads.

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

First day, as YYYY-MM-DD. Used only when Period is "Custom dates".

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

Last day, as YYYY-MM-DD. Empty = today. Used only when Period is "Custom dates".

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

Text ads (Google Search), image ads (Display, Shopping) or video ads (YouTube).

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

Stop after this many ads for each line above. Big brands have thousands of ads; you pay per ad stored.

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

For each ad, also read its detail page: every country where it was shown and all its versions (images or previews). One extra request per ad, so runs take about twice as long. Same price.

## `requestDelaySecs` (type: `number`):

The Actor sends one request at a time and waits this long between them, to stay within Google's limits. Minimum 1.

## `maxBlockWaitSecs` (type: `integer`):

If Google answers with its rate-limit page, the Actor waits (30 s, then 60 s, 120 s...) and retries on the same IP. It never solves captchas and never switches IP to get around a block. After this much waiting the run stops and keeps the ads already read.

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

Default: the Apify proxy (datacenter), one IP for the whole run. The Apify RESIDENTIAL and GOOGLE_SERP groups are not available in this Actor; for other IPs add your own proxy URLs.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com"
  ],
  "region": "US",
  "period": "anytime",
  "format": "all",
  "maxAdsPerQuery": 10,
  "includeDetails": true,
  "requestDelaySecs": 2,
  "maxBlockWaitSecs": 180,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All ads of this run.

## `summary` (type: `string`):

Per search: advertiser found, ads reported by Google, ads stored, errors.

# 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 = {
    "searchTerms": [
        "nike.com"
    ],
    "region": "US",
    "maxAdsPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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