# Google Ads Transparency Center Advertiser Ads Scraper (`bareezh_codes/google-ads-transparency-advertiser-ads`) Actor

Pulls every publicly listed ad creative for a Google advertiser (by domain or name) from the Ads Transparency Center: format, first/last shown dates, regions shown, preview URL and ad text when Google exposes it. No login needed.

- **URL**: https://apify.com/bareezh\_codes/google-ads-transparency-advertiser-ads.md
- **Developed by:** [Salman Bareesh](https://apify.com/bareezh_codes) (community)
- **Categories:** Marketing, 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 creatives

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

### What does Google Ads Transparency Center Advertiser Ads Scraper do?

This actor pulls every publicly listed ad creative for a Google advertiser straight from
[Google's Ads Transparency Center](https://adstransparency.google.com/) - the tool Google itself
runs so anyone can see the ads a given advertiser is currently running (or has run) across Search,
Display, YouTube and Shopping. Give it an **advertiser domain** (e.g. `nike.com`) or an
**advertiser name**, and it returns one row per ad: format, when it first/last ran, which countries
it ran in, a link to the ad on Google's own transparency page, and the ad's headline/description
text when Google exposes it. Think of it as a **Google Ads API alternative for competitor and lead
research** - no Google Ads account, no login, and no access to the advertiser's real account data
required, because none of this is private: it is exactly what `adstransparency.google.com` already
shows the public.

### Why use this scraper?

- **Competitor research** - see what ad creative, messaging and formats a competitor is actively
  running, in which countries, and how long a campaign has been live.
- **Lead / prospecting research** - check whether a prospect is running paid ads at all (a signal
  for ad-budget and marketing maturity) before a sales outreach.
- **Creative monitoring** - track when a competitor launches or refreshes a creative.
- Runs on Apify's schedule, API and integrations, so you can re-check the same advertisers weekly
  or monthly without touching a browser.

### What data can it extract?

| Field | Description |
| --- | --- |
| `advertiserId` / `advertiserName` | Google's internal advertiser ID and display name |
| `advertiserDomain` | Advertiser's verified website domain, when Google shows one |
| `creativeId` | Google's ID for this specific ad creative |
| `format` | Best-effort `TEXT` / `IMAGE` / `VIDEO` classification (see Limits) |
| `regions` | Two-letter country codes the ad has run in |
| `firstShown` / `lastShown` | Date range the ad has been observed running |
| `adDetailUrl` | Link to the ad on adstransparency.google.com |
| `creativePreviewUrl` | Direct image URL, or Google's ad-preview render URL |
| `adHeadline` / `adDescription` | Ad copy, when Google's preview data exposes it |

### How to find a competitor's Google ads

1. Open the actor's **Input** tab.
2. Add the competitor's website domain (e.g. `nike.com`) under **Advertiser domains**, or their
   company name under **Advertiser names** if you don't know the domain.
3. Optionally narrow by **region** (two-letter country code), a **date range**, or **ad formats**.
4. Run the actor. Each ad becomes one row in the dataset, downloadable as JSON, CSV, Excel or HTML.

### How much will it cost?

This actor is **free to use** and charges **$0.002 per ad** returned (Apify Store subscription
tiers lower this further: Bronze $0.0018, Silver $0.0016, Gold/Platinum/Diamond $0.0015 per ad).
Apify's free plan includes $5/month of platform credit, which covers roughly 2,500 ads on the
base rate. You only pay for ads actually returned - no charge for empty results.

### Input

See the **Input** tab for the full list of options. The short version:

- `advertiserDomains` / `advertiserNames` - who to look up (use at least one; domains are more
  reliable, see Limits below).
- `region` - two-letter country code to only see ads running in that country; leave empty for
  worldwide.
- `dateFrom` / `dateTo` - only include ads last shown in this date range.
- `formats` - only include `TEXT`, `IMAGE` and/or `VIDEO` ads.
- `maxItemsPerAdvertiser` - cap on ads per domain/name (default 20).
- `fetchRegions` - off by default. Turn on to fetch each ad's exact per-country breakdown, at the
  cost of roughly double the requests (and run time), since it's one extra request per ad.

An empty input (`{}`) scrapes a small sample from `nike.com` so you can see the output shape
immediately.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Example output
(from a real local run against `nike.com`, formats and region numbers vary run to run since
Google's ad mix changes constantly):

```json
[
  {
    "advertiserId": "AR16735076323512287233",
    "advertiserName": "Nike, Inc.",
    "advertiserDomain": "nike.com",
    "domainVerified": true,
    "creativeId": "CR06152928169239248897",
    "format": "IMAGE",
    "formatCode": 1,
    "regions": ["CA"],
    "firstShown": "2026-06-05",
    "lastShown": "2026-09-17",
    "adDetailUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR06152928169239248897?region=anywhere",
    "creativePreviewUrl": "https://tpc.googlesyndication.com/archive/simgad/17720214098677970069",
    "adHeadline": null,
    "adDescription": null,
    "adDestinationUrl": null,
    "searchedBy": "nike.com"
  }
]
```

### Tips

- Prefer **advertiser domains** over names when you know them. Google's advertiser-name search is
  a fuzzy "did you mean" match and can occasionally resolve to a similarly-named but unrelated
  advertiser; domain search matches Google's own verified-domain record for the account.
- Large `maxItemsPerAdvertiser` values take longer, and turning on `fetchRegions` roughly doubles
  request volume since it adds one extra request per ad. This actor paces every request at
  roughly 1/second per session, by design, to stay well under Google's rate limits.
- If Google rate-limits this run's IP (see **Limits** below), the actor automatically rotates to a
  fresh Apify Proxy session (when Apify Proxy is available on your plan) and retries, up to 5
  sessions per run. Enabling Apify Proxy on the actor's run options gives it the best chance of
  working around a block; without it, every rotation is still the same direct IP and a persistent
  block will end the run in failure with a clear status message.

### FAQ, disclaimers and support

**Does this need a Google Ads account or login?** No. It reads only the public
`adstransparency.google.com` tool that Google runs for anyone to inspect any advertiser's ads.

**Why is `adHeadline`/`adDescription` sometimes null?** Google only exposes decodable ad-copy text
for some creative types (mainly text and standard responsive ads); Shopping ads, most video ads and
plain image ads don't carry decodable text in the data Google's own tool sends to the browser, so
those fields are left `null` rather than guessed.

**Why is `format` sometimes imprecise?** Google does not publish its internal ad-format code
mapping, and this actor's `format` field is a best-effort read of that undocumented code. The raw
`formatCode` is always included so you can spot-check it.

Our Actors are ethical and do not extract any private user data, such as email addresses, gender,
or location. They only extract what Google itself already publishes for any visitor to see on the
Ads Transparency Center. You should still be mindful that ad creatives can contain personal data
incidentally (e.g. a testimonial with a name); if in doubt about a specific use case, consult your
lawyers.

Found a bug or an endpoint that changed? Please use the **Issues** tab. Programmatic access is
available from the **API** tab.

### Limits

- Google does not publish an official API for the Ads Transparency Center; this actor calls the
  same unauthenticated endpoints the public web app itself uses. Google can change these without
  notice, which would need an actor update.
- **Rate limiting is real and expected.** Google enforces an undocumented per-IP request budget on
  these endpoints - once an IP sends "too many" requests it gets an HTTP redirect instead of data.
  This actor paces requests at roughly 1/second per session and, on a block, rotates to a fresh
  Apify Proxy session (up to 5 per run) with backoff before giving up. If every session stays
  blocked:
  - a run that ends with **zero ads and no ads were legitimately absent** fails loudly with a clear
    status message (rather than reporting a misleading "success, 0 results") - try again later, or
    reduce `maxItemsPerAdvertiser`;
  - a run that already pushed some ads before hitting the block **succeeds**, but logs a visible
    warning that the results may be incomplete.
- `fetchRegions` (off by default) requires one extra request per ad; when it's on and a specific
  request gets rate-limited, that ad is still returned with `regions` falling back to the Region
  filter (or `null`) rather than being dropped.
- **Legal / compliance note.** This actor only reads data Google itself already publishes for any
  visitor on `adstransparency.google.com` - no login, no scraping of private account data. You are
  responsible for using the output in a way that complies with Google's own Terms of Service and
  any laws that apply to your use case (e.g. competitive intelligence is generally fine; scraping
  to build a competing transparency product may not be).
- **Attribution.** The domain-search request format and the ad-text overlay-decoding approach were
  cross-checked against the open-source [google-ads-transparency-mcp](https://github.com/block-town/google-ads-transparency-mcp)
  project (MIT license) while reverse-engineering Google's undocumented endpoints; see
  `THIRD_PARTY_NOTICES.md` in this actor's source for details on what was reused (no code was
  copied - see that file for specifics).

# Actor input Schema

## `advertiserDomains` (type: `array`):

Website domains to look up (e.g. "nike.com"). Every advertiser account Google has linked to that domain is scraped. Leave empty if you use advertiser names instead. Up to 50 domains per run (extras beyond 50, and exact duplicates, are dropped).

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

Advertiser names to look up (e.g. "Nike, Inc."). The best-matching advertiser from Google's own search suggestions is used. Prefer advertiser domains when you know them — names can match the wrong company when several advertisers share a similar name. Up to 50 names per run (extras beyond 50, and exact duplicates, are dropped).

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

Two-letter country code (e.g. "US", "GB", "IN") to only return ads that ran in that country. Leave empty for worldwide ("anywhere").

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

Only include ads last shown on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

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

Only include ads last shown on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `formats` (type: `array`):

Only include ads of these formats. Leave empty to include all formats. Format detection is best-effort: Google does not publish its internal format codes, so a small share of image/video creatives can be mislabeled — the raw formatCode field is always included so you can verify.

## `maxItemsPerAdvertiser` (type: `integer`):

Stop after this many ads for each domain/name in the input (each list can have up to 50 domains/names). Google's Ads Transparency Center pages 40 ads per request, so with 'Fetch exact region breakdown per ad' off this is roughly 1 request per 40 ads per advertiser (a few seconds). With it on, expect roughly 1 extra request per ad at this actor's ~1 request/second pace, e.g. around 100 seconds for 100 ads for one advertiser.

## `fetchRegions` (type: `boolean`):

When on, fetches each ad's full list of countries it has run in as a separate request per ad, paced at roughly 1/second — this roughly doubles the number of requests and adds about 1 second per ad to the run time versus leaving it off. When off (default), 'regions' is just the Region filter above if you set one, or empty for a worldwide search. Turn this on only when you specifically need the per-country breakdown.

## Actor input object example

```json
{
  "advertiserDomains": [
    "nike.com"
  ],
  "advertiserNames": [],
  "region": "",
  "formats": [],
  "maxItemsPerAdvertiser": 20,
  "fetchRegions": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One item per matching ad creative

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("bareezh_codes/google-ads-transparency-advertiser-ads").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("bareezh_codes/google-ads-transparency-advertiser-ads").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 '{}' |
apify call bareezh_codes/google-ads-transparency-advertiser-ads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bareezh_codes/google-ads-transparency-advertiser-ads"
        }
    }
}
```

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/15CGs7KWujMLirQlP/builds/kxEqvGywo1ds1kbeQ/openapi.json