# Google Ads Transparency Scraper by Advertiser Name (`sourcedirect/google-ads-transparency-scraper`) Actor

Find any advertiser by name, no domain needed, then pull every ad they run from Google Ads Transparency Center. Worldwide by default, full pagination, image and video creatives, first and last shown dates.

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

## Pricing

from $1.50 / 1,000 ad creatives

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Ads Transparency Scraper

Pull every ad an advertiser is running from [Google's Ads Transparency Center](https://adstransparency.google.com/), by company name, domain or advertiser ID, with full pagination, creative images and video, and the dates each ad was first and last shown.

**See it working before you pay.** A [free lookup page](https://vaytric.com/google-ads-lookup/?utm_source=apify\&utm_medium=readme) runs this exact engine one query at a time: type a company name, see every matching advertiser with its live ad count, open the creatives. If that output fits your need, this Actor is the same data at volume, with CSV and JSON export and no per-hour limit.

![Live ad creatives this Actor returned for Stripe, Nike, Airbnb, Spotify, Notion and Shopify](https://vaytric.com/wall-small.jpg)

*Real output: creatives returned by this Actor for stripe.com, nike.com, airbnb.com, spotify.com, notion.so and shopify.com on 6 August 2026.*

**Worldwide by default.** Most Ads Transparency scrapers make you pick a region and quietly return only that country's ads. This one searches every region unless you ask it not to. For `stripe.com` that is the difference between 17 results and 6,977.

***

### What you get

| Field | Description |
|---|---|
| `advertiserId` | Google advertiser ID (`AR…`), feed it back in to get everything that advertiser runs |
| `advertiserName` | Verified advertiser name as Google shows it |
| `creativeId` | Google creative ID (`CR…`) |
| `domain` | Advertiser's domain |
| `creativeType` | `image`, `video`, or `text_or_display` |
| `firstShown` / `lastShown` | ISO timestamps, how long the ad has been running |
| `imageUrl` | Direct URL to the creative image |
| `previewUrl` | Google-hosted preview of the ad |
| `transparencyUrl` | Link to the ad on Google's own site |
| `queriedCountry` | The country this row was found under, or `worldwide` |

Two raw Google fields are also included but left out of the table view: `formatCode` and `googleRegionValue`. Google does not document either, and neither maps cleanly onto anything useful. `formatCode` does not track creative type, and `googleRegionValue` is near-unique per creative. They are passed through unchanged rather than dressed up as something they are not. Use `creativeType` for format.

### Search by name, not just by domain

Every other Ads Transparency scraper makes you supply a domain or a Google advertiser ID. This one also takes a plain **advertiser name**:

```json
{ "advertiserNames": ["Nike"] }
```

You get back every advertiser Google matches, with its ID, its country, and roughly how many ads it is currently running, so you can tell `Nike Retail BV` (74 ads) apart from `Nikenbah Constructions Pty Ltd` before you spend anything. Matching domains come back too. Put the ID you want into `advertiserIds` to pull that advertiser's ads.

### Input

```json
{
  "domains": ["nike.com", "stripe.com"],
  "advertiserNames": ["Nike"],
  "advertiserIds": ["AR18378488041124659201"],
  "countries": [],
  "maxAdsPerAdvertiser": 50,
  "delayBetweenPages": 0.5,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

- **`domains`**: any advertiser domain, e.g. `nike.com`.
- **`advertiserNames`**: a plain name like `Nike`. Returns matching advertisers and domains, not ads.
- **`advertiserIds`**: Google advertiser IDs, if you already have them.
- **`countries`**: ISO-3166 codes like `US`, `GB`, `AU`. **Leave empty for worldwide**, which is what you almost always want, because the worldwide set contains every country's ads. Listing several countries runs them in the order given and merges the results, de-duplicated.
- **`maxAdsPerAdvertiser`**: `0` means no limit. Big advertisers run tens of thousands of ads, so the default of 50 keeps a first run fast and cheap. The cap is the total per target across all selected countries, so if you list several countries *and* set a low cap, the cap can be used up before the later countries are reached. Leave `countries` empty to avoid this entirely.
- **`delayBetweenPages`**: seconds between requests. Defaults to `0.5`, which costs about 12 seconds per 1,000 ads and keeps you well clear of Google's rate limiter. Set it to `0` if you want maximum speed on a small job.
- **`proxyConfiguration`**: on by default, and it should stay on. See below.

### Sample output

```json
{
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "creativeId": "CR07332215593312976897",
  "domain": "nike.com",
  "creativeType": "image",
  "firstShown": "2026-05-14T00:00:00+00:00",
  "lastShown": "2026-08-04T00:00:00+00:00",
  "imageUrl": "https://tpc.googlesyndication.com/…",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR07332215593312976897",
  "queriedCountry": "worldwide"
}
```

### What it costs

$1.50 per 1,000 ads, and you are charged only for ads actually returned. Results are de-duplicated across every target in a run, so if you query a domain and that same advertiser's ID together you are billed once for each creative, not twice. There is no monthly fee.

This Actor runs on Apify's standard datacenter proxy and does not need residential proxies, so there is no per-gigabyte proxy surcharge buried in the price. Actors in this category range from about $0.45 to $18 per 1,000 results, and some add a per-run start fee of up to $50 per 1,000 starts on top, which matters more than the headline rate if you run many small jobs. The start fee here is $0.05 per 1,000.

### Common uses

- **Competitor ad monitoring**: track which creatives a rival launches, and when they retire them, using `firstShown` and `lastShown`.
- **Creative research**: build a swipe file of live ads in your category, with images.
- **Ad spend signals**: advertisers running hundreds of live creatives are spending, a domain with none is not.
- **Lead qualification**: check whether a prospect is already buying Google traffic before you pitch them.

### Notes and limits

- **Keep the proxy on.** Google throttles the Ads Transparency endpoint per source IP, and it throttles shared cloud IP ranges hardest. Measured on the Apify platform on 6 August 2026: with the proxy off, a `nike.com` lookup returned HTTP 429 and zero ads after 4 minutes 45 seconds. With the proxy on, the same lookup returned 50 ads in 8 seconds. The proxy is on by default for this reason. Turning it off only makes sense if you run the Actor somewhere with its own clean IP.
- **Rate limiting.** Even behind a proxy, Google's block is not brief. After roughly 300 rapid requests from one IP during testing, that IP stayed blocked for over 90 minutes, with no `Retry-After` header to say when it clears. Normal jobs do not come close. If you pull several very large advertisers back to back, the Actor backs off automatically, logs each wait, and reports which targets were affected in the run log and in the `SUMMARY` key. If you hit it, raise **Delay between pages**.
- Data comes from Google's public Ads Transparency Center, the same records anyone can view on the site. No login, and nothing private is accessed.
- Google publishes ads for advertisers it has verified. Very small or unverified advertisers may have no records at all, and an empty result is a real answer rather than a failure.

### Finding an advertiser ID

Run a domain first. Every row includes `advertiserId`, and one advertiser often owns several domains, so querying by ID catches ads a single-domain search would miss.

# Actor input Schema

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

Domains to look up, e.g. `nike.com`. Returns every ad Google is showing for the advertiser that owns the domain.

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

Search for an advertiser by **name** instead of hunting for their domain or ID, e.g. `Nike`. You get back every matching advertiser with its ID, its country and roughly how many ads it is running, plus any matching domains. Take the ID you want and put it in **Advertiser IDs** to pull that advertiser's ads. Matches are ranked for the first country in **Countries**, or the United States if you leave that empty.

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

Google advertiser IDs (they start with `AR`). Use these instead of, or as well as, domains. Every result row includes the `advertiserId` it came from, so you can feed IDs back in later.

## `countries` (type: `array`):

ISO-3166 alpha-2 country codes, e.g. `US`, `GB`, `AU`. **Leave empty to search worldwide, which is what you usually want.** The worldwide result set contains every ad from every country. Only narrow this if you specifically want the ads Google serves in one market. Numeric Google geo-target IDs also work.

## `maxAdsPerAdvertiser` (type: `integer`):

Stop after this many ads for each domain or advertiser ID. Set to 0 for no limit, which follows pagination until the advertiser is exhausted. Large advertisers run tens of thousands of ads, so the default of 50 keeps a first run fast and cheap. Raise it once you know the shape of the data you are getting.

## `delayBetweenPages` (type: `number`):

Politeness delay between paginated requests. Half a second costs about 12 seconds per 1,000 ads and keeps a single IP well under Google's throttle. Set it to 0 for maximum speed on small jobs, or raise it for very large ones.

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

**Leave this on.** Google throttles the Ads Transparency endpoint per source IP, and it throttles shared cloud IP ranges hard. Measured on the Apify platform: with the proxy off, a nike.com lookup returned HTTP 429 and zero ads after 4 minutes 45 seconds. With the proxy on, the same lookup returned 40 ads in under a second. Turning this off is only sensible if you are running the Actor somewhere with its own clean IP.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "maxAdsPerAdvertiser": 50,
  "delayBetweenPages": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every ad creative found, one row per creative, de-duplicated across all targets in the run.

## `adsCsv` (type: `string`):

The same results as a CSV download.

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

Totals for the run: targets attempted, ads scraped, duplicates skipped, and any targets that failed or were rate limited.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourcedirect/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"] }

# Run the Actor and wait for it to finish
run = client.actor("sourcedirect/google-ads-transparency-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ]
}' |
apify call sourcedirect/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sourcedirect/google-ads-transparency-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dHnGEZR3prNcDaZJ9/builds/ZwkoTqp1Y6w0DQ7Vw/openapi.json