# Google Ads Scraper - Transparency Monitor (`vortex_data/google-ads`) Actor

Competitor ad intelligence for $0.50/1K results. Monitor new and removed Google, YouTube, Search, Display and Shopping ads, build swipe files, download creatives, and inspect copy, CTAs, landing pages, markets, platforms and dates.

- **URL**: https://apify.com/vortex\_data/google-ads.md
- **Developed by:** [VortexData](https://apify.com/vortex_data) (community)
- **Categories:** Developer tools, Lead generation, SEO tools
- **Stats:** 26 total users, 6 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$0.50 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🎯 Google Ads Scraper - Competitor Monitor

Scrape public ads from the [Google Ads Transparency Center](https://adstransparency.google.com/) by domain, company name, keyword, advertiser ID, or Transparency Center URL.

Use this Actor to build a clean competitor ads table with ad creatives, copy, CTAs, landing pages, active dates, preview media, downloaded creative files, OCR text, reach stats, and new/removed ad monitoring.

**💸 Price: $0.50 / 1,000 saved ads.** No Google Ads account, no Google Ads API key, and no browser setup required.

### ✅ What You Can Get

| Data group | Example fields |
| --- | --- |
| 👤 Advertiser | `advertiserName`, `advertiserLegalName`, `advertiserId`, `advertiserRegionCode` |
| 🆔 Creative | `creativeId`, `format`, `adTransparencyUrl`, `preview` |
| ✍️ Ad copy | `headline`, `description`, `cta`, `text`, `textLines` |
| 🔗 Landing pages | `landingUrl`, `landingDomain`, optional archived HTML in key-value store |
| 📅 Activity dates | `firstShown`, `lastShown`, `daysActive`, `isActive` |
| 🌍 Reach stats | `regions`, `platforms`, `impressionsMin`, `impressionsMax`, `targetingSummary` |
| 🖼️ Media | `media`, `variantUrls`, optional downloaded assets in key-value store |
| 🔎 OCR | `ocrText` for image ads, `videoOcrText` for video ads |
| 📌 Monitoring | `status`, `firstSeenAt`, `lastSeenAt`, `removedAt` |

The default output is one practical **📊 Ads table**. The **📌 Run report** gives totals, top formats, top landing domains, long-running ads, performance stats, and next actions.

### 🎯 Best For

- Monitoring competitors' Google, YouTube, Search, Display, and Shopping ads.
- Building a swipe file of competitor creatives and landing pages.
- Finding fresh ad copy, CTAs, offers, formats, and active campaigns.
- Tracking new and removed creatives on a daily or weekly Apify Schedule.
- Exporting Google Ads Transparency Center data to CSV, Excel, JSON, Clay, n8n, or your own API workflow.
- Auditing advertisers by region, format, date range, platform, impression range, and targeting signals when Google exposes them.

### 🚀 Quick Start

For a first run, fill only:

1. **🎯 Domains, names, IDs, or URLs** - for example `nike.com`, `Shopify`, or an `AR...` advertiser ID.
2. **🔢 Max ads** - use `20` for a cheap test.
3. Click **Start**.

Example input:

```json
{
  "searchTargets": ["nike.com"],
  "resultsLimit": 20
}
```

After the run, open **📊 Ads table** first. It contains the rows most users need without opening technical storage tabs.

### 🧭 How To Choose Input

| Input type | Example | Best use |
| --- | --- | --- |
| Domain | `nike.com` | Easy competitor research |
| Company name | `Shopify` | Quick brand lookup |
| Keyword | `running shoes` | Broader market discovery |
| Advertiser ID | `AR08888592736429539329` | Most reliable for repeat runs and monitoring |
| Transparency Center URL | `https://adstransparency.google.com/advertiser/...` | Exact advertiser or exact creative |
| Creative URL | `https://adstransparency.google.com/advertiser/AR.../creative/CR...` | Fetch one known ad |

For scheduled monitoring, use exact `AR...` advertiser IDs whenever possible. They avoid ambiguity from brand search suggestions.

### ⚙️ Input Options

The input form is intentionally short. Start with competitors and a result limit, then enable only the extras you need.

| Field | What it does | Recommended use |
| --- | --- | --- |
| 🎯 Domains, names, IDs, or URLs | Competitors or exact Google Transparency targets. | Add one target per line. |
| 🔢 Max ads | Total saved rows across the whole run. | Use `20` for tests, `100-500` for normal research, `0` only for everything available. |
| 🌍 Country | Optional country filter. | Leave **All countries** for the broadest view. |
| 🎞️ Ad format | Text, image, video, or all formats. | Leave **All formats** unless you need a specific creative type. |
| 📅 Date range | Activity window. | Use **Last 30 days** for active campaign checks. |
| 🎨 Download creative files | Saves direct media files to key-value store. | Enable for swipe files. |
| 🔎 Image OCR | Extracts text from image creatives. | Enable when image copy matters. |
| 🎬 Video OCR | Extracts text from video frames or thumbnails. | Enable when video overlays matter. |
| 🔗 Archive landing pages | Saves HTML copies of decoded landing pages. | Enable when you need evidence or later review. |
| 📈 Reach and targeting stats | Adds regions, platforms, impressions, and targeting flags. | Enable for the fullest competitor-intelligence rows. |
| 📌 Track new and removed ads | Stateful monitoring across scheduled runs. | Enable for daily or weekly competitor watches. |

### 📊 Output

Each dataset item is one Google ad creative.

Common fields:

| Field | Meaning |
| --- | --- |
| `advertiserName` / `advertiserId` | Google advertiser identity. |
| `creativeId` | Stable Google creative ID. |
| `format` | `TEXT`, `IMAGE`, or `VIDEO`. |
| `text`, `headline`, `description`, `cta` | Decoded ad copy when Google exposes it. |
| `ocrText`, `videoOcrText` | Optional text extracted from images or videos. |
| `landingUrl`, `landingDomain` | Decoded destination when available. |
| `firstShown`, `lastShown`, `daysActive` | Date range in `YYYY-MM-DD` format and active duration. |
| `regions`, `platforms`, `impressionsMin`, `impressionsMax` | Optional Google-exposed reach stats. |
| `preview`, `media`, `assetUrl` | Preview/media links and optional downloaded creative file. |
| `status` | `new`, `seen`, or `removed` in monitor mode. |
| `adTransparencyUrl` | Direct link to the ad in Google Ads Transparency Center. |

Example output item:

```json
{
  "advertiserName": "Nike, Inc.",
  "advertiserId": "AR16735076323512287233",
  "creativeId": "CR01753144146295521281",
  "format": "IMAGE",
  "text": "Nike Running | New arrivals are here | Shop now",
  "ocrText": "Run your best mile | New shoes available now",
  "cta": "Shop now",
  "landingUrl": "https://www.nike.com/",
  "landingDomain": "nike.com",
  "regions": ["United States"],
  "platforms": ["YouTube", "Google Search"],
  "impressionsMin": 1000,
  "impressionsMax": 2000,
  "firstShown": "2026-01-15",
  "lastShown": "2026-03-18",
  "daysActive": 62,
  "preview": "https://tpc.googlesyndication.com/archive/simgad/...",
  "assetUrl": "https://api.apify.com/v2/key-value-stores/.../records/ASSET_...?signature=...",
  "adTransparencyUrl": "https://adstransparency.google.com/advertiser/AR.../creative/CR..."
}
```

Apify lets you download the dataset as JSON, CSV, Excel, JSONL, XML, RSS, HTML, or through the API.

### 🎨 Download Creative Files

Enable **Download creative files** when you need a saved swipe file instead of links that may disappear.

When Google exposes durable direct media URLs, the Actor stores files as `ASSET_*` records in the default key-value store and adds:

- `mediaDownloaded`
- `assetKey`
- `assetUrl`
- `assetKeys`
- `assetUrls`
- `assets`

YouTube watch URLs and expiring `googlevideo.com` streams remain as links because they are not durable creative files.

### 🔎 OCR For Image And Video Ads

Enable **Image OCR** to extract text baked into image creatives.

Image OCR adds:

- `ocrText`
- `ocrLines`
- `ocrSourceUrls`
- `ocrImagesCount`
- `ocrStatus`

Enable **Video OCR** to extract text overlays from video creatives. Direct video assets are sampled with `ffmpeg` when Google exposes them. YouTube-only video ads use public thumbnail OCR instead of downloading full YouTube videos.

Video OCR adds:

- `videoOcrText`
- `videoOcrLines`
- `videoOcrSourceUrls`
- `videoOcrFramesCount`
- `videoOcrStatus`

OCR is best-effort and adds extra CPU and network work, so leave it off for the fastest bulk exports.

### 🔗 Archive Landing Pages

Enable **Archive landing pages** when you need proof of competitor landing pages, not just final URLs.

The Actor saves one HTML archive per unique decoded landing URL and adds:

- `landingPageDownloaded`
- `landingPageKey`
- `landingPageUrl`
- `landingPageStatus`
- `landingPageContentType`
- `landingPageBytes`

Landing-page archiving is optional because it fetches external websites and can slow large runs.

### 📌 Monitor New And Removed Ads

Enable **Track new and removed ads**, keep the same **Monitor name**, and run the Actor on an Apify Schedule.

Example:

```json
{
  "searchTargets": ["AR08888592736429539329"],
  "resultsLimit": 100,
  "monitorMode": true,
  "monitorName": "NIKE_US"
}
```

Monitor rows include:

- `status`: `new`, `seen`, or `removed`
- `firstSeenAt`
- `lastSeenAt`
- `removedAt`

With a limited run such as `20`, `100`, or `500`, the Actor labels `new` and `seen` inside that sampled window. Accurate removed-ad detection requires a full advertiser scan with `resultsLimit: 0` and `maxPages: 0`, because Google's top-results window can shift between runs.

Monitor state is stored in the named key-value store `google-ads-monitor-state` and mirrored into the run's default key-value store for visibility.

### ⚡ Speed Benchmarks

Benchmarked on June 17-18, 2026. Times vary by advertiser, media volume, Google response speed, and enabled extras.

| Mode | Saved ads | Actor processing time | Full Apify run time | Notes |
| --- | ---: | ---: | ---: | --- |
| Default Ads table | 20 | 3.5s | 14.3s | Preview-rich rows, 0 Google 429s |
| Default Ads table | 100 | 5.3s | 15.8s | Preview-rich rows, direct connection only |
| Default Ads table | 500 | 42.1s | 54.5s | Preview-rich rows, direct connection only |
| Reach and targeting stats | 100 | 21.4s | 23.6s | 100 enriched rows, 0 Google 429s |
| Reach and targeting stats | 500 | 122.3s | 125.2s | 500 enriched rows, 2 Google 429s recovered, 0 Residential traffic |
| All extras + reach stats | 20 | 10.3s | 20.8s | Assets, OCR, video OCR, landing archives, reach stats |
| All extras + reach stats + monitor | 500 | 124.5s | 135.6s | 500/500 enriched rows, 473 assets, 2 Google 429s recovered, 0 Residential traffic |
| Media-heavy all-extras run | 500 | 419.4s | 429.9s | 802 assets, 56 video OCR rows, 10 landing archives |

The default Ads table is the fastest mode. Reach stats, OCR, media downloads, video OCR, and landing-page archives are optional because they add detail lookups, downloads, CPU work, and storage writes.

### 🔌 API Example

Use this Actor as a Google Ads Transparency Center API alternative.

```bash
curl -X POST "https://api.apify.com/v2/acts/vortex_data~google-ads/run-sync-get-dataset-items?format=json&clean=true&timeout=300" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTargets": ["nike.com"],
    "resultsLimit": 20,
    "extractOcrText": true
  }'
```

Use the same input fields in API calls as in the Apify Console form.

### 🔄 Clay And n8n

#### Clay

Use Clay's Apify integration:

1. Add **Run Apify Actor**.
2. Actor: `vortex_data/google-ads`.
3. Input JSON:

```json
{
  "searchTargets": ["nike.com"],
  "resultsLimit": 20,
  "extractOcrText": true
}
```

Map fields such as `advertiserName`, `format`, `text`, `ocrText`, `cta`, `landingDomain`, `firstShown`, `lastShown`, `preview`, and `adTransparencyUrl` into your Clay table.

#### n8n

Import `integrations/n8n-google-ads-monitor.json` from this Actor source, set `APIFY_TOKEN`, and edit the JSON body in the **Run Google Ads Monitor** node.

For scheduled alerts, replace **Manual Trigger** with **Schedule Trigger**, keep `monitorMode: true`, and reuse the same `monitorName`.

```json
{
  "searchTargets": ["AR08888592736429539329"],
  "resultsLimit": 100,
  "monitorMode": true,
  "monitorName": "COMPETITOR_US"
}
```

### ⚠️ Notes And Limitations

- Google Ads Transparency Center is a public transparency UI, not an official bulk export API.
- Google does not expose exact impressions for every ad. When available, impressions are returned as ranges.
- Some ads do not expose copy, CTA, targeting, platform stats, media files, or landing URLs.
- Large repeated all-extras runs against the same advertiser can trigger temporary Google 429 responses. The Actor rotates warmed sessions, uses cheaper proxy routes first, and keeps Residential Proxy as a last rescue tier.
- Rich modes do not invent missing data. If Google does not expose a field, the Actor leaves it empty.
- Image and video OCR are best-effort. Video OCR does not transcribe speech.
- Landing-page archiving saves HTML only when the decoded destination returns an HTML page within safety limits.
- Signed `googlevideo.com` URLs expire and are kept as links, not downloaded files.
- Brand and keyword search depend on Google's advertiser suggestions. Exact `AR...` IDs are more stable.

### ❓ FAQ

#### Can I search by domain?

Yes. Paste a domain such as `nike.com` or `shopify.com`. The Actor resolves matching Google advertiser accounts and scrapes their public ads.

#### Can I search by advertiser ID?

Yes. `AR...` advertiser IDs are the fastest and most reliable input, especially for scheduled monitoring.

#### Can I scrape one exact ad?

Yes. Paste a Google Ads Transparency Center creative URL containing both `AR...` and `CR...`.

#### Does it support text, image, and video ads?

Yes. Leave **Ad format** set to **All formats** for normal competitor research, or filter to text, image, or video ads.

#### Can it download creatives?

Yes. Enable **Download creative files**. Direct durable images, thumbnails, videos, and HTML5 bundles are stored in the key-value store when Google exposes them.

#### Does it support OCR?

Yes. Image OCR and video OCR are optional. Leave them off for faster bulk runs.

#### Does it support landing pages?

Yes. The default table includes decoded landing URLs when available. Enable **Archive landing pages** to save HTML snapshots.

#### Do I need a Google Ads account?

No. The Actor uses public Google Ads Transparency Center data.

#### Is this affiliated with Google?

No. This Actor is not affiliated with Google. Users are responsible for using scraped data lawfully and respecting applicable rules.

### 🧯 Support

If a run returns fewer ads than expected, open the run log and check the target, country, format, date range, and result limit first. For repeatable monitoring, prefer exact `AR...` advertiser IDs.

Need help with a run? Open the Issues tab and include the run ID, input target, expected result count, and whether optional extras were enabled.

# Actor input Schema

## `searchTargets` (type: `array`):

Paste a brand name, keyword, domain, Google Ads Transparency advertiser ID such as AR08888592736429539329, or a Transparency Center URL.

## `resultsLimit` (type: `integer`):

Maximum dataset rows saved across all competitors. Use 20 for a cheap test, 100-500 for normal research, and 0 only when you want everything available.

## `filterRegion` (type: `string`):

Return ads shown in a specific country. Leave All countries for the broadest competitor view.

## `filterFormat` (type: `string`):

Choose Text, Image, or Video only when you need a specific creative type. Leave All formats for normal competitor research.

## `timeRangePreset` (type: `string`):

Return ads whose active period overlaps this date range. Custom dates below override this preset.

## `customStartDate` (type: `string`):

Optional exact start date. Use YYYY-MM-DD, for example 2026-06-01.

## `customEndDate` (type: `string`):

Optional exact end date. Use YYYY-MM-DD, for example 2026-06-30.

## `downloadAssets` (type: `boolean`):

Download direct images, thumbnails, videos, and HTML5 bundles to the key-value store when Google exposes durable media URLs. YouTube videos and expiring googlevideo streams stay as links.

## `extractOcrText` (type: `boolean`):

Extract text baked into image creatives. This adds image downloads and CPU work, so leave it off when speed matters most.

## `extractVideoOcrText` (type: `boolean`):

Best-effort text extraction for video creatives. Direct video assets are sampled with a few frames when Google exposes them; YouTube videos use thumbnail OCR instead of downloading full videos.

## `archiveLandingPages` (type: `boolean`):

Save one HTML copy per unique decoded landing URL to the key-value store. Use this when you need evidence of competitor landing pages, not just final URLs.

## `includeReachStats` (type: `boolean`):

Fetch Google-exposed regions, platforms, impression ranges, and targeting flags. This is the most complete competitor-intelligence mode, but it is slower because Google requires one extra detail lookup per ad.

## `monitorMode` (type: `boolean`):

Use this for daily or weekly schedules. Limited runs label ads as new or seen inside the sampled result window. Accurate full-advertiser new/removed tracking requires Max ads set to 0, because Google's top results window can shift.

## `monitorName` (type: `string`):

Use the same name every time for one competitor watchlist, for example NIKE\_US. Change it only when you want to start a separate monitor history.

## Actor input object example

```json
{
  "searchTargets": [
    "nike.com",
    "shopify",
    "AR08888592736429539329"
  ],
  "resultsLimit": 20,
  "filterRegion": "ALL",
  "filterFormat": "ALL",
  "timeRangePreset": "ALL_TIME",
  "downloadAssets": false,
  "extractOcrText": false,
  "extractVideoOcrText": false,
  "archiveLandingPages": false,
  "includeReachStats": false,
  "monitorMode": false,
  "monitorName": "NIKE_US"
}
```

# Actor output Schema

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

Main table with preview, advertiser, format, copy, CTA, landing page, dates, saved asset link, monitor status, and Google Transparency link.

## `summary` (type: `string`):

Short JSON report with totals, status counts, top formats, top landing domains, performance, and next actions.

# 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 = {
    "searchTargets": [
        "nike.com",
        "shopify",
        "AR08888592736429539329"
    ],
    "resultsLimit": 20,
    "monitorName": "NIKE_US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("vortex_data/google-ads").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 = {
    "searchTargets": [
        "nike.com",
        "shopify",
        "AR08888592736429539329",
    ],
    "resultsLimit": 20,
    "monitorName": "NIKE_US",
}

# Run the Actor and wait for it to finish
run = client.actor("vortex_data/google-ads").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTargets": [
    "nike.com",
    "shopify",
    "AR08888592736429539329"
  ],
  "resultsLimit": 20,
  "monitorName": "NIKE_US"
}' |
apify call vortex_data/google-ads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vortex_data/google-ads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hx1PUkxRyD6rc1WJS/builds/rZCw2rgYteOHWKgsz/openapi.json