# Google Ads Transparency Scraper: Advertisers, Ads & Creatives (`fairfetch/google-ads-transparency-scraper`) Actor

Scrape every ad an advertiser runs on Google from the Ads Transparency Center: search by brand name, advertiser ID or domain, filter by country, date, format and platform. Get ad images, YouTube links, first/last shown dates, regions, EU reach and ad text where Google shows it. $1 per 1,000 ads.

- **URL**: https://apify.com/fairfetch/google-ads-transparency-scraper.md
- **Developed by:** [Naveen Raja](https://apify.com/fairfetch) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ads

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Ads Transparency Scraper: Advertisers, Ads & Creatives

Export **every ad an advertiser runs on Google** (Search, YouTube, Shopping, Maps, Play and the Display network) from the public **Google Ads Transparency Center**. Search by **brand name, advertiser ID or website domain**, filter by **country, date range, ad format and platform**, and get one clean JSON row per ad: format, first and last shown dates, days shown, regions, a **picture of every ad**, **YouTube video links**, variations, the **ad text where Google renders it**, and for ads shown in the EU / EEA and Türkiye the **number of times shown, topic and audience selection**.

No login, no browser, no Google account: the Actor talks to the same JSON API that adstransparency.google.com uses. Apify's residential proxy is on by default (included in the price) because Google blocks IPs that send many requests.

**Price: $1 per 1,000 ads** ($0.001 per ad). Details, ad text and video links are included, not extra events. No subscription, no usage fees.

### What you get

- **Advertiser**: `advertiserId` (AR...), `advertiserName` (the display name, the same on every row of an advertiser), `advertiserVerified` (Google's "Advertiser has verified their identity" badge), `advertiserLegalName` (the legal name Google shows for verified advertisers, e.g. "Booking.com B.V." for "Booking.com"), `advertiserCountry`.
- **Ad**: `creativeId` (CR...), `format` (`text` / `image` / `video`, Google's own classification), `adUrl` (the ad's page on the Transparency Center), `firstShown`, `lastShown`, `daysShown`.
- **Creative content**: `previewImageUrl` (static creative, archived picture of text ads, product image or video thumbnail), `imageUrls`, `videoUrl` + `youtubeVideoId` for most video ads (not when Google's preview carries no video ID, as for some YouTube home-feed ads shown as an image), `html5Url`, `previewUrl`, all `variations` with sizes, and `adText` / `adTexts` (headline, description, product title, call to action) when Google renders the ad from its preview service. That is about **1 ad in 10**: since 2025 Google shows most text ads only as a picture (`previewImageUrl`).
- **Where and when**: `regions` (every country the ad ran in) and `regionStats` with the last shown date per country, and the first shown date for EU / EEA and Türkiye regions (Google gives it only there and in a few other regions).
- **EU / Türkiye transparency data** (Digital Services Act): `impressionsEuMin` / `impressionsEuMax` and `impressionsEuByPlatform` (times shown in all EU / EEA and Türkiye regions together), per country in `regionStats`, and for the **Region** you filter on in `impressionsMin` / `impressionsMax` / `impressionsByPlatform`. Plus `topic` and `audienceSelection` (demographics, locations, contextual signals: included / excluded / not used).
- **Grouping IDs** from the preview: `googleCustomerId` (ad account), `adGroupId`, `googleCreativeId`. Group ads by account or campaign.
- Built for automation and AI agents: the same fields on every row, pay-per-event pricing without usage fees, limited permissions, a machine-readable `SUMMARY` record, and a clean stop when your spending limit or the run timeout is reached.

### Use cases

- **Competitor ad research**: see every ad a competitor runs right now, on which platforms and in which countries, and how long each has been live (`daysShown` is a strong "this ad works" signal).
- **Creative inspiration and swipe files**: collect image, video and search ads of the best advertisers in your niche, with direct image and YouTube links.
- **Political and brand monitoring**: watch when an advertiser launches or stops ads in a country, track ads that point to your domain (brand abuse, affiliates, resellers), archive ads for compliance.
- **Agencies**: audit a prospect's live ads before a pitch, report on clients' competitors every week, check which regions and formats a market leader uses.
- **Lead generation**: find out which companies actively advertise on Google and roughly how many ads they run.
- **AI agents and LLM apps**: give an agent a reliable tool to answer "What YouTube ads is Nike running in Germany?" with structured data.

### How to use

1. Add entries to **Advertisers, domains or URLs** (one per line):
   - an advertiser **name** (`Nike`): the advertiser with the closest name and the most ads is used (its name and ID are in every row and in the run summary),
   - an advertiser **ID** (`AR16735076323512287233`, from the advertiser's Transparency Center URL),
   - a **domain** (`booking.com`): ads that lead to this website, from any advertiser,
   - a **Transparency Center URL**: an advertiser page, a single ad page or a domain search.
     Force a type with a prefix when a name looks like a domain: `name:Booking.com`, `domain:booking.com`, `id:AR...`.
2. Optional filters: **Region**, **Shown from / until** (a date or "30 days"), **Ad format**, **Google platform**.
3. Set **Max ads per advertiser** (most recently shown first; 0 = no limit). Each entry returns up to that many ads that no other entry of the run returned, so two entries for the same advertiser (its name and its ID, or a brand and its domain) can return up to twice as many different ads; each ad is returned and charged once. For more than about 9,000 ads, raise **Timeout** in the run options (see [Speed and limits](#speed-and-limits)).
4. Keep **Include ad details** and **Extract ad text, images and video links** on for the richest data, or switch them off for the fastest listing.
5. Run the Actor and download the results as JSON, CSV or Excel, or read them via API. A per-input summary (status, ads returned, errors, and the advertisers of the returned ads) is saved as the `SUMMARY` record in the run's key-value store.

### Input examples

The latest 50 YouTube ads of Nike in Germany, with times shown in Germany and in the EU:

```json
{
  "advertisers": ["Nike"],
  "region": "DE",
  "platform": "youtube",
  "maxAdsPerAdvertiser": 50
}
```

Two competitors by ID plus every advertiser whose ads lead to a domain, shown in the last 30 days:

```json
{
  "advertisers": ["AR16735076323512287233", "AR02934798844673654785", "booking.com"],
  "dateFrom": "30 days",
  "maxAdsPerAdvertiser": 200
}
```

A fast inventory (no details, no ad text): 2,000 ads of one advertiser in about a minute:

```json
{
  "advertisers": ["AR02934798844673654785"],
  "maxAdsPerAdvertiser": 2000,
  "includeDetails": false,
  "decodePreviews": false
}
```

### Output example

Two rows from cloud runs on 18 Oct 2026 (trimmed: `variations`, `previewUrl` and most regions left out). A Booking.com video ad with the **Region** filter set to Germany:

```json
{
  "advertiserId": "AR02934798844673654785",
  "advertiserName": "Booking.com",
  "advertiserLegalName": "Booking.com B.V.",
  "advertiserCountry": "NL",
  "advertiserVerified": true,
  "creativeId": "CR10972321219872817153",
  "format": "video",
  "adUrl": "https://adstransparency.google.com/advertiser/AR02934798844673654785/creative/CR10972321219872817153?region=DE",
  "firstShown": "2024-09-05T12:09:56Z",
  "lastShown": "2026-10-18T20:37:51Z",
  "daysShown": 774,
  "previewImageUrl": "https://i.ytimg.com/vi/EBibnSGOZ5c/hqdefault.jpg",
  "videoUrl": "https://www.youtube.com/watch?v=EBibnSGOZ5c",
  "youtubeVideoId": "EBibnSGOZ5c",
  "adText": null,
  "variationCount": 4,
  "regionStats": [
    {
      "region": "DE",
      "regionName": "Germany",
      "firstShown": "2024-09-05",
      "lastShown": "2026-10-13",
      "impressionsMin": 2000,
      "impressionsMax": 3000,
      "impressionsByPlatform": [
        {"platform": "youtube", "impressionsMin": 0, "impressionsMax": 1000},
        {"platform": "google_search", "impressionsMin": 1000, "impressionsMax": 2000}
      ]
    }
  ],
  "impressionsMin": 2000,
  "impressionsMax": 3000,
  "impressionsEuMin": 10000000,
  "impressionsEuMax": null,
  "topic": null,
  "audienceSelection": {"demographics": "included", "locations": "included_and_excluded", "contextualSignals": "included_and_excluded"},
  "searchInput": "AR02934798844673654785",
  "regionFilter": "DE",
  "detailsIncluded": true
}
```

`impressionsEuMax` is null because Google shows this ad's EU total as "10M+" (no upper bound). A Nike search ad whose text Google renders (no region filter, shown only in the US, so no EU numbers):

```json
{
  "advertiserName": "Nike, Inc.",
  "advertiserLegalName": "Nike, Inc.",
  "advertiserVerified": true,
  "creativeId": "CR07944289166462812161",
  "format": "text",
  "firstShown": "2023-11-16T22:06:39Z",
  "lastShown": "2026-10-18T20:34:26Z",
  "daysShown": 856,
  "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/16766497924704493925",
  "adText": "Nike | nike.com | Nike® Just Do It | Paramus | 810 Bergen Town Center Suite 37 | Be comfortable and confident in what you wear. Long sleeve shirts made to move with you. | Central Valley · 600 Race Track Lane",
  "regions": ["US"],
  "impressionsMin": null,
  "impressionsEuMin": null
}
```

### Filters

| Filter | Values | Notes |
|---|---|---|
| Region | 243 countries and territories, or anywhere | Only ads shown in that country. `impressionsMin/Max` then hold the times shown in that country; Google publishes them only for EU / EEA countries and Türkiye, so for other countries they stay empty. The EU / EEA + Türkiye total is always in `impressionsEuMin/Max`. |
| Shown from / until | `2026-01-31`, `30 days`, `6 months` | Ads shown in the period. Dates are in US Pacific time, like on the website. |
| Ad format | all, text, image, video | Google's own format classification. |
| Google platform | Search, YouTube, Shopping, Maps, Play | Google records platforms for ads shown since 4 Sep 2023; older ads are left out when a platform is selected. |

A **single ad URL** (`/advertiser/AR.../creative/CR...`) always returns that ad: the filters above don't apply to it, and `firstShown` / `daysShown` stay empty because the ad page doesn't have them (`regionStats` has per-region dates).

### Pricing

Pay per event, no subscription and no extra usage fees:

| Event | Price |
|---|---|
| `ad`: one ad in the dataset, with details, ad text and video links | **$0.001** ($1 per 1,000 ads) |
| Actor start (standard Apify event, per GB of memory: one at the default 256 MB) | $0.00005 |

Examples:

- **100 ads = $0.10**: the latest 100 ads of one competitor.
- **1,000 ads = $1.00**: ten competitors, 100 ads each.
- **10,000 ads = $10**: a large advertiser's recent ads (about an hour with details: set the run timeout to 2 hours).

Apify platform costs (compute, proxy, storage) are included. Inputs that fail (unknown name, no ads), ads whose details Google doesn't return, and the `SUMMARY` record are free. Set **Maximum cost per run** in the run options (or `maxTotalChargeUsd` via API) to cap spending; the Actor stops cleanly at the cap, never fetches details for ads it can't charge, and everything returned up to that point is in the dataset.

### Use it from the API, an app or an AI agent

Run synchronously and get the ads in one call (keep your own API token in the `APIFY_TOKEN` environment variable):

```bash
curl -X POST "https://api.apify.com/v2/acts/fairfetch~google-ads-transparency-scraper/run-sync-get-dataset-items?maxTotalChargeUsd=0.20" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"advertisers": ["Nike"], "region": "DE", "adFormat": "video", "maxAdsPerAdvertiser": 50}'
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("fairfetch/google-ads-transparency-scraper").call(
    run_input={"advertisers": ["booking.com"], "dateFrom": "30 days", "maxAdsPerAdvertiser": 200}
)
for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(ad["format"], ad["lastShown"], ad["advertiserName"], ad["videoUrl"] or ad["previewImageUrl"])
```

The Actor runs with limited permissions and pay-per-event pricing without usage fees, so AI agents can call it through the Apify MCP server and pay per run.

### Speed and limits

Measured on Apify with the default settings (residential proxy, 256 MB):

| Settings | Speed | Example |
|---|---|---|
| Details and ad text on (default) | about 2.7 ads per second, **1,000 ads in about 6 minutes** | 150 ads in 55 s |
| Details and ad text off | about 40 ads per second | 500 ads in 11 s |

Advertisers with many video or rendered ads need one preview download per ad. When Google throttles those downloads, the Actor switches them to another route (see the proxy FAQ), which can make such runs up to about twice as slow (150 Spotify ads: 67-77 s normally, 115 s while throttled).

- Apify's default run timeout is 1 hour, which fits about **9,000 ads with details**. For bigger exports raise **Timeout** in the run options (2 hours for 10,000-15,000 ads). If the timeout comes first, the Actor stops starting new ads **25 seconds before it** (batches are sized to the time left at the speed the run measures), cancels requests still running 15 seconds before it (those ads are not charged), keeps every ad returned so far, writes the `SUMMARY` record and says so in the run status; the run still succeeds.
- **Use a run timeout of at least 60 seconds.** In 60-second test runs the Actor returned 62-86 ads with details and ended as succeeded well before the timeout. With a shorter timeout there is little or no time left for ads after start-up and those 25 seconds, so the run returns few or no ads (still as succeeded, with the reason in the status).
- **Max ads per advertiser** goes up to 50,000 per entry. Some advertisers have millions of ads (Google shows "~15.5m ads" for Booking.com), so use the filters (region, dates, format, platform) to get the ads you need.
- Google publishes "times shown", topic and audience selection only for ads shown in the EU / EEA and Türkiye (and for political ads).

### FAQ

**Do I need a Google account or API key?**
No. The Actor reads the public Ads Transparency Center, the same data every visitor can see.

**How do I find an advertiser ID?**
Search the advertiser on adstransparency.google.com; the ID is the `AR...` part of the page URL. Or just enter the name: the rows and the run summary show the advertiser that was used and its ID.

**Why does a name return a different company than I expected?**
Names are matched with Google's own advertiser search. The Actor picks the closest name with the most ads (for "Nike": Nike, Inc. with about 10,000 ads, not a small reseller called "Nike"). To see the other advertisers with that name, search it on adstransparency.google.com and enter the ID of the one you want, or raise **Advertisers per name**.

**What if I enter the same advertiser twice?**
For example its name and its ID, or a brand and its domain. Each entry returns up to **Max ads per advertiser** ads that no other entry of the run returned, so together they can return up to twice as many different ads. No ad is returned or charged twice.

**What does a domain search return?**
Ads that lead to that website, from every advertiser, including resellers, affiliates and partners. That's useful for brand monitoring. Use the advertiser name or ID if you only want the brand's own ads.

**Why do most ads have no `adText`?**
Since 2025 Google shows most text ads as a static picture (a screenshot of the ad), so their content is in `previewImageUrl` rather than as text. Text appears only for ads that Google still renders from its preview service: in our test runs about 1 ad in 10, varying a lot by advertiser. Most video ads get their YouTube link this way too. Some don't: Google previews certain YouTube home-feed ads (for example app ads) as an image that carries no video ID, so they have no `videoUrl` (in one test run 39 of an advertiser's 126 video-format ads). The Transparency Center has no landing page URLs (Google removed click-through on purpose).

**Why are impressions empty for most ads?**
Google only publishes "times shown", topic and audience selection for ads shown in the EU / EEA and Türkiye (and for political ads). `impressionsEuMin/Max` hold the total over those regions, `regionStats` the number per country, and with **Region** set to an EU country `impressionsMin/Max` hold that country's number. Ranges like "10M+" have no upper bound, so the max is empty.

**What does "verified" mean?**
`advertiserVerified` mirrors the badge on the advertiser's Transparency Center page: true for "Advertiser has verified their identity", false for "Advertiser hasn't verified their identity yet". Google shows the legal name only for verified advertisers, so `advertiserLegalName` is empty for the others.

**What does `daysShown` mean?**
The number of days Google showed the ad, as published by the Transparency Center. It can be lower than the span between `firstShown` and `lastShown` when the ad paused.

**Do I need a proxy?**
It's on by default and included in the price: Apify residential proxy for the Transparency Center. Google redirects IPs that send many requests to a CAPTCHA page; the Actor detects that and retries on a new IP. Ad preview scripts (ad text, video links) are downloaded directly, through Apify's datacenter proxy when Google throttles that, and through the residential proxy only if both are refused. Without a proxy (e.g. local runs) it stops with a clear message instead of hammering a blocked IP.

**What happens if one input fails?**
The other inputs still run. The reason is in the `SUMMARY` record (`perInput[].error`, `errorKind`) and in the run status message. Failed inputs cost nothing, and a run whose only problem is a mistyped name or entry still ends as succeeded, with the reason in the status. The free `SUMMARY` holds statuses, counts and errors, and names only the advertisers of ads you were charged for.

### Legal

This Actor only reads information that Google publishes openly in its Ads Transparency Center for public accountability. It does not log in and does not solve CAPTCHAs. It returns what the Transparency Center shows about each ad and its advertiser: the advertiser's name, legal name, country and verification status, the ad's content, dates, regions and reach figures. Most advertisers are companies, but some are individuals (for example sole traders), and Google publishes their names too, so the output can contain personal data. You are responsible for having a lawful basis to process it (for example under the GDPR or CCPA), for how you use the data, and for complying with Google's terms and the laws that apply to you. This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by Google.

# Actor input Schema

## `advertisers` (type: `array`):

One entry per line. Accepted forms:

- Advertiser name: Nike (the advertiser with the closest name and the most ads is used; see "Advertisers per name")
- Advertiser ID: AR16735076323512287233 (from the advertiser's Transparency Center URL)
- Domain: nike.com (ads that lead to this website, from any advertiser)
- Transparency Center URL: an advertiser page, a single ad page (/advertiser/AR.../creative/CR...) or a domain search (?domain=...)
  Force a type with a prefix: name:Booking.com, domain:booking.com, id:AR...

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

Only ads shown in this country. "Anywhere" returns ads from all regions. With a country set, impressionsMin/Max are the times shown in that country (Google publishes them only for EU / EEA countries and Türkiye; elsewhere they stay empty).

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

Only ads shown on or after this date (US Pacific time, like the website). A date (2026-01-31) or a relative period ("30 days", "6 months"). Leave empty for any time.

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

Only ads shown on or before this date. Leave empty for today.

## `adFormat` (type: `string`):

Text ads (Search), image ads (display, Shopping) or video ads (YouTube).

## `platform` (type: `string`):

Only ads shown on this Google platform. Google records platforms for ads shown since 4 Sep 2023; older ads are left out when a platform is selected.

## `maxAdsPerAdvertiser` (type: `integer`):

Maximum number of ads returned per advertiser (per domain for domain entries), most recently shown first. 0 = no limit (up to 50,000). Each entry returns up to this many ads that no other entry of the run returned, so two entries for the same advertiser (e.g. its name and its ID) can return up to twice as many different ads; each ad is returned and charged once. With details and ad text on, the Actor returns about 1,000 ads in 6 minutes, so the default run timeout of 1 hour fits about 9,000 ads: for bigger exports raise "Timeout" in the run options. Use a timeout of at least 60 seconds: the Actor stops starting new ads 25 seconds before the timeout, so that it always ends cleanly as succeeded with everything found so far.

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

One extra request per ad for all variations, every region the ad ran in with its last shown date, and for ads shown in the EU / EEA or Türkiye the number of times shown (in total and per country, also per platform), the topic and the audience selection. Ads whose details Google does not return are left out and not charged. Included in the price.

## `decodePreviews` (type: `boolean`):

Decode Google's ad preview to get the ad text (headline, description, product title), image URLs and the YouTube video of most video ads (some previews carry no video ID). Google renders text for only about 1 in 10 ads; most text ads come as a picture only (previewImageUrl). One extra request per ad that has a preview. Included in the price.

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

How many advertisers to take for each advertiser name (brands often have several accounts, e.g. per country). The best matches with the most ads come first. The rows and the run summary name the advertisers whose ads were returned.

## `maxConcurrency` (type: `integer`):

Requests in flight at the same time. Higher is faster but more likely to be throttled by Google.

## `requestTimeoutSecs` (type: `integer`):

Timeout for a single HTTP request.

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

Retries for network errors, HTTP 5xx and Google throttling. With a proxy, every throttled retry uses a new IP address.

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

On by default (Apify residential proxy, included in the price): Google blocks IP addresses that send many requests to the Transparency Center (CAPTCHA page). Blocked requests are retried on a new IP. Turning it off is only advised for small local runs.

## Actor input object example

```json
{
  "advertisers": [
    "Nike",
    "AR16735076323512287233",
    "booking.com",
    "https://adstransparency.google.com/advertiser/AR02934798844673654785?region=DE"
  ],
  "region": "anywhere",
  "adFormat": "all",
  "platform": "all",
  "maxAdsPerAdvertiser": 10,
  "includeDetails": true,
  "decodePreviews": true,
  "maxAdvertisersPerName": 1,
  "maxConcurrency": 4,
  "requestTimeoutSecs": 30,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All ads from this run as JSON: advertiser, format, first/last shown, regions, ad text, image and video links, details.

## `media` (type: `string`):

The same ads in the "Creatives & media" view: preview image, YouTube video, image URLs and ad text.

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

Per-input results (status, ads returned, the advertisers of the returned ads) and any errors.

# 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 = {
    "advertisers": [
        "AR16735076323512287233",
        "AR02934798844673654785"
    ],
    "maxAdsPerAdvertiser": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fairfetch/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 = {
    "advertisers": [
        "AR16735076323512287233",
        "AR02934798844673654785",
    ],
    "maxAdsPerAdvertiser": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fairfetch/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 '{
  "advertisers": [
    "AR16735076323512287233",
    "AR02934798844673654785"
  ],
  "maxAdsPerAdvertiser": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fairfetch/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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