# Google Ads Transparency Scraper (`lazybloomworld/google-ads-transparency-scraper`) Actor

Scrape the Google Ads Transparency Center (Google's ad library) by brand name, domain or advertiser ID. Get competitors' Search, YouTube, Shopping and image ads with text, landing pages and EU impressions. Monitor new ads daily. Export to CSV, Excel or JSON. Pay per ad, no monthly fee.

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

## Pricing

from $1.00 / 1,000 ad with full details

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: competitor ads by brand name

Get the ads a company runs on Google (Search, YouTube, Shopping, Maps and Play) straight from the [Google Ads Transparency Center](https://adstransparency.google.com/), the public Google Ads Library. Type a brand name like `Nike` or `El Corte Inglés`, a domain like `nike.com`, an advertiser ID or a Transparency Center URL, and get a clean dataset with ad text, images, YouTube videos, landing pages, dates and, in the EU, **impressions per country and platform**.

No login, no Google account, no coding. Export to JSON, CSV, Excel or Google Sheets, or connect it to Make, Zapier, n8n or your own code through the Apify API, as a simple Google Ads Transparency Center API.

![Sample output of the Google Ads Transparency Scraper: ads from Liverpool, Coppel, Amazon and Zara with image, format, headline, landing page, last shown date and days active](https://api.apify.com/v2/key-value-stores/s4oga5QyZepoYbYSt/records/ads-transparency-output.png)

### Why this scraper

- **Search by brand name.** Many scrapers need an advertiser URL. Here you type `Nike` and it finds the real Nike, Inc. account, not a look-alike.
- **The full ad in one run**: headline, description, YouTube link, call to action and landing page, plus images and dates.
- **EU impressions by country and platform**, as Google publishes them.
- **Alerts for competitors' new ads**: turn on *Only new ads* and schedule it to get just what changed since the last run.
- **Pay only for what you get.** No start fee, no monthly fee. If Google refuses an ad's details, you pay the basic price.

### What you can use it for

- **Competitor research**: see which messages, offers and creatives your competitors are running right now, and for how long. A Google ad spy tool built on Google's own public data.
- **Agency pitches and audits**: pull a brand's Google ad library in minutes before a meeting.
- **Creative inspiration**: collect headlines, descriptions and YouTube ads that have been running for months (a strong hint that they work). It also works as a YouTube ads scraper for any advertiser.
- **Market and media research**: compare impressions by country and by Google platform (EU data).
- **Compliance and brand protection**: check what is being advertised under a brand or a domain.

### What data you get

| Field | What it is |
|---|---|
| `advertiserName`, `advertiserId` | The verified advertiser behind the ad |
| `creativeId`, `adUrl` | The ad's ID and its page in the Transparency Center |
| `format` | `TEXT`, `IMAGE` or `VIDEO` |
| `headline`, `description`, `displayDomain` | The ad text (search ads and many video/Shopping ads) |
| `imageUrl`, `previewUrl` | Ad image or screenshot |
| `videoUrl` | Direct YouTube link for video ads |
| `callToAction`, `landingUrl` | Button (e.g. `VISIT_SITE`) and destination page, when Google provides them (mostly video ads) |
| `firstShown`, `lastShown`, `daysActive` | When the ad ran |
| `platforms` | Where it was shown: `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY` |
| `regionsShown[]` | Every country where it ran, with first/last date and, in the EU, **impressions range per country and per platform** |
| `detailsIncluded` | `true` when the full ad details were fetched |
| `source`, `regionFilter`, `scrapedAt` | What you searched for and when |

Google only publishes impressions and platform breakdowns for countries with transparency obligations (the European Union). For other countries you get the dates. Fields Google does not provide are returned as `null`, never as placeholders.

#### Example output (real ad, shortened)

```json
{
  "advertiserName": "El Corte Ingles S.A.",
  "creativeId": "CR12812890421910831105",
  "adUrl": "https://adstransparency.google.com/advertiser/AR05601758993283284993/creative/CR12812890421910831105?region=es",
  "format": "VIDEO",
  "firstShown": "2024-06-12",
  "lastShown": "2026-10-24",
  "daysActive": 836,
  "imageUrl": "https://i1.ytimg.com/vi/cCcNW4decls/hqdefault.jpg",
  "videoUrl": "https://www.youtube.com/watch?v=cCcNW4decls",
  "headline": "Productos de paseo",
  "callToAction": "VISIT_SITE",
  "landingUrl": "https://www.elcorteingles.es/mundo-paseo/bebes/Bebés/Paseo",
  "platforms": ["YOUTUBE"],
  "regionsShown": [
    {
      "region": "ES",
      "firstShown": "2024-06-11",
      "lastShown": "2026-10-23",
      "impressions": { "min": 1000000, "max": 1250000 },
      "platforms": [{ "platform": "YOUTUBE", "impressions": { "min": 1000000, "max": 1250000 } }]
    }
  ],
  "detailsIncluded": true
}
```

A search ad from the same run:

```json
{
  "format": "TEXT",
  "headline": "El Corte Inglés",
  "description": "Haz que aprendan jugando con nuestra variedad de juguetes educativos de ciencia. Entra ya.",
  "displayDomain": "elcorteingles.es",
  "platforms": ["MAPS", "SEARCH", "SHOPPING", "YOUTUBE"]
}
```

### How to use it

1. Click **Try for free**.
2. Enter one or more **brand names** (for example `Nike`), **domains**, **advertiser IDs** or **Transparency Center URLs**.
3. Optionally choose a **country** (`US`, `ES`, `MX`…), an **ad format** and a **date range**.
4. Set **Max ads per advertiser** and click **Start**.
5. Download the results or send them to Google Sheets, Make, Zapier or n8n.

#### Searching by brand name

Google often lists small look-alike accounts first (searching "Nike" returns a one-ad account before Nike, Inc.). This scraper picks the matching advertiser with **the most ads**, and when you choose a country it prefers advertisers registered there. Use **Advertisers per name search** to include several (e.g. a brand and its travel or retail subsidiaries).

Some big brands are not among Google's name suggestions at all (Zara is registered as Industria de Diseño Textil). When only small accounts match, the scraper searches the brand's own domain instead (`zara.com`, or `liverpool.com.mx` when the country is Mexico), and the log tells you which advertiser or domain it used. If you still get the wrong company, enter its **domain** directly.

#### Input example

```json
{
  "searchTerms": ["Nike"],
  "region": "US",
  "adFormat": "ALL",
  "maxAdsPerAdvertiser": 200,
  "includeDetails": true,
  "includeAdContent": true
}
```

### Recipe: weekly competitor ad report in Google Sheets

1. Enter your competitors' brand names and turn on **Only new ads (monitoring)**.
2. Create an Apify **Schedule** for this Actor, for example every Monday at 8:00.
3. Add the **Google Sheets** integration to the Actor so each run appends its results to your sheet.

The first run saves the competitors' current ads as a starting point. From then on, each run returns only the ads that are new since the previous one, so your sheet becomes a running log of every new campaign. Runs with no new ads return nothing and you pay nothing for results.

### Use it from code

Call the Actor from Python with the [Apify client](https://docs.apify.com/api/client/python) (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lazybloomworld/google-ads-transparency-scraper").call(run_input={"searchTerms": ["Nike"], "region": "US", "maxAdsPerAdvertiser": 50})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["format"], ad["headline"], ad["adUrl"])
```

### Pricing

You pay per ad, with no monthly fee:

- **Full ad** (text, media, regions, impressions, platforms): **$1.00 per 1,000 ads**.
- **Basic ad** (list only, with `includeDetails` off): **$0.40 per 1,000 ads**.

Examples: 200 ads from one brand cost about $0.20. Ten competitors with 500 ads each cost about $5. No start fee and no monthly fee.

If Google refuses the details of an ad, that ad is charged at the basic price, so you never pay full price for partial data. Apify's free plan includes monthly credit, enough to try it on a few thousand ads.

### Reliability and speed

Google limits how fast its Transparency Center can be read. The scraper fetches ads in parallel, slows down automatically when Google pushes back, retries, and switches connection if the proxy is blocked, so a run finishes with your data instead of failing halfway. A typical run returns around 100 complete ads per one to two minutes. Turn off **Include ad details** for a much faster list.

### What Google does not publish

The Transparency Center does not show ad spend, clicks, CTR, keywords or detailed audience targeting, so no scraper can return them. Impressions and platform breakdowns exist only for EU countries. Some ads only have a screenshot (no text), and Google only exposes a YouTube link for part of video ads. Missing fields come back as `null`.

### FAQ

**Do I need a Google account or API key?** No.

**Why are some headlines empty?** For some ads Google only stores a screenshot, which you get in `previewUrl`/`imageUrl`. Text that Google fills in at serving time (ad customizers) is returned as `null` rather than as a template.

**Why are impressions missing for my country?** Google only publishes impression ranges for EU countries.

**Is this legal?** The scraper reads only public information that Google publishes for transparency. It does not log in. Advertisers are businesses or individuals verified by Google; when an advertiser is a person, their name may be personal data under GDPR, so use it accordingly. You are responsible for how you use the data. This tool is not affiliated with or endorsed by Google.

**Something broke or a field is missing?** Open an issue in the **Issues** tab. We usually reply within 24 hours.

# Actor input Schema

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

Brand names, also multi-word (e.g. "Coca-Cola Company"). The Actor finds the matching advertiser.

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

Advertiser website domains, e.g. nike.com.

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

IDs that start with AR, e.g. AR16735076323512287233.

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

Advertiser or domain URLs copied from adstransparency.google.com.

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

ISO country code (US, ES, MX...) or leave empty for anywhere.

## `adFormat` (type: `string`):

Only ads of this format. Filtered on Google's side.

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

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

Stop after this many ads for each advertiser, domain or search.

## `maxAdvertisersPerSearch` (type: `integer`):

How many matching advertisers to scrape for each brand name. The ones with the most ads go first.

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

Return only ads that were not returned by previous runs with the same advertiser, region and format. The first run saves the current ads as a starting point and returns up to the maximum. Schedule the Actor daily or weekly to get alerts about new competitor ads.

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

Fetch media URLs, last shown date and regions for every ad. Turn off for a faster, cheaper list.

## `includeAdContent` (type: `boolean`):

Read each ad's preview to get the headline, description, display domain and YouTube video link. Needs ad details. Adds one or two requests per ad.

## `maxConcurrency` (type: `integer`):

How many ads are fetched at the same time, each through its own proxy IP. Higher is faster; lower it if you see blocking (429) warnings in the log. Without a proxy, keep it at 5 or less.

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

Proxy used for the requests. Apify Proxy is recommended.

## Actor input object example

```json
{
  "searchTerms": [
    "Nike"
  ],
  "adFormat": "ALL",
  "maxAdsPerAdvertiser": 100,
  "maxAdvertisersPerSearch": 1,
  "onlyNewAds": false,
  "includeDetails": true,
  "includeAdContent": true,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of the scraped ads: advertiser, format, text, landing page, dates and media.

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

Every ad with all fields, including regions, impressions and platforms.

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

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

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

```

## MCP server setup

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