# Google Ads Transparency Scraper - Ads by Advertiser (`zaver.api/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center without an API key: every ad an advertiser runs or ran, with format, first and last shown dates and preview links, plus optional creative, regions, payer and landing page. Look up by name, ID or link, filter by region. No account, no start fee.

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

## Pricing

Pay per event

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 — Every Ad an Advertiser Runs on Google

**Scrape the Google Ads Transparency Center without an API key.** Enter advertiser names, advertiser IDs or Transparency Center links and get every ad they are running or have run across Search, YouTube, Display and Gmail: format, first and last shown dates and preview links and, with the add-on, the creative image or video, the regions it ran in, who paid for it and the landing page. Filter by region. No account, no browser, no start fee. Pay per ad.

> ⭐ All ads of any Google advertiser · text, image and video formats · first and last shown dates · region filter · creatives, regions, payer and landing pages as an add-on · parallel collection · API and MCP ready

### What does Google Ads Transparency Scraper do?

Google's Ads Transparency Center shows the ads every verified advertiser has run on Google since 2023. This Actor reads it through the same requests the Center's own page makes and returns the ads as rows.

| You enter | You get |
|---|---|
| An advertiser name, such as `HubSpot` | That advertiser's ads (the exact or best match, or every matching account if you ask) |
| An advertiser ID, such as `AR13611357312189988865` | That account's ads |
| A Transparency Center link to an advertiser or a single ad | The advertiser's ads, or that one ad with details |

### What data does it extract?

#### Every ad

| Field | Description |
|---|---|
| `id`, `url` | Creative ID and link to the ad in the Transparency Center |
| `advertiserId`, `advertiserName`, `advertiserCountry` | The advertiser account and its verified country |
| `advertiserAdCountLower`, `advertiserAdCountUpper` | How many ads the advertiser has in total, as a range |
| `format` | `text`, `image` or `video` |
| `firstShown`, `lastShown`, `daysShown` | When the ad ran |
| `previewUrl` | Link to Google's rendering of the ad |
| `position`, `source` | Rank and the advertiser input it came from |

#### With the details add-on

| Field | Description |
|---|---|
| `imageUrl`, `videoUrl` | The creative as Google renders it (text ads are rendered as an image) |
| `landingPage` | Destination link found in the creative, when present |
| `regions`, `regionsShown` | Countries the ad ran in, each with its last shown date |
| `paidBy` | The entity that paid for the ad, often an agency |
| `previewUrls`, `variantCount` | All size and placement variants of the ad |

Single-ad links you paste always return the full details.

### A Google Ads Transparency API alternative

Google offers no API for the Transparency Center, and the Google Ads API shows you only your own accounts. Competitor ads are visible on the Center's website and nowhere else.

This Actor is a **Google Ads Transparency API alternative**: it reads the Center the way the website does. No developer token, no Google account, no quota.

| | Google Ads API | This Actor |
|---|---|---|
| Whose ads | Your own accounts | Any verified advertiser |
| Access | Developer token and OAuth | Anyone |
| Output | API objects | Flat rows: CSV, Excel, JSON |

### Why use this Google Ads Transparency scraper

#### Every ad, with dates

The Center shows ads one grid at a time. The Actor pages through all of them and records when each ad first and last ran, so you can tell evergreen campaigns from tests.

#### Any advertiser, resolved for you

Type a name and the Actor finds the advertiser accounts behind it, with their country and ad counts. Ask for all matches to cover every regional entity of a brand.

#### Creatives, regions and payers

The add-on opens each ad and adds the rendered creative, the countries it ran in with dates, the paying entity and the destination link when one is embedded.

#### No start fee, and failures are free

You pay per ad delivered. Unknown advertisers and repeated ads are free.

### How to scrape the Google Ads Transparency Center

1. Open the Actor and paste **Advertisers**: names, IDs or Center links, one per line.
2. Optionally set a **Region** (two-letter code) and an **Ad format**.
3. Set **Max ads per advertiser**.
4. Turn on **Add ad details** if you need creatives, regions, payers and landing pages.
5. Press **Start**, then export as CSV, Excel, JSON or XML, or read the dataset through the API.

### Input examples

Competitors' ads in the United States:

```json
{
  "advertisers": ["HubSpot", "Salesforce", "Zoho"],
  "region": "US",
  "maxAdsPerAdvertiser": 500
}
```

Every regional account of a brand, with creatives:

```json
{
  "advertisers": ["adidas"],
  "allMatches": true,
  "format": "video",
  "maxAdsPerAdvertiser": 100,
  "includeDetails": true
}
```

| Field | Type | Description |
|---|---|---|
| `advertisers` | array | Advertiser names, advertiser IDs (`AR…`) or Transparency Center links. |
| `region` | string | Two-letter country code, or `anywhere` (default). |
| `format` | string | `all` (default), `text`, `image` or `video`. |
| `allMatches` | boolean | Collect every advertiser account matching a name, not only the best match. |
| `maxAdsPerAdvertiser` | integer | Ads per advertiser. Default `100`. |
| `maxItems` | integer | Hard cap for the run. 0 means no cap. |
| `includeDetails` | boolean | Add creative, regions, payer and landing page. Charged per ad. |
| `concurrency` | integer | Advertisers collected in parallel. Default `4`. |

### Output example

```json
{
  "type": "ad",
  "id": "CR07804239568659546113",
  "advertiserId": "AR13611357312189988865",
  "advertiserName": "HubSpot",
  "advertiserCountry": "US",
  "url": "https://adstransparency.google.com/advertiser/AR13611357312189988865/creative/CR07804239568659546113",
  "format": "video",
  "firstShown": "2026-09-30",
  "lastShown": "2026-10-26",
  "daysShown": 27,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&creativeId=826361695860",
  "source": "HubSpot",
  "position": 1
}
```

### Pricing

Pay per result. **No start fee, no monthly rental, no minimum.**

| Event | Charged for | Price |
|---|---|---|
| `ad-scraped` | each ad delivered | **$2.99 / 1,000** |
| `ad-detailed` | each ad that got creative, regions, payer and landing page (add-on) | **$4.99 / 1,000** |
| - | unknown advertisers and repeated ads | **free** |

| You export | You pay |
|---|---|
| 100 ads | **$0.30** |
| 1,000 ads | **$2.99** |
| 1,000 ads with details | **$7.98** |
| 10,000 ads | **$29.90** |

You are charged right after each batch lands in your dataset, so a run you stop early costs only what it delivered. Proxies are included.

### Use cases

#### Competitor PPC research

See every Search, Display and YouTube ad a competitor runs, when each started, and which ones they keep alive.

#### Creative analysis

Export the rendered creatives across a whole category and see which formats and messages advertisers keep running.

#### Agency prospecting and audits

Check what a prospect advertises today and for how long before the first call.

#### Market entry research

Compare advertisers and ad volumes by region before you spend.

#### Brand protection

Find advertisers using your brand in their ads, with the Transparency Center link as proof.

### FAQ

**Do I need a Google account or API key?**
No. The Transparency Center is public and the Actor reads it as a visitor.

**Is scraping the Google Ads Transparency Center legal?**
This is general information, not legal advice. The Center exists to make advertising public, and the Actor collects only what it shows to every visitor. The data is about advertisers, not private individuals, but Google's terms restrict automated access, and how you use the data depends on the laws where you are. Use it for research and analysis, and ask a lawyer before building a commercial product on it.

**Can I search by keyword or by domain?**
No. The Transparency Center looks up ads by advertiser only. Enter the advertiser's name, ID or link; use **Collect every advertiser matching a name** to get all accounts behind a brand.

**Why does one brand have several advertiser accounts?**
Google verifies each legal entity separately, so a brand often has one account per country. The advertiser's country is in each row.

**What do the dates mean?**
`firstShown` and `lastShown` are the first and last days Google recorded the ad being shown. The Center covers ads since 2023.

**Does it return the ad text?**
Google publishes text ads as rendered images, not as text, so the add-on returns the image of the ad rather than its words.

**How fast is it?**
Hundreds of ads per second without details (427 ads in 12 seconds in testing); with the add-on, a few ads per second.

**Can I run it on a schedule?**
Yes. Daily runs over the same advertisers show new and dropped ads.

### Use it from AI agents and MCP clients

This Actor is available as a tool on Apify's MCP server. Point Claude, Cursor, Windsurf, ChatGPT agents or any other MCP client at `https://mcp.apify.com` with your Apify token, add the tool `zaver.api/google-ads-transparency-scraper`, and the agent can pull an advertiser's Google ads in the same conversation. From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaver.api/google-ads-transparency-scraper").call(run_input={"advertisers": ["HubSpot"], "region": "US", "maxAdsPerAdvertiser": 200})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["advertiserName"], ad["format"], ad["firstShown"], ad["url"])
```

### Integrations

- **Apify API** - start runs and fetch datasets from Python, Node.js, cURL or any HTTP client.
- **MCP server** - call this Actor as a tool from Claude, Cursor, ChatGPT agents and any MCP client.
- **No-code** - Make, Zapier, n8n, Google Sheets, Airtable, Slack, webhooks.
- **Schedules** - run daily and append to the same dataset to build history.
- **Exports** - JSON, JSONL, CSV, Excel (XLSX), XML, HTML table.

### Related actors

**Advertising**

- [Meta Ad Library Scraper](https://apify.com/zaver.api/meta-ad-library-scraper) - Facebook and Instagram ads by keyword or advertiser page
- [Google Search Scraper](https://apify.com/zaver.api/google-search-scraper) - organic results for any query and country
- [Google Shopping Scraper](https://apify.com/zaver.api/google-shopping-scraper) - product listings and prices

**Leads**

- [Website Contact Extractor](https://apify.com/zaver.api/website-contact-extractor) - emails, phones and social profiles from the landing pages you collect
- [Google Maps Scraper](https://apify.com/zaver.api/google-maps-scraper) - local businesses with phones, GPS and optional emails

***

*Not affiliated with, endorsed by or sponsored by Google. This Actor reads only what the Ads Transparency Center shows publicly to a visitor and does not log in. You are responsible for using the data in line with applicable laws and Google's terms.*

# Actor input Schema

## `advertisers` (type: `array`):

One per line: an advertiser name (<code>HubSpot</code>), an advertiser ID (<code>AR13611357312189988865</code>), or a Transparency Center link to an advertiser or a single ad.

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

Two-letter country code to list only ads shown there (<code>US</code>, <code>GB</code>, <code>IN</code>), or <code>anywhere</code> for all regions.

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

Keep only one format.

## `allMatches` (type: `boolean`):

A name can match several advertiser accounts (one per country or legal entity). Off: the exact or best match only. On: all of them.

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

The Actor pages through the Center until it has this many ads for each advertiser.

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

Hard cap on ads for the whole run. 0 means no cap.

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

Opens each ad and adds the rendered creative (image or video link), the countries it ran in with last-shown dates, who paid for it, the landing page when embedded, and all preview variants. Charged as a separate event per ad.

## `concurrency` (type: `integer`):

Advertisers collected at the same time, each on its own session.

## Actor input object example

```json
{
  "advertisers": [
    "HubSpot"
  ],
  "region": "anywhere",
  "format": "all",
  "allMatches": false,
  "maxAdsPerAdvertiser": 100,
  "maxItems": 0,
  "includeDetails": false,
  "concurrency": 4
}
```

# Actor output Schema

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

All dataset items.

## `resultsCsv` (type: `string`):

CSV download.

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

Counts for the run.

# 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 = {
    "advertisers": [
        "HubSpot"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zaver.api/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 = { "advertisers": ["HubSpot"] }

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

```

## MCP server setup

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