# Google Ads Transparency Scraper (`weirworks/google-ads-transparency`) Actor

Get any brand's or domain's Google ads from the Ads Transparency Center: text, image and YouTube ads with dates, ad copy, sitelinks and countries. Monitoring mode returns only new ads.

- **URL**: https://apify.com/weirworks/google-ads-transparency.md
- **Developed by:** [Weirworks](https://apify.com/weirworks) (community)
- **Categories:** Marketing, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.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.

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

See every ad a brand runs on Google — Search, Display and YouTube — straight from the public [Google Ads Transparency Center](https://adstransparency.google.com/). Search by brand name, website domain, advertiser ID or Transparency Center URL, filter by country and ad format, and get clean, structured data back.

**What makes it different:** it reads the **actual ad copy** (headline, description, display URL and extensions) of Search ads. Google shows about 97% of Search ads in the Transparency Center only as a picture of the ad; this Actor reads the text back out of the picture, so you get searchable, spreadsheet-ready copy instead of screenshots.

### What you can do with it

- **Competitor research:** pull every Google ad a competitor is running, with their headlines and offers, in one table.
- **Ad monitoring:** turn on *Only new ads* and schedule a daily run to get a feed of competitors' new ads as they launch.
- **Agency prospecting and audits:** check how long a brand's ads have been live and in which countries.
- **Creative inspiration:** collect headline and description patterns across a whole industry.
- **AI agents and automations:** call it through the Apify API, MCP, Make, Zapier or n8n.

### Input

| Field | What it does |
|---|---|
| **Brands or domains** | Brand names like `Nike` or domains like `nike.com`. A name matches the closest advertiser; a domain returns every advertiser running ads for that site. |
| **Advertiser IDs** | IDs starting with `AR`, for exact matches. |
| **Transparency Center URLs** | Paste advertiser pages straight from adstransparency.google.com. |
| **Country** | Only ads shown in one country, or anywhere. |
| **Ad format** | All, text (Search), image (Display) or video (YouTube). |
| **Max ads per advertiser or domain** | Default 100. Large brands have tens of thousands of ads. |
| **Include ad copy and details** | Adds headline, description, display URL, extensions, YouTube links, all image variations and every country the ad ran in. |
| **Only new ads (monitoring)** | Returns only ads you haven't received in earlier runs with the same input. |

Example input:

```json
{
  "searchTerms": ["geico.com"],
  "region": "US",
  "adFormat": "text",
  "maxAdsPerSource": 200,
  "includeAdDetails": true
}
```

### Output

One row per ad. With *Include ad copy and details* turned on, a Search ad looks like this:

```json
{
  "advertiserId": "AR00000000000000000000",
  "advertiserName": "Government Employees Insurance Company",
  "creativeId": "CR00000000000000000000",
  "format": "text",
  "firstShown": "2025-03-14T18:02:11Z",
  "lastShown": "2026-10-02T21:28:17Z",
  "daysActive": 568,
  "displayName": "GEICO",
  "displayUrl": "www.geico.com/",
  "headline": "GEICO® Official Site - Fast, Free Insurance Quote",
  "description": "GEICO® was Named the Best Car Insurance Company for 2026-2027. Get a Free Quote Today.",
  "extensionsText": ["Get A Quote GEICO® Free Quote in Minutes"],
  "copySource": "ocr",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/...",
  "variationCount": 3,
  "regions": ["US"],
  "adUrl": "https://adstransparency.google.com/advertiser/AR.../creative/CR...?region=US",
  "source": "geico.com",
  "region": "US",
  "scrapedAt": "2026-10-02T22:40:00Z"
}
```

Video ads include `videoUrl` and `youtubeVideoIds`. Image ads include `imageUrl` and, with details on, every variation in `imageUrls`. You can export results as JSON, CSV, Excel or HTML, or read them through the API.

`copySource` tells you where the copy came from: `preview` when Google provides the text directly, `ocr` when it was read from the ad image. OCR is very accurate on these clean renders but not perfect — occasionally a character is misread or an extension line is split.

### Pricing

Pay per result, no subscription:

- **$1.00 per 1,000 ads**
- **+$1.50 per 1,000 ads** when *Include ad copy and details* is on

You can set a maximum cost per run in the run options; the Actor stops cleanly when it's reached.

### Tips

- Use **domains** when a brand advertises under several legal entities or agencies: `nike.com` finds them all.
- For monitoring, keep the input identical between runs — the Actor remembers seen ads per input.
- Leave the proxy on its default (**Apify residential**). Google blocks most shared datacenter IPs on this site; proxy costs are included in the price.
- Speed: about 1 ad per second with ad copy and details, much faster without.

### FAQ

**Is this legal?** The Actor only reads information Google publishes openly in its Ads Transparency Center for public accountability. It doesn't log in, bypass access controls or collect personal data. You're responsible for using the data in line with the laws and terms that apply to you.

**Why are some fields empty?** Google doesn't publish every detail for every ad. Older or limited ads can lack variations, regions or copy.

**Something broke or you need a feature?** Open an issue on the Actor's Issues tab or email hello@weirworks.com — fixes usually ship within a day.

*Independent tool by weirworks. Not affiliated with or endorsed by Google.*

# Actor input Schema

## `searchTerms` (type: `array`):

Advertiser names (e.g. <code>Nike</code>) or website domains (e.g. <code>nike.com</code>). Names are matched to the closest advertiser in the Transparency Center; domains return every advertiser running ads for that site.

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

Google advertiser IDs starting with <code>AR</code>, e.g. <code>AR16735076323512287233</code>.

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

Website domains whose ads you want, e.g. <code>shopify.com</code>.

## `startUrls` (type: `array`):

Paste advertiser pages from adstransparency.google.com, e.g. <code>https://adstransparency.google.com/advertiser/AR16735076323512287233?region=US</code>.

## `maxAdvertisersPerSearchTerm` (type: `integer`):

How many matching advertisers to include for each brand name. Raise it for brands that advertise under several legal entities.

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

Only ads shown in this country.

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

Only one kind of ad: text ads on Google Search, image ads on the Display Network, or video ads on YouTube.

## `maxAdsPerSource` (type: `integer`):

Stops after this many ads for each advertiser or domain. Big brands can have tens of thousands.

## `includeAdDetails` (type: `boolean`):

Also extract each ad's headline, description, display URL, sitelinks, YouTube video, all image variations and the countries it ran in. Charged as an extra event per ad.

## `onlyNewAds` (type: `boolean`):

Return only ads not seen in earlier runs with the same inputs. Schedule the Actor daily or weekly to get a feed of competitors' new ads.

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

Google blocks most shared datacenter IPs on this site, so residential proxies are the default. Proxy costs are covered by the Actor's price.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com"
  ],
  "maxAdvertisersPerSearchTerm": 1,
  "region": "anywhere",
  "adFormat": "all",
  "maxAdsPerSource": 100,
  "includeAdDetails": false,
  "onlyNewAds": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

One row per ad: advertiser, format, dates, ad copy, images, YouTube link and countries.

# 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 = {
    "searchTerms": [
        "nike.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("weirworks/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 = {
    "searchTerms": ["nike.com"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("weirworks/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 '{
  "searchTerms": [
    "nike.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call weirworks/google-ads-transparency --silent --output-dataset

```

## MCP server setup

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