# Google Ads Transparency Scraper | Ad Text + Domain Check (`zrk1212/google-ads-transparency-ad-copy`) Actor

Scrape the Google Ads Transparency Center by domain, advertiser or URL. Get each ad's dates and format, Search ad copy as text (headline, description, sitelinks), YouTube links for video ads, a bulk "does this domain run Google Ads?" check, and new/stopped ad monitoring.

- **URL**: https://apify.com/zrk1212/google-ads-transparency-ad-copy.md
- **Developed by:** [zachary klein](https://apify.com/zrk1212) (community)
- **Categories:** SEO tools, Developer tools
- **Features:** Limited permissions
- **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.

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 Text, Domain Check, New and Stopped Ads

Scrape the Google Ads Transparency Center by website, advertiser or URL and get the actual ad copy as text: headline, description, display URL and sitelinks for every Search ad, YouTube links for video ads, dates and formats for all ads. Also checks in bulk whether a domain runs Google Ads, and monitors advertisers for new and stopped ads.

### What does it do?

- **Ad copy as text.** Most Search (text) ads in the Transparency Center are stored by Google only as a screenshot (in our samples, 43 of 50 Nike ads and 30 of 40 GEICO text ads). This actor reads Google's structured preview data when it exists and reads the screenshot (OCR) when it does not. You get `headline`, `description`, `displayUrl` and `sitelinks` as separate fields, plus one `adText` field for spreadsheets and LLMs. `adTextSource` tells you which method produced the text.
- **Search by domain, advertiser ID, advertiser name or Transparency Center URL.** Filter by region (about 60 countries or anywhere), ad format (text, image, video) and date range.
- **YouTube links for video ads.** `youtubeVideoId` and `youtubeUrl` for every video ad.
- **Domain check mode.** One row per domain: does it run Google Ads, roughly how many ads, which formats, when was it last shown. Built for lead qualification at $2 per 1,000 domains.
- **Monitor mode.** Give your watch list a name and schedule the actor. Each run outputs only what changed: `new` ads and `stopped` ads.
- **No login, no cookies, no CAPTCHA solving.** Public transparency data only.

### Who is it for?

- **PPC and SEM agencies** auditing a prospect's competitors before a pitch.
- **SEO and marketing tools** that enrich domains with "runs Google Ads, since when".
- **Sales teams** qualifying leads: does this company spend on Google Ads?
- **Copywriters and creative teams** building swipe files of real headlines and descriptions.
- **Brand protection teams** watching who advertises against their domain.
- **Analysts** tracking competitor ad launches and stops over time.

### What data do you get?

#### Ads mode (one row per ad)

| Field | Example |
|---|---|
| `id` | `CR02335147347736002561:US` (creative ID and region, stable) |
| `advertiserName`, `advertiserId` | `Nike, Inc.`, `AR16735076323512287233` |
| `format` | `text`, `image` or `video` |
| `firstShownAt`, `lastShownAt`, `daysShown` | `2022-11-30T15:50:13.000Z`, `2026-11-18T12:35:53.000Z`, `1036` |
| `isActive` | `true` (shown within the last 2 days) |
| `landingDomain` | `nike.com` (domain searches only, or when you set the landing domain filter) |
| `headline`, `description`, `displayUrl` | `Men's Football Cleats & Shoes. Nike.com`, `Shop The Official Nike Store...`, `www.nike.com/` |
| `sitelinks` | `["Nike For Women", "Nike For Kids"]` |
| `adText` | headline, description and sitelinks in one text field |
| `adTextSource` | `preview_data`, `ocr`, or `null` when no text was extracted |
| `ocrConfidence` | `95` (only for OCR rows) |
| `youtubeVideoId`, `youtubeUrl` | video ads |
| `previewImageUrl`, `imageUrls` | the ad screenshot or image creatives |
| `regionsShown`, `variationCount` | with "Include ad details" |
| `adUrl` | link to the ad in the Transparency Center |
| `changeType` | monitor mode: `baseline`, `new` or `stopped` |

#### Domain check mode (one row per domain)

| Field | Example |
|---|---|
| `domain`, `region` | `shopify.com`, `US` |
| `runsGoogleAds` | `true` |
| `adCountMin`, `adCountMax` | `10000`, `20000` (Google publishes only a range) |
| `lastShownAt`, `activeLast30Days` | `2026-11-18T09:12:00.000Z`, `true` |
| `advertisers`, `formatsSeen`, `sampleAdUrls`, `transparencyUrl` | who advertises, which formats, example ads |

### How much does it cost?

Pay per event. You pay only for what you use.

| What | Price per 1,000 | 100 | 1,000 | 10,000 |
|---|---|---|---|---|
| Ad row | $1.20 | $0.12 | $1.20 | $12 |
| Ad text found (headline or description) | $1.00 | $0.10 | $1.00 | $10 |
| Domain check row | $2.00 | $0.20 | $2.00 | $20 |

Example: 1,000 ads from a Search-heavy advertiser where text is found on 75% of them costs about $1.95. The free plan's monthly credit covers a few thousand ads.

Never charged: error rows, duplicate ads, ads that did not change in monitor mode, OCR attempts that found no text, the text of `stopped` rows (only the ad row is charged), and anything after your maximum cost limit is reached. "Include ad details" and monitor mode cost nothing extra: in monitor mode you pay only for `baseline`, `new` and `stopped` rows. Turn off "Extract ad text" for the cheapest metadata-only run.

### How to use it

1. Open the actor and add a domain such as `nike.com`, an advertiser ID, an advertiser name, or a Transparency Center URL.
2. Pick the region and, if you like, the ad formats and date range.
3. Set "Max ads per target" (the prefilled input fetches 20 ads, the default is 200).
4. Click Start. Download the dataset as JSON, CSV or Excel, or read it through the API.

Example input:

```json
{
  "mode": "ads",
  "domains": ["nike.com"],
  "region": "US",
  "adFormats": ["text"],
  "maxAdsPerTarget": 100,
  "includeAdText": true
}
```

Domain check example:

```json
{ "mode": "domainCheck", "domains": ["shopify.com", "geico.com", "example-small-shop.com"], "region": "US" }
```

#### Monitor new and stopped ads

Set `monitorKey` (for example `competitors-us`) and schedule the actor daily or weekly. The first run lists the current ads with `changeType: "baseline"`. Later runs output only `new` ads (including ads that came back) and `stopped` ads (Google's last shown date is older than "Stopped after days", or the ad disappeared from a complete fetch). Set "Max ads per target" high enough to cover the advertiser, otherwise missing ads cannot be judged and are never reported as stopped.

### Example output

```json
{
  "id": "CR02569849984564330497:US",
  "advertiserName": "GEICO Corporation",
  "format": "text",
  "lastShownAt": "2026-11-18T12:35:53.000Z",
  "headline": "GEICO® Car Insurance - Get a Free GEICO® Quote Today",
  "description": "GEICO® was Named the Best Car Insurance Company for 2026-2027. Get a Free Quote Today.",
  "displayUrl": "www.geico.com/",
  "sitelinks": [],
  "adTextSource": "ocr",
  "ocrConfidence": 95,
  "adUrl": "https://adstransparency.google.com/advertiser/AR14408770578271961089/creative/CR02569849984564330497?region=US"
}
```

```json
{
  "id": "shopify.com:US",
  "domain": "shopify.com",
  "region": "US",
  "runsGoogleAds": true,
  "adCountMin": 10000,
  "adCountMax": 20000,
  "formatsSeen": ["text", "image"]
}
```

### Use it via API, MCP, n8n, Make, Zapier

```bash
curl -X POST "https://api.apify.com/v2/acts/Zrk1212~google-ads-transparency-ad-copy/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"domains":["geico.com"],"region":"US","adFormats":["text"],"maxAdsPerTarget":100}'
```

The actor also works from the Apify MCP server (so AI agents can call it), and from n8n, Make and Zapier through their Apify integrations.

### FAQ

**Where does the ad text come from?** Google stores most Search ads only as a screenshot. We read the structured preview data when it exists and run OCR on the screenshot otherwise. `adTextSource` tells you which. OCR is very accurate on these clean renders, but text hidden behind the ad's own product image cannot be recovered, and unreadable screenshots (for example local map ads) return no text and are not charged.

**Why do some ads have no landing domain?** Google returns it only for domain searches. Add the "Landing domain" filter to get it with advertiser searches.

**How far back can I search?** The date filter works only for roughly the last 12 months of shown history. Older ranges may return nothing and the actor logs a warning.

**Why are ad counts ranges?** Google publishes only approximate totals in the Transparency Center.

**Do I need a proxy?** No, and there is no proxy picker. Google blocks direct connections from cloud servers for this site, so the actor sends its search calls through Apify residential proxy by default, at no extra charge to you. If you turn off "Use residential proxy", the actor connects directly and a run that Google blocks stops with a `RATE_LIMITED` error row and keeps the partial results. The actor never solves CAPTCHAs.

**Why did `nike` return a tiny advertiser?** Advertiser names are resolved with Google's own search and an exact name match wins. Paste the exact advertiser name as shown in the Transparency Center (for example `Nike, Inc.`), or use the advertiser ID.

**Is it legal?** The actor reads public transparency data that Google publishes for accountability. No login, no cookies, no CAPTCHA solving, no personal contact data. It is not affiliated with Google. Use it for competitive research, ad monitoring and market analysis, and follow the laws and terms that apply to you.

**Does OCR cost extra?** Only the per-ad text price, and only when text was found.

**Free plan limits?** OCR for up to 200 ads per run on the free plan. Text taken from Google's preview data is unlimited.

**How often does the data refresh?** Live on every run.

**Something broke?** Open an Issue on the actor page. We respond within 24 hours.

### Related actors

- [Pagespeed Bulk Auditor](https://apify.com/zrk1212/pagespeed-bulk-auditor): site speed audits for the same agency buyers, to pair with a competitor's ad copy.
- [Google Hotels Prices Scraper](https://apify.com/zrk1212/google-hotels-prices-scraper): hotel prices from Google Hotels, from the same developer.

# Changelog

This Actor's version history is a separate document: https://apify.com/zrk1212/google-ads-transparency-ad-copy/changelog.md

# Actor input Schema

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

ads: one row per ad. domainCheck: one row per domain saying whether it runs Google Ads, how many, which formats and when last shown.

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

Advertised websites, for example nike.com or https://www.nike.com/us. We search ads that point to this domain.

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

Google advertiser IDs, for example AR16735076323512287233 (Nike, Inc.). Find them in the Transparency Center URL. Ignored in domainCheck mode.

## `advertiserNames` (type: `array`):

Advertiser names, for example Nike, Inc. or GEICO. Resolved with Google's own advertiser search. An exact name match wins, so paste the name exactly as shown in the Transparency Center, or use the advertiser ID. Ignored in domainCheck mode.

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

Advertiser pages (/advertiser/AR...), domain searches (/?domain=nike.com) or single ads (/advertiser/AR.../creative/CR...). The region in the URL wins over the region field.

## `maxAdvertisersPerName` (type: `integer`):

How many matching advertisers to take per advertiser name (exact match first, then by ad count).

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

Country where the ads were shown, or anywhere for all countries.

## `adFormats` (type: `array`):

Keep only these formats. One format is filtered by Google (faster). Two formats run two filtered searches. Ignored in domainCheck mode.

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

Only ads shown at any time in this range (overlap). Sent to Google as a filter. Ranges more than about 12 months back may return nothing. Ignored in domainCheck mode.

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

End of the date range, see Shown from. Ignored in domainCheck mode.

## `landingDomain` (type: `string`):

Only ads that send traffic to this domain. With advertiser IDs or names it means this advertiser's ads for this site. Ignored in domainCheck mode.

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

Maximum number of ads per domain, advertiser or URL.

## `includeAdText` (type: `boolean`):

Extract the ad copy (headline, description, display URL, sitelinks) as text, from Google's preview data or by reading the ad screenshot. Charged only for ads where text was found. Turn off for the cheapest metadata-only run. Ignored in domainCheck mode.

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

One extra request per ad: all regions where the ad was shown with last shown date per region, number of variations, and EU impression ranges where Google publishes them. No extra charge, but slower. Ignored in domainCheck mode.

## `monitorKey` (type: `string`):

Turn on monitor mode with a name for this watch list, for example competitors-us. Each run compares with the previous run under the same key and outputs only new and stopped ads. The first run lists the current ads as baseline. Ignored in domainCheck mode.

## `stoppedAfterDays` (type: `integer`):

Monitor mode: an ad counts as stopped when Google's last shown date is older than this many days.

## `useResidentialFallback` (type: `boolean`):

Google blocks direct connections from cloud servers for this site, so search calls go through Apify residential proxy at no extra charge to you. Turn off to connect directly: if Google blocks the connection, the run stops with a rate-limit error row and keeps the partial results.

## Actor input object example

```json
{
  "mode": "ads",
  "domains": [
    "nike.com"
  ],
  "maxAdvertisersPerName": 1,
  "region": "US",
  "adFormats": [
    "text",
    "image",
    "video"
  ],
  "maxAdsPerTarget": 20,
  "includeAdText": true,
  "includeDetails": false,
  "stoppedAfterDays": 7,
  "useResidentialFallback": true
}
```

# 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 = {
    "domains": [
        "nike.com"
    ],
    "region": "US",
    "maxAdsPerTarget": 20,
    "includeAdText": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("zrk1212/google-ads-transparency-ad-copy").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 = {
    "domains": ["nike.com"],
    "region": "US",
    "maxAdsPerTarget": 20,
    "includeAdText": True,
}

# Run the Actor and wait for it to finish
run = client.actor("zrk1212/google-ads-transparency-ad-copy").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 '{
  "domains": [
    "nike.com"
  ],
  "region": "US",
  "maxAdsPerTarget": 20,
  "includeAdText": true
}' |
apify call zrk1212/google-ads-transparency-ad-copy --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zrk1212/google-ads-transparency-ad-copy"
        }
    }
}
```

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/2GeVKuK40lOTgtgL5/builds/FS8VaocGS9LYFEdO6/openapi.json
