# Google Ads Transparency Scraper: Ads & Advertisers by Domain (`transparent_meteorite/google-ads-transparency-scraper`) Actor

Scrape every ad in the Google Ads Transparency Center by domain or advertiser ID: advertiser, format, first and last shown, days shown, preview, regions. No login, no key.

- **URL**: https://apify.com/transparent_meteorite/google-ads-transparency-scraper.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, SEO tools
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.58 / 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: Ads & Advertisers by Domain

Use this to see every ad a company runs on Google. Give it a domain such as `nike.com` or an advertiser ID, and get one row per ad from the public Google Ads Transparency Center: advertiser, ad format, first and last date shown, days shown, landing domain, a preview image and a link to the ad's own transparency page.

It uses the same public data the Transparency Center website shows. No login, no cookies, no API key and no proxy is needed.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled test asks for 30 ads from `nike.com` in the US.
2. Click **Start**. The run normally finishes in well under a minute.
3. Open the **Ads** table in the Output tab, or download the dataset as JSON, CSV, Excel or HTML.
4. Add your own domains (one per line), pick a country and ad format, raise **Max ads per domain**, and run again.

### What does this Actor do?

For each domain or advertiser ID, the Actor pages through the Transparency Center search results and returns one flat row per ad:

| Group | Fields |
|---|---|
| Who | `advertiserName`, `advertiserId`, `landingDomain` |
| Which ad | `creativeId`, `format` (text, image, video), `previewUrl`, `transparencyUrl` |
| When | `firstShown`, `lastShown`, `daysShown` |
| Volume | `targetAdCount`: approximate number of ads Google lists in total for that domain or advertiser (Google gives a range, this is its upper estimate) |
| Where (optional) | `regions`: the countries each ad ran in, when you turn on **Add countries where each ad ran** |
| Bookkeeping | `target`, `targetType`, `position`, `scrapedAt` |

A run also saves a summary to the key-value store under `OUTPUT`: ads per target, the total number of ads Google lists for it, any target that failed, and any target that was not reached.

### Limits

- It reads only what the public Transparency Center shows. Google does not publish ad spend, impressions or targeting for most ads, so those fields do not exist here.
- The preview is the ad image or thumbnail Google serves. Text-ad copy is not returned.
- Google can change the public page without notice. If it answers with an error for a domain, that domain gets a clear status in `OUTPUT` and is not charged.
- Very large advertisers have thousands of ads. Use **Max ads per domain** (up to 5,000) to control size and cost.
- If a run reaches its time limit, it stops cleanly, keeps everything already delivered and lists what was not reached.

### Input

| Field | What it does |
|---|---|
| `domains` | Company domains, one per line. Website URLs work too. |
| `advertiserIds` | Optional advertiser IDs starting with AR, to get all ads of one advertiser. |
| `country` | Two-letter country code, or ALL. Default US. |
| `format` | all, text, image or video. |
| `maxAdsPerDomain` | Ads to return per domain or advertiser. Default 100. |
| `includeDetails` | Adds the countries each ad ran in. Slower, billed per ad. |

### Example input

```json
{
  "domains": ["nike.com", "hubspot.com"],
  "country": "US",
  "format": "video",
  "maxAdsPerDomain": 50
}
```

### Output sample

```json
{
  "target": "nike.com",
  "advertiserName": "Nike, Inc.",
  "advertiserId": "AR16735076323512287233",
  "creativeId": "CR02941722916070359041",
  "format": "text",
  "firstShown": "2023-11-16",
  "lastShown": "2026-11-10",
  "daysShown": 921,
  "targetAdCount": 18400,
  "landingDomain": "nike.com",
  "regions": null,
  "previewUrl": "https://tpc.googlesyndication.com/archive/simgad/16361263004756957907",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR02941722916070359041?region=US"
}
```

Your own run will show the real values for every field.

### Use cases

- Check what a competitor is advertising and for how long.
- Build a swipe file of video and image ads for a market.
- Track which ads were added or stopped by comparing `lastShown` over time.
- Qualify leads: companies that run many ads are spending on growth.

### Tips for good results

- Start with a small **Max ads** to see the shape of the data, then raise it.
- Use the advertiser ID when a company advertises under several domains.
- Schedule a weekly run and compare `firstShown` to find new ads.

### Field reference

`daysShown` is how many days Google reports the ad as active. `firstShown` and `lastShown` are dates. `format` is the creative type. `landingDomain` is the site the ad points to. `regions` is null unless **Add countries where each ad ran** is on. `position` is the row number within the run.

### Pricing and cost control

Pay per ad: **$0.00095 per ad on the free plan, $0.000583 on the Gold plan** (Bronze $0.000885, Silver $0.000755), plus a $0.00005 start fee per run. That is $0.95 per 1,000 ads. The optional region lookup adds $0.000475 per ad on the free plan. Use **Maximum cost per run** or **Max ads per domain** to cap spend; the run stops cleanly at the limit.

### Integrations and scheduling

Send results to Google Sheets, Slack or email with the Apify integrations, or put the Actor on a schedule to watch an advertiser week by week.

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~google-ads-transparency-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" -H "Content-Type: application/json" -d '{"domains": ["nike.com"], "country": "US", "maxAdsPerDomain": 30}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/google-ads-transparency-scraper").call(run_input={"domains": ["nike.com"], "country": "US", "maxAdsPerDomain": 30})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/google-ads-transparency-scraper`, paste the input JSON, then map the dataset items to your sheet or CRM.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/google-ads-transparency-scraper` to Claude, Cursor or any MCP client, and your agent can run this Actor as a tool.

### Fair use and legal

The Actor reads the same public pages as the Google Ads Transparency Center website and requests them at a gentle pace, one request every half second or so. It does not log in or bypass any access control, and it collects advertiser and ad information only, not personal data about viewers. This is an independent tool and is not affiliated with Google. You are responsible for how you use the data.

### FAQ

**Do I need a Google account or API key?** No.

**Does it need a proxy?** No. The Actor connects directly.

**Why are some domains empty?** The domain has no ads in the selected country or format. Try country `ALL`.

**Can I search by advertiser name?** Search by domain or by advertiser ID. The ID is in the URL of the advertiser's page in the Transparency Center.

**Are failed targets charged?** No. Only ads that are delivered are charged.

**How many ads can I get?** Up to 5,000 per domain or advertiser per run.

### Support

Found a bug or need a field? Open an issue on the Issues tab with the run URL and you will get a reply there.

### Related actors

- [Competitor Ad Checker: Google and Meta Ads by Domain](https://apify.com/transparent_meteorite/ad-footprint-by-domain) for one summary row per domain across Google and Meta.
- [Company Enrichment by Domain](https://apify.com/transparent_meteorite/company-enrichment-by-domain) to add firmographics to a lead list.
- [Website Tech Stack](https://apify.com/transparent_meteorite/website-tech-stack-detector) for technology detection on company sites.

### Changelog

- **0.1**: First private build. Ads by domain or advertiser ID, country and format filters, optional regions.

# Actor input Schema

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

Company domains whose ads you want, one per line (for example "nike.com"). Website URLs work too. Every ad that Google lists for the domain becomes one row.

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

Advertiser IDs that start with AR, from an advertiser page URL in the Ads Transparency Center. Use this to get every ad of one advertiser, whatever domain it links to.

## `country` (type: `string`):

Two-letter country code for where the ads were shown, for example US, GB, DE. Use ALL for no country filter.

## `format` (type: `string`):

Only return ads of one format.

## `maxAdsPerDomain` (type: `integer`):

Stops after this many ads for each target. You pay per ad returned.

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

Looks up every ad one more time to fill the regions field. Slower, and billed as a separate small event per ad.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "advertiserIds": [],
  "country": "US",
  "format": "all",
  "maxAdsPerDomain": 30,
  "includeDetails": false
}
```

# Actor output Schema

## `ads` (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 = {
    "domains": [
        "nike.com"
    ],
    "advertiserIds": [],
    "country": "US",
    "format": "all",
    "maxAdsPerDomain": 30,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/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 = {
    "domains": ["nike.com"],
    "advertiserIds": [],
    "country": "US",
    "format": "all",
    "maxAdsPerDomain": 30,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/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 '{
  "domains": [
    "nike.com"
  ],
  "advertiserIds": [],
  "country": "US",
  "format": "all",
  "maxAdsPerDomain": 30,
  "includeDetails": false
}' |
apify call transparent_meteorite/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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