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

Scrape the Google Ads Transparency Center (Google Ad Library) by brand, domain or advertiser ID. Get every Search, image and YouTube ad a competitor runs, with ad copy, run dates, countries and daily new/stopped-ad alerts. $1.50 per 1,000 ads.

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

## Pricing

from $1.50 / 1,000 ad results

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 Center Scraper & Google Ad Library API

Scrape **every Google ad a competitor runs** (Search/text, image and YouTube/video) from the public [Google Ads Transparency Center](https://adstransparency.google.com), also called the Google Ad Library. Enter brand names, website domains or advertiser IDs and get clean JSON, CSV or Excel. Each ad comes with its format, first and last shown dates, days running, image preview, text-ad copy and per-country details. Schedule it to get **new and stopped ad alerts**. There's no official Google Ads Transparency Center API; this Actor works as one.

**Try it:** the prefilled input (`HubSpot`, `nike.com`, 50 ads each) finishes in under 20 seconds for less than $0.20.

### Why use this Google Ads Transparency scraper

- Search by **brand name, domain or `AR…` advertiser ID**, with a match-quality score so you know you got the right company.
- **Text-ad copy** (headline, display URL, description) when Google serves it.
- **Change tracking**: daily `NEW_AD` / `STOPPED_AD` alerts for ad spy monitoring.
- **EU impression ranges** and per-country last-shown dates.
- Pay-per-result pricing, with proxies included: **$1.50 per 1,000 ads**.

### What you can do with it

- **Competitor ads research**: see every creative a rival is running right now and how long each has run (long-running ads are usually the winners).
- **Ad spy monitoring**: schedule it daily with `previousRunDatasetId` to get `NEW_AD` / `STOPPED_AD` alerts.
- **Agency pitches and audits**: export a brand's full Google ad library in one click.
- **Market and regional analysis**: filter by country and format.

### Input

| Field | What it does |
|---|---|
| `queries` | Brand names (`HubSpot`) or domains (`nike.com`). Names are fuzzy-matched; see `matchQuality` in the summary. |
| `advertiserIds` | Exact `AR…` IDs (most precise). |
| `region` | Country filter (US, GB, DE, …) or `anywhere`. |
| `format` | `ALL`, `TEXT`, `IMAGE`, `VIDEO`. |
| `dateFrom` / `dateTo` | Keep ads active in this window. |
| `maxAdsPerAdvertiser` | Cap per advertiser (newest first). |
| `extractAdText` | Pull headline / display URL / description for text ads (when Google serves an HTML preview). |
| `includeRegionDetails` | Per-country last-shown dates and EU impression ranges (one extra lookup per ad). |
| `previousRunDatasetId` | Turns on change tracking against an earlier run. |

### How to use the Google Ads Transparency Center scraper

1. Enter one or more competitors under **Advertiser names or domains** (e.g. `nike.com`, `HubSpot`), or paste `AR…` advertiser IDs.
2. Optionally choose a **Region**, an **Ad format** and a date window.
3. Click **Start**. A 2-advertiser, 50-ad run finishes in about 10–20 seconds and costs under $0.20.
4. Download the **Ads**, **Advertiser summaries** and **Changes** views as JSON, CSV or Excel, or pull them through the API.
5. **Ad spy mode:** schedule a daily run and set `previousRunDatasetId` to the previous run's dataset to get only NEW_AD / STOPPED_AD alerts. You can push those alerts to Slack, Google Sheets or email with Apify integrations (Zapier, Make, n8n).

### Use it from AI agents (MCP)

This Actor works with the [Apify MCP server](https://docs.apify.com/mcp). Ask your agent, for example: *"Find all Google ads Nike ran in Germany this month."* The agent can search for this Actor, read its input schema and call it, with a spending cap set through `maxTotalChargeUsd`.

### FAQ

**Is scraping the Google Ads Transparency Center legal?** The Transparency Center is a public library that Google publishes so anyone can inspect ads. This Actor only collects that public information. Check your local rules for how you use the data.

**How much does it cost?** $1.50 per 1,000 ads, $0.01 per advertiser summary and $0.005 per change alert. Proxies and compute are included.

**Why does a name return the wrong company?** Brand names are ambiguous. Use the domain (`canva.com`) or the `AR…` ID from the advertiser's Transparency Center URL.

**Can I get impressions and spend?** Google publishes impression ranges only for ads shown in the EU. Turn on *Include per-region details* to get them.

**Something broke?** Open an issue on the Issues tab. We monitor it daily.

### Output

The dataset holds three record types (`type` field), each with its own view: **Ads**, **Advertiser summaries** and **Changes**.

Example ad:

```json
{
  "type": "ad",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR06830598236735012865",
  "format": "TEXT",
  "firstShown": "2023-11-16",
  "lastShown": "2026-10-30",
  "daysShown": 911,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/2387327144059582008",
  "previewUrl": null,
  "adText": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR06830598236735012865",
  "regions": [{ "region": "US", "regionGeoId": 2840, "lastShown": "2026-10-30", "impressionsMin": null, "impressionsMax": null }],
  "variantCount": 5,
  "query": "nike.com",
  "region": "US",
  "scrapedAt": "2026-10-30T21:25:42.434Z"
}
```

Text ads with an HTML preview get `adText`, e.g. `{"headline":"CRM for MedTech","displayUrl":"www.salesforce.com/","description":"Manage commercial processes, build provider relationships, and engage with patients."}`.

Advertiser summary fields: `totalAdsEstimate` (Google's range), `adsScraped`, `adsByFormat`, `activeLast48h`, `newestFirstShown`, `longestRunning` (top 5), `newAds`, `stoppedAds`, `matchQuality`, `alternativeAdvertisers`.

### Notes and limits

- Impression ranges exist only for ads shown in the EU (Google publishes them only there).
- Many text ads are archived as rendered images. For those, `imageUrl` is set and `adText` is empty.
- `stoppedAds` is reported only when the advertiser's full list was scraped (it is not capped by `maxAdsPerAdvertiser`).
- Uses residential proxies with automatic session rotation and retries.

### Pricing

Pay per result: $1.50 per 1,000 ads, $0.01 per advertiser summary and $0.005 per change alert.

### Code examples (Python, Node.js, API)

Ready-to-run scripts, including a daily new-ads alert, are on GitHub: <https://github.com/kendallcoding202/google-ads-transparency-api-examples>.

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("crunchy_galaxy_qcr/google-ads-transparency-scraper").call(
    run_input={"queries": ["nike.com"], "region": "US", "maxAdsPerAdvertiser": 50})
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad.get("format"), ad.get("firstShown"), ad.get("adUrl"))
```

### Related

- [AI Brand Visibility Tracker](https://apify.com/crunchy_galaxy_qcr/ai-visibility-tracker): see whether ChatGPT and Gemini recommend your competitors instead of you.

# Actor input Schema

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

Who to spy on. Enter competitor brand names (e.g. "HubSpot") or website domains (e.g. "nike.com"), one per line. A domain returns every advertiser whose ads point to that site and is the most reliable choice. A name is matched to the closest verified Google advertiser (see matchQuality in the summary).

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

Google advertiser IDs (start with AR…), copied from an adstransparency.google.com/advertiser/AR… URL. This is the most precise option.

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

Only return ads shown in this country.

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

Only return ads of this format.

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

Only keep ads whose last-shown date is on or after this date (YYYY-MM-DD).

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

Only keep ads whose first-shown date is on or before this date (YYYY-MM-DD).

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

Stop paging an advertiser once this many ads are collected. Ads come newest first.

## `extractAdText` (type: `boolean`):

For TEXT ads, fetch the preview and pull out the headline, display URL and description. This adds one request per text ad, so it is slower.

## `includeRegionDetails` (type: `boolean`):

Make one extra lookup per ad to get the countries it ran in, first/last shown dates per country and (EU only) impression ranges.

## `previousRunDatasetId` (type: `string`):

The dataset ID of an earlier run with the same inputs. The run then outputs NEW_AD and STOPPED_AD change records. Schedule this daily to get competitor ad alerts.

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

Parallel requests. Keep this low to stay polite and avoid blocks.

## `proxyCountry` (type: `string`):

Country of the residential proxy (ISO code).

## Actor input object example

```json
{
  "queries": [
    "HubSpot",
    "nike.com"
  ],
  "region": "anywhere",
  "format": "ALL",
  "maxAdsPerAdvertiser": 50,
  "extractAdText": false,
  "includeRegionDetails": false,
  "maxConcurrency": 4,
  "proxyCountry": "US"
}
```

# Actor output Schema

## `ads` (type: `string`):

No description

## `summaries` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `stats` (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": [
        "HubSpot",
        "nike.com"
    ],
    "maxAdsPerAdvertiser": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crunchy_galaxy_qcr/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 = {
    "queries": [
        "HubSpot",
        "nike.com",
    ],
    "maxAdsPerAdvertiser": 50,
}

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

```

## MCP server setup

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