# Google Ads Transparency Scraper (Competitor Ads by Domain) (`pagecraft/google-ads-transparency-scraper`) Actor

Get any company's Google ads from the Ads Transparency Center: search, image and video ads with the ad image, format and first and last shown dates. Search by website, advertiser name or ID, in any country. No login.

- **URL**: https://apify.com/pagecraft/google-ads-transparency-scraper.md
- **Developed by:** [Pagecraft Tools](https://apify.com/pagecraft) (community)
- **Security:** Limited permissions
- **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.
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: Any Competitor's Google Ads by Website or Name

See **every Google ad a company runs**: search ads, image ads and video ads from the **Google Ads Transparency Center**, with the advertiser, format, **first and last shown dates**, the **ad image** as Google shows it, and a link to the ad. Search by **website domain**, **advertiser name** or **advertiser ID**, in any country. No login, no API key.

### What it does

- **By website**: `nike.com` returns ads from every advertiser whose ads point to that site.
- **By name**: `Monzo Bank` finds MONZO BANK LIMITED with Google's own advertiser search (advertisers with ads and verified ones first; choose how many matches to read). Use the company's registered name: a short brand name can match only small look-alike accounts.
- **By advertiser ID**: `AR...` from any Transparency Center link.
- **Region**: ads shown in a given country (GB, US, DE...) or anywhere.
- One **row per ad**: advertiser, ad ID, format (text, image, video), domain, first shown, last shown, image URL and a link to the ad in the Transparency Center.
- **Headlines and descriptions** of text (search) ads, on request, where Google publishes the text (many text ads are shown only as images; you pay only for ads whose text is read).
- Filters: **formats**, **shown since** a date. One summary row per search with Google's estimate of the total number of ads.

### Who it's for

- **Performance marketers and agencies** studying competitors' creatives, formats and how long ads run (long-running ads are usually the winners).
- **Brand protection**: find ads that point to your domain from other advertisers.
- **Market research and sales teams**: see who is advertising, where and how much.
- **Creative teams** collecting ad inspiration by industry.

### Input

| Field | What to enter |
| --- | --- |
| Advertisers or websites | `nike.com`, `Monzo Bank` or `AR07289389941828616193` |
| Region | `GB`, `US`... or `anywhere` |
| Maximum ads per advertiser or website | Default 200 |
| Ad formats | Optional: text, image, video |
| Shown since | Optional date |
| Include text ad headlines and descriptions | Optional, charged per text ad |
| Advertisers per name | Default 1 |

```json
{ "searches": ["monzo.com", "starlingbank.com"], "region": "GB", "maxAdsPerSearch": 500 }
```

### Output

```json
{
  "type": "ad", "advertiserId": "AR07289389941828616193", "advertiserName": "MONZO BANK LIMITED",
  "creativeId": "CR12006363827932233729", "format": "text", "domain": "monzo.com",
  "firstShown": "2026-06-09T10:20:20.000Z", "lastShown": "2026-11-02T14:57:33.000Z",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/...",
  "adUrl": "https://adstransparency.google.com/advertiser/AR07289389941828616193/creative/CR12006363827932233729?region=GB"
}
```

Every ad that Google shows as an image (most search ads too) carries `imageUrl`. With "Include text ad headlines and descriptions" on, `headline`, `displayUrl` and `description` are filled for the few text ads whose text Google publishes. Each search also gets a `"type": "search"` row with `adsReturned`, `adsEstimate` (Google's own range, e.g. 1000-2000) and a link to the search in the Transparency Center.

### Pricing

| Event | When it is charged | Price per 1,000 (Free / Bronze / Silver / Gold plan) |
| --- | --- | --- |
| Advertiser checked | Each advertiser, website or name searched: reading its ad pages, once per started 30 seconds or 3 MB (about 1,000 ads). Also charged when nothing is found. | $2 on every plan |
| Ad scraped | Each ad returned in the dataset. | $1.50 / $1.35 / $1.20 / $1 |
| Ad text read | Each text ad whose headline and description are read (only with "Include text ad headlines and descriptions" on). | $3 on every plan |

Example: 3 competitors with 200 ads each costs about 3 × $0.002 + 600 × $0.0015 = $0.91 on the Free plan.

Set a **maximum cost per run** in Apify and the scraper stops cleanly when it is reached.

### Notes and limits

- Data comes from Google's public Ads Transparency Center; it covers ads from verified advertisers, as Google shows them.
- Google gives the ad count as a range, so `adsEstimate` is approximate.
- Name search uses Google's own advertiser suggestions, which match registered advertiser names. The website domain is the most reliable way to find a company's ads.
- Google publishes the text of some text ads; others are shown only as rendered images, so `headline` stays empty for them (not charged). Image and video ads come with their image or preview link.
- Spend and audience figures are only published by Google for political ads in some regions and are not included.

### More Pagecraft tools

- [Company Data Enrichment from Domain](https://apify.com/pagecraft/website-intelligence): logo, contacts and tech stack for competitors' websites.
- [Tech Stack Detector](https://apify.com/pagecraft/tech-stack-detector): which analytics and ad tools a site uses.
- [Shopify Store Products Scraper](https://apify.com/pagecraft/shopify-products-scraper): competitors' products, prices and discounts, if they sell on Shopify.

# Actor input Schema

## `searches` (type: `array`):

One per line: a website domain (nike.com: every advertiser whose ads point to it), an advertiser name (Nike) or an advertiser ID (AR...) from the Transparency Center.

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

Two-letter country code (GB, US, DE...) for ads shown there, or anywhere.

## `maxAdsPerSearch` (type: `integer`):

Most recently shown first.

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

Optional: only these formats.

## `shownSince` (type: `string`):

Optional: only ads last shown on or after this date.

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

For text (search) ads, read the headline, display URL and description where Google publishes them as text. Google shows many text ads only as images; those have no text and are not charged. Charged per ad whose text is read.

## `advertisersPerName` (type: `integer`):

When you search by name, how many matching advertisers to read (best match first).

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

Optional. Residential proxies are not supported.

## Actor input object example

```json
{
  "searches": [
    "nike.com"
  ],
  "region": "US",
  "maxAdsPerSearch": 40,
  "includeAdText": false,
  "advertisersPerName": 1
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "nike.com"
    ],
    "region": "US",
    "maxAdsPerSearch": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("pagecraft/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 = {
    "searches": ["nike.com"],
    "region": "US",
    "maxAdsPerSearch": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("pagecraft/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 '{
  "searches": [
    "nike.com"
  ],
  "region": "US",
  "maxAdsPerSearch": 40
}' |
apify call pagecraft/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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