# Google Ads Transparency Center API - Competitor Ads (`ocius-data/google-ads-transparency-reliable`) Actor

Google Ads Transparency Center API and ad library: advertiser ads by domain with full creatives, formats, regions and dates. Track new or stopped ads.

- **URL**: https://apify.com/ocius-data/google-ads-transparency-reliable.md
- **Developed by:** [Christian Barbosa](https://apify.com/ocius-data) (community)
- **Categories:** SEO tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 ad saveds

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 Center API - Competitor Ads

Scrape the **Google Ads Transparency Center** for any advertiser, brand or website and get **full ad creatives**, not just metadata: headlines, descriptions, calls to action, **image URLs**, **YouTube video URLs** and landing pages, plus first and last shown dates, regions, platforms and EU impression ranges. Run it once for competitor ad research, or schedule it in **monitoring mode** to receive only the ads that are **new or stopped since the last run**. You pay only for rows saved. Empty results, errors and duplicates are free.

This Actor works as a Google Ads Transparency API: call it from your code, a schedule, Google Sheets, Zapier, Make, n8n or an AI agent through MCP.

### What this Google Ads Transparency scraper does

- **Search by advertiser name, domain or advertiser ID.** A domain such as `nike.com` returns every ad that points to that website, from all advertiser accounts. A name such as `Nike` is matched against the Transparency Center advertiser search.
- **Full creatives for every format.** Text, image and video ads. With **Full creative** on, the Actor reads every variation of each ad and returns all headlines, descriptions, calls to action, image URLs with their size, YouTube video URLs and landing pages.
- **Monitoring mode.** Keeps a snapshot of each advertiser in a named key-value store and returns only ads that are `NEW`, `STOPPED` or `RESUMED` since the previous run. Unchanged ads cost nothing.
- **Filters.** Country, date range, ad format (text, image, video) and platform (Google Search, YouTube, Shopping, Maps, Play).
- **Clean, normalized data.** Dates in ISO 8601 (UTC), country codes in ISO 3166, a validated `format` value and an `isActive` flag on every row.
- **Reliable by design.** No browser. The Actor calls the same endpoints the Transparency Center website uses, retries with backoff and new IP addresses, and switches from datacenter to residential proxies automatically when Google rate-limits.
- **Batches of domains.** Enter hundreds of domains or advertiser IDs in one run. Up to three inputs are processed in parallel within the request limit you set.

### Use cases

- **Competitor ad monitoring.** Schedule a daily run for your top competitors and receive a webhook or a Google Sheets row only when they launch or stop an ad.
- **Creative research and swipe files.** Collect every headline, description, image and video a brand runs, with first and last shown dates to see which creatives last longest.
- **Agency pitches and market analysis.** Show a prospect what their competitors run, in which countries and on which platforms.
- **Brand protection.** Find every ad that points to your domain, including ads from accounts you do not control.
- **Regional campaign tracking.** Filter by country to see local campaigns and, in the EU, impression ranges per platform.
- **Academic and policy research** on online advertising.

### How to use it

1. Enter one or more **advertiser names or domains** (for example `Nike` or `nike.com`), or **advertiser IDs** (for example `AR11877675844556029953`, or the advertiser page URL).
2. Optional filters: **region** (`US`, `GB`, `CO`, `ES`, `BR`), **Shown from** and **Shown until**, **ad format** and **platform**.
3. Set **Max ads per advertiser or domain**. The limit is applied in code, so you never pay for more ads than this.
4. Choose the level of detail:
   - **Fetch ad details** (on by default): regions, dates per region, ad text, media and landing page.
   - **Full creative** (premium): every variation of each ad, with all text, images and videos.
5. Optional: turn on **Only new or stopped ads since the last run** to use monitoring mode.
6. Run the Actor, or schedule it.

#### Input examples

One-off competitor research with full creatives:

```json
{
  "searchQueries": ["nike.com", "adidas.com"],
  "region": "US",
  "maxAdsPerAdvertiser": 100,
  "fullCreative": true
}
```

Daily monitoring of three competitors (schedule this input):

```json
{
  "searchQueries": ["rappi.com"],
  "advertiserIds": ["AR11877675844556029953"],
  "maxAdsPerAdvertiser": 200,
  "monitorChanges": true,
  "monitorStoreName": "competitors-co",
  "stoppedAfterDays": 3
}
```

### Monitoring mode: only new or stopped ads

Monitoring mode turns the Actor into a competitor ad tracker.

- **First run (baseline).** The current ads of each advertiser are saved and returned with `changeType: "NEW"` and `monitorBaseline: true`.
- **Later runs.** Only changes are returned:
  - `NEW`: an ad that was not in the previous snapshot.
  - `STOPPED`: an ad that was active and whose last shown date is now older than **Stopped after (days)** (default 3).
  - `RESUMED`: an ad that had stopped and is running again.
- **Snapshot storage.** One record per advertiser or domain, and per region, format and platform filter, in the named key-value store set in **Monitoring store name** (default `google-ads-monitor`). Named stores are kept between runs in your Apify account. Use a different store name for each independent setup.
- **What is checked.** In this mode, **Max ads per advertiser** is how many of the most recent ads are checked on each run. Known active ads that fall outside that window are looked up one by one (up to 100 per advertiser and run) to confirm whether they stopped.
- **Cost safety.** The snapshot only records rows that were actually saved. If your maximum cost per run stops the Actor early, the remaining changes are returned on the next run, not lost.
- **Statuses.** An input without changes ends as `NO_CHANGES` and is not charged.

### Advertiser summary: one row per advertiser

Turn on **Advertiser summary** to get one row per advertiser instead of one row per ad. It is useful for comparing many competitors at a glance before pulling their full ad lists.

- **Fields.** `advertiserId`, `advertiserName`, `adsReportedByGoogle` (total shown by the Transparency Center for an advertiser ID; it may be rounded), `adsScanned`, `scanComplete`, `activeAds`, `textAds`, `imageAds`, `videoAds`, `formats`, `regions` and `platforms` (most frequent first), `regionsCount`, `adsWithDetails`, `firstSeen`, `lastSeen`, `advertiserUrl`, plus `recordType: "advertiserSummary"`, `input`, `filters`, `sourceUrl` and `scrapedAt`.
- **What is scanned.** **Max ads per advertiser** sets how many of the most recent ads are read. Regions and platforms come from the ads opened with **Fetch ad details** on (up to 100 per advertiser). Formats, dates and active ads come from every ad scanned.
- **Domains.** A domain can show ads from several advertisers (resellers, regional branches, agencies); each one gets its own row.
- **Limits.** It cannot be combined with **Full creative** or monitoring mode. Region, format, platform and date filters apply.
- **Cost.** Summary rows use the `advertiser-summary` event; no `ad` event is charged in this mode. See the Pricing section.

### Output

Each row is one unique ad. The output tab has four views: **Ads overview**, **Ad content**, **Full creative** and **Monitoring changes**. Download as JSON, CSV, Excel or HTML, or read it through the API.

```json
{
  "advertiserId": "AR11877675844556029953",
  "advertiserName": "RAPPI INC",
  "creativeId": "CR09363344213577564161",
  "format": "VIDEO",
  "firstShown": "2024-06-12T04:53:02.000Z",
  "lastShown": "2026-10-31T19:31:48.000Z",
  "daysShown": 873,
  "isActive": true,
  "regions": ["MX"],
  "headline": "Vender en Rappi sí funciona",
  "channelName": "Rappi Restaurantes",
  "videoUrl": "https://www.youtube.com/watch?v=AKlF58rtl3c",
  "landingUrl": "https://merchants.rappi.com/es-mx/restaurants",
  "landingDomain": "merchants.rappi.com",
  "variationsCount": 3,
  "variationsRead": 3,
  "allHeadlines": ["Vender en Rappi sí funciona", "Afíliate hoy a Rappi"],
  "allVideoUrls": [
    "https://www.youtube.com/watch?v=AKlF58rtl3c",
    "https://www.youtube.com/watch?v=6JgAgbc1aWI"
  ],
  "creativeAssetsCount": 4,
  "changeType": null,
  "previewUrl": "https://adstransparency.google.com/advertiser/AR11877675844556029953/creative/CR09363344213577564161?region=anywhere",
  "input": "rappi.com",
  "scrapedAt": "2026-11-01T20:52:31.035Z"
}
```

#### Field dictionary

| Field | Type | Meaning | When it is null or empty |
|---|---|---|---|
| `advertiserId`, `advertiserName` | string | Transparency Center advertiser ID and verified name. | `advertiserName` when Google does not report it |
| `creativeId` | string | Unique ad ID. Rows are deduplicated by this ID. | Never |
| `format` | string | `TEXT`, `IMAGE` or `VIDEO`. | Never |
| `firstShown`, `lastShown` | ISO 8601 | First and last time the ad was shown (UTC). | When Google does not report the date |
| `daysShown` | number | Days the ad was shown. | When Google does not report it |
| `isActive` | boolean | `true` when `lastShown` is within **Stopped after (days)**. | Never |
| `regions` | array | Country codes where the ad was shown. | Details off and no region filter |
| `regionStats` | array | Per region: code, name, first and last shown date, impression range and platforms. | Details off |
| `platforms` | array | `SEARCH`, `YOUTUBE`, `SHOPPING`, `MAPS`, `PLAY`. | Outside the EU without a platform filter |
| `impressionsMin`, `impressionsMax` | number | Total impression range (EU only). | Outside the EU |
| `headline`, `longHeadline`, `description`, `callToAction` | string | Ad text. | Ads Google stores only as an image |
| `adText` | string | Visible text of ads rendered as HTML, such as Search, Maps and Shopping ads. | Structured or image-only ads |
| `appName`, `channelName` | string | App name (app ads) or YouTube channel (video ads). | Not applicable |
| `imageUrl`, `imageUrls` | string, array | Ad image or the rendered snapshot of a text ad. | Video and HTML ads without an image |
| `videoId`, `videoUrl`, `videoThumbnailUrl` | string | YouTube video of the ad. | Non-video ads |
| `landingUrl`, `landingDomain` | string | Page the ad links to and its domain. | When Google does not include it |
| `variationsCount` | number | Variations shown in the Transparency Center. | Details off |
| `variations` | array | Full creative only: one entry per variation with text, image URL and size, video URL and landing page. | Full creative off |
| `allHeadlines`, `allDescriptions`, `allCallsToAction` | array | Full creative only: every distinct text asset. | Full creative off |
| `allImageUrls`, `allVideoUrls`, `allLandingUrls` | array | Full creative only: every distinct image, video and landing page. | Full creative off |
| `creativeAssetsCount`, `variationsRead` | number | Full creative only: assets found and variations read. | Full creative off |
| `changeType` | string | Monitoring only: `NEW`, `STOPPED` or `RESUMED`. | Monitoring off |
| `monitorBaseline` | boolean | Monitoring only: `true` on the first run of an advertiser. | Monitoring off |
| `detailsFetched` | boolean | `true` when the ad detail was read. | Never |
| `previewUrl` | string | The ad in the Transparency Center, to check it yourself. | Never |
| `input`, `filters`, `sourceUrl` | mixed | The input and filters that found the ad, and the matching Transparency Center page. | Never |
| `scrapedAt` | ISO 8601 | When the data was collected (UTC). | Never |

### Pricing and cost calculator

This Actor uses pay-per-event pricing. You pay only for the events below; inputs with no ads, failed inputs, unchanged ads in monitoring mode and duplicate ads (the same ad found through two inputs) are never charged. Your maximum cost per run is respected: the Actor checks the remaining budget before saving each row and stops as soon as it is reached.

| Event | Price | When it is charged |
|---|---|---|
| `ad` | USD 0.0015 | Each unique ad saved, including `NEW` rows in monitoring mode. Ad details are included. |
| `ad-creative-full` | USD 0.003 | Premium, only with **Full creative** on: each ad saved that has at least one creative asset (text, image or video). |
| `ad-change-detected` | USD 0.002 | Premium, monitoring mode only: each `STOPPED` or `RESUMED` row. |
| `advertiser-summary` | USD 0.01 | Advertiser summary mode only: each advertiser row. |

| Scenario | Rows | Approximate cost |
|---|---|---|
| Weekly check of 5 competitors, 50 ads each | 250 ads | USD 0.38 |
| The same check with Full creative | 250 ads | USD 1.13 |
| 20 advertisers, 100 ads each | 2,000 ads | USD 3.00 |
| Full history of one large advertiser | 10,000 ads | USD 15.00 |
| Daily monitoring of 10 competitors: baseline of 100 ads each, then 30 new and 10 stopped ads per day | 1,000 ads once, then 40 rows a day | USD 1.50 once, then about USD 0.07 a day |

Formula: `ads × 0.0015 + ads with assets × 0.003 (Full creative) + stopped or resumed rows × 0.002 (monitoring)`.

### Integrations: schedules, API, webhooks, Google Sheets, Zapier, Make and AI agents

- **Schedules.** In Apify Console, open **Schedules**, create a schedule (for example daily at 07:00), and add this Actor with your saved input. Combine it with monitoring mode to track competitors automatically.

- **API.** Run the Actor and get the rows in one call:

  ```bash
  curl -X POST "https://api.apify.com/v2/acts/ocius-data~google-ads-transparency-reliable/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
    -H "Content-Type: application/json" \
    -d '{"searchQueries":["nike.com"],"maxAdsPerAdvertiser":50}'
  ```

  Python, with the official `apify-client` package:

  ```python
  from apify_client import ApifyClient

  client = ApifyClient("YOUR_API_TOKEN")
  run = client.actor("ocius-data/google-ads-transparency-reliable").call(
      run_input={"searchQueries": ["nike.com"], "monitorChanges": True}
  )
  for ad in client.dataset(run["defaultDatasetId"]).iterate_items():
      print(ad["changeType"], ad["creativeId"], ad["headline"])
  ```

- **Webhooks.** In the Actor's **Integrations** tab, add a webhook for the event `ACTOR.RUN.SUCCEEDED`. Your endpoint receives the run, and the rows are at `/v2/datasets/{defaultDatasetId}/items`. In monitoring mode every row is a change, so the webhook works as a "competitor launched or stopped an ad" alert.

- **Google Sheets.** Use the Google Sheets integration in the **Integrations** tab to append the rows of each run to a sheet.

- **Zapier, Make and n8n.** Use the official Apify app in each tool: trigger on "Actor run finished" and read the dataset items, or start a run from your own workflow.

- **MCP and AI agents.** The Actor runs with limited permissions and a flat input, so it can be used through the Apify MCP server (`mcp.apify.com`) by Claude, ChatGPT, Cursor and other MCP clients. Ask the agent to run `ocius-data/google-ads-transparency-reliable` with a domain and it returns structured ads.

Related Actor from the same developer: Google Trends Scraper, to compare the search demand behind the brands you monitor.

### Statuses and errors

Every input ends with one status in the `RUN_SUMMARY` record (Storage, key-value store), together with ads requested, available and delivered, and the reason when fewer were delivered.

| Status | Meaning | Charged | What to do |
|---|---|---|---|
| `OK` | Ads returned. `reason` explains any shortfall. | Rows saved | Nothing |
| `NO_RESULTS` | No matching advertiser, or no ads for these filters. | No | Check the name or domain, or widen the filters. |
| `NO_CHANGES` | Monitoring: nothing new, stopped or resumed. | No | Nothing |
| `PARTIAL` | Some ads saved, then Google kept rate-limiting or failed. | Rows saved | Run again later. |
| `BLOCKED` | Google kept rate-limiting after all retries and proxy changes. | No | Run again later or use residential proxies. |
| `SOURCE_ERROR` | The Transparency Center returned an error. | No | Run again; if it persists, open an issue. |
| `INVALID_INPUT` | The advertiser ID is not valid. | No | Use an ID such as `AR11877675844556029953`. |
| `NOT_PROCESSED` | The run stopped first: cost limit reached or five inputs failed in a row. | No | Raise the cost limit or run again. |

Invalid filters stop the run within seconds with a message that explains how to fix them. If more than 20% of inputs fail, the run is marked as failed so you notice.

### Known limits

- Google stores many text ads only as a rendered image. For those you get the image snapshot and no text; Full creative still returns every snapshot with its size.
- Full creative reads up to 10 preview scripts per ad. Ads with more variations report the total in `variationsCount`.
- Platforms and impression ranges are disclosed by Google only for EU countries. Google applies the platform filter only to ads shown since 4 September 2023.
- The ad count Google reports for large advertisers is approximate.
- Monitoring compares runs with the same region, format and platform filters. Changing those filters starts a new baseline; date filters do not.
- `STOPPED` and `RESUMED` use the global last shown date Google reports for the ad, also when a region filter is set. An ad that stops in one country but keeps running elsewhere stays active.
- Google rate-limits by IP address. Very large runs take longer because the Actor paces requests to avoid blocks.

### FAQ

**Is it legal to scrape the Google Ads Transparency Center?** The Actor collects ads that Google publishes so anyone can review them. Advertisers are businesses and no personal data is collected. Check the rules that apply to your use case.

**What is the difference between Fetch ad details and Full creative?** Details add regions, dates per region, the main text, media and landing page, at the base price. Full creative reads every variation and returns all assets, for an extra premium event.

**How do I get only new competitor ads every day?** Turn on monitoring mode and create a daily schedule. The first run is the baseline; after that you receive only changes.

**Can I monitor many advertisers?** Yes. Each advertiser or domain has its own snapshot record. Use one store name per project.

**Why is the ad text empty for some ads?** Google stores those ads only as an image. The image URL is included.

**Why do counts differ from the website?** The website shows rounded counts. Use the same region, dates, format and platform to compare.

**Do you offer volume pricing?** For more than one million rows per month, open an issue on the Actor page to agree on a volume price.

### Related Actors from ocius-data

Built to the same standard: a status for every input in `RUN_SUMMARY`, actionable error messages and list-based inputs, so they chain well in one workflow:

- **[Bulk Keyword Search Volume & CPC - Keyword Planner](https://apify.com/ocius-data/keyword-metrics)**: absolute monthly search volume, cost per click (CPC) and competition from Google Ads data, no Ads account needed.
- **[Bulk Domain Authority & Backlinks Checker API](https://apify.com/ocius-data/domain-authority)**: domain authority (0 to 100), backlinks and referring domains for up to 50,000 domains.
- **[Google Trends API: Interest, Related & Trending Now](https://apify.com/ocius-data/google-trends-reliable)**: relative interest over time and by region, related queries and Trending Now.

### Changelog

- **November 2026** Advertiser summary mode (off by default): one row per advertiser with ads scanned, active ads, ads per format, regions, platforms and first and last seen dates. Event `advertiser-summary`, USD 0.01 per advertiser.
- **0.2** (November 2026) Full creative mode with every variation, image size and all video URLs (premium event `ad-creative-full`). Monitoring mode with `NEW`, `STOPPED` and `RESUMED` rows, snapshots in a named key-value store and lookups of ads that left the list (premium event `ad-change-detected`). `isActive` field. Video IDs and landing pages found in more ad types. Budget checked before each row. Up to three inputs in parallel.
- **0.1** (November 2026) First version: search by name, domain or advertiser ID; region, date, format and platform filters; ad details; pay per ad; per-input statuses and run summary.

### Support

Open an issue on the Actor page. Issues are reviewed every day and fixes are released quickly.

# Actor input Schema

## `searchQueries` (type: `array`):

Advertiser names (for example Nike) or website domains (for example nike.com). A domain returns every ad that points to that website. A name is matched against the Transparency Center advertiser search. You are charged once per unique ad saved.

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

Transparency Center advertiser IDs (for example AR11877675844556029953) or advertiser page URLs. The ID is the part after /advertiser/ in the URL.

## `maxAdvertisersPerQuery` (type: `integer`):

When you search by name, how many matching advertisers to scrape. 1 keeps only the best match (an exact name match is preferred). Not used for domains or advertiser IDs.

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

Two-letter country code, such as US, GB, CO, ES, BR or MX. Only ads shown in that country are returned. Leave empty for all regions.

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

Only ads shown on or after this date (YYYY-MM-DD). Set it together with Shown until, or leave both empty for all dates. Google applies dates in Pacific time.

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

Only ads shown on or before this date (YYYY-MM-DD). Set it together with Shown from.

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

Return only ads of this format, as in the Transparency Center format filter.

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

Return only ads shown on this Google platform. Google only applies this filter to ads shown since 4 September 2023.

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

Maximum number of ads saved for each advertiser or domain. The limit is applied in code, so you never pay for more ads than this.

## `fetchDetails` (type: `boolean`):

Open each ad to add the regions where it was shown (with first and last shown dates and, in the EU, impression ranges and platforms), the ad text (headline, description, call to action), image and video URLs, and the landing page. Turn off for a faster list with dates, format and preview links only. The price per ad is the same.

## `fullCreative` (type: `boolean`):

Read every variation of each ad and return the complete creative: all headlines, descriptions and calls to action, every image URL with its size, every YouTube video URL and every landing page, plus one entry per variation. Turns on ad details automatically. Adds the premium "ad-creative-full" event for each ad that has at least one creative asset; ads without assets are not charged for it. See the Pricing section.

## `advertiserSummary` (type: `boolean`):

Return one row per advertiser instead of one row per ad: ads scanned, active ads, ads per format, regions and platforms (from the ads opened when Fetch ad details is on, up to 100 per advertiser), and first and last seen dates. Max ads per advertiser sets how many of the most recent ads are scanned. Cannot be combined with Full creative or monitoring mode. Charged with the advertiser-summary event; while that event is not listed in the Pricing section, summary rows are not charged.

## `monitorChanges` (type: `boolean`):

Monitoring mode. The Actor keeps a snapshot of each advertiser or domain in a named key-value store and returns only ads that are NEW, STOPPED or RESUMED since the previous run. The first run saves the current ads as the baseline. Unchanged ads are free. Schedule the Actor (for example daily) to track competitors. In this mode, Max ads per advertiser is how many of the most recent ads are checked per run.

## `monitorStoreName` (type: `string`):

Name of the key-value store that keeps one snapshot per advertiser or domain (and per region, format and platform filter) between runs. Use a different name for each independent monitoring setup. Lowercase letters, digits and hyphens.

## `stoppedAfterDays` (type: `integer`):

An ad counts as active when Google shows it as last shown within this many days, and as STOPPED once its last shown date is older. Also used for the isActive field in every row.

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

How many requests run in parallel. Higher is faster but more likely to be rate-limited by Google.

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

How many times a rate-limited or failed request is retried with a new session and IP address, after the first attempt.

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

By default the Actor starts with Apify datacenter proxies and switches automatically to residential proxies (in the selected region, if any) when Google rate-limits requests.

## Actor input object example

```json
{
  "searchQueries": [
    "rappi.com"
  ],
  "maxAdvertisersPerQuery": 1,
  "region": "",
  "adFormat": "",
  "platform": "",
  "maxAdsPerAdvertiser": 50,
  "fetchDetails": true,
  "fullCreative": false,
  "advertiserSummary": false,
  "monitorChanges": false,
  "monitorStoreName": "google-ads-monitor",
  "stoppedAfterDays": 3,
  "maxConcurrency": 4,
  "maxRetries": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per unique ad: advertiser, dates, regions, platforms, format, ad text, image and video URLs, landing page and preview link. In monitoring mode, only NEW, STOPPED and RESUMED ads. With Advertiser summary on, one row per advertiser (recordType advertiserSummary) instead.

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

Status per input (OK, NO_RESULTS, NO_CHANGES, PARTIAL, BLOCKED, SOURCE_ERROR, INVALID_INPUT, NOT_PROCESSED), with ads requested, available and delivered, monitoring counts, events charged and the reason when fewer ads were delivered.

# 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 = {
    "searchQueries": [
        "rappi.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ocius-data/google-ads-transparency-reliable").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 = { "searchQueries": ["rappi.com"] }

# Run the Actor and wait for it to finish
run = client.actor("ocius-data/google-ads-transparency-reliable").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 '{
  "searchQueries": [
    "rappi.com"
  ]
}' |
apify call ocius-data/google-ads-transparency-reliable --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ocius-data/google-ads-transparency-reliable"
        }
    }
}
```

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/tRK9jicRlVmGU3kvj/builds/RwHT6sP3ddgAve6s1/openapi.json