# Google Ads Transparency Scraper - Ad Copy & Creatives (`ritaya/google-ads-transparency-scraper`) Actor

Scrape competitors' Google ads from the Ads Transparency Center by brand or domain: search ad headlines and descriptions as text, image and YouTube video ads, first/last shown dates. No login.

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

## Pricing

from $1.50 / 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.

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 - Ad Copy & Creatives

**Google Ads Transparency Center scraper** for **competitor ad research**: give it brand names
or domains and get every Google ad they run — **Search ad headlines and descriptions as text**,
image creatives, **YouTube video ads**, and first/last shown dates. No login, no Google account,
no API key.

Keywords: google ads transparency scraper, google ads library, google ads spy tool, competitor
ads, google ad copy, search ads examples, ppc competitor research, google ads creatives,
youtube ads scraper, ad intelligence.

### What you get

- **Search ad copy as text** — headline, description, display URL and sitelinks. The
  Transparency Center stores most Search ads as screenshots, so other scrapers only return an
  image URL; this Actor reads the screenshot and hands you the words.
- **YouTube video ads** — the video ID and watch URL when the ad uses a YouTube video (most
  brand video ads; auto-generated Performance Max videos have no public YouTube ID).
- **Image / display ads** — the creative image URL.
- **Run dates** — when each ad was first and last shown, and on how many days.
- **Every advertiser behind a domain** — `canva.com` returns Canva's ads plus resellers and
  agencies advertising that site.
- **Filters** — country, Google platform (Search, YouTube, Shopping, Maps, Play), ad format and
  date range.

### Use cases

- **PPC competitor research** — collect the exact headlines and offers your competitors bid
  with, then spot the angles they keep running (long-running ads are the winners).
- **Ad copy swipe file** — build a library of Search ad copy by industry for copywriting and
  AI prompt examples.
- **Agency pitches and audits** — show a prospect what their competitors run on Google today.
- **Brand protection** — find resellers or affiliates bidding on your brand domain.
- **Video ad research** — pull a brand's YouTube ad creatives in one list.
- **Monitoring** — schedule the Actor weekly and diff the results to catch new campaigns.

### How to use

1. Enter **brands or domains** in *Brands or domains* (domains are the most precise).
2. Pick a **region** (default US) and, optionally, a platform, ad format or date range.
3. Click **Start**. A few hundred ads take about a minute.
4. Download the results as **CSV, Excel, JSON or HTML**, or fetch them via the Apify API.

### Output (one item per ad)

```json
{
  "advertiserName": "Hubspot, Inc.",
  "format": "TEXT",
  "headline": "HubSpot Smart CRM",
  "description": "Keep contacts, deals, and conversations current in HubSpot Smart CRM. Get started today.",
  "displayUrl": "hubspot.com",
  "businessName": null,
  "sitelinks": [],
  "copySource": "ocr",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/8502171896821904706",
  "firstShown": "2026-10-15T04:04:27+00:00",
  "lastShown": "2026-10-16T05:56:20+00:00",
  "daysShown": 2,
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR04680345614729347073?region=US",
  "searchTerm": "HubSpot",
  "region": "US",
  "platform": "ALL"
}
```

Video ads come with `youtubeVideoId` / `youtubeUrl` when they use a YouTube video, plus a
`previewUrl` either way; image ads come with `imageUrl`.

### Input

| field | meaning |
|---|---|
| `searchTerms` | brand names (`Canva`) or domains (`canva.com`) |
| `advertiserIds` | Transparency Center IDs (`AR…`) from an advertiser page URL |
| `region` | country code where ads were shown (`US`, `GB`, `DE`, …) or `anywhere` |
| `platform` | `ALL`, `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY` |
| `adFormat` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `startDate` / `endDate` | only ads shown in this window (`YYYY-MM-DD`) |
| `maxAdsPerTarget` | newest ads first, per brand/domain |
| `maxAdvertisersPerTerm` | a brand name can map to several advertiser accounts |
| `extractAdCopy` | read text-ad copy and video links (on by default) |

### Pricing (pay per event)

| event | price | when |
|---|---|---|
| `ad-scraped` | $0.0015 | every ad returned |
| `ad-copy-extracted` | $0.003 | a text ad whose headline and description were recovered |

Examples: 1,000 ads with copy ≈ $4.50; 1,000 image/video ads ≈ $1.50; turning
`extractAdCopy` off makes every ad $0.0015.

### FAQ

**Do I need a Google account, Google Ads account or API key?**
No. The Actor reads the public Google Ads Transparency Center, the same pages anyone can open.

**Why do I sometimes get a domain instead of the brand I typed?**
Google's advertiser search is a prefix match that often hides large brands among look-alike
names. When no advertiser with that name has many ads, the Actor searches the brand's own
domain instead and says so in the log. Typing the domain gives the most predictable result.

**How accurate is the ad copy?**
It is read from Google's own rendering of the ad, which is clean text, so headlines and
descriptions come out nearly verbatim for English and other Latin-script ads. `copySource`
tells you whether copy came from the screenshot (`ocr`) or from Google's preview data
(`preview`). HTML5 ads have no screenshot and are returned without copy — and without the copy
charge.

**Which countries are supported?**
Every country the Transparency Center covers; use its two-letter code, or `anywhere`.

**Can I track competitors over time?**
Yes — save your input as a task, schedule it weekly, and compare `firstShown` dates or
`creativeId`s between runs.

**Can I use it from my own code, Make, Zapier or an AI agent?**
Yes. Call it through the Apify API or the official integrations (Make, Zapier, n8n, Google
Sheets, webhooks). AI agents can run it through the Apify MCP server.

**Is it legal?**
The Transparency Center is published by Google for public inspection of ads. You are
responsible for how you use the data; check your local rules if in doubt.

### Related Actors by the same developer

- [Podcast Email Scraper](https://apify.com/ritaya/podcast-email-scraper) — podcast host emails by topic
- [Podcast Guest Booking Leads](https://apify.com/ritaya/podcast-guest-booking-leads) — interview podcasts that book guests
- [YouTube Email Scraper](https://apify.com/ritaya/youtube-creator-finder) — creator contacts by niche
- [TikTok Email Scraper](https://apify.com/ritaya/tiktok-email-scraper) — creator contacts from profiles

# Actor input Schema

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

Advertiser names (e.g. "HubSpot") or website domains (e.g. "hubspot.com"). Domains return every advertiser running ads for that site; names are matched to the advertiser with the most ads.

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

Transparency Center advertiser IDs starting with AR, e.g. AR16735076323512287233 (from the advertiser page URL).

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

Two-letter country code where the ads were shown (US, GB, DE, ...), or "anywhere".

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

Only ads shown on this Google surface. Platform data exists for ads shown since September 2023.

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

Text ads are the classic Search ads; their headline and description are extracted when "Extract ad copy" is on.

## `startDate` (type: `string`):

Only ads shown on or after this date, YYYY-MM-DD.

## `endDate` (type: `string`):

Only ads shown on or before this date, YYYY-MM-DD.

## `maxAdsPerTarget` (type: `integer`):

Newest ads first. Each page from Google holds up to 40 ads.

## `maxAdvertisersPerTerm` (type: `integer`):

A brand name can match several advertiser accounts (e.g. regional entities). Domains ignore this.

## `extractAdCopy` (type: `boolean`):

Read the headline, description, display URL and sitelinks of text ads, and the YouTube link of video ads. Text ads with recovered copy are charged the ad-copy event.

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

Google rate-limits the Transparency Center per IP; residential proxy keeps large runs going. Brand-name matching follows the proxy country.

## Actor input object example

```json
{
  "searchTerms": [
    "hubspot.com",
    "Canva"
  ],
  "region": "US",
  "platform": "ALL",
  "adFormat": "ALL",
  "maxAdsPerTarget": 50,
  "maxAdvertisersPerTerm": 1,
  "extractAdCopy": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Dataset items — one per ad: advertiserId, advertiserName, format, headline, description, displayUrl, sitelinks, youtubeUrl, imageUrl, firstShown, lastShown, daysShown, adUrl.

## `run` (type: `string`):

Public run page with status, stats and the results table.

# 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": [
        "hubspot.com"
    ]
};

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

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

```

## MCP server setup

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