# Google Ads Transparency Scraper & Ad Monitor (`fetch_cat/google-ads-transparency-scraper`) Actor

Export Google Ads Transparency Center creatives across 178 regions. Filter by advertiser, domain, keyword, date, status, format, and platform; download available media.

- **URL**: https://apify.com/fetch\_cat/google-ads-transparency-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Marketing, Lead generation, Automation
- **Stats:** 4 total users, 1 monthly users, 89.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 ad extracteds

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

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 Transparency Scraper & Ad Monitor

Export and monitor public Google Ads Transparency Center creatives across 178 countries and regions, with format, platform, status, and date filters plus downloadable media when Google exposes it.

Use this actor when you need a repeatable CSV, JSON, Excel, or API export of public ad records for competitor research, creative monitoring, market analysis, ad intelligence, or AI-agent workflows.

### At a glance

- **Input:** Advertiser names, brand names, domains, direct `AR…` advertiser IDs, or Transparency Center advertiser URLs.
- **Output:** Advertiser, creative, status, format, platform, dates, media, regional impression ranges, and scrape time.
- **Filters:** 178 countries and regions, Google platform, creative format, active or historical status, date range, and result limit.
- **Best for:** Google Ads Transparency exports, competitor ad monitoring, creative research, and ad-library workflows.
- **No login required:** Uses public Google Ads Transparency Center data.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Monitor Nike Google Search ads](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-nike-ad-library)**
- **[Build a YouTube video creative dataset](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-video-creative-dataset)**
- **[Download an image creative swipe file](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-image-creative-dataset)**
- **[Research ads in an expanded country market](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-country-comparison)**
- **[Collect advertiser transparency statistics](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-advertiser-id-enrichment)**
- **[Monitor Google ad creatives on a schedule](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-weekly-new-creatives)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples)** (38 examples)

### What can it do?

- **Export Google ads transparency data:** Save public ad records from Google Ads Transparency Center.
- **Collect advertiser context:** Capture advertiser names, IDs, regions, and ad dates when available.
- **Inspect creatives:** Save ad text, headlines, descriptions, images, videos, landing pages, and snapshot URLs when exposed.
- **Filter by Google platform and format:** Narrow results to Search, YouTube, Shopping, Maps, Play, text, image, or video creatives.
- **Preserve creative assets:** Optionally download exposed image and video files to the run key-value store.
- **Analyze transparency statistics:** Collect published regional dates, impression ranges, and platform breakdowns where available.
- **Detect campaign changes:** Compare this run with a previous dataset and get new, removed, and unchanged ad IDs.
- **Understand filtered runs:** Use per-query scanned, filtered, duplicate, detail, and scan-limit diagnostics.
- **Track competitors:** Schedule repeat runs for the same brands or keywords.
- **Use as a Google Ads Transparency API alternative:** Run from the Apify UI, API, schedules, webhooks, or the official Apify MCP server.

### Common workflows

- **Competitor ad research:** Export ads for a brand and compare active creative themes.
- **Creative swipe files:** Save image, video, headline, and landing-page fields for review.
- **Market monitoring:** Track public ad activity by country and date range.
- **Landing-page analysis:** Export ad landing pages for downstream crawling or classification.
- **AI-agent briefings:** Let an agent collect public ad examples before summarizing messaging patterns.

### Input example

```json
{
  "queries": ["Nike, Inc.", "adidas.com", "AR16735076323512287233"],
  "country": "US",
  "platforms": ["GOOGLE_SEARCH", "YOUTUBE"],
  "formats": ["text", "video"],
  "adStatus": "active",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-07-01",
  "maxResultsPerQuery": 20,
  "maxAdsScannedPerQuery": 500,
  "compareDatasetId": "OPTIONAL_PREVIOUS_DATASET_ID",
  "includeAdDetails": true,
  "includeTransparencyStats": true,
  "downloadMedia": false,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

### Output example

```json
{
  "query": "Nike, Inc.",
  "country": "US",
  "advertiserName": "Nike, Inc.",
  "advertiserId": "AR123456789",
  "adId": "CR987654321",
  "adUrl": "https://adstransparency.google.com/advertiser/...",
  "adText": "Shop the latest running shoes.",
  "headline": "Nike Running Shoes",
  "description": "Performance styles for every run.",
  "imageUrls": ["https://tpc.googlesyndication.com/..."],
  "videoUrl": null,
  "landingPageUrl": "https://www.nike.com/",
  "platforms": ["Google Search"],
  "regions": ["US"],
  "adStatus": "active",
  "impressionsLowerBound": 1000,
  "impressionsUpperBound": 2000,
  "regionStats": [],
  "downloadedMediaKeys": [],
  "firstShownDate": "2026-06-10",
  "lastShownDate": "2026-07-01",
  "snapshotUrl": "https://adstransparency.google.com/advertiser/...",
  "creativePageUrl": "https://adstransparency.google.com/creative/...",
  "format": "text",
  "rawCreativeType": 2,
  "scrapedAt": "2026-07-03T10:00:00.000Z"
}
```

### Input configuration

| Setting | JSON key | What to enter |
| --- | --- | --- |
| Advertisers, domains, keywords, IDs, or URLs | `queries` | Brand names, domains, direct `AR…` advertiser IDs, or Transparency Center advertiser URLs. |
| Direct advertiser IDs | `advertiserIds` | Optional `AR…` IDs that skip advertiser suggestion lookup. |
| Legacy search terms | `searchTerms` | Compatibility alias for `queries`; retained for older tasks and API clients. |
| Legacy region | `regions` | Compatibility alias for `country`; the first country code is used. |
| Legacy creative formats | `adFormats` | Compatibility alias for `formats`. |
| Country | `country` | Choose one of 178 supported countries and regions in the input form. Unsupported codes are rejected. |
| Google platforms | `platforms` | Optional Google Search, YouTube, Shopping, Maps, or Play filters. |
| Creative formats | `formats` | Optional text, image, or video filters. |
| Ad status | `adStatus` | Save all, active, or inactive/historical ads based on the public last-shown date. |
| First date | `dateFrom` | Optional ISO date; ads last shown before this date are skipped. |
| Last date | `dateTo` | Optional ISO date; ads first shown after this date are skipped. |
| Maximum ads per query | `maxResultsPerQuery` | Maximum ad records to save for each query. |
| Legacy maximum ads | `maxItems` | Compatibility alias for `maxResultsPerQuery`. |
| Maximum ads scanned per query | `maxAdsScannedPerQuery` | Safety limit for narrow filters; partial matches are preserved when reached. |
| Baseline dataset ID | `compareDatasetId` | Optional previous dataset used to create `CHANGE_SUMMARY`. |
| Include ad details | `includeAdDetails` | Fetch extra creative details and media. Disabled by default for faster, more reliable runs. |
| Include transparency statistics | `includeTransparencyStats` | Fetch published regional impression ranges and platform breakdowns where available. |
| Download creative media | `downloadMedia` | Store exposed image/video assets in the key-value store and return their record keys. |
| Proxy configuration | `proxyConfiguration` | Apify Proxy is used only when a direct Google request fails. |

### Output fields

| Field | Description |
| --- | --- |
| `query`, `country` | Search term and requested country. |
| `advertiserName`, `advertiserId` | Advertiser information returned by Google. |
| `adId`, `adUrl`, `creativePageUrl`, `snapshotUrl` | Ad identifiers and Google Transparency URLs. |
| `adText`, `headline`, `description` | Text fields extracted from the ad record or detail page. |
| `imageUrls`, `videoUrl`, `landingPageUrl` | Creative media and destination fields when exposed. |
| `platforms`, `regions`, `regionStats` | Platform and regional context, including published impression breakdowns when available. |
| `adStatus` | Active, inactive, or unknown based on the public last-shown date. |
| `impressionsLowerBound`, `impressionsUpperBound` | Google's published impression range when available. |
| `downloadedMediaKeys` | Key-value store records created when media downloading is enabled. |
| `mediaAssets`, `detailAvailable` | Media URLs with download outcomes, plus whether requested creative detail was available. |
| `firstShownDate`, `lastShownDate` | Public ad display dates when available. |
| `format`, `rawCreativeType`, `scrapedAt` | Creative format, raw source type, and scrape timestamp. |

The default key-value store contains `RUN_SUMMARY`, including pages fetched, ads scanned, filter counts, duplicates, missing details, partial-result notices, connection diagnostics, shared rate-limit wait time, and any compatibility aliases applied. It also stores `RUN_CHECKPOINT` after each completed query so completed work and remaining queries are visible if a large run is interrupted. When `compareDatasetId` is provided, it contains `CHANGE_SUMMARY` with new, removed, and unchanged ad IDs.

### Pricing

This Actor uses pay-per-event pricing: one small start fee, then a charge for each public ad successfully saved to the dataset.

| Event | When it is charged | Price |
| --- | --- | ---: |
| `start` | Once when the run starts | `$0.005` per run |
| `ad` | Each time an ad record is saved | Depends on your Store tier below |

#### Price per saved ad

| Apify Store tier | Price per ad | Approx. price per 1,000 ads |
| --- | ---: | ---: |
| Free | `$0.000045555` | 0.045555 USD |
| Starter / Bronze | `$0.000039613` | 0.039613 USD |
| Scale / Silver | `$0.000030898` | 0.030898 USD |
| Business / Gold | `$0.000023768` | 0.023768 USD |
| Custom / Platinum | `$0.000015845` | 0.015845 USD |
| Custom / Diamond | `$0.000011092` | 0.011092 USD |

For example, a Free-tier run that saves 1,000 ads costs about `$0.050555` in Actor charges: `$0.005` to start plus `$0.045555` for the saved ads.

Only saved ad dataset rows trigger the `ad` event. No-result queries, failed queries, and the `RUN_SUMMARY` record are not charged as ads. Apify platform usage for compute, storage, proxies, or data transfer may be billed separately; check the run's Pricing tab for the final amount.

### Tips for best results

- Use a direct `AR…` advertiser ID for repeat monitoring; it skips the advertiser suggestion step.
- Search exact advertiser names when possible, and try both brand names and domains if the first query returns sparse results.
- Use country filters deliberately; the same advertiser can show different ads by region.
- Leave detail, statistics, and media downloading off for fast discovery runs. Enable them only when the richer fields matter.
- Platform-filtered Google results cover ads shown from September 4, 2023 onward.
- Use date filters to narrow recurring monitoring jobs.
- For scheduled monitoring, pass the previous run's dataset ID as `compareDatasetId` to receive a machine-readable change summary.
- Keep `maxAdsScannedPerQuery` close to your expected workload when using narrow combinations such as active video ads.

### Limits and caveats

- The actor exports public Google Ads Transparency Center data. It is not an official Google API.
- Some ads expose only partial creative details.
- Narrow post-filters can return fewer rows than `maxResultsPerQuery`; check `RUN_SUMMARY.queryResults[].diagnostics` to see why.
- Impression ranges and platform breakdowns are available only where Google publishes extra transparency data; empty values do not mean zero impressions.
- This Actor searches the general Ads Transparency Center. Google's separate political-ad archive, demographic targeting, and spend reports are not included.
- Logged-out public access can return fewer ads than a signed-in Google session, especially for restricted creatives.
- Google can temporarily rate-limit bursts across separate runs. The Actor paces the next run in proportion to the preceding run's RPC volume. Retries then escalate from direct access to standard proxy rotation and, when you did not choose a custom proxy group, a target-country residential fallback. If all transport tiers remain blocked, the cooldown is extended. `RUN_SUMMARY.transport` reports residential attempts and wait time; no input or result data is stored in the anonymous account-level coordination record. Residential proxy traffic can add Apify platform proxy charges.
- A temporary block that outlasts the bounded run budget, or a source change, can still cause a query to fail. Other queries continue, and `RUN_SUMMARY` records each outcome.
- Older API clients can continue using `searchTerms`, `regions`, `adFormats`, and `maxItems`; new clients should use the primary field names shown above.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-ads-transparency-scraper').call({
  queries: ['Nike, Inc.', 'AR16735076323512287233'],
  country: 'US',
  maxResultsPerQuery: 20,
  includeAdDetails: false
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-ads-transparency-scraper').call(run_input={
    'queries': ['Nike, Inc.', 'AR16735076323512287233'],
    'country': 'US',
    'maxResultsPerQuery': 20,
    'includeAdDetails': False,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~google-ads-transparency-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["Nike, Inc."],
    "country": "US",
    "maxResultsPerQuery": 20,
    "includeAdDetails": false
  }'
```

### MCP and AI agents

You can run this actor through the official Apify MCP server at `https://mcp.apify.com`.

Claude Code setup:

```bash
claude mcp add apify "https://mcp.apify.com?tools=fetch_cat/google-ads-transparency-scraper"
```

Claude Desktop, Cursor, or VS Code JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/google-ads-transparency-scraper"
    }
  }
}
```

Agent-friendly inputs are `queries`, `advertiserIds`, `country`, `platforms`, `formats`, `adStatus`, `dateFrom`, `dateTo`, `maxResultsPerQuery`, `maxAdsScannedPerQuery`, `compareDatasetId`, `includeAdDetails`, `includeTransparencyStats`, `downloadMedia`, and `proxyConfiguration`.

Example prompts:

- "Export the latest public Google ads for Nike in the United States."
- "Use this Google advertiser ID and return 20 ad creatives without detail enrichment."
- "Compare public ad dates and formats for these three competitor domains."

### FAQ

**Can I export Google Ads Transparency data to CSV or Excel?**

Yes. Download the Apify dataset as CSV, Excel, JSON, XML, RSS, or through the Dataset API.

**Can I monitor competitor ads?**

Yes. Schedule repeat runs for the same advertiser, domain, or brand queries.

**Does it include landing pages and media?**

When Google exposes them and detail fetching is enabled, rows can include landing page URLs, image URLs, video URLs, regional impression ranges, and platform breakdowns. Enable `downloadMedia` to preserve exposed image and video files in the run key-value store.

**Why did a query return no ads?**

Check the advertiser in a logged-out browser session, try the exact advertiser name or domain, use another supported country, or use a direct `AR…` advertiser ID. Restricted ads may only be visible while signed in to Google.

**Is this an official Google API?**

No. It exports public data from Google Ads Transparency Center.

### Related actors

- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Google Trending Searches Scraper](https://apify.com/fetch_cat/google-trending-searches-scraper)
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper)
- [Website Content Crawler Lite](https://apify.com/fetch_cat/website-content-crawler-lite)

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses search/query inputs and public search, trend, app, patent, news, or profile results to produce the output dataset and sends requests to public Google Ads Transparency pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

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

Enter advertiser or brand names, domains, Google advertiser IDs beginning with AR, or advertiser/creative URLs from Google Ads Transparency Center. Domains skip advertiser lookup; exact creative URLs skip search and pagination.

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

Optional Google advertiser IDs beginning with AR. Direct IDs skip advertiser suggestion lookup and are best for repeat monitoring.

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

Backward-compatible alias for queries used by older tasks and API integrations. New integrations should use queries.

## `regions` (type: `array`):

Backward-compatible alias for country. The first two-letter country code is used when country is not explicitly set.

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

Backward-compatible alias for formats. Accepts text, image, and video.

## `country` (type: `string`):

Country used for the public Google Ads Transparency search. Unsupported codes are rejected instead of silently using another country.

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

Only return ads shown on the selected Google platforms. Platform-filtered results cover ads shown from September 4, 2023 onward.

## `formats` (type: `array`):

Only save creatives matching the selected formats.

## `adStatus` (type: `string`):

Save all ads, active ads whose last-shown date is today or later, or inactive historical ads.

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

Optional date in YYYY-MM-DD format. Ads last shown before this date are skipped.

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

Optional date in YYYY-MM-DD format. Ads first shown after this date are skipped.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of ad records to save for each query or advertiser ID.

## `maxItems` (type: `integer`):

Backward-compatible alias for maxResultsPerQuery used by older tasks and API integrations.

## `maxAdsScannedPerQuery` (type: `integer`):

Safety limit for ads inspected while applying format, status, or date filters. A query returns partial results instead of scanning indefinitely.

## `compareDatasetId` (type: `string`):

Optional previous dataset (ID or name) to compare with this run. The Actor writes new, removed, and unchanged ad IDs to CHANGE\_SUMMARY.

## `includeAdDetails` (type: `boolean`):

Fetch extra creative details and media. Leave disabled for faster, more reliable discovery runs; enable when detail fields are important.

## `includeTransparencyStats` (type: `boolean`):

Fetch detailed regions, impression ranges, and platform breakdowns where Google publishes them. Availability varies by country and ad.

## `downloadMedia` (type: `boolean`):

Save exposed image and video files to the run key-value store and return their record keys. This automatically fetches ad details.

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

Uses the exact proxy configuration supplied here as the primary Google connection. Search country is controlled separately by the country input; proxy geography is applied only when you explicitly select it. Disable Apify Proxy to use direct connections only.

## Actor input object example

```json
{
  "queries": [
    "Nike, Inc."
  ],
  "advertiserIds": [],
  "country": "US",
  "platforms": [],
  "formats": [],
  "adStatus": "all",
  "maxResultsPerQuery": 10,
  "maxAdsScannedPerQuery": 20,
  "includeAdDetails": false,
  "includeTransparencyStats": false,
  "downloadMedia": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `runSummary` (type: `string`):

No description

## `changeSummary` (type: `string`):

No description

## `runCheckpoint` (type: `string`):

No description

## `overview` (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": [
        "Nike, Inc."
    ],
    "advertiserIds": [],
    "country": "US",
    "maxResultsPerQuery": 10,
    "maxAdsScannedPerQuery": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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": ["Nike, Inc."],
    "advertiserIds": [],
    "country": "US",
    "maxResultsPerQuery": 10,
    "maxAdsScannedPerQuery": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-ads-transparency-scraper").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 '{
  "queries": [
    "Nike, Inc."
  ],
  "advertiserIds": [],
  "country": "US",
  "maxResultsPerQuery": 10,
  "maxAdsScannedPerQuery": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fetch_cat/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/8KTWmX4xqvRRmkDeo/builds/pkwhRdJ18ZQ5ffeMc/openapi.json