# Google Ads Transparency Scraper & Ads Library (`andracore/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center (Google Ads Library) by brand or domain. Get competitor ads from Search, YouTube, Shopping and Maps: ad copy as text, videos, images, days shown and countries. Monitor new ads. API, no login.

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

## Pricing

from $1.20 / 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 & Ads Library

Get every ad a brand runs on Google Search, YouTube, Shopping, Maps and Play from the public [Google Ads Transparency Center](https://adstransparency.google.com), often called the Google Ads Library, with the **ad copy of Search ads as real text**, not just screenshots.

Search by brand name, domain, advertiser ID or Transparency Center URL. Filter by country, platform, format and date. Schedule it to get only the ads that are new since the last run.

No login, no browser, no API key.

![How the Google Ads Transparency Scraper works: enter a brand or domain, the scraper collects every ad, and you get each ad's copy, format and days shown as JSON, CSV, Excel or through the API](https://api.apify.com/v2/key-value-stores/zZwndLrYGfCvgDJLT/records/google-ads-transparency-scraper-how-it-works.png?signature=9aAFs9u3PxFe7cd9cpQ1)

### Why use this Google Ads scraper

- **Ad copy as text.** Most Search ads come back with their headline, description, display URL and business name as text you can sort, search and analyze. Store addresses attached to the ad (location extensions) are included too.
- **Everything included in one price.** Ad copy, YouTube video, all image variations, countries and dates cost the same flat price per ad. There is no extra "details" fee.
- **Long-running ads at a glance.** `daysShown` tells you how many days Google has served each ad, the fastest way to spot the creatives a competitor keeps paying for.
- **Monitoring built in.** Turn on *Only new ads* and schedule a daily or weekly run. Ads already returned are skipped and not charged.
- **Fast.** It talks to the same JSON endpoints the Transparency Center website uses. A few hundred ads take seconds. If Google rate-limits the run, it switches to Apify Proxy on its own.

### Google Ads data you get for each ad

| Field | What it is |
|---|---|
| `advertiserName`, `advertiserId`, `advertiserCountry` | Who runs the ad and where they are based |
| `format` | TEXT, IMAGE or VIDEO |
| `headline`, `description`, `displayUrl`, `businessName` | The ad copy of Search ads |
| `isDynamicSearchAd` | True when Google writes the headline from the landing page |
| `locations` | Store addresses attached to the ad |
| `targetDomain` | Domain the ad points to, when Google reports it |
| `firstShown`, `lastShown`, `daysShown` | When the ad ran and for how many days |
| `videoId`, `videoUrl`, `videoThumbnailUrl` | The YouTube video behind video ads |
| `imageUrls` | Every image variation of the ad |
| `regions` | Countries where the ad ran and the last date it was shown in each |
| `adUrl`, `advertiserUrl` | Links to the ad and advertiser pages on the Transparency Center |

### Use cases for competitor ad research

- **Competitor research.** Read every Search ad a competitor runs, sorted by how long each one has been live.
- **Copywriting swipe file.** Collect headlines and descriptions from a whole niche in a spreadsheet.
- **YouTube creative library.** Pull every video ad a brand runs, with direct YouTube links.
- **Agency prospecting.** See who advertises on a domain or in a country, how many ads they run and where they are based.
- **New-ad alerts.** Monitor competitors and get only their new creatives every morning.
- **Brand protection.** Watch for ads that use your brand name or domain.

### How to scrape the Google Ads Transparency Center

1. Type brands or domains in **Advertiser names or domains** (for example `Nike` or `shopify.com`).
2. Optional: pick a **Region**, **Platforms**, **Ad format** and a date range.
3. Set **Max ads per advertiser, domain or URL** and click **Start**.
4. Download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

A brand name is matched to the advertiser with the most ads among Google's suggestions. Big brands often have several legal entities ("Nike, Inc.", "Nike Retail BV"). Raise **Advertisers per search term** to get more than one, or paste exact advertiser IDs. You can also paste a Transparency Center URL: the platform and format filters in the URL are respected.

#### Input examples

Competitor Search ads in the US, with ad copy:

```json
{
  "domains": ["nike.com"],
  "region": "US",
  "platforms": ["SEARCH"],
  "maxAdsPerSource": 300
}
```

YouTube creatives of a brand:

```json
{
  "searchTerms": ["Shopify"],
  "platforms": ["YOUTUBE"],
  "format": "VIDEO",
  "maxAdsPerSource": 200
}
```

Weekly monitoring of three competitors (schedule it in the Schedules tab):

```json
{
  "domains": ["competitor-one.com", "competitor-two.com", "competitor-three.com"],
  "region": "US",
  "onlyNewAds": true,
  "monitorName": "my-competitors",
  "maxAdsPerSource": 500
}
```

### Monitoring new ads

With **Only new ads** on, the first run saves every ad currently running as a baseline (only the ads it returns are charged) and later runs return only ads it has not seen before. The history is kept in your account in a key-value store named `google-ads-monitor-<monitor name>`. Use a different **Monitor name** for each client or project so their histories stay separate. Connect the run to Slack, email, Google Sheets, Make or Zapier through Apify integrations to get the new ads where you work.

### Google Ads Library API

Run the scraper from your own code and get the ads back as JSON. Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("andracore/google-ads-transparency-scraper").call(
    run_input={"domains": ["nike.com"], "region": "US", "maxAdsPerSource": 100}
)
for ad in client.dataset(run.default_dataset_id).iterate_items():
    print(ad["format"], ad.get("daysShown"), ad.get("headline"))
```

Or with one HTTP request that waits for the run and returns the ads:

```bash
curl -X POST "https://api.apify.com/v2/acts/andracore~google-ads-transparency-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["nike.com"], "region": "US", "maxAdsPerSource": 100}'
```

Your token is in Apify Console under Settings > API & Integrations. The same input works from JavaScript, Make, Zapier, n8n and the Apify MCP server for AI agents.

### Output example

```json
{
  "advertiserName": "Nike, Inc.",
  "advertiserCountry": "US",
  "format": "TEXT",
  "headline": "Nike® Men's Cushioned Shoes",
  "description": "Nike® cushioned running shoes are built for comfort that goes the distance.",
  "displayUrl": "nike.com",
  "businessName": "Nike",
  "isDynamicSearchAd": false,
  "locations": ["Nike Factory Store - Staten Island, 15 Richmond Terrace Suite 300, Staten Island, New York, 10301, US"],
  "targetDomain": "nike.com",
  "firstShown": "2026-07-27T16:00:56.000Z",
  "lastShown": "2026-10-04T02:31:55.000Z",
  "daysShown": 19,
  "imageUrls": ["https://tpc.googlesyndication.com/archive/simgad/2798216613677354783"],
  "regions": [{ "countryCode": "US", "lastShown": "2026-09-01" }],
  "variationCount": 5,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR05331710493595795457?region=US"
}
```

A video ad comes with its YouTube link:

```json
{
  "advertiserName": "Shopify Inc.",
  "format": "VIDEO",
  "videoUrl": "https://www.youtube.com/watch?v=k13WUuvi-y4",
  "daysShown": 94,
  "firstShown": "2026-07-02T14:38:12.000Z",
  "lastShown": "2026-10-04T02:19:44.000Z",
  "regions": [{ "countryCode": "US", "lastShown": "2026-10-03" }]
}
```

### Pricing

**$1.50 per 1,000 ads**, everything included. Platform usage is on us.

| Ads | Cost |
|---|---|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |

Paid Apify plans pay less: **$1.40** on Bronze, **$1.30** on Silver and **$1.20** on Gold and above, per 1,000 ads.

In monitoring mode you pay only for new ads. Set a maximum cost per run in the run options and the scraper stops exactly there.

### Good to know

- **Ad copy coverage.** In our tests about 3 out of 4 Search ads came back with their copy as text. The rest are published by Google only as images; their image URLs are always returned.
- **Platform filter.** Google applies it only to ads shown since September 4, 2023.
- **Landing pages.** The Transparency Center does not publish full landing page URLs. You get the domain when Google reports it and the display URL of Search ads.
- **Counts.** Google gives ad totals as ranges ("7,000–8,000"). The log shows that range for every search.
- **Speed vs. detail.** Turn off *Extract ad copy, videos and countries* when you only need a quick list of ads.

### Other Actors by Andracore

- [YouTube Transcript Scraper](https://apify.com/andracore/youtube-transcript-scraper): turn the video ads you find here, or whole channels, into text, SRT or VTT.
- [Shopify Store Analyzer](https://apify.com/andracore/shopify-store-intelligence): apps, ad pixel IDs, contacts and best sellers of any Shopify store.
- [Shopify Store Finder](https://apify.com/andracore/shopify-store-finder): find Shopify stores by keyword or niche.

### FAQ

**Is it legal to scrape the Google Ads Transparency Center?**
The Transparency Center is a public library Google publishes so anyone can see who advertises and what they show. This scraper reads only that public data and collects no personal information. Check the rules that apply to your use case.

**Do I need a proxy?**
No. If Google rate-limits a large run, the scraper moves to Apify Proxy automatically.

**Can I get ads from several countries?**
Leave Region on Anywhere and every ad comes with the list of countries where it ran.

**Can I use it from my code or AI agent?**
Yes. See the Google Ads Library API section above, or connect it to your AI agent through the Apify MCP server.

Found a bug or need a field that is missing? Open an issue in the Issues tab and it will be looked at quickly.

# Actor input Schema

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

Type a brand (e.g. Nike) or a domain (e.g. nike.com). Names are matched to the advertiser with the most ads.

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

IDs that start with AR, taken from the advertiser page URL on adstransparency.google.com.

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

Return ads from every advertiser verified for these domains.

## `startUrls` (type: `array`):

Advertiser pages (https://adstransparency.google.com/advertiser/AR...) or domain searches (?domain=example.com).

## `advertisersPerSearchTerm` (type: `integer`):

How many matching advertisers to scrape for each name. Big brands often have several legal entities.

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

Only ads shown in this country.

## `platforms` (type: `array`):

Only ads shown on these Google products. Leave empty for all. Google only applies this filter to ads shown since September 4, 2023.

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

Only ads in this format. Text covers Google Search ads.

## `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).

## `maxAdsPerSource` (type: `integer`):

Stops after this many ads for each advertiser, domain or URL.

## `extractAdContent` (type: `boolean`):

Opens each ad to return the headline, description and display URL of Search ads, the YouTube video of video ads, every image variation and the countries where the ad ran. Included in the price. Turn off for a faster list of ads only.

## `onlyNewAds` (type: `boolean`):

Remembers the ads returned in earlier runs and only returns ads it has not seen before. Ads skipped this way are not charged. Schedule the Actor daily or weekly to get alerts on new creatives.

## `monitorName` (type: `string`):

Use a different name for each monitoring setup (for example one per client) so their histories stay separate.

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

Usually not needed. If Google rate-limits the run, the Actor switches to Apify Proxy on its own.

## Actor input object example

```json
{
  "searchTerms": [
    "Nike"
  ],
  "advertisersPerSearchTerm": 1,
  "region": "anywhere",
  "format": "ALL",
  "maxAdsPerSource": 20,
  "extractAdContent": true,
  "onlyNewAds": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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"
    ],
    "maxAdsPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("andracore/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 = {
    "searchTerms": ["Nike"],
    "maxAdsPerSource": 20,
}

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

```

## MCP server setup

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