# Google Ads Transparency Scraper: Competitor Ads Library (`vncntlabs/google-ads-transparency`) Actor

Google Ads Transparency Center scraper: get any competitor's Google ads by domain, brand or advertiser ID with format, first/last shown dates, creative and preview URLs and per-country reach. Check if a company runs Google Ads, find advertiser IDs and monitor only new ads. Licensed data.

- **URL**: https://apify.com/vncntlabs/google-ads-transparency.md
- **Developed by:** [vncntlabs Labs](https://apify.com/vncntlabs) (community)
- **Categories:** Marketing, SEO tools, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 ad scrapeds

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 Scraper: competitor ads library, advertisers and new-ad monitor

**Scrape the Google Ads Transparency Center** for any competitor: every Google Search, Shopping, YouTube and Display ad an advertiser runs, by domain, brand name or advertiser ID, with format, first and last shown dates, creative and preview URLs and per-country reach. Use it as a Google ads library for PPC research, as a quick 'does this company run Google Ads?' check for lead lists, or as a monitor that returns only new ads. Data comes through a licensed API, so there are no captchas or proxies.

**Who it's for**

- PPC agencies doing competitor research.
- Lead-gen teams qualifying prospects ("are they already spending on Google Ads?").
- Brand-protection teams watching for impersonators.
- Market researchers.

### What you can do

| Mode | You give | You get |
|---|---|---|
| **Ads library** | domains, company names, advertiser IDs or Transparency Center URLs | One row per ad: format (text/image/video), first and last shown dates, days running, preview image, creative preview URL, Transparency Center link, advertiser name/ID, verified flag, and the regions (from your selected countries) where the ad appeared |
| **Quick check** | a list of domains or company names | One row per company: **runs Google Ads? yes/no**, active now (last ad within N days), approximate ad count, last ad date, formats, advertiser names. Built for lead lists |
| **Monitor** | the same targets on a schedule | **Only ads that are new since the last run.** It remembers what it has already seen in a named key-value store in your own Apify account |
| **Find advertisers** | company names | Google's advertiser accounts that match: advertiser ID, legal name, country, verified status and approximate ad count. Also lists related advertiser domains |

**Filters**

- Country, or several countries for **per-country reach**
- Ad format
- Google platform: Search, YouTube, Shopping, Play or Maps
- Date range (history goes back to 31 May 2018)

### Input examples

Competitor ads in the US and UK:

```json
{ "mode": "ads", "targets": ["printify.com", "Canva"], "countries": ["US", "GB"], "maxAdsPerTarget": 100 }
```

Does each lead run Google Ads?

```json
{ "mode": "check", "targets": ["acme-plumbing.com", "bestdentist.com", "Joe's Pizza"], "countries": ["US"] }
```

Daily new-ad alerts (schedule it in Apify):

```json
{ "mode": "monitor", "targets": ["competitor.com"], "maxAdsPerTarget": 120, "monitorStoreName": "competitor-watch" }
```

Only YouTube video ads from the last 30 days:

```json
{ "targets": ["nike.com"], "adFormat": "video", "platform": "youtube", "dateFrom": "30 days" }
```

**Targets** can be any of these:

- `nike.com` or `https://www.nike.com/…` (domain)
- `Nike` (company name)
- `AR16735076323512287233` (advertiser ID)
- An `adstransparency.google.com/advertiser/…` or `…?domain=…` URL

**How names are matched**

- Names are matched to Google's advertiser accounts, ignoring case, punctuation and suffixes like Inc, LLC or GmbH.
- By default only exact name matches count, and every matching verified account is included (big brands often have several).
- Set **Advertiser name matching** to *Best guess* to fall back to the closest match.
- Or use **Find advertisers** to pick advertiser IDs yourself.

### Output

**Ad row** (`type: "ad"`), trimmed:

```json
{
  "target": "printify.com", "advertiserName": "Printify LLC", "advertiserId": "AR08671856592045473793",
  "verified": true, "creativeId": "CR16010598130466684929", "format": "text",
  "adUrl": "https://adstransparency.google.com/advertiser/AR08671856592045473793/creative/CR16010598130466684929?region=US",
  "previewImageUrl": "https://tpc.googlesyndication.com/archive/simgad/17118618634733905916",
  "firstShown": "2025-06-21T01:48:06Z", "lastShown": "2026-10-16T12:38:18Z", "daysRunning": 482,
  "activeNow": true, "advertiserMatchesTarget": true, "regions": ["US", "GB"], "rankInTarget": 1
}
```

**Quick-check row** (`type: "check"`):

- `hasAds`, `hasOwnAds`, `activeNow`, `adsCountApprox`
- `lastAdShown`, `daysSinceLastAd`
- `formatsInSample`, `advertiserNames`, `countriesWithAds`
- `byCountry`, `transparencyUrl`

**Every run also writes:**

- A `target` row per input, with its status:
  - `ok`
  - `no_ads`
  - `no_advertiser_match`
  - `no_new_ads`
  - `baseline_saved`
  - `error`
  - `not_processed`
- `skipped` rows for invalid or duplicate inputs.
- A run summary in the `OUTPUT` record.

Dataset views: **Ads**, **Quick check**, **Advertisers**, **Run summary**. Export to JSON, CSV, Excel or via the API.

### Pricing (pay per event)

You pay only for results.

| Event | Charged when |
|---|---|
| **Ad scraped** | Each ad delivered to your dataset (monitor mode: each *new* ad) |
| **Advertiser processed** | Ads library: each target looked up per country that returned ads. Quick check and Monitor: each target looked up per country (a "no ads" answer is still an answer). Find advertisers: each advertiser account returned |
| **Actor start** | Once per run (Apify standard) |

**Never charged**

- Invalid inputs
- Provider errors
- Names that match no advertiser (Ads library and Monitor)
- Ads library targets with no ads

Set a maximum charge per run and the Actor stops cleanly before going over it.

**Apify free plan:** up to 3 targets, 40 ads per target and 1 country per run.

### Good to know

- **Order and limits.** Ads come most recently shown first.
  - Up to 1,000 ads per target per country.
  - For advertisers with more than 120 ads, the Actor automatically splits the search by format and platform and removes duplicates.
  - Very large advertisers (100k+ ads) return their most recent ads, and the summary shows `allAdsFetched: false`.
- **Counts are estimates.** Ad counts (`adsAvailableApprox`, `adsCountApprox`, `approxAdsCount`) are Google's rounded estimates (for example "~400").
- **How regions work.**
  - `regions` lists the countries you selected where the ad appeared in that country's results.
  - It's complete when the advertiser has fewer ads in that country than *Max ads per target*.
  - Leave Countries empty to search all regions worldwide (`regions` is then empty).
- **Third-party advertisers in domain searches.** A domain search also returns ads from other advertisers that point to that domain, such as partners, resellers and agencies.
  - Every ad carries `advertiserMatchesTarget`, which is true when the advertiser's name looks like the domain owner.
  - Quick check reports both `hasAds` and `hasOwnAds`.
  - Set **Ads found by domain** to *matching* to keep only owner-named advertisers. This also drops agencies that buy ads on a brand's behalf.
- **What's in a creative.**
  - Text ads come with a rendered preview image, not raw headline text.
  - Image, video and rich-media ads come with a preview URL.
  - Per-creative variants and impression or spend ranges are not available (Google publishes spend only for political ads).
- **Monitor runs.**
  - The monitor compares creative IDs against what earlier runs saw for the same target, countries and filters.
  - Run one monitor schedule per store name at a time.
  - Ads cut off by your maximum charge are not marked as seen, so they show up in the next run.

### Use from AI agents (MCP)

AI assistants such as Claude, ChatGPT and Cursor can run this Actor through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp) (`https://mcp.apify.com`). The agent can look up the Actor, read its input schema, run it and read the results. Runs use your own Apify account and are charged at the prices on this page.

- **Actor name:** `vncntlabs/google-ads-transparency`
- **Server URL with only this tool:** `https://mcp.apify.com?tools=vncntlabs/google-ads-transparency`. The default `https://mcp.apify.com` also works; the agent can then search Apify Store and call the Actor by name.
- **Claude** (desktop app or claude.ai): Settings > Connectors > Add custom connector, paste the server URL, then sign in to Apify.
- **ChatGPT:** turn on Developer mode, then Settings > Apps & Connectors > Create, paste the server URL and choose OAuth.
- **Cursor:** run `/add-plugin apify` in Cursor chat and connect the Apify MCP server under Cursor Settings > Tools & MCPs, or add the server to `mcp.json`:

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

Example prompt: *"Use the Apify Actor vncntlabs/google-ads-transparency to list up to 50 Google ads that competitor.com ran in the US, and summarise their main offers."*

To cap the cost of an agent's run, it can pass `maxTotalChargeUsd` in the run options.

### FAQ

**Is this legal?** The Ads Transparency Center is a public Google service. This Actor retrieves its data through a licensed third-party API and does not log in or bypass any protection. You are responsible for how you use the data.

**Why does a company show "no ads"?**

- It isn't running Google Ads in that country.
- It advertises under a different domain or legal name. Try **Find advertisers**.
- All of its ads are older than your date filter.

**Not affiliated with Google.** "Google" and "Google Ads" are trademarks of Google LLC and are used here only to describe the data source.

Questions or a missing feature? Open an issue on the Actor page.

# Actor input Schema

## `mode` (type: `string`):

<b>Ads library</b>: every ad of each target with format, first/last shown dates, preview image/creative URLs and regions. <b>Quick check</b>: one row per target with hasAds, activeNow, approximate ad count and last ad date (great for lead lists). <b>Monitor</b>: schedule it; each run returns only ads not seen before. <b>Find advertisers</b>: search Google's advertiser directory by name.

## `targets` (type: `array`):

One per line. Domain (<code>nike.com</code>), company name (<code>Nike</code>), advertiser ID (<code>AR16735076323512287233</code>) or an adstransparency.google.com URL. Names are matched to Google's advertiser accounts (see Advertiser name matching).

## `countries` (type: `array`):

Region(s) where the ads were shown. Pick several to see per-country reach: each ad lists the selected countries it appeared in. Leave empty for all regions worldwide. Each country is a separate lookup.

## `maxAdsPerTarget` (type: `integer`):

Most recently shown ads first. Up to 1,000 per target; very large advertisers (e.g. 100k+ ads) return the most recent ones.

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

Only ads of this format.

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

Only ads shown on this Google platform.

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

Only ads shown on or after this date: YYYY-MM-DD (earliest 2018-05-31) or a relative period such as '30 days' (= 30 days ago, handy for scheduled runs).

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

Only ads shown on or before this date (YYYY-MM-DD). Defaults to today when 'Shown from' is set.

## `activeWithinDays` (type: `integer`):

activeNow is true when the ad (or, in quick check, the newest ad) was last shown within this many days.

## `advertiserMatch` (type: `string`):

How company names map to advertiser accounts. Exact: names equal after ignoring case, punctuation and suffixes like Inc/LLC/GmbH; all matching verified accounts are included. Best guess: falls back to the closest match. Domains and advertiser IDs are always exact.

## `domainAdvertisers` (type: `string`):

A domain search also returns ads by other advertisers that point to that domain (partners, resellers, agencies). Every ad has advertiserMatchesTarget; choose 'matching' to keep only advertisers whose name looks like the domain owner (e.g. 'HubSpot, Inc.' for hubspot.com). Note: agencies buying ads for a brand are dropped too.

## `includeUnverified` (type: `boolean`):

When matching names, also use advertiser accounts Google has not verified (used anyway if no verified account matches).

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

Find advertisers mode: maximum advertiser accounts per name.

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

Monitor mode keeps the ad IDs it has seen in this named key-value store in your Apify account. Use different names for independent monitors.

## `monitorFirstRun` (type: `string`):

What the very first monitor run returns for a target.

## Actor input object example

```json
{
  "mode": "ads",
  "targets": [
    "printify.com",
    "Canva"
  ],
  "countries": [
    "US"
  ],
  "maxAdsPerTarget": 40,
  "adFormat": "all",
  "platform": "all",
  "activeWithinDays": 30,
  "advertiserMatch": "exact",
  "domainAdvertisers": "all",
  "includeUnverified": false,
  "maxAdvertisersPerQuery": 10,
  "monitorStoreName": "google-ads-transparency-monitor",
  "monitorFirstRun": "return_all"
}
```

# Actor output Schema

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

No description

## `checks` (type: `string`):

No description

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

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "ads",
    "targets": [
        "printify.com",
        "Canva"
    ],
    "countries": [
        "US"
    ],
    "maxAdsPerTarget": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/google-ads-transparency").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 = {
    "mode": "ads",
    "targets": [
        "printify.com",
        "Canva",
    ],
    "countries": ["US"],
    "maxAdsPerTarget": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/google-ads-transparency").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 '{
  "mode": "ads",
  "targets": [
    "printify.com",
    "Canva"
  ],
  "countries": [
    "US"
  ],
  "maxAdsPerTarget": 40
}' |
apify call vncntlabs/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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

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/5Q7DvLndAyDvnpmVh/builds/JLDeRgZUQqzDX9JTx/openapi.json