# Google Ads Transparency Scraper & Real-Time MCP Server (`spiky_closet/google-ads-transparency-scraper`) Actor

Extract Google Ads creatives, structured copy, EU DSA reach & targeting, political spend, fundedBy end-payers, KVS asset archiving, and batch B2B domain ad-spend signals in milliseconds via Go RPC + Standby /mcp. Independent tool, not affiliated with Google.

- **URL**: https://apify.com/spiky_closet/google-ads-transparency-scraper.md
- **Developed by:** [AdPulse Labs](https://apify.com/spiky_closet) (community)
- **Categories:** Marketing, Lead generation, MCP servers
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ad creative results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 & Real-Time MCP Server (`v1.4`)

**Extract Google Ads creatives, structured ad copy, unwrapped landing URLs, EU DSA reach & audience targeting, 7-year political spend, `fundedBy` agency end-payers, and batch B2B domain ad-spend signals in seconds — with zero residential proxies required and native `0s` cold-start Standby `/mcp`.**

Built from the ground up as a **`16 MB` static Go binary** (`CGO_ENABLED=0`, `128–256 MB` RAM) that talks directly to Google Ads Transparency Center (`adstransparency.google.com`) RPC endpoints. No Chromium startup, no bloated browser containers, and `$0` actor start fee.

> *Independent tool, not affiliated with, endorsed by, or sponsored by Google LLC.*

***

### Why Teams Switch to This Scraper (Verified Apify Cloud Benchmarks)

All measurements below were captured directly on live **Apify Cloud** runs comparing this Go engine against leading Node.js and headless browser Store scrapers under identical target inputs:

| Workload | This Actor (Go `v1.4`) | Standard Node.js / Browser Store Scrapers | Measured Advantage |
| :--- | :--- | :--- | :--- |
| **Search Ads + Structured Copy**<br>(`shopify.com`, `US`, 15 ads) | **`2.49s`**, **`8.3 MB`** avg RAM (`8.29 MB`), **`0.00017 CU`** + `adBusinessName` & unwrapped `destinationUrl` via Google Wiz JSON | **`14.76s`**, **`68.6 MB`** avg RAM on a leading Node.js Store scraper | **5.9× faster, 8.3× lower memory** |
| **Multi-Entity Brand Search**<br>(`"Nike"`, `DE`, 20 ads + Full Details) | **`4.91s`**, **`8.1 MB`** avg RAM (`8.07 MB`), **`0.00034 CU`**, **3 verified Nike entities** via round-robin, **0 false positives**, **20/20 `fundedBy` end-payers** | **`105.91s`**, **`74.3 MB`** avg RAM, unrelated substring accounts & `0` `fundedBy` | **21.6× faster, 9.2× lower memory** |
| **Batch B2B Domain Ad-Spend Screening**<br>(5 SaaS domains, `screeningMode: true`) | **`1.31s`**, **1 clean deterministic row per domain** (strict 0-ad domain guard) | **`114.63s`**, fragmented multi-row output (missing 0-ad edge cases) | **87.5× faster** |
| **High-Volume EU DSA Endurance**<br>(`shopify.com`, `DE`, 220 ads + `includeDetails` + `includeAdText`) | **`23.39s`**, **`11.9 MB`** avg RAM (`16.6 MB` peak), **`0.00162 CU`**, **204/220 EU DSA reach**, **220/220 `regionStats` & `audienceSelection`**, **0 rate-limit errors** | Standard Node.js / Browser runners require far higher RAM and proxy retries at scale | **0 rate-limit errors, 220/220 `regionStats` & `audienceSelection`** |
| **7-Year Political & Election Archive**<br>(`politicalAds: true`, 15 ads) | **`1.16s–2.06s`**, **15/15 `spendMin`/`spendMax` (`USD`)** + explicit **age, gender, and 52-region geo targeting** | Often missing or unavailable in standard commercial Store scrapers | **15/15 spend bounds & 52-region targeting** |
| **Container Footprint & AI Agent Latency** | **`16 MB`** static Go (`CGO_ENABLED=0`) container image, **`256 MB`** default runtime (`128 MB` min) + **`0s` cold start Standby `/mcp` & REST** | **`322–541 MB`** Node.js / Playwright containers (`512–4,096 MB` default RAM, batch-only) | **20×–34× smaller image, `0s` Standby MCP** |

**How it stays this fast and reliable:** A single `16 MB` static Go binary executes bounded goroutine worker pools over Google's `adstransparency.google.com` RPC endpoints with persistent HTTP connection reuse, strict word-boundary entity matching, and Google Wiz `<c-wiz data-p>` structured copy extraction — eliminating headless Chromium startup overhead and residential proxy bottlenecks.

***

### Feature Comparison Matrix

| Feature | This Actor (`v1.4`) | Standard RPC Store Scrapers | Headless Browser Scrapers |
| :--- | :---: | :---: | :---: |
| **Zero-Proxy Free Start** (`useApifyProxy: false` default) | ✅ | ⚠️ Often proxy-required | ❌ Residential proxy needed |
| **1-Field Universal Auto-Detect** (`domain` / `work email` / `brand` / `CJK` / `AR-ID` / `URL` + `creativeIds`) | ✅ | ⚠️ Multi-field / strict | ⚠️ URL-only |
| **Standby MCP (`/mcp`) & Real-Time REST (`/search`, `/screen`)** | ✅ | ❌ Batch-only | ❌ Batch-only |
| **Agency End-Payer (`fundedBy`) & Rebrand History (`advertiserPreviousNames`)** | ✅ | ❌ | ❌ |
| **AI Synthetic Media Flag (`containsSyntheticMedia`)** | ✅ | ❌ | ❌ |
| **Nonprofit Ad Grants Flag (`isGoogleGrantsAccount`)** | ✅ | ❌ | ❌ |
| **7-Year Political Spend (`spendMin`/`Max`) & Age/Gender/Geo Targeting** | ✅ | ⚠️ Partial / absent | ❌ |
| **Server-Side `adTextKeyword` & `sortBy` (`LAST_ACTIVITY_DATE`, `IMPRESSIONS`, `REVENUE`)** | ✅ | ⚠️ Sort only | ❌ |
| **246 GeoTargets + `"EU"` (27) & `"EEA"` (30) Regional Macros** | ✅ | ⚠️ Country codes only | ⚠️ Country codes only |
| **Rolling `dateRangePreset`** (`TODAY`, `LAST_7_DAYS`, `LAST_30_DAYS`, `THIS_MONTH`, etc.) | ✅ | ⚠️ Rare | ❌ |
| **Incremental Monitor Mode (`onlyNewAds` + Named KV Store)** | ✅ | ⚠️ Rare | ❌ |
| **Permanent Signed KVS Image Archiving (`downloadAssets` -> `storedImageUrl`)** | ✅ | ⚠️ Rare | ❌ |
| **Batch Domain Screening (`screeningMode`: 1 row/domain, 0-ad guard)** | ✅ | ⚠️ Fragmented multi-row | ❌ Too slow |
| **Atomic `maxResults` Hard Cap (Zero Over-Billing)** | ✅ | ⚠️ Frequent over-delivery | ⚠️ Page-level overshoot |
| **Drop-In JSON Compatibility Across Common Store Payloads** | ✅ | ❌ | ❌ |

***

### 10-Second Drop-In Migration (No Code Rewrite Needed)

Switching from another Google Ads Transparency scraper in `apify-client`, **Make**, **Zapier**, or **n8n**? Keep your existing JSON payload as-is — this Actor automatically normalizes legacy and third-party field names under the hood:

| Your Existing Input Key | Normalized Behavior in This Actor |
| :--- | :--- |
| `domains`, `advertiserIds`, `startUrls` (`["..."]` or `[{"url":"..."}]`), `urlsFromFile`, `searchQuery`, `domain`, `search` | Merged automatically with `query` / `queries` (deduplicated, order-preserved). |
| `creativeIds` or `advertiserId`/`advertiser_id` + `creativeId`/`creative_id` | Targets exact creatives (`CR...` paired with `AR...`, or `AR.../CR...` shorthand). |
| `adFormat` / `platform` | Mapped to `format` (`ALL`, `TEXT`, `IMAGE`, `VIDEO`) and `platforms` (`SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY`). |
| `dateFrom` / `dateTo` / `customStartDate` / `customEndDate` / `start_date` / `end_date` | Mapped to `startDate` / `endDate` (`YYYY-MM-DD`, overriding `dateRangePreset` when set). |
| `maxItems` / `ads_count` / `count` / `maxAdsPerSearch` | Enforced via atomic global `maxResults` / per-target caps with **zero over-delivery**. |
| `resultType: "advertisers"` | Automatically enables `screeningMode: true` (1 deterministic summary row per domain). |
| `includeDetails` / `detail` / `politicalAds` / `political` / `maxAdvertisersPerQuery` / `max_advertisers` | Normalized seamlessly into detail enrichment, 7-year political archive, and regional brand expansion. |
| `onlyNewAds` / `monitorStateName` | Persists seen `creativeId`s in `monitorStoreName` so scheduled runs emit `0` duplicates. |
| `downloadAssets` / `downloadPreviews` | Archives creative images to Apify Key-Value Store and emits signed `storedImageUrl` links. |
| `detailConcurrency` / `minDelay` / `maxRequestRetries` | Mapped directly to bounded worker `concurrency` (`1–32`), `requestDelayMs`, and `maxRetries`. |

***

### 5 Copy-Paste JSON Recipes

#### 1. Competitor Search Copy & Unwrapped Landing URLs (Last 30 Days)

Extracts structured `adHeadline`, `adDescription`, `adDisplayUrl`, `adBusinessName`, `adTextLines`, and unwrapped `destinationUrl` from dynamic search ads shown over the last 30 days:

```json
{
  "query": "shopify.com",
  "region": "US",
  "dateRangePreset": "LAST_30_DAYS",
  "includeAdText": true,
  "maxResults": 50
}
```

#### 2. Fast B2B Lead-Gen Ad-Spend Screening

Returns exactly **1 row per domain** (`hasActiveAds`, `approxAdCountLow`/`High`, verified legal entity, `advertisersObserved`, `latestAdShownAt`, `formatsObserved`) — ideal for Clay, HubSpot, Apollo, or outbound lead qualification. Dirty website URLs (`https://www.stripe.com/pricing?utm=1`) and work emails (`ceo@linear.app`, `mailto:ops@vercel.com`) are automatically normalized to clean company domains:

```json
{
  "domains": ["stripe.com", "ceo@linear.app", "https://www.vercel.com/pricing", "figma.com", "notion.so"],
  "screeningMode": true,
  "region": "US"
}
```

#### 3. EU DSA Reach, Audience & Agency `fundedBy` Audit

Expands verified regional entities across all 27 EU member states, sorts by highest EU reach, and extracts `impressionsMin`/`Max`, per-country `regionStats`, `audienceSelection`, `targeting`, `fundedBy` end-payers, and AI/Grants flags:

```json
{
  "query": "Nike",
  "region": "EU",
  "sortBy": "IMPRESSIONS",
  "includeDetails": true,
  "maxResults": 40
}
```

#### 4. Automated Weekly Competitor Watch (`onlyNewAds`)

Pair with an Apify Schedule (weekly or daily cron). Remembers seen `creativeId`s in `monitorStoreName` (`SEEN_CREATIVES`) so recurring runs only emit and bill genuinely new creatives:

```json
{
  "queries": ["stripe.com", "adyen.com"],
  "onlyNewAds": true,
  "monitorStoreName": "payments-competitor-watch",
  "dateRangePreset": "LAST_7_DAYS",
  "includeAdText": true,
  "maxResults": 100
}
```

#### 5. Permanent KVS Image Asset Archiving (`downloadAssets`)

Downloads static ad creative images directly into your default Apify Key-Value Store and attaches permanent signed `storedImageUrl` links alongside original `imageUrl` values:

```json
{
  "query": "shopify.com",
  "format": "IMAGE",
  "downloadAssets": true,
  "maxAssetSizeKb": 10240,
  "maxResults": 50
}
```

***

### Real-Time AI Agents (`/mcp` Standby) & Programmatic API

#### Connect via Streamable HTTP MCP (`/mcp`)

Natively implements **Streamable HTTP MCP (`2025-03-26` / `2025-06-18` / `2024-11-05`)** at `/mcp` with zero cold-start latency and three structured tools:

1. **`search_google_ads`** — Real-time creative & structured copy lookup with `region` (`EU`/`EEA`/ISO), `format`, `platforms`, `sortBy`, `adTextKeyword`, `politicalAds`, and date filters (up to `200` creatives per call).
2. **`check_domains_running_ads`** — Parallel B2B ad-spend signal check across up to `100` domains per call.
3. **`get_google_ad_creative`** — Full A/B variations, optional structured ad copy, EU DSA reach/audience, and intelligence flags for a specific `creativeUrl` or `advertiserId` + `creativeId`.

Add to Claude Code, Cursor, or any MCP client:

```json
{
  "mcpServers": {
    "google-ads-transparency": {
      "type": "http",
      "url": "https://spiky-closet--google-ads-transparency-scraper.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

#### Standby REST Endpoints (`/search` & `/screen`)

- `GET /search?query=shopify.com&region=US&dateRangePreset=LAST_30_DAYS&includeAdText=true&maxResults=25`
- `POST /search` (full JSON input payload, up to `200` creatives per call)
- `POST /screen` (parallel B2B ad-spend check for up to `1,000` domains, URLs, or work emails per call)
- `GET /healthz` (lightweight readiness check)

#### JavaScript (`apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('spiky_closet/google-ads-transparency-scraper').call({
  query: 'shopify.com',
  region: 'EU',
  dateRangePreset: 'LAST_30_DAYS',
  includeDetails: true,
  includeAdText: true,
  maxResults: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python (`apify-client`)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("spiky_closet/google-ads-transparency-scraper").call(run_input={
    "domains": ["stripe.com", "ceo@linear.app", "https://www.vercel.com/pricing"],
    "screeningMode": True,
    "region": "US",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

***

### Transparent `$0`-Start-Fee Pay-Per-Event (PPE) Billing

Unified across Batch runs and Standby (`/mcp`, `/search`, `/screen`) with **zero actor start fee** and **zero billing on empty results**. See the Apify Store **Pricing** tab for current per-tier USD event rates. Free-tier users (`APIFY_USER_IS_PAYING=0`) are safely capped at `80` items per run.

| Event Name | Trigger Condition |
| :--- | :--- |
| `ad-result` | Charged per emitted ad creative record (`0` if target/creative does not exist). |
| `creative-detail` | Charged **only** when `includeDetails: true` enriches variations, EU DSA reach/targeting, and disclosures. |
| `ad-text` | Charged **only** when `includeAdText: true` actually extracts non-empty copy (`adHeadline`, `adDescription`, or `adTextLines`). Static image ads without copy incur `$0` `ad-text` fee. |
| `domain-screen` | Charged per screened domain/company summary row in `screeningMode: true` (`/screen` or `check_domains_running_ads`). |

***

### Output Schema Sample & Platform Transparency Note

#### Creative Search Record (`includeDetails: true`, `includeAdText: true`)

```json
{
  "advertiserId": "AR16951989901585285121",
  "advertiserName": "Stripe, Inc.",
  "advertiserLegalName": "Stripe, Inc.",
  "advertiserCountry": "US",
  "advertiserVerified": true,
  "fundedBy": "Stripe, Inc.",
  "creativeId": "CR15274085619446317057",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16951989901585285121/creative/CR15274085619446317057",
  "format": "TEXT",
  "adVertical": "COMMERCIAL",
  "domain": "stripe.com",
  "destinationUrl": "https://stripe.com/payments",
  "destinationUrlSource": "preview_js",
  "firstShownAt": "2026-02-10T08:15:00Z",
  "lastShownAt": "2026-11-14T22:10:00Z",
  "activeDays": 245,
  "previewType": "script",
  "googleCustomerId": "4771748616",
  "containsSyntheticMedia": false,
  "isGoogleGrantsAccount": false,
  "adTextKind": "search",
  "adHeadline": "Stripe Official Site - Accept Payments Online",
  "adDescription": "Financial infrastructure for the internet. Build global checkout in minutes.",
  "adDisplayUrl": "www.stripe.com/payments",
  "adBusinessName": "Stripe",
  "adTextLines": [
    "www.stripe.com/payments",
    "Stripe Official Site - Accept Payments Online",
    "Financial infrastructure for the internet. Build global checkout in minutes."
  ],
  "variationCount": 1,
  "matchedQuery": "Stripe"
}
```

When `"downloadAssets": true` is enabled on image creatives, `storedImageUrl` is populated alongside the preserved `imageUrl`:

```json
{
  "format": "IMAGE",
  "previewType": "image",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/example",
  "storedImageUrl": "https://api.apify.com/v2/key-value-stores/<STORE_ID>/records/asset-CR15274085619446317057.png?signature=..."
}
```

#### Honest Note on `destinationUrl` vs `domain`

When Google's creative detail payload includes a direct landing page URL, `destinationUrl` is populated automatically (`"destinationUrlSource": "landing_page_rpc"`). For dynamic preview scripts (`displayads-formats.googleusercontent.com/ads/preview/content.js`), enabling `"includeAdText": true` extracts unwrapped click URLs (`"destinationUrlSource": "preview_js"`), `adBusinessName`, `adDisplayUrl`, YouTube video IDs, and structured ad copy when present. For archived static image creatives (`tpc.googlesyndication.com/archive/simgad/...`) where Google's public registry omits click-through paths, `domain` is populated and `destinationUrl` is explicitly `null` (`"destinationUrlSource": "domain_only"`).

***

### FAQ

**Why are `impressionsMin`/`Max`, `regionStats`, and `audienceSelection` populated on EU/EEA ads?**
Under the EU Digital Services Act (DSA), Google publishes impression ranges, per-country reach, surface breakdowns (`platformImpressions`), and targeting category disclosures (`audienceSelection`) for ads served in the 27 EU / 30 EEA countries. Set `"region": "EU"` (or `"EEA"`) and `"includeDetails": true` to retrieve them, or `"politicalAds": true` for US/regional 7-year political spend (`spendMin`/`spendMax`/`spendCurrency`) and explicit demographic/geo targeting.

**Do I need Apify Residential Proxies?**
No. `proxyConfiguration` defaults to `useApifyProxy: false`, and standard runs execute cleanly over direct Go HTTP connections. For ultra-high-volume batch scraping, you can optionally raise `requestDelayMs` (e.g. `100–250 ms`), adjust `maxRetries` (`1–10`), or attach proxy rotation.

**How should I schedule recurring competitor monitoring?**
Enable `"onlyNewAds": true`, assign a unique `"monitorStoreName"` per competitor/watchlist, and pair with a rolling `"dateRangePreset"` (e.g. `"LAST_7_DAYS"`). Seen `creativeId`s are persisted in your named Apify Key-Value Store (`SEEN_CREATIVES`), ensuring recurring cron runs emit `0` duplicates and avoid re-billing previously captured creatives.

**Do Google creative image URLs expire?**
Upstream Google preview links can change or expire over time. Set `"downloadAssets": true` to archive creative images into your default Apify Key-Value Store and emit permanent signed `"storedImageUrl"` links (oversized assets above `maxAssetSizeKb` — default `10,240 KB` / `10 MB` — are safely skipped fail-open while keeping the original `"imageUrl"`).

# Actor input Schema

## `query` (type: `string`):

Single target to extract: e.g. 'stripe.com', 'ceo@stripe.com', 'Stripe', '삼성전자', 'AR16951989901585285121', or a full Google Ads Transparency URL.

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

Optional list of domains, brand names, Advertiser IDs, or Transparency URLs to process in a single run.

## `urlsFromFile` (type: `string`):

Optional multiline, comma-separated, or tab-separated list of company domains, brand names, Advertiser IDs, or Transparency URLs.

## `creativeIds` (type: `array`):

Optional CR... Creative IDs (pair with an AR... Advertiser ID in Target Query) or AR.../CR... shorthand pairs to fetch exact creatives.

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

Real upstream Google GeoTarget filter: ISO-3166-1 alpha-2 code ('US', 'GB', 'DE', 'FR', 'KR', 'JP', 'SD'), regional macro ('EU', 'EEA'), English country name ('Germany', 'United States'), comma-separated list, or 'ANYWHERE' for worldwide.

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

Filter by exact Google Ads creative format enum.

## `platforms` (type: `array`):

Optional server-side Google surface filter. Leave empty for all surfaces.

## `dateRangePreset` (type: `string`):

Convenient rolling date window for manual runs or scheduled cron monitors. Ignored when custom Start/End Dates are set.

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

Optional inclusive start date filter in YYYY-MM-DD format (e.g. '2026-01-01'). Overrides Date Range Preset when set.

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

Optional inclusive end date filter in YYYY-MM-DD format (e.g. '2026-12-31'). Overrides Date Range Preset when set.

## `sortBy` (type: `string`):

Server-side creative sort order. Use IMPRESSIONS in EU/EEA to surface highest-reach ads first, or LAST_ACTIVITY_DATE for newest creatives.

## `adTextKeyword` (type: `string`):

Optional server-side keyword matched against ad copy text.

## `politicalAds` (type: `boolean`):

When true, queries Google's 7-year Political & Election Ads archive (populating spendMin/spendMax/spendCurrency and explicit age/gender/geo targeting).

## `maxResults` (type: `integer`):

Strict global cap across all queries (0 = unlimited for paying users). Guaranteed zero over-delivery.

## `maxAdsPerSearch` (type: `integer`):

Optional per-target creative cap when extracting multiple domains or queries in one batch (0 = governed by global maxResults).

## `maxAdvertisersPerQuery` (type: `integer`):

When searching a brand name (e.g. 'Samsung', 'Nike'), expand up to N verified regional legal entities (1-20).

## `screeningMode` (type: `boolean`):

When true, emits 1 summary row per domain/query with active ad status, approximate ad count range (approxAdCountLow/High), primary verified legal entity, advertisersObserved, country, and latest ad date.

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

Fetches A/B variations, per-country dates, EU DSA & US impression bounds, audience & demographic targeting, adCategory, agency end-payer (fundedBy), AI synthetic-media disclosure (containsSyntheticMedia), and Google Ad Grants status.

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

Extracts structured adHeadline, adDescription, adDisplayUrl, adBusinessName, adTextLines, YouTube video IDs, and unwrapped click URLs from dynamic preview scripts (with variation fallback). Billed via ad-text PPE only when copy is actually extracted.

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

Downloads static ad image assets to your default Apify Key-Value Store (signed storedImageUrl) so assets remain accessible even if upstream links expire.

## `maxAssetSizeKb` (type: `integer`):

Maximum per-asset size in KB when Archiving is enabled (default 10,240 KB = 10 MB; larger assets are safely skipped).

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

Remembers seen creativeIds in a named Key-Value Store across scheduled runs (defaulting sortBy to LAST_ACTIVITY_DATE) so daily/weekly alerts only emit and bill genuinely new creatives.

## `monitorStoreName` (type: `string`):

Named Apify Key-Value Store used when onlyNewAds is enabled (use separate names per monitored competitor).

## `concurrency` (type: `integer`):

Parallel worker goroutines for batch screening and detail enrichment (1-32).

## `requestDelayMs` (type: `integer`):

Optional minimum delay in milliseconds between upstream requests (0 = automatic adaptive pacing; higher values can reduce rate limits on very large batches).

## `maxRetries` (type: `integer`):

Retry attempts on transient HTTP 429 or 5xx responses (1-10).

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

Optional Apify Proxy or custom HTTP/HTTPS proxy rotation for high-volume extraction.

## Actor input object example

```json
{
  "query": "shopify.com",
  "region": "ANYWHERE",
  "format": "ALL",
  "dateRangePreset": "ANYTIME",
  "sortBy": "DEFAULT",
  "politicalAds": false,
  "maxResults": 100,
  "maxAdvertisersPerQuery": 5,
  "screeningMode": false,
  "includeDetails": false,
  "includeAdText": false,
  "downloadAssets": false,
  "maxAssetSizeKb": 10240,
  "onlyNewAds": false,
  "monitorStoreName": "ads-transparency-monitor",
  "concurrency": 8,
  "requestDelayMs": 0,
  "maxRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `adCopy` (type: `string`):

No description

## `euDsaIntel` (type: `string`):

No description

## `screening` (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 = {
    "query": "shopify.com",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("spiky_closet/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 = {
    "query": "shopify.com",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("spiky_closet/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 '{
  "query": "shopify.com",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call spiky_closet/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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