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

Export public Google Ads Transparency Center ad records by advertiser, domain or ID. Filter by country, date, format and platform; request available media and statistics.

- **URL**: https://apify.com/fetch_cat/google-ads-transparency-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Marketing, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 21 total users, 1 monthly users, 93.9% 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/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

Export public Google Ads Transparency Center ad records for advertiser research and creative comparison. This Google Ads Transparency scraper returns advertiser and creative IDs, display dates, snapshot links and available text or media, with optional regional statistics and media downloads.

Search advertiser names, domains or `AR…` IDs in one of 178 supported countries and regions. Results depend on public availability: this is not an ad-spend report or a keyword search across ad copy, and optional fields can be empty.

### Quick start

Paste this bounded input into the form, then start the Actor and open its dataset:

```json
{
  "queries": ["Nike, Inc."],
  "country": "US",
  "maxResultsPerQuery": 5,
  "includeAdDetails": false
}
```

Download the dataset as CSV, Excel or JSON, or retrieve it through the Dataset API. Enable additional details only when the extra fields matter.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Choose a public example to see its settings before starting a run:

- [Google Ads Transparency Advertiser Id Enrichment](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-advertiser-id-enrichment)
- [Google Ads Transparency Video Creative Dataset](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-video-creative-dataset)
- [Google Ads Transparency Airbnb Creatives](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-airbnb-creatives)
- [Google Ads Transparency Nike Ad Library](https://apify.com/fetch_cat/google-ads-transparency-scraper/examples/google-ads-transparency-nike-ad-library)

### What you get

Saved public ad records with advertiser and creative identities, source snapshot links, display dates and available text or media. Optional detail, regional-statistic and media-download work can add fields. Missing impression ranges or media fields remain unknown rather than zero or guaranteed coverage.

### Who is it for?

- **Creative-research teams** reviewing public advertiser messaging and formats.
- **Agencies** preparing source-linked advertiser comparison reports.
- **Advertising researchers** inspecting selected public creative records and dates.
- **Data teams** organizing bounded ad-identity observations and available regional statistics.

### How you can use the data

- **Prepare a Nike creative shortlist.** Use the existing advertiser-name query with US search context and a small per-query cap. Keep advertiserId, adId, snapshotUrl and available text or format fields together for manual creative review.
- **Inspect a known advertiser directly.** Supply a real AR identifier to avoid advertiser suggestions. A creative URL containing that identifier searches the advertiser's ads rather than retrieving only the single linked creative.
- **Review video or regional detail selectively.** Use the existing YouTube/video recipe when useful and enable optional details or published regional statistics deliberately. Preserve impression bounds as ranges, and do not treat requested country context as verified full reach.
- **Compare collected identities with an earlier dataset.** Supply the actual prior dataset as compareDatasetId and inspect CHANGE_SUMMARY, which compares up to 10,000 ad IDs from each dataset. Missing IDs can reflect scan limits, filters or source availability rather than proving that a campaign stopped.

### Input settings

| Setting | JSON key | Purpose |
| --- | --- | --- |
| Advertiser names, domains or URLs | `queries` | Discover advertisers or use an `AR…` ID contained in an advertiser URL. |
| Advertiser IDs | `advertiserIds` | Direct `AR…` IDs. Avoids advertiser suggestion lookup. |
| Country | `country` | Supported country code.  API default `US`. |
| Platforms | `platforms` | `GOOGLE_SEARCH`, `YOUTUBE`, `GOOGLE_SHOPPING`, `GOOGLE_MAPS`, `GOOGLE_PLAY`. |
| Creative formats | `formats` | Optional `text`, `image`, `video` selection. |
| Status | `adStatus` | `all` (default), `active` or `inactive`. Inferred from last-shown date. |
| Date range | `dateFrom`, `dateTo` | Optional `YYYY-MM-DD` overlap boundaries. |
| Saved result limit | `maxResultsPerQuery` | 1–1,000 per query.  API default 20, form prefill 10. |
| Inspection limit | `maxAdsScannedPerQuery` | At least the saved result limit, at most 10,000. Default 500. |
| Baseline dataset | `compareDatasetId` | Optional dataset ID or name for `CHANGE_SUMMARY`. |
| Extra details | `includeAdDetails` | Optional creative details. Default false. |
| Regional statistics | `includeTransparencyStats` | Requests details and published statistics. Default false. |
| Media downloads | `downloadMedia` | Requests details and stores available media. Default false. |
| Connection settings | `proxyConfiguration` | Apify Proxy by default. Supports custom proxies or explicit direct-only access. See field help. |
| Older input aliases | `searchTerms`, `regions`, `adFormats`, `maxItems` | Accepted aliases for advertiser queries, country, formats and saved limit. |

Supply at least one advertiser source for collection. Empty explicit sources are rejected. Omitted sources perform no collection. `queries` and `advertiserIds` can be combined. A creative URL containing an advertiser ID searches that advertiser's ads. It does not request only that creative. Names and domains use advertiser suggestions. Results retain source order rather than promising newest-first sorting.

#### Example input with filters

```json
{
  "queries": ["Nike, Inc."],
  "country": "US",
  "platforms": ["YOUTUBE"],
  "formats": ["video"],
  "adStatus": "all",
  "maxResultsPerQuery": 5,
  "maxAdsScannedPerQuery": 100,
  "includeAdDetails": true
}
```

### Output data

Illustrative shape only, not a captured ad or a promise of field availability:

```json
{
  "query": "Example advertiser",
  "country": "US",
  "advertiserName": null,
  "advertiserId": "AR00000000000000000000",
  "adId": "CR00000000000000000000",
  "adText": null,
  "imageUrls": [],
  "videoUrl": null,
  "landingPageUrl": null,
  "platforms": [],
  "regions": ["US"],
  "adStatus": "unknown",
  "regionStats": [],
  "impressionsLowerBound": null,
  "impressionsUpperBound": null,
  "downloadedMediaKeys": [],
  "mediaAssets": [],
  "detailAvailable": true,
  "firstShownDate": null,
  "lastShownDate": null,
  "format": null
}
```

| Fields | Meaning |
| --- | --- |
| `query`, `country` | Input query and requested market. |
| `advertiserName`, `advertiserId`, `adId` | Available advertiser name and stable source identifiers. |
| `adUrl`, `snapshotUrl`, `creativePageUrl` | Links to the same Google Transparency creative page. |
| `adText`, `headline`, `description` | Available creative text. Headline is derived from its first suitable line and description repeats the extracted text. |
| `imageUrls`, `videoUrl`, `landingPageUrl` | Available media and destination URLs. Not guaranteed for every ad. |
| `platforms`, `regions`, `regionStats` | Selected platform context or published statistics. Without regional statistics, `regions` contains the requested country, not independently verified full reach. |
| `adStatus` | Date-based `active`, `inactive` or `unknown`, not Google's campaign delivery status. |
| `impressionsLowerBound`, `impressionsUpperBound` | Published impression bounds when returned. Null is not zero. |
| `downloadedMediaKeys`, `mediaAssets` | Stored media keys and per-asset download outcomes. |
| `detailAvailable` | False when requested details were unavailable. True also when details were not requested. |
| `firstShownDate`, `lastShownDate` | Available source timestamps in ISO format. |
| `format`, `rawCreativeType`, `scrapedAt` | Interpreted format, source type and collection timestamp. |

The key-value store includes `RUN_SUMMARY` with per-query outcomes and scan/filter counts, and `RUN_CHECKPOINT` after completed queries. Checkpoints describe progress. They do not automatically resume a later run. When requested, `CHANGE_SUMMARY` compares up to 10,000 ad IDs from each dataset. Downloaded media appears in the same key-value store.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

Pay-per-event pricing uses a `start` event once for a collection run after input validation and an `ad` event for each saved ad row. No-result or failed queries and summary records are not saved-ad charges. A collection run can still incur its start event without results.

Current rates and Store discounts are on the [Pricing tab](https://apify.com/fetch_cat/google-ads-transparency-scraper/pricing).

### Tips for best results

- **Start with one advertiser and small saved and scan limits.** Narrow filters can produce fewer results than requested.
- **Use a direct advertiser ID when known.** Name and domain searches use advertiser suggestions, while a full creative URL is not a single-creative lookup.
- **Enable optional detail work only when needed.** Statistics and media downloads can add work without guaranteeing every field.
- **Keep inferred status separate from account delivery status.** It is based on last-shown dates rather than Google's campaign controls.
- **Inspect summary outcomes before interpreting comparisons.** Partial scans or unavailable queries can affect which IDs appear in a saved dataset.

### Limits and caveats

This is public advertiser research rather than ad-copy keyword search, ad-spend reporting, targeting or campaign-account data. The separate political-ad archive is not included. Public access can expose fewer records than a signed-in browser, without Google login or cookies, and the Actor is not affiliated with Google.

Names and domains use advertiser suggestions, while direct AR IDs avoid that lookup. A creative URL containing an advertiser identifier searches that advertiser's ads. Results retain source order rather than a newest-first guarantee. Omitted sources perform no collection, and empty explicit sources are rejected.

Details, published regional statistics and media downloads are optional. Available media can be stored in the key-value store, while files over 25 MiB are not stored. Optional text, media and ranges can be empty. Without published regional statistics, regions contains requested-country context rather than independently verified full reach.

Status is inferred from last-shown dates, not Google's actual campaign-delivery state. DetailAvailable can be true when details were not requested, so it is not proof of successful detail enrichment. Display dates and impression ranges do not establish spend or performance.

Source limits can cause partial or failed queries while already-saved rows remain available. Inspect RUN_SUMMARY scan/filter counts and per-query outcomes. RUN_CHECKPOINT records progress rather than automatic resume. CHANGE_SUMMARY compares at most 10,000 IDs per dataset and does not prove that missing ads or campaigns stopped.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~google-ads-transparency-scraper/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  --data @- <<'JSON'
{
  "queries": [
    "Nike, Inc."
  ],
  "country": "US",
  "maxResultsPerQuery": 5,
  "includeAdDetails": false
}
JSON
```

#### 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."
  ],
  "country": "US",
  "maxResultsPerQuery": 5,
  "includeAdDetails": false
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

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

#### API usage notes

For longer requests use the asynchronous runs endpoint, wait for completion and retrieve `defaultDatasetId`.

#### MCP and AI agents notes

Ask: “Collect up to five public ads for Nike in the US using `queries`, `country` and `maxResultsPerQuery`. Summarize only returned fields and report partial or empty results.” Retrieve dataset rows after the run completes. Do not infer actual campaign spend or complete market coverage from the export.

### MCP and AI agents

You can ask your AI assistant to collect data with **Google Ads Transparency Scraper & Ad Monitor** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **Google Ads Transparency Scraper & Ad Monitor**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

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

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **Google Ads Transparency Scraper & Ad Monitor** by Fetch Cat, or give it the identifier `fetch_cat/google-ads-transparency-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Use Fetch Cat’s Google Ads Transparency Scraper to collect up to 5 records for Nike, Inc. in the US with extra details off. Show advertiser IDs, ad IDs and snapshot links for manual creative research.”
- “Collect at most 3 video creatives for Nike, Inc. using YouTube and video filters with extra details enabled. Show available creative text and media links without inferring spend, targeting or campaign performance.”
- “Retrieve up to 5 ads for the real advertiser AR identifier I provide and compare collected IDs with my actual earlier dataset. Explain missing-ID differences with scan and source limits rather than claiming the campaign stopped.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/google-ads-transparency-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

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

Yes. Open the completed dataset and choose CSV, Excel or JSON, or use the Dataset API.

#### Is this a Google Ads API alternative?

It exports public Transparency Center records, not private Google Ads account reporting, campaign management, spend or demographic targeting.

#### Can I monitor competitor ads?

Run the same bounded input again and optionally compare datasets with `compareDatasetId`. Comparisons cover collected IDs, not guaranteed complete campaign history. The Actor does not create schedules or automatically select a baseline.

#### Why are some fields empty or no ads returned?

Check the advertiser, requested country and filters. Public source availability varies, and details or statistics may not be published. Empty optional fields are not zero values. Review the per-query summary for no matches, incomplete work or failures.

### Related Actors

- [Bing Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper) — Compare public search visibility.
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper) — Research brand news alongside creatives.
- [Google Trending Searches Scraper](https://apify.com/fetch_cat/google-trending-searches-scraper) — Collect current country-level trending topics with traffic labels and available news context.
- [Google Shopping Results Scraper](https://apify.com/fetch_cat/google-shopping-results-scraper) — Compare publicly listed products.
- [Website Content Crawler Lite](https://apify.com/fetch_cat/website-content-crawler-lite) — Analyze public landing-page content separately.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/google-ads-transparency-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review](https://apify.com/fetch_cat/google-ads-transparency-scraper/reviews) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

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

# Actor input Schema

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

Enter advertiser or brand names, domains, Google advertiser IDs beginning with AR, or advertiser URLs from Google Ads Transparency Center. Names and domains use advertiser suggestions; URLs containing an AR ID search that advertiser's ads, not one exact creative. This is advertiser discovery, not an ad-copy keyword search.

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

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

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

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

## `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.

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

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

## `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.

## `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.

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

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

## `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`):

Apify Proxy is enabled by default and used from the first Google request when initialization succeeds. Keep the default, select your own proxy URLs or groups, or disable Apify Proxy with no custom URLs for direct-only access. Explicit saved-task/API settings are preserved; omission enables the same existing managed configuration. Country defaults to the search country; initialization can retry without the country restriction. Retries use the configured proxy product without automatic residential escalation. Invalid settings are rejected before collection and charging, not converted into a managed default. If proxy initialization is unavailable, requests use direct access only. Proxy traffic can incur platform usage. Never share proxy credentials in support requests.

## Actor input object example

```json
{
  "queries": [
    "Nike, Inc."
  ],
  "advertiserIds": [],
  "country": "US",
  "adStatus": "all",
  "maxResultsPerQuery": 10,
  "platforms": [],
  "formats": [],
  "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(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 '{
  "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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/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/8KTWmX4xqvRRmkDeo/builds/iRBfhgg38BzJmPFf5/openapi.json