# Google Ads Transparency Scraper - Ad Text, No Login (`cliqtomedia/google-ads-transparency-scraper`) Actor

Get Google ads by advertiser name, AR ID or domain from the Ads Transparency Center: ad text, image and YouTube links, first/last shown dates, per-country reach and impressions. Region, format and date filters. No login.

- **URL**: https://apify.com/cliqtomedia/google-ads-transparency-scraper.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** Marketing, SEO tools
- **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.
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 gets the ads that a brand or website runs on Google. Add a domain, an advertiser name or an advertiser ID (AR…), and the Actor returns one row per ad from the public [Google Ads Transparency Center](https://adstransparency.google.com/): ad text, image or YouTube link, first and last shown dates, countries and impression ranges.

No Google login, cookies or API key. The prefilled run (20 ads for `apify.com`) usually takes about 30–70 seconds and costs about $0.028 ($0.004 start + 20 ads, from $0.024 on paid plans).

![Google Ads Transparency Scraper: add brands or domains, get each Google ad with its text, dates, regions and impressions](https://api.apify.com/v2/key-value-stores/wM3KzjT3BMUvxqMYa/records/README-BANNER-20261014.png)

### Table of contents

- [What it does](#what-it-does)
- [Quick start](#quick-start)
- [Input](#input)
- [Output](#output)
- [Pricing](#pricing)
- [Use cases](#use-cases)
- [Scheduling and monitoring](#scheduling-and-monitoring)
- [API, export and integrations](#api-export-and-integrations)
- [Limits and partial results](#limits-and-partial-results)
- [Troubleshooting](#troubleshooting)
- [FAQ](#faq)
- [Related Actors](#related-actors)
- [Support](#support)

### What it does

The Google Ads Transparency Center shows the ads that verified advertisers run on Google: search (text) ads, image and display ads, and YouTube video ads. This Actor reads the same public pages for you and saves each ad as a clean dataset row.

For every ad you get:

- **Who:** advertiser name, advertiser ID (AR…), domain.
- **What:** format (`text`, `image`, `video`), headline, description, display URL, call-to-action, image URL, YouTube link.
- **When:** first shown, last shown, days shown, as reported by Google.
- **Where and how much:** countries where the ad ran, with dates and impression ranges per country, plus a total impression range.
- **Links:** the public Transparency Center page of the ad and the Google preview URL.

Filters: region (one country or anywhere), format, and a date range.

#### Good fit

- See which ads a competitor runs on Google right now, and when Google first showed them.
- Collect ad copy (headlines and descriptions) of a brand for PPC research.
- Check in which countries a brand advertises and how big the reach is.
- Save image ads and YouTube ads of a brand for creative research.

#### Not a fit / limits

- The Actor shows what Google publishes in the Transparency Center. It does not show clicks, spend, keywords or targeting.
- Impressions are ranges from Google (for example 1,000–2,000), not exact numbers. Google does not show them for every ad.
- Some text ads exist only as a picture. For them `headline` and `description` are `null`, and `imageUrl` has the picture.
- Up to 500 ads per advertiser or domain, and about 600–800 ads per run in total. For more, split the job across several runs.
- The Actor does not solve CAPTCHAs. If Google blocks all requests, the run stops with a clear error.

### Quick start

1. Open the **Input** tab.
2. Keep the prefilled domain `apify.com` in **Domains**, or add your own domain, for example `shopify.com`.
3. Keep **Max ads per advertiser or domain** at `20` and **Region** at `anywhere`.
4. Click **Start**.
5. Open the **Output** tab. The **Ads** view shows advertiser, format, dates, impressions and ad text.

Expected result: about 20 ad rows for the domain, each with `status` `complete`.

### Input

#### Input fields

| Field | Plain name | Type | Required | Default / prefill | Allowed values | Effect | Example | Recommendation |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `domains` | Domains | array of strings | one of `domains` / `advertisers` | prefill `["apify.com"]` | domain or URL | ads of every advertiser that links to the domain | `["shopify.com"]` | best way to find a brand |
| `advertisers` | Advertisers (name or ID) | array of strings | one of `domains` / `advertisers` | empty | name, AR… ID or advertiser page URL | ads of one advertiser account | `["AR04545223091738902529"]` | use the AR… ID for an exact account |
| `region` | Region | string | no | `anywhere` | `anywhere` or a 2-letter country code | only ads shown in this country | `US`, `DE` | keep `anywhere` for all countries |
| `format` | Ad format | string | no | `all` | `all`, `text`, `image`, `video` | only this ad format | `text` | use for copy or creative research |
| `dateFrom` | Shown from | string | no | empty | `YYYY-MM-DD`, from 2018-01-01 | only ads shown on or after this date | `2026-09-01` | for a time window |
| `dateTo` | Shown until | string | no | empty (today) | `YYYY-MM-DD`, not before `dateFrom` | only ads shown on or before this date | `2026-09-30` | leave empty for today |
| `maxAds` | Max ads per advertiser or domain | integer | no | `20` | 1–500 | max ad rows for each domain or advertiser | `100` | each ad row is charged |
| `includeDetails` | Per-country reach and impressions | boolean | no | `true` | `true`, `false` | adds `regions` and impression ranges | `true` | keep on; it is in the price |
| `includeAdText` | Ad text and YouTube link | boolean | no | `true` | `true`, `false` | reads headline, description, image and YouTube link from the ad preview | `true` | keep on; it is in the price |
| `proxyConfiguration` | Proxy | object | no | Apify Proxy (datacenter) | Apify Proxy settings | how requests reach Google | `{"useApifyProxy": true}` | keep the default |

Notes:

- Add at least one domain or advertiser. You can mix both, up to **20 inputs** in total.
- Duplicates are merged: `apify.com` and `https://www.apify.com/` count as one input.
- An advertiser **name** must match whole words of an advertiser in the Transparency Center. If several advertisers match, the Actor takes the best match and writes a warning in the run summary. If nothing matches, you get a free `not_found` row that lists the closest names with their AR… IDs.
- With the default proxy, the Actor switches to Apify residential proxy by itself when Google blocks the datacenter proxy. If you choose your own proxy group or URLs, this switch is off.

#### Interacting settings

| When | Input A | Input B | Effective behavior | Example | Cost/result effect |
| --- | --- | --- | --- | --- | --- |
| Filter by country and date | `region` | `dateFrom` / `dateTo` | only ads shown in this country in this window | `FR`, September 2026 | fewer rows, fewer charges |
| Only text ads | `format` = `text` | `includeAdText` = `true` | headline and description for each text ad that has them | `shopify.com` | some text ads have only an image |
| Faster light run | `includeDetails` = `false` | `includeAdText` = `false` | no `regions`, no headline/description/YouTube link (image and creative links stay) | — | same price per row |

#### Input examples

##### Ads of a website

```json
{
  "domains": ["apify.com"],
  "region": "anywhere",
  "maxAds": 20
}
```

Expected behavior: finds all advertisers that link to `apify.com` and returns up to 20 ads.
Expected output: rows with `advertiserName`, `format`, `headline`, `firstShown`, `regions`.
Limit or cost note: 20 ad rows + start = about $0.028.

##### Image ads of one advertiser in France, one month

```json
{
  "advertisers": ["AR04545223091738902529"],
  "region": "FR",
  "format": "image",
  "dateFrom": "2026-09-01",
  "dateTo": "2026-09-30",
  "maxAds": 50
}
```

Expected behavior: returns only image ads of this account shown in France in September 2026.
Expected output: rows with `imageUrl`, `callToAction`, `firstShown`, `lastShown`.
Limit or cost note: if the advertiser had no such ads, you get one free `not_found` row.

### Output

Each ad is one row in the default dataset. Each input without ads gives one free `not_found` row, so you always see what happened to every input.

#### Output example

Input: `{"domains": ["apify.com"], "maxAds": 20}`. One row, `regions` trimmed to two countries:

```json
{
  "status": "complete",
  "statusReason": null,
  "errorCode": null,
  "input": "apify.com",
  "inputType": "domain",
  "advertiserId": "AR04545223091738902529",
  "advertiserName": "Apify Technologies s.r.o.",
  "advertiserCountry": null,
  "domain": "apify.com",
  "creativeId": "CR12249652250414153729",
  "format": "text",
  "firstShown": "2026-07-02T13:54:49.000Z",
  "lastShown": "2026-10-14T10:26:38.000Z",
  "daysShown": 105,
  "regions": [
    { "code": "IE", "name": "Ireland", "criteriaId": 2372, "firstShown": "2026-07-03", "lastShown": "2026-10-13", "impressionsMin": 0, "impressionsMax": 1000 },
    { "code": "IL", "name": "Israel", "criteriaId": 2376, "firstShown": null, "lastShown": "2026-10-14", "impressionsMin": null, "impressionsMax": null }
  ],
  "impressionsMin": 1000,
  "impressionsMax": 2000,
  "variations": 1,
  "headline": "Apify for your AI - Largest marketplace for AI",
  "description": "Connect Claude, ChatGPT, or Cursor to Apify Store via MCP and put tools to work today.",
  "displayUrl": "www.apify.com/",
  "callToAction": null,
  "text": "Apify for your AI - Largest marketplace for AI — Connect Claude, ChatGPT, or Cursor to Apify Store via MCP and put tools to work today.",
  "imageUrl": null,
  "videoUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR04545223091738902529/creative/CR12249652250414153729?region=anywhere",
  "regionFilter": "anywhere",
  "sourceUrl": "https://adstransparency.google.com/?region=anywhere&domain=apify.com",
  "fetchedAt": "2026-10-14T11:15:51.596Z"
}
```

`creativeUrl` is left out here because it is long. In this row Google shows no dates or impressions for Israel, so those values are `null`.

How much you get depends on the ad. In our test runs, 9 of 20 `apify.com` ads had a headline (the rest were text ads shown only as a picture), and 18 of 20 `shopify.com` image ads had an `imageUrl`.

#### Output fields

| Field | Meaning | Type | Can be empty? | Example / enum | Source / notes |
| --- | --- | --- | --- | --- | --- |
| `status` | row result | string | no | `complete`, `partial`, `not_found`, `error` | only `complete` and `partial` are charged |
| `statusReason` | why a row is partial, not_found or error | string | yes, `null` when complete | `The Transparency Center shows no ads for ...` | plain English |
| `errorCode` | machine code of an error row | string | yes | `SOURCE_BLOCKED`, `DEADLINE_REACHED` | `null` if no error |
| `input` | your input as given | string | no | `apify.com` | |
| `inputType` | how the input was read | string | no | `domain`, `advertiserId`, `advertiserName` | |
| `advertiserId` | Google advertiser ID | string | yes | `AR04545223091738902529` | |
| `advertiserName` | advertiser name in the Transparency Center | string | yes | `Apify Technologies s.r.o.` | |
| `advertiserCountry` | advertiser country, 2-letter code | string | yes | `null` | often `null`: Google shows it only for some advertisers |
| `domain` | domain the ad links to | string | yes | `apify.com` | when Google shows it |
| `creativeId` | Google ad ID | string | yes | `CR12249652250414153729` | |
| `format` | ad format | string | yes | `text`, `image`, `video` | |
| `firstShown` | first time the ad was shown | string (ISO time) | yes | `2026-07-02T13:54:49.000Z` | |
| `lastShown` | last time the ad was shown | string (ISO time) | yes | `2026-10-14T10:26:38.000Z` | |
| `daysShown` | days shown, as reported by Google | integer | yes | `105` | |
| `regions` | countries where the ad ran | array | yes | `[{"code": "IE", ...}]` | `code`, `name`, `criteriaId`, `firstShown`, `lastShown`, `impressionsMin`, `impressionsMax` |
| `impressionsMin` | lower end of the total impression range | integer | yes | `1000` | Google range, not exact |
| `impressionsMax` | upper end of the total impression range | integer | yes | `2000` | |
| `variations` | number of ad variations | integer | yes | `1` | |
| `headline` | text ad headline | string | yes | `Apify for your AI - Largest marketplace for AI` | from the ad preview |
| `description` | text ad description | string | yes | `Connect Claude, ChatGPT, or Cursor ...` | from the ad preview |
| `displayUrl` | display URL of a text ad | string | yes | `www.apify.com/` | |
| `callToAction` | button text of a display ad | string | yes | `Sign Up` | when Google shows it |
| `text` | headline and description in one string | string | yes | | `null` when the ad has no text |
| `imageUrl` | image of the ad | string | yes | `https://tpc.googlesyndication.com/archive/simgad/...` | image, display and image-only text ads |
| `videoUrl` | YouTube link of a video ad | string | yes | `https://www.youtube.com/watch?v=...` | |
| `creativeUrl` | Google preview URL of the ad | string | yes | | |
| `adUrl` | public Transparency Center page of the ad | string | yes | `https://adstransparency.google.com/advertiser/AR.../creative/CR...` | |
| `regionFilter` | region filter of this run | string | no | `anywhere` | |
| `sourceUrl` | Transparency Center page for your input | string | yes | | |
| `fetchedAt` | when the Actor read the row | string (ISO time) | no | `2026-10-14T11:15:51.596Z` | |

`null` means Google does not show this value for the ad. The Actor never writes `0` or an empty string instead of a missing value. Impression ranges can start at `0` because Google shows "less than 1,000" as 0–1,000.

#### Output entities and surfaces

| Situation | Dataset/API/KVS/live view | Result shape | User action |
| --- | --- | --- | --- |
| Normal ad | Dataset, **Ads** view | one row, `status` = `complete` | open, export or use the fields |
| Some details missing | Dataset | row with `status` = `partial` and `statusReason` | data is still useful; missing fields are `null` |
| No ads for an input | Dataset | one free row, `status` = `not_found` | check the domain, name, region or dates |
| Google blocked the run or time ran out | Dataset + key-value store `RUN_SUMMARY` | free `error` rows for inputs not done, summary with `status` and `stopReason` | run again later, or split the inputs |

The key-value store record `RUN_SUMMARY` has the run status (`COMPLETE`, `PARTIAL`, `NO_RESULTS`, `CAPPED`, `ERROR`, `INVALID_INPUT`, `CANCELLED`), counts for each input, and warnings.

### Pricing

#### Pricing unit

This Actor uses pay-per-event pricing:

| Event | When | FREE | BRONZE | SILVER | GOLD and higher |
| --- | --- | ---: | ---: | ---: | ---: |
| Actor start | once per run (per GB of memory; default 256 MB = 1 event) | $0.004 | $0.004 | $0.004 | $0.004 |
| Ad | each `complete` or `partial` ad row | $0.0012 | $0.0011 | $0.00105 | $0.001 |

Ad text, images, YouTube links, countries and impressions are all included in the ad price. `not_found` and `error` rows are free. A run with no ads costs only the start event ($0.004). You pay no separate platform usage.

You can set a maximum cost for a run in Apify. When the Actor reaches it, it stops cleanly, keeps the rows it already saved, and the run summary shows `CAPPED` with `CHARGE_LIMIT`.

#### Cost examples

| Scenario | Input scope | Ad rows | Start | Ads (FREE plan) | Stop/cap behavior |
| --- | --- | ---: | ---: | ---: | --- |
| Small | 1 domain, `maxAds` 10 | 10 | $0.004 | $0.012 | about 30–70 seconds |
| Prefill | 1 domain, `maxAds` 20 | 20 | $0.004 | $0.024 | about 30–70 seconds |
| Medium | 3 domains, `maxAds` 100 | 300 | $0.004 | $0.36 | about 1–2 minutes |
| Large | 5 domains, `maxAds` 200 | up to ~800 | $0.004 | up to ~$0.96 | stops after about 4.5 minutes of work with the rows it has |
| 1,000 ads | 2 runs, 500 ads each | 1,000 | $0.008 | $1.20 (GOLD: $1.00) | split into 2 runs |
| Nothing found | 20 domains with no ads, or a filter with no match | 0 | $0.004 | $0 | 20 free `not_found` rows |

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next integration |
| --- | --- | --- | --- | --- |
| Competitor ad monitoring | `domains` | one row per ad | `headline`, `firstShown`, `lastShown`, `daysShown` | schedule + Google Sheets |
| PPC copy research | `domains` or `advertisers`, `format` = `text` | text ad | `headline`, `description`, `displayUrl` | export CSV |
| Market and country check | `advertisers` + `region` | ad with regions | `regions`, `impressionsMin`, `impressionsMax` | BI tool via API |
| Creative library | `format` = `image` or `video` | image or video ad | `imageUrl`, `videoUrl`, `callToAction` | download images |

### Scheduling and monitoring

- Create an Apify schedule that runs the same input every day or week.
- Each run returns the ads Google shows at that time. Compare runs by `creativeId` to find new ads, or sort by `firstShown`.
- `lastShown` tells you if an ad is still running.
- The Actor does not keep state between runs; each run is a full snapshot and each ad row is charged again.

### API, export and integrations

- **API:** start the Actor with the [Apify API](https://docs.apify.com/api/v2) and read the dataset items as JSON.
- **Export:** download the dataset as JSON, CSV, Excel or XML from the **Output** tab.
- **Webhooks / no-code:** use Apify integrations (Make, Zapier, Google Sheets, webhooks) to send new rows to your tools.

#### Use with AI agents (MCP)

- MCP server URL with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/google-ads-transparency-scraper`
- Smallest useful input:

```json
{ "domains": ["apify.com"], "maxAds": 20 }
```

- Key output fields: `advertiserName` (who runs the ad), `format` (text, image or video), `headline` and `description` (ad copy), `firstShown` / `lastShown` (when it ran), `regions` (countries with impression ranges).
- Typical run: 20 ads in about 30–70 seconds for about $0.028. Limits: up to 20 inputs and 500 ads per input; about 600–800 ads per run.

### Limits and partial results

- Up to 20 domains and advertisers per run, up to 500 ads for each.
- One run works for about 4.5 minutes and collects about 600–800 ads in total in our tests. If it has more to do, it stops with the ads it has and the summary shows `CAPPED` with `DEADLINE`. Split big jobs into several runs.
- A larger run timeout does not make one run collect more.
- A row with `status` `partial` is still charged: the ad is there, but some details (for example text or countries) could not be read. `statusReason` says what is missing.
- Inputs that were not done when the run stopped get free `error` rows.

### Troubleshooting

#### I get a `not_found` row for my advertiser name

Symptom: `status` is `not_found` and `statusReason` lists "Closest" names.
Likely reason: the name does not match whole words of an advertiser in the Transparency Center.
Check: look at the closest names and their AR… IDs in `statusReason`.
Action: put the right AR… ID in **Advertisers**, or use the website domain in **Domains**.

#### I get `not_found` for a domain that runs ads

Symptom: `status` is `not_found` with "The Transparency Center shows no ads for ...".
Likely reason: there are no ads for this region, format or date range. For example, a brand may show no text ads in one country.
Check: open the `sourceUrl` link in your browser.
Action: set **Region** to `anywhere`, **Ad format** to `all`, or remove the dates.

#### The run stopped with `SOURCE_BLOCKED`

Symptom: the run summary shows `ERROR` or `PARTIAL` with `SOURCE_BLOCKED`, and inputs that were not done have free `error` rows.
Likely reason: Google showed a CAPTCHA to all proxy IPs. The Actor does not solve CAPTCHAs.
Check: did you set your own proxy? Then the automatic switch to residential proxy is off.
Action: keep the default proxy and run again later.

#### I asked for 500 ads but got fewer

Symptom: the summary shows `CAPPED` with `DEADLINE`, or the advertiser simply has fewer ads.
Likely reason: one run works for about 4.5 minutes; many inputs with large `maxAds` do not fit.
Action: run fewer inputs per run.

### FAQ

#### Do I need a Google account or an API key?

No. The Actor reads the public Ads Transparency Center pages. No login, cookies or API key.

#### Why are `headline` and `description` empty for some text ads?

Google stores some text ads only as a picture. Then the text is only in the image, `headline` and `description` are `null`, and `imageUrl` has the picture.

#### Are impressions exact?

No. Google shows ranges, for example 1,000–2,000. The Actor returns the lower and upper end. Google does not show impressions for every ad or country; then the values are `null`.

#### How fresh is the data?

Every run reads the Transparency Center live. `lastShown` tells you when Google last showed the ad.

#### Which name match does the Actor use?

For a name, it looks for an advertiser whose name has the same whole words (exact name first). It never guesses a different company. For an exact account, use the AR… ID from the advertiser page URL.

### Related Actors

- [Google Autocomplete Scraper](https://apify.com/cliqtomedia/google-autocomplete-scraper) — find the search phrases around a brand before you check its ads.
- [Website Metadata & Open Graph Scraper](https://apify.com/cliqtomedia/website-metadata-open-graph-scraper) — check titles and descriptions of the landing pages from the ads.

### Support

For a bug, a question or a feature request, open an issue in the **Issues** tab of this Actor. Include the run ID, your input (domains or advertisers) and the `statusReason` or error text. Never send tokens, cookies or billing data.

# Changelog

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

# Actor input Schema

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

Website domains whose ads you want, e.g. apify.com. Returns ads of every advertiser that points to the domain. URLs and www. are cleaned up automatically. Up to 20 domains and advertisers in total.

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

Advertiser names (e.g. Apify Technologies) or advertiser IDs starting with AR (from the advertiser page URL, which you can also paste). A name must match whole words of a Transparency Center advertiser; if nothing matches, you get a free not_found row with the closest names and their AR… IDs. Use the AR… ID to pick an exact account.

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

Where the ads were shown: "anywhere" (default) or a two-letter country code such as US, GB, DE.

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

Only text, image or video ads. "all" keeps every format.

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

Only ads shown on or after this date (YYYY-MM-DD). Leave empty for no start limit.

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

Only ads shown on or before this date (YYYY-MM-DD). Leave empty for today.

## `maxAds` (type: `integer`):

Maximum ads returned for each advertiser or domain, 1–500. One run collects about 600–800 ads in total within its ~4.5-minute working time; split bigger jobs across runs. Each ad row is charged; not-found and error rows are free.

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

Adds the countries where each ad ran, with first/last shown dates and impression ranges per country. Included in the price; turn off only for faster runs.

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

Reads the headline, description and display URL of text ads and the YouTube link of video ads from the Google ad preview. Included in the price; turn off only for faster runs.

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

Apify datacenter proxy by default. If Google blocks it, the Actor switches to Apify residential proxy by itself. Choose your own proxy group or URLs to turn this off. The Actor never solves CAPTCHAs.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "region": "anywhere",
  "format": "all",
  "maxAds": 20,
  "includeDetails": true,
  "includeAdText": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Ad creatives as a table.

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

Status, per-target counts, charged ads and request statistics.

# 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 = {
    "domains": [
        "apify.com"
    ],
    "region": "anywhere",
    "maxAds": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/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 = {
    "domains": ["apify.com"],
    "region": "anywhere",
    "maxAds": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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