# Google Ads Transparency Scraper — Competitor Ads | $0.60/1K (`actor-forge/ads-transparency`) Actor

Scrape competitor ads from the Google Ads Transparency Center by domain, advertiser name or ID: format, first/last shown, regions, impressions, ad copy, images, video and landing domain. Schedule it to get only new ads. $0.60 per 1,000 ads.

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

## Pricing

from $0.60 / 1,000 ad results

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## Google Ads Transparency Scraper — Competitor Ads | $0.60/1K

Scrape competitor ads from the Google Ads Transparency Center by domain, advertiser name or ID: format, first/last shown, regions, impressions, ad copy, images, video and landing domain. Schedule it to get only new ads. $0.60 per 1,000 ads.

See **what ads your competitors are running** on Google, and get told when they launch new ones. This **Google Ads Transparency scraper** reads the public **ad library** at adstransparency.google.com (Search, YouTube, Display, Shopping and Maps ads) and returns one clean row per ad: advertiser (company name, ID, country), creative ID, format (text / image / video), first and last shown, days running, countries, impression ranges, best-effort headline and description, image and video URLs, landing domain and a link to the ad's transparency page. Search by **competitor domain** (nike.com), **advertiser name** (HubSpot) or advertiser ID; filter by country, date range and format. The main use is **ad monitoring**: switch on *Only new ads since the last run*, schedule it daily, and each run returns just the **competitor ads** that appeared since the last run (already-seen ads are skipped and never charged). Plain HTTP, no browser, 256 MB. **$0.60 per 1,000 ads**, about a third of the leading Google Ads Transparency actors ($1.50-2.00 per 1,000).

📘 **Step-by-step guide:** [How to Monitor Competitor Ads in Google Ads Transparency Center](https://devtaonas.github.io/actorforge-site/guides/monitor-competitor-ads-google-ads-transparency/)

### What data does it return?

Every run outputs clean, schema-validated rows like these:

| advertiserName | format | firstShown | lastShown | regions | landingDomain | previewUrl |
| --- | --- | --- | --- | --- | --- | --- |
| Nike, Inc. | text | 2022-11-30 | 2026-10-19 | US | nike.com | https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR00144196208338927617 |
| INITIATIVE MEDIA B.V. | video | 2023-10-17 | 2026-10-19 | FR, BE, DE, IT, ES, … | nike.com | https://adstransparency.google.com/advertiser/AR11154049584043393025/creative/CR03397377851928870913 |
| Hubspot, Inc. | text | 2025-11-03 | 2026-10-19 | US, DE, FR, IN, BR, … | hubspot.com | https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/… |
| Argos Limited | text | 2025-… | 2026-10-19 | GB | argos.co.uk | https://adstransparency.google.com/advertiser/AR08556219150266007553/creative/CR07375270183734083585 |

### How much does it cost?

Transparent pay-per-event pricing — you only pay for what you get, and the
actor **always respects your run budget**: set a maximum total charge and it
stops cleanly at the cap instead of overrunning.

| Event | Price | Charged | Worked example |
| --- | --- | --- | --- |
| `ad-result` | $0.0006 | per ad delivered | 100 ads = $0.06; 1,000 ads = $0.60; a daily monitor returning ~20 new ads = $0.012 a day |
| `ad-detail` | $0.001 | per ad, only when 'Include ad details' is on (one extra lookup: regions, impressions, ad copy) | 100 ads with details = $0.06 + $0.10 = $0.16 |
| `apify-actor-start` | $0.00005 | per run per GB of memory (platform start fee) | One run at 256 MB = $0.0000125 |

### Input options

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `domains` | array | no | — | Competitor websites, e.g. nike.com. Returns every ad Google shows for that domain, from the brand itself and from agencies or resellers advertising it. |
| `advertiserNames` | array | no | — | Company names as shown in the Ads Transparency Center, e.g. HubSpot, Argos Limited. Exact name matches are used (a brand's several legal entities are all kept); otherwise the closest advertiser with the most ads. |
| `advertiserIds` | array | no | `[]` | Google advertiser IDs (AR… from an adstransparency.google.com/advertiser/AR… link). |
| `regions` | array | no | `[]` | Only ads shown in these countries, as two-letter codes (US, GB, DE, FR…). Empty = anywhere. |
| `dateFrom` | string | no | — | Only ads shown on or after this date (YYYY-MM-DD). |
| `dateTo` | string | no | — | Only ads shown on or before this date (YYYY-MM-DD). |
| `formats` | array | no | `[]` | Only these formats. Empty = all. |
| `maxAdsPerAdvertiser` | integer | no | `100` | How many ads to read for each domain, advertiser name or advertiser ID, newest first as the Transparency Center lists them. |
| `maxResults` | integer | no | `1000` | Stop after this many ads across all searches. You pay per ad delivered ($0.60 per 1,000). |
| `includeDetails` | boolean | no | `false` | One extra lookup per ad: countries shown, impression ranges and first/last shown per country, plus best-effort headline/description text. Charged as ad-detail ($1 per 1,000). |
| `onlyNewSinceLastRun` | boolean | no | `false` | Remember every ad delivered in a named key-value store (ads-seen-\<monitor name>) and return only ads not seen before. Schedule the actor daily to get a feed of competitors' new ads; already-seen ads are skipped and never charged. |
| `monitorName` | string | no | `"default"` | Name of the seen-ads memory used by 'Only new ads'. Use one name per schedule (e.g. uk-competitors) so separate watch lists don't share state. |
| `proxyConfiguration` | object | no | `{"useApifyProxy":false}` | Not needed: the Transparency Center is public. Leave off unless you have your own reason to route requests through a proxy. The actor never rotates proxies to get around a block. |

### Limits & honest notes

- No CAPTCHA solving, no protection bypass. If Google answers with a CAPTCHA or its "unusual traffic" page (or keeps answering 429/403), the actor stops the run at once, keeps the ads already delivered, and says so in the run's status message and RUN_SUMMARY. Blocked requests are never charged. Google can do this to automated traffic from busy IP ranges, so some runs may return partial results; re-run later.
- No proxy rotation and no browser imitation: requests use an honest user agent naming this actor. You can set your own proxy for your own reasons; the default is none.
- Data comes from the same keyless JSON calls the public Transparency Center page makes (its robots.txt has no rules). Requests are paced (at most 2 at a time, 0.8-2 s apart, backoff on errors).
- Ad copy (headline/description) needs 'Include ad details' and is best-effort: many Google text ads are published only as a rendered snapshot image (returned as previewImageUrl), and image ads have no text.
- There is no ad-text keyword search in the Transparency Center: search by domain, advertiser name or advertiser ID. A domain search returns ads from every advertiser that advertises that domain (agencies and resellers included).
- Advertiser country is filled for advertiser-name searches (from Google's advertiser search); domain and ID searches leave it empty.
- Advertisers are businesses. Where Google lists a verified individual as the advertiser, only the name Google itself publishes is returned. No other personal data is collected.
- 'Max ads per domain / advertiser' counts ads read, newest first, so a daily monitor stays fast and cheap. Already-seen ads (monitoring), filtered-out formats and errors are never charged.
- Respects your run budget: set a maximum total charge and the actor stops cleanly at the cap.

### Related ActorForge actors

- [Website Change Monitor](https://apify.com/actor-forge/website-change-monitor) — watch competitors' landing pages change
- [Tech Stack Detector](https://apify.com/actor-forge/tech-stack-detector) — see which ad and analytics tags a competitor runs
- [SEO Audit Crawler](https://apify.com/actor-forge/seo-audit)
- [Domain WHOIS & DNS Lookup](https://apify.com/actor-forge/domain-lookup)
- **Learn more:** [How to Monitor Competitor Ads in Google Ads Transparency Center](https://devtaonas.github.io/actorforge-site/guides/monitor-competitor-ads-google-ads-transparency/)

### Changelog

- **2026-10-19** — Initial release: Google Ads Transparency Center search by domain, advertiser name and ID; region, date and format filters; per-country impressions and ad copy with details; only-new-ads monitoring; hard stop on CAPTCHA.

***

*Built and maintained by **ActorForge**. Reliability first: every actor in the
portfolio is monitored by an automated nightly self-test, and breakages are
typically fixed the same day.*

# Actor input Schema

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

Competitor websites, e.g. nike.com. Returns every ad Google shows for that domain, from the brand itself and from agencies or resellers advertising it.

## `advertiserNames` (type: `array`):

Company names as shown in the Ads Transparency Center, e.g. HubSpot, Argos Limited. Exact name matches are used (a brand's several legal entities are all kept); otherwise the closest advertiser with the most ads.

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

Google advertiser IDs (AR… from an adstransparency.google.com/advertiser/AR… link).

## `regions` (type: `array`):

Only ads shown in these countries, as two-letter codes (US, GB, DE, FR…). Empty = anywhere.

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

Only ads shown on or after this date (YYYY-MM-DD).

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

Only ads shown on or before this date (YYYY-MM-DD).

## `formats` (type: `array`):

Only these formats. Empty = all.

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

How many ads to read for each domain, advertiser name or advertiser ID, newest first as the Transparency Center lists them.

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

Stop after this many ads across all searches. You pay per ad delivered ($0.60 per 1,000).

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

One extra lookup per ad: countries shown, impression ranges and first/last shown per country, plus best-effort headline/description text. Charged as ad-detail ($1 per 1,000).

## `onlyNewSinceLastRun` (type: `boolean`):

Remember every ad delivered in a named key-value store (ads-seen-<monitor name>) and return only ads not seen before. Schedule the actor daily to get a feed of competitors' new ads; already-seen ads are skipped and never charged.

## `monitorName` (type: `string`):

Name of the seen-ads memory used by 'Only new ads'. Use one name per schedule (e.g. uk-competitors) so separate watch lists don't share state.

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

Not needed: the Transparency Center is public. Leave off unless you have your own reason to route requests through a proxy. The actor never rotates proxies to get around a block.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "advertiserNames": [
    "HubSpot"
  ],
  "advertiserIds": [],
  "regions": [],
  "formats": [],
  "maxAdsPerAdvertiser": 20,
  "maxResults": 1000,
  "includeDetails": false,
  "onlyNewSinceLastRun": false,
  "monitorName": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per ad from the Google Ads Transparency Center.

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

Ads delivered, already-seen ads skipped, and whether Google stopped the run early (CAPTCHA / rate limit).

# 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": [
        "nike.com"
    ],
    "advertiserNames": [
        "HubSpot"
    ],
    "maxAdsPerAdvertiser": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("actor-forge/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 = {
    "domains": ["nike.com"],
    "advertiserNames": ["HubSpot"],
    "maxAdsPerAdvertiser": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("actor-forge/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 '{
  "domains": [
    "nike.com"
  ],
  "advertiserNames": [
    "HubSpot"
  ],
  "maxAdsPerAdvertiser": 20
}' |
apify call actor-forge/ads-transparency --silent --output-dataset

```

## MCP server setup

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