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

See the ads any company runs on Google Search, YouTube, Shopping, Maps and Play. Get ad text, YouTube video links, landing pages, dates, countries, EU reach and targeting. For competitor ad research, ad checks and new-ad alerts. No login.

- **URL**: https://apify.com/panix/google-ads-transparency-scraper.md
- **Developed by:** [PANIX AI LAB](https://apify.com/panix) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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.
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 & Ad Monitor

See the ads any company runs on Google Search, YouTube, Shopping, Maps and Play. Type a brand or a website and get the ad text, landing page and how long each ad has run.

- **Every ad Google lists** in its public Ads Transparency Center, with first and last shown dates and days shown.
- **Ad text and media**: headlines, descriptions and YouTube video links, not just a preview image.
- **European reach and targeting** where Google publishes it. No Google account, login or cookies.

**Try it now:** the input is already filled in (Nike's ads in the US with their ad text, 20 ads). Click **Start** and the results appear in a table you can export to Excel, CSV or JSON. That example run costs a few cents, which the $5 of free monthly credit on Apify's free plan covers.

**Price:** from **$0.80 per 1,000 ads**, and you pay only for results you get. The full price table is in the Pricing section below.

### Example result

One result, shortened. Every field is described in the Output section below.

```json
{
  "advertiserName": "Hubspot, Inc.",
  "format": "TEXT",
  "firstShown": "2022-10-18T07:00:00Z",
  "lastShown": "2026-11-11T05:43:03Z",
  "daysShown": 785,
  "domain": "hubspot.com",
  "headline": "Best CRM for Small Businesses - HubSpot CRM Software",
  "description": "Organize, track, and sell with ease. HubSpot CRM has tools for everyone on your team. Increase leads, accelerate sales...",
  "displayUrl": "www.hubspot.com/",
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR06404346990582300673"
}
```

### What you get

See the ads any company runs on **Google Search, YouTube, Google Shopping, Google Maps and Google Play**. Type a brand name or a website, and you get every ad Google shows in its public [Ads Transparency Center](https://adstransparency.google.com/), with the ad text, YouTube video link, landing page, first and last shown dates, countries, and (for ads shown in Europe) how many times each ad was shown and which audience it targeted.

No Google account, no login, no cookies.

> This Actor is an independent tool. It is not made, endorsed or sponsored by Google. It reads the public Google Ads Transparency Center website.

### What you can do with it

- **Spy on competitor ads.** See every ad a competitor runs right now, on which Google platforms, and since when.
- **Find the ads that work.** Ads that run for months are usually the profitable ones. Filter by "Minimum days shown" and sort by `daysShown`.
- **Get new-ad alerts.** Turn on "Only new ads", schedule the run daily or weekly, and get only the ads launched since the last run.
- **Check who runs Google ads** (lead generation). Paste a list of company names or websites in "Advertisers" mode and see which ones advertise, how many ads they run, their legal name and whether Google verified them. Websites without ads are listed too, for free.
- **Collect ad copy and videos.** Headlines, descriptions, sitelinks, Shopping product titles and YouTube video links for swipe files, AI training or messaging research.
- **Research reach in Europe.** For ads shown in the EU, Google publishes "times shown" ranges per country and platform and the audience targeting used.
- **Track political ads.** Election ads with Google's spend and impression ranges, for any country Google covers.

### Who uses it

- Marketing agencies and media buyers doing competitor research and ad audits
- PPC and Google Ads managers looking for winning ad copy
- E-commerce and DTC brands watching rivals' Shopping and YouTube ads
- Sales teams and lead-gen agencies finding companies that spend on Google Ads
- Brand protection teams checking who runs ads for their website (resellers, affiliates, fake shops)
- Journalists and researchers following political advertising

### Why this scraper

- **Four ways in:** brand names, websites, advertiser IDs, or links copied from the Transparency Center (the filters in the link are used).
- **Ad text and media in one switch:** headline, description, display URL, sitelinks and business name of search ads, product title of Shopping ads, YouTube video link of video ads, landing page and image links.
- **Details on demand:** every country with dates, EU reach per country and platform, audience targeting, who paid, all A/B variations.
- **Smart brand matching:** a brand name picks the advertiser accounts that really carry that name, the biggest first, and skips tiny namesakes (for "nike" it finds Nike, Inc. with ~8,000 US ads, not a one-ad shop called "Nike").
- **New-ad monitoring built in**, with a watchlist per task.
- **Advertiser check mode** with free rows for websites that run no ads.
- **"Launched after" and "Minimum days shown" filters** that cost nothing for the ads they leave out.
- **Pay only for what you get:** failed lookups, ads without text, filtered and duplicate ads are free. Details and ad text are charged only when found.
- **Fast and light:** 500 ads in about 11 seconds on 512 MB; no browser.

#### Coming from another Google Ads Transparency scraper?

| Common problem | How this Actor handles it |
| --- | --- |
| A brand name returns ads from unrelated companies with a similar name | Names must match as whole words, and accounts with under 1% of the top account's ads are skipped. The `SOURCES` record shows which accounts were used. |
| You pay extra for "details" on every ad, even when Google has none | Details and ad text are separate switches, and each is charged only for ads where it was actually found. |
| Ad text is missing for most ads | Text is read from Google's own preview data. Text ads that Google keeps only as a picture have no readable text; for those you still get the picture link, and you are not charged for text. |
| Monitoring reports old ads as "new" | The watchlist remembers ad IDs per input and only counts ads Google first showed since the last check. |
| Runs fail or get stuck on blocks | Every request batch uses a fresh proxy IP; blocked requests are retried on another IP. A run stops cleanly at your spending limit and keeps everything collected. |
| You can't tell whether a website simply has no ads | Websites and names with no ads get a free `no_ads` row. |

### How to use

1. Click **Try for free** (or **Start**) on this page.
2. Type brand names or websites in **Brand names or websites**, for example `nike` or `hubspot.com`.
3. Pick a **Country** (or leave "Anywhere"), and switch on **Add ad text and media** or **Add ad details** if you want them.
4. Click **Start**. Ads appear in the **Output** tab as they are collected. Download them as Excel, CSV, JSON or HTML, or use the API.

#### Input examples

Competitor ads in one country, with ad text:

```json
{
  "searchTerms": ["nike"],
  "region": "US",
  "maxAdsPerSource": 20,
  "includeAdContent": true
}
```

Every ad that points to some websites, with details (countries, EU reach, targeting):

```json
{
  "domains": ["hubspot.com", "shopify.com", "canva.com"],
  "maxAdsPerSource": 50,
  "includeDetails": true,
  "includeAdContent": true
}
```

YouTube video ads only, launched in the last 14 days:

```json
{
  "searchTerms": ["temu", "canva"],
  "adFormat": "VIDEO",
  "platforms": ["YOUTUBE"],
  "launchedAfter": "14 days",
  "includeAdContent": true
}
```

Ad check: which of these companies run Google ads in the US?

```json
{
  "resultType": "advertisers",
  "searchTerms": ["nike", "hellofresh", "allbirds"],
  "domains": ["hubspot.com", "example-no-ads-site-123.com"],
  "region": "US"
}
```

Daily new-ad alerts for two competitors (schedule this input):

```json
{
  "domains": ["competitor-one.com", "competitor-two.com"],
  "onlyNewAds": true,
  "watchlistName": "my-rivals",
  "includeAdContent": true
}
```

Links copied from the Transparency Center (an ad, an advertiser with filters, a website search):

```json
{
  "startUrls": [
    { "url": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR10265941400537268225?region=US" },
    { "url": "https://adstransparency.google.com/advertiser/AR10072600183532683265?region=DE&format=VIDEO&preset-date=Last+30+days" },
    { "url": "https://adstransparency.google.com/?region=GB&domain=booking.com" }
  ],
  "includeDetails": true
}
```

Political ads in the US with spend ranges:

```json
{ "politicalAdsOnly": true, "region": "US", "maxAdsPerSource": 100 }
```

#### Input fields

| Field | What it does |
| --- | --- |
| `searchTerms` | Brand names (`nike`) or websites (`hubspot.com`). Names find the advertiser accounts named like it; websites find all ads pointing to the site. |
| `domains` | Websites. Every ad that sends people there, from any advertiser account (also agencies and resellers). |
| `advertiserIds` | IDs starting with `AR`, from an advertiser's Transparency Center link. |
| `startUrls` | Transparency Center links: a single ad, an advertiser page, or a website search. Region, format, platform and date filters in the link are used. |
| `resultType` | `ads` (default) or `advertisers` (one row per advertiser account: the ad check). |
| `region` | Two-letter country code (`US`, `GB`, `DE`, ...) or `anywhere`. |
| `platforms` | `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY`. Empty = all. |
| `adFormat` | `ALL`, `TEXT`, `IMAGE` or `VIDEO`. |
| `shownAfter`, `shownBefore` | Only ads shown in this window: `2026-10-01` or `30 days`. Google's date filter covers about the last 12 months. |
| `launchedAfter` | Only ads Google first showed after this date (new ads). |
| `minDaysShown` | Only ads shown on at least this many days (long-running ads). |
| `politicalAdsOnly` | Election ads with spend and impression ranges. Without other inputs it lists all political ads in the country. |
| `maxAdsPerSource` | Ads per input (default 100). A brand name shares it across its accounts. |
| `maxAdvertisersPerSearchTerm` | Advertiser accounts per brand name (default 3). |
| `maxResults` | Stop after this many rows in total. |
| `includeDetails` | Countries, dates, EU reach, audience targeting, who paid, variations. |
| `includeAdContent` | Ad text, YouTube video link, landing page, images. |
| `onlyNewAds`, `watchlistName` | Deliver only ads not seen in earlier runs of the same watchlist. |

### Output

Each ad is one row. This is a real row from a run on 2026-11-11 (`hubspot.com`, ad text on; long links shortened):

```json
{
  "type": "ad",
  "creativeId": "CR06404346990582300673",
  "advertiserId": "AR10072600183532683265",
  "advertiserName": "Hubspot, Inc.",
  "format": "TEXT",
  "firstShown": "2022-10-18T07:00:00Z",
  "lastShown": "2026-11-11T05:43:03Z",
  "daysShown": 785,
  "shownRecently": true,
  "domain": "hubspot.com",
  "advertiserVerified": true,
  "contentKind": "search",
  "headline": "Best CRM for Small Businesses - HubSpot CRM Software",
  "description": "Organize, track, and sell with ease. HubSpot CRM has tools for everyone on your team. Increase leads, accelerate sales...",
  "displayUrl": "www.hubspot.com/",
  "businessName": "HubSpot",
  "contentStatus": "ok",
  "googleCreativeId": "605822891185",
  "googleCustomerId": "7615749964",
  "adGroupId": "108033248144",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...",
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR06404346990582300673",
  "advertiserUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265",
  "region": "anywhere",
  "input": "hubspot.com",
  "inputType": "domain",
  "scrapedAt": "2026-11-11T05:59:04Z"
}
```

A YouTube video ad with ad text and media on (same day, input `temu`):

```json
{
  "advertiserName": "ELEMENTARY INNOVATION PTE. LTD.",
  "format": "VIDEO",
  "firstShown": "2026-10-18T05:09:46Z",
  "lastShown": "2026-11-11T05:35:12Z",
  "daysShown": 25,
  "contentKind": "video",
  "youtubeVideoId": "Tr5MYCCtjZg",
  "youtubeVideoUrl": "https://www.youtube.com/watch?v=Tr5MYCCtjZg",
  "landingUrl": "https://www.temu.com/ul/kuiper/un1.html?subj=feed-un&...&_x_ads_channel=google",
  "displayUrl": "temu.com",
  "contentStatus": "ok"
}
```

With **Add ad details** on, an ad shown in Germany (`zalando.de`, region DE) also carries:

```json
{
  "regionCount": 1,
  "regions": [
    {
      "region": "DE", "regionName": "Germany", "firstShown": "2024-06-13", "lastShown": "2026-11-10",
      "impressionsMin": 10000, "impressionsMax": 15000,
      "platformImpressions": [
        { "platform": "SEARCH", "impressionsMin": 10000, "impressionsMax": 15000 },
        { "platform": "SHOPPING", "impressionsMin": 0, "impressionsMax": 1000 },
        { "platform": "YOUTUBE", "impressionsMin": 0, "impressionsMax": 1000 }
      ]
    }
  ],
  "euImpressionsMin": 10000,
  "euImpressionsMax": 15000,
  "platforms": ["SEARCH", "SHOPPING", "YOUTUBE"],
  "audienceTargeting": {
    "demographics": "included",
    "geography": "included and excluded",
    "contextual": "included and excluded",
    "topicsOfInterest": null,
    "customerLists": null
  },
  "paidBy": "Zalando SE",
  "variationCount": 3,
  "variations": [
    { "kind": "image", "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/15729422377328768247", "width": 348, "height": 204 }
  ],
  "detailsStatus": "ok"
}
```

In **Advertisers** mode each row is one account (real rows, region US):

```json
[
  { "type": "advertiser", "name": "Nike, Inc.", "country": "US", "legalName": "Nike, Inc.", "verified": true,
    "runsGoogleAds": true, "adCountMin": 7000, "adCountMax": 8000, "matchedVia": "advertiser name", "input": "nike" },
  { "type": "advertiser", "name": "Floorboard LLC", "country": "US", "verified": true, "runsGoogleAds": true,
    "adsInSample": 4, "sampleSize": 100, "matchedDomain": "hubspot.com", "matchedVia": "website", "input": "hubspot.com" },
  { "type": "no_ads", "runsGoogleAds": false, "input": "example-no-ads-site-123.com",
    "message": "No Google ads for example-no-ads-site-123.com (US)." }
]
```

#### Main fields

| Field | Meaning |
| --- | --- |
| `format` | `TEXT`, `IMAGE` or `VIDEO`, as Google labels it. |
| `firstShown`, `lastShown`, `daysShown` | When Google first and last showed the ad, and on how many days. A long `daysShown` is a good sign the ad works. |
| `shownRecently` | `true` when the ad was shown in the last 2 days. |
| `domain` | The website the ad points to (on website searches). |
| `previewImageUrl` | Picture of the ad (text ads that Google stores as an image, and image ads). |
| `headline`, `description`, `displayUrl`, `businessName`, `sitelinks` | Text of search ads. `headlineDynamic: true` marks Dynamic Search Ads, whose headline Google writes from the landing page. |
| `contentKind` | `search`, `shopping`, `local`, `video` or `display`. |
| `youtubeVideoId`, `youtubeVideoUrl`, `landingUrl` | Video and click-through page when the preview holds them. |
| `contentStatus` | `ok`, `image_only` (text only as a picture, not charged), `nothing_found` (not charged), `no_preview`, or `failed: ...` (not charged). |
| `regions` | Every country with first and last dates and, for EU countries, "times shown" ranges per platform. |
| `audienceTargeting` | Targeting categories the advertiser used (EU ads): `included`, `excluded`, `included and excluded` or `null`. |
| `paidBy` | The payer Google lists for the ad. |
| `impressionsMin/Max`, `spendMin/Max`, `spendCurrency` | Political ads: Google's ranges. |

The Output tab has ready views: **Ads**, **Ad text and media**, **Reach and targeting**, **Political ads**, **Advertisers (ad check)**, and **All rows incl. errors**.

The run's key-value store also has `SOURCES` (per input: matched accounts, Google's total ad count, pages read, why it stopped), `ADVERTISERS` (per advertiser: ads delivered, formats, oldest and newest dates, longest-running ad) and `SUMMARY` (totals and charges).

### Pricing

Pay per event: you pay only for results, not for the Apify platform usage.

| Event | Free plan | Bronze | Silver | Gold and up |
| --- | --- | --- | --- | --- |
| Ad (each ad row) | $1.20 / 1,000 | $1.00 / 1,000 | $0.90 / 1,000 | $0.80 / 1,000 |
| Ad details (only with "Add ad details", per ad whose details were read) | $0.60 / 1,000 | $0.50 / 1,000 | $0.40 / 1,000 | $0.30 / 1,000 |
| Ad text and media (only with "Add ad text and media", per ad where text, a video or a landing page was found) | $1.20 / 1,000 | $1.00 / 1,000 | $0.80 / 1,000 | $0.70 / 1,000 |
| Advertiser (each row in Advertisers mode) | $2.50 / 1,000 | $2.00 / 1,000 | $1.80 / 1,000 | $1.50 / 1,000 |
| Actor start (once per run, per GB of memory; the default 512 MB counts as one) | $0.001 | $0.001 | $0.001 | $0.001 |

**Free:** error rows, `no_ads` rows, duplicates, ads left out by your filters or by "Only new ads", and details or ad text that could not be found.

Examples at the Bronze price:

- 1,000 competitor ads: **$1.00**.
- 1,000 ads with details and ad text found on all of them: **$2.50**.
- Checking 500 companies in Advertisers mode: **about $1.00**.

Set a spending limit when you start the run (or in the API with `maxTotalChargeUsd`). The run stops cleanly when the limit is reached and keeps everything collected.

### Good to know

- **Ad text.** Google stores many text ads only as a picture. For those you get `previewImageUrl` and `contentStatus: "image_only"`, and no text charge. Video ads usually have a YouTube link, and many search, Shopping and local ads have readable text. In our test runs ad text or media was found for 19 of 20 Nike US ads, 44 of 50 YouTube video ads, and about a third of a mixed set of 150 ads.
- **Reach, platforms and audience exist only for ads shown in the EU** (Google publishes them under the EU Digital Services Act). Outside the EU, `regions` still lists countries and dates.
- **"Times shown" and ad counts are Google's own ranges**, refreshed by Google from time to time. Use them as a scale, not an exact count.
- **Shopping prices** are hidden in Google's archived previews (`priceShown: false`).
- **Dates:** Google's date filter covers about the last 12 months. `firstShown` can go back further. Per-country first dates before 1 March 2023 show `firstShownOnOrBefore: true`.
- **Brand names vs websites:** many brands advertise under a parent company or agency name. If a name finds nothing, try the website.
- **Only new ads:** the first run delivers up to "Max ads per input" and remembers them (and the other ads Google first showed in the last 3 days). Later runs deliver ads Google first showed since the previous run that you have not received yet.
- Only public data from the Transparency Center is collected.

### FAQ

**Do I need a Google account or API key?** No.

**Which countries work?** All countries the Transparency Center lists (about 240). Use the two-letter code, or `anywhere`.

**Can I get the ads of a single ad link?** Yes, paste the ad's Transparency Center link in `startUrls`.

**How fast is it?** About 500 ads in 11 seconds without extras; with details and ad text, about 150 ads in 20 seconds.

**Which memory should I use?** The default 512 MB is enough. More memory does not speed it up and the start fee is charged per GB.

**Why did a brand name return no ads?** No advertiser account carries that name in the Transparency Center. Use the brand's website, or find the advertiser ID on the site.

**Can I schedule it?** Yes. Save your input as a task, add a schedule, and turn on "Only new ads" to get only new ads each time.

### Use it from code, n8n, Make or Zapier

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/google-ads-transparency-scraper").call(run_input={
    "domains": ["hubspot.com"],
    "region": "US",
    "maxAdsPerSource": 100,
    "includeAdContent": True,
})
for ad in client.dataset(run.default_dataset_id).iterate_items():
    print(ad["advertiserName"], ad["format"], ad.get("headline"), ad["adUrl"])
```

JavaScript (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/google-ads-transparency-scraper').call({
    searchTerms: ['nike'],
    region: 'US',
    maxAdsPerSource: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

One HTTP call that runs the Actor and returns the rows:

```text
POST https://api.apify.com/v2/acts/panix~google-ads-transparency-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
Content-Type: application/json

{"searchTerms": ["nike"], "region": "US", "maxAdsPerSource": 20}
```

- **n8n:** use the Apify node (Run an Actor and get dataset items) with `panix/google-ads-transparency-scraper`, or an HTTP Request node with the URL above.
- **Make:** the Apify app, module "Run an Actor", then "Get Dataset Items".
- **Zapier:** the Apify app, action "Run Actor", then "Fetch Dataset Items"; send new ads to Slack, Sheets or email.
- **AI agents:** the Actor works through the Apify MCP server like any other Store Actor.

### Need something else?

Open an issue on the Actor's **Issues** tab. Requests for new fields and filters are welcome.

# Actor input Schema

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

Brand or company names (nike, hellofresh) or websites (hubspot.com). A name finds the advertiser accounts named like it, the biggest first; a website finds every ad that points to it.

## `domains` (type: `array`):

Websites such as nike.com. You get every ad that sends people to the website, from any advertiser account (also agencies and resellers).

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

IDs that start with AR, from the advertiser's Transparency Center page link, e.g. AR16735076323512287233.

## `startUrls` (type: `array`):

Links copied from adstransparency.google.com: an advertiser page, a single ad, or a search by website. Filters in the link (region, format, platform, dates) are used.

## `resultType` (type: `string`):

Ads: one row per ad. Advertisers: one row per advertiser account with its ad count, country, legal name and verification (an ad check: does this company run Google ads?).

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

Only ads shown in this country. Anywhere = all countries.

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

Only ads shown on these platforms. Empty = all platforms.

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

Text, image or video ads only.

## `shownAfter` (type: `string`):

Only ads shown on or after this date: 2026-10-01, or a period such as '30 days'. Google's date filter covers about the last 12 months.

## `shownBefore` (type: `string`):

Only ads shown on or before this date (2026-10-31 or '7 days').

## `launchedAfter` (type: `string`):

Only ads Google first showed after this date, e.g. '14 days' for ads launched in the last two weeks. Ads left out are free.

## `minDaysShown` (type: `integer`):

Only ads Google showed on at least this many days. Ads that run for a long time are usually the ones that work. Ads left out are free.

## `politicalAdsOnly` (type: `boolean`):

Election ads with Google's spend and impression ranges. With no names or websites above, lists all political ads in the chosen country.

## `maxAdsPerSource` (type: `integer`):

How many ads to collect for each input. A brand name shares this limit across its advertiser accounts.

## `maxAdvertisersPerSearchTerm` (type: `integer`):

A brand name can match several accounts (countries, agencies). The biggest ones are used; accounts with under 1% of the biggest one's ads are skipped.

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

Stop after this many rows across all inputs. Empty = no total limit.

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

Every country the ad ran in with first and last dates, Google's 'times shown' ranges per country and platform (EU ads), the audience targeting used, who paid, ad variations and the landing page when Google lists it. Charged per ad with details.

## `includeAdContent` (type: `boolean`):

Headline, description, display URL, sitelinks and business name of text ads, product title of Shopping ads, YouTube video link of video ads, landing page and image links. Charged only for ads where text, a video or a landing page is found.

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

Remember the ads of every input and deliver only ads not seen before. Schedule the run daily or weekly to get new competitor ads.

## `watchlistName` (type: `string`):

Keeps separate memories for different monitoring tasks (letters, digits, - and \_).

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

Apify datacenter proxy works well. Each request batch uses a fresh IP.

## Actor input object example

```json
{
  "searchTerms": [
    "nike"
  ],
  "resultType": "ads",
  "region": "US",
  "adFormat": "ALL",
  "politicalAdsOnly": false,
  "maxAdsPerSource": 20,
  "maxAdvertisersPerSearchTerm": 3,
  "includeDetails": false,
  "includeAdContent": true,
  "onlyNewAds": false,
  "watchlistName": "default",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All delivered rows. Filter by the type column: ad, advertiser, no_ads or error. no_ads and error rows are free.

## `sources` (type: `string`):

Matched advertiser accounts, Google's total ad count, pages read, ads delivered and why each input stopped.

## `advertisers` (type: `string`):

Ads delivered per advertiser with formats, dates and the longest-running ad.

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

Totals, charged events, ads left out per filter, request statistics and warnings.

# 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 = {
    "searchTerms": [
        "nike"
    ],
    "region": "US",
    "maxAdsPerSource": 20,
    "includeAdContent": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("panix/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 = {
    "searchTerms": ["nike"],
    "region": "US",
    "maxAdsPerSource": 20,
    "includeAdContent": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("panix/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 '{
  "searchTerms": [
    "nike"
  ],
  "region": "US",
  "maxAdsPerSource": 20,
  "includeAdContent": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call panix/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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