# Google Ads Transparency & Ad Library Scraper API – No Login (`k-data-lab/google-ad-library-scraper`) Actor

Get Google Ads Transparency Center ads for any domain, brand or advertiser ID, no login: format, first/last shown, days shown, images, plus optional ad text, landing page, variations and countries with EU impressions. Search, YouTube, Shopping, Maps, Play. 100 results free each month.

- **URL**: https://apify.com/k-data-lab/google-ad-library-scraper.md
- **Developed by:** [K-Data Lab](https://apify.com/k-data-lab) (community)
- **Categories:** SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 ad scrapeds

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 & Ad Library Scraper API – No Login

**Type a competitor's domain or brand, click Start, get every Google ad they run as a table.** This actor reads the
public **Google Ads Transparency Center** (Google's ad library): format, first and last shown dates, days shown, the
ad image or preview and, with one add-on, the **ad text, landing page, video, every variation and each country it ran
in** with EU impression ranges. Search, YouTube, Shopping, Maps and Play ads.

- ✅ **No login, no cookies, no Google account**: paste `nike.com` or `HubSpot` and run
- 💰 **First 100 results every month free**, then from **$0.60 per 1,000 ads**; ad text + landing page + countries for $1 per 1,000 more
- 🔌 **Use it as an API**: one HTTP call returns JSON, CSV or Excel; works with n8n, Make, Zapier and AI agents (MCP)

Example row (real ad, `adidas.com`, US, full details on):

| advertiserName | format | firstShown | lastShown | daysShown | variationCount | landingUrl |
|---|---|---|---|---|---|---|
| Adidas America, Inc | IMAGE | 2026-10-20 | 2026-10-23 | 4 | 3 | https://www.adidas.com/us/stan_smith |

> Independent tool by K-Data Lab. Not affiliated with, endorsed or sponsored by Google. It reads only the public
> Ads Transparency Center (adstransparency.google.com), no login, and returns only what Google publishes there.

#### 🔍 What does Google Ad Library Scraper do?

- **Ads by domain**: `nike.com` returns every advertiser's ads that point to nike.com (brand, resellers, agencies)
- **Ads by brand name**: `HubSpot` is matched to the verified advertiser with the most ads
- **Ads by advertiser ID or link**: paste `AR…` IDs or Transparency Center links (an advertiser page, a domain search or a single ad)
- **Filters**: country shown in (243 countries), format (text / image / video), Google platform (Search, YouTube, Shopping, Maps, Play), date range
- **Full ad details** (optional): headline, description, display URL, texts, landing page URL, YouTube video ID or MP4, every variation, countries with first/last shown dates, EU impressions by platform, topic
- **Advertisers only** output: find advertiser IDs, verified countries and ad counts for a brand, or every advertiser running ads to a domain

#### 💡 Why choose this actor?

- 💰 **Lower price**: ads from $0.60–0.90 per 1,000 and full details for $1 per 1,000, with 100 free results every month
- 📝 **Ad text and landing page included in one add-on**, not split into several paid extras
- 🌍 **Per-country reach**: each country the ad ran in, with dates and (in the EU) impression ranges by platform
- ⚡ **Fast and light**: plain HTTP, 256 MB, about 40 ads per request; Apify Proxy only when Google slows down
- 🛡️ **Never charged twice**: an ad found by two input lines is returned and charged once; empty queries cost nothing

#### 📥 Input example

```json
{
  "queries": ["nike.com", "HubSpot", "AR16735076323512287233"],
  "region": "US",
  "format": "ALL",
  "platform": "ALL",
  "dateFrom": "2026-09-01",
  "maxAdsPerQuery": 200,
  "includeDetails": true
}
```

| Field | What it does |
|---|---|
| `queries` | Domains, brand names, advertiser IDs (AR…) or Transparency Center links, one per line |
| `region` | Country the ads were shown in (`anywhere` = all) |
| `format` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `platform` | `ALL`, `GOOGLE_SEARCH`, `YOUTUBE`, `GOOGLE_SHOPPING`, `GOOGLE_MAPS`, `GOOGLE_PLAY` |
| `dateFrom` / `dateTo` | Only ads shown in this period (YYYY-MM-DD) |
| `maxAdsPerQuery` | Stop after this many ads per line |
| `includeDetails` | Ad text, landing page, video, variations, countries, impressions, topic |
| `advertisersPerName` | How many advertisers to take for a brand name (most ads first) |
| `mode` | `ads` or `advertisers` (advertiser lookup only) |

#### 🧪 Ready-made inputs

| Goal | Input |
|---|---|
| Every ad pointing to a website (brand, resellers, affiliates) | `{"queries": ["nike.com"], "maxAdsPerQuery": 500}` |
| A brand's YouTube video ads in the UK | `{"queries": ["Spotify"], "region": "GB", "platform": "YOUTUBE", "format": "VIDEO"}` |
| Ad copy and landing pages of Search ads | `{"queries": ["hubspot.com"], "platform": "GOOGLE_SEARCH", "includeDetails": true}` |
| New ads only (schedule daily) | `{"queries": ["shopify.com"], "dateFrom": "2026-10-24"}` |
| Find the exact advertiser IDs for a brand | `{"queries": ["Samsung"], "mode": "advertisers"}` |

#### 📤 Output example

One row per ad (the `Ads` view shows the image, advertiser, dates and links). A real record with full details:

```json
{
  "adId": "CR07054792377080217601",
  "advertiserId": "AR14017378248766259201",
  "advertiserName": "Adidas America, Inc",
  "domain": "adidas.com",
  "format": "IMAGE",
  "firstShown": "2026-10-20T17:44:06Z",
  "lastShown": "2026-10-23T23:43:41Z",
  "daysShown": 4,
  "imageUrl": null,
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&…",
  "adUrl": "https://adstransparency.google.com/advertiser/AR14017378248766259201/creative/CR07054792377080217601?region=US",
  "query": "adidas.com",
  "region": "US",
  "variationCount": 3,
  "regions": [{"countryCode": "US", "country": "United States", "firstShown": null, "lastShown": "2026-10-23",
               "impressionsMin": null, "impressionsMax": null, "impressionsByPlatform": []}],
  "adText": {
    "texts": ["Explore The Latest Shoes, Clothing & Accessories On", "adidas.com.",
              "The Stan Smith sneaker is a timeless design", "inspired by the tennis legend", "Place Your Order Today"],
    "landingUrls": ["https://www.adidas.com/us/stan_smith"],
    "headline": null, "youtubeVideoId": null, "videoUrl": null
  },
  "landingUrl": "https://www.adidas.com/us/stan_smith"
}
```

For ads shown in the EU, `regions` also carries Google's impression ranges by platform (real `adidas.de` ad):

```json
"regions": [{
  "countryCode": "DE", "country": "Germany", "firstShown": "2023-03-01", "lastShown": "2026-10-23",
  "impressionsMin": 10000000, "impressionsMax": null,
  "impressionsByPlatform": [
    {"platform": "GOOGLE_SEARCH", "impressionsMin": 10000000, "impressionsMax": null},
    {"platform": "GOOGLE_SHOPPING", "impressionsMin": 1500000, "impressionsMax": 1750000},
    {"platform": "YOUTUBE", "impressionsMin": 70000, "impressionsMax": 80000}
  ]
}]
```

Field notes:

- `daysShown`: number of days Google showed the ad (from the Transparency Center)
- `imageUrl`: image ads and older text ads are archived by Google as images; `previewUrl` is Google's preview script for HTML and video ads
- `impressionsMin` / `impressionsMax`: Google publishes impression ranges for ads shown in the EU (and political ads); `impressionsMax: null` means "or more"
- `adText.headline` / `description` / `displayUrl`: for search text ads with a live preview; other ads list their visible `texts`
- Run summary (key-value store `RUN_SUMMARY`): per input line, the advertisers used, how many ads Google reports for your filters, and a status (`OK`, `NO_ADS`, `NO_ADVERTISER_FOUND`, `INVALID_QUERY`, `ERROR`)

#### ⚠️ When a line returns nothing

- `NO_ADVERTISER_FOUND`: no verified advertiser name contains every word you typed. Use the website domain instead (`brand.com`), or `Advertisers only` mode to see the exact advertiser names.
- `NO_ADS`: the advertiser or domain has no ads for these filters (country, format, platform, dates).
- `INVALID_QUERY`: a Transparency Center link without an advertiser, ad or domain in it.

Nothing is charged for a line that returns nothing.

#### 💰 How much does it cost to scrape Google ads?

| Event | Price |
|---|---|
| Ad scraped | **$0.0009** (Free plan) · $0.0008 (Bronze) · $0.0007 (Silver) · $0.0006 (Gold and up) |
| Ad details (only with *Full ad details* on) | $0.001 per ad |
| Advertiser found (*Advertisers only*) | $0.0005 |
| Actor start | $0.005 per run |

**The first 100 results each calendar month are free**, details included. Examples: 1,000 ads ≈ $0.90; 1,000 ads with full
details ≈ $1.90. Set *Maximum cost per run* in the run options and the actor stops cleanly at that limit.

#### 🚀 How to scrape Google Ads Transparency Center (step by step)

1. Open the actor and click **Try for free**.
2. Paste competitor domains or brand names into **Advertisers, brands or domains**.
3. Pick a country, format, platform or dates if you need them.
4. Turn on **Full ad details** for ad text, landing pages and countries.
5. Click **Start**, then download the results as Excel, CSV or JSON.

#### 📊 Popular use cases

- **Competitor ad research**: which messages, offers and landing pages a rival is testing right now
- **Ad creative swipe files** for agencies and copywriters
- **Market entry checks**: which countries a competitor advertises in, since when, and how much (EU)
- **Brand protection**: find resellers, affiliates and look-alike advertisers bidding on your domain
- **Lead lists for agencies**: which companies are actively advertising (advertiser names and IDs, no personal contact data)
- **Monitoring**: schedule a daily run with a `dateFrom` of yesterday to see new ads

#### 🔌 Integrations & API

Run it from your code with the Apify API or client libraries:

```python
from apify_client import ApifyClient

client = ApifyClient('<YOUR_APIFY_TOKEN>')
run = client.actor('k-data-lab/google-ad-library-scraper').call(run_input={
    'queries': ['nike.com'], 'region': 'US', 'maxAdsPerQuery': 100, 'includeDetails': True})
for ad in client.dataset(run['defaultDatasetId']).iterate_items():
    print(ad['advertiserName'], ad['format'], ad['lastShown'], ad.get('landingUrl'))
```

```bash
curl -X POST "https://api.apify.com/v2/acts/k-data-lab~google-ad-library-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H 'Content-Type: application/json' -d '{"queries": ["hubspot.com"], "maxAdsPerQuery": 50}'
```

It also connects to Google Sheets, Slack, Zapier, Make, n8n and webhooks through Apify integrations, and works as an
MCP tool for AI agents.

#### 💡 Tips

- A **domain** finds more ads than a brand name: big brands advertise under several legal entities (e.g. Nike, Inc. and Nike Retail BV).
- Leave **Full ad details** off for fast, cheap lists; turn it on for the ads you want to study.
- Use **Advertisers only** first to get exact advertiser IDs, then scrape those IDs.
- Google reports totals as ranges (e.g. 70,000–80,000 ads); the run summary shows them per query.

#### ❓ 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 what. This actor reads only that public data, without login, at a polite
rate. You are responsible for how you use the data; check your local laws and Google's terms for your use case.

**Does it return personal data?** No contact data at all. Advertiser names are the verified names Google itself
publishes for each advertiser; some advertisers are verified individuals, so treat names as you would any public record.

**Why is there no text for some ads?** Google archives many text ads as images; the actor then returns the `imageUrl`.
Ads with a live preview get their text and landing page with *Full ad details*.

**How far back does it go?** As far as the Transparency Center does (several years for many advertisers).

**Can I get only new ads?** Set `dateFrom` and schedule the actor; each run returns ads shown since that date.

#### 🧰 More from K-Data Lab

- [Amazon ASIN Rating & Review Count Scraper](https://apify.com/k-data-lab/amazon-asin-rating-scraper): star rating, review count, 5★–1★ breakdown, price and Best Sellers Rank for ASINs on 19 Amazon marketplaces
- [Amazon Seller Central Review Scraper & Monitor](https://apify.com/k-data-lab/amazon-seller-central-review-scraper): export and monitor your brand's customer reviews from Seller Central (US, EU, JP, IN), with order ID and photos; you sign in yourself

#### 💬 Feedback

Missing a field or found a wrong value? Open an issue on the actor's **Issues** tab.

Tags: google ads transparency, google ads transparency center api, google ads library, google ad library scraper, competitor ads, ad spy tool, google ads
scraper, youtube ads, google shopping ads, ad creatives, ppc competitor research, advertiser lookup

# Actor input Schema

## `queries` (type: `array`):

One per line. A <b>website domain</b> (nike.com) returns every advertiser's ads that point to that site. A <b>brand or company name</b> (HubSpot) is matched to the verified advertiser with the most ads. An <b>advertiser ID</b> (AR…) or a <b>Transparency Center link</b> (an advertiser, a domain search or a single ad) is used as is.

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

Only ads shown in this country. A Transparency Center link with its own region keeps that region.

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

Only text, image or video ads.

## `platform` (type: `string`):

Only ads shown on this Google product.

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

Only ads shown on or after this date (YYYY-MM-DD). Leave empty for no limit.

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

Only ads shown on or before this date (YYYY-MM-DD). Leave empty for today.

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

Stop after this many ads for each line above. Big brands have tens of thousands of ads.

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

Also open each ad: headline and description, landing page URL, YouTube video ID, every variation, each country it ran in with first/last shown dates, EU impression ranges by platform, and topic. Charged as an extra <b>Ad details</b> event per ad.

## `advertisersPerName` (type: `integer`):

How many matching advertisers to take for a brand or company name (the ones with the most ads first). Use a domain to get every advertiser running ads for a website.

## `mode` (type: `string`):

<b>Advertisers only</b> does not scrape ads. For a brand name it lists up to 10 matching advertisers with their verified country and ad count; for a domain it lists every advertiser found in the domain's first 200 ads (how many of them each ran).

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

Used for ad previews and whenever Google slows down direct requests. The default Apify Proxy works well.

## `debug` (type: `boolean`):

Save the raw preview of each detailed ad to the run's key-value store (DEBUG\_<adId>) for troubleshooting.

## Actor input object example

```json
{
  "queries": [
    "nike.com",
    "HubSpot"
  ],
  "region": "anywhere",
  "format": "ALL",
  "platform": "ALL",
  "maxAdsPerQuery": 20,
  "includeDetails": false,
  "advertisersPerName": 1,
  "mode": "ads",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "queries": [
        "nike.com",
        "HubSpot"
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("k-data-lab/google-ad-library-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 = {
    "queries": [
        "nike.com",
        "HubSpot",
    ],
    "maxAdsPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("k-data-lab/google-ad-library-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 '{
  "queries": [
    "nike.com",
    "HubSpot"
  ],
  "maxAdsPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call k-data-lab/google-ad-library-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,k-data-lab/google-ad-library-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/6OKVPkdST50aS6klL/builds/i2CoJ9BenbRj76F3y/openapi.json