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

Scrape Google Ads Transparency Center by domain or advertiser ID: advertiser, ad format, first and last shown dates, image and ad link. One result per ad.

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

## Pricing

from $1.60 / 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.
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

Scrape the [Google Ads Transparency Center](https://adstransparency.google.com) by domain or by advertiser ID. One result per ad: advertiser, ad format, first and last shown dates, image and a link to the ad. $2 per 1,000 ads on the Free plan, less on paid plans. No browser.

### What you get

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | Domain or advertiser ID from the input that produced this ad |
| `advertiser_id` | string | Advertiser ID, starts with AR |
| `advertiser_name` | string or null | Advertiser name as verified by Google |
| `creative_id` | string | Ad ID, starts with CR |
| `format` | string or null | Ad format: text, image or video |
| `domain` | string or null | Domain the ad points to |
| `first_shown` | string or null | UTC time the ad was first shown, ISO 8601 |
| `last_shown` | string or null | UTC time the ad was last shown, ISO 8601 |
| `days_shown` | integer or null | Number of days the ad has been shown |
| `image_url` | string or null | Image of the ad, when Google provides one |
| `preview_url` | string or null | Script URL Google uses to render the ad, when there is no image |
| `ad_url` | string | Page of the ad in the Ads Transparency Center |
| `scraped_at` | string | UTC time the ad was scraped, ISO 8601 |

### Input

- `domains`: websites whose ads you want, for example `nike.com`. A full URL works too; only the host name is used.
- `advertiserIds`: advertiser IDs from the Ads Transparency Center URL, for example `AR18378488041124659201`.

Give at least one domain or one advertiser ID.

- `maxItemsPerQuery`: stop a domain or advertiser after this many ads. Default 100.
- `maxItems`: stop after this many ads in total. Default 100.
- `proxyConfiguration`: fallback proxy, Apify datacenter by default. Each request is tried directly first.

```json
{
  "domains": ["nike.com"],
  "advertiserIds": ["AR18378488041124659201"],
  "maxItemsPerQuery": 200,
  "maxItems": 400
}
```

### Example output

```json
{
  "query": "nike.com",
  "advertiser_id": "AR18378488041124659201",
  "advertiser_name": "Nike Retail BV",
  "creative_id": "CR07648843056275259393",
  "format": "text",
  "domain": "nike.com",
  "first_shown": "2025-10-24T11:09:21+00:00",
  "last_shown": "2026-10-13T15:25:43+00:00",
  "days_shown": 355,
  "image_url": "https://tpc.googlesyndication.com/archive/simgad/6893155671454626194",
  "preview_url": null,
  "ad_url": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR07648843056275259393",
  "scraped_at": "2026-10-13T12:00:00+00:00"
}
```

### Pricing

Pay per result: one `ad` event per ad saved. The run stops cleanly when your maximum charge per run is reached.

### Limitations

- Ads are returned for all regions together. Filtering by country, date range or platform is not supported yet.
- The ad text itself is not extracted. Google serves text ads as an image (`image_url`) and other ads as a render script (`preview_url`).
- A domain returns ads from every advertiser that advertises it, including resellers and affiliates.
- Searching by advertiser name is not supported; use the domain, or copy the advertiser ID from the Ads Transparency Center URL.
- No personal data. Advertisers are the businesses verified by Google.

### For AI agents

Minimal input:

```json
{ "domains": ["nike.com"], "maxItems": 20 }
```

Each dataset item is one ad with the fields listed under "What you get". `first_shown` and `last_shown` are UTC timestamps.

# Actor input Schema

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

Websites whose Google ads you want, as shown in the Ads Transparency Center. Example: nike.com.

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

Advertiser IDs from the Ads Transparency Center URL. They start with AR. Example: AR18378488041124659201.

## `maxItemsPerQuery` (type: `integer`):

Stop a domain or advertiser after this many ads and move on to the next one. Example: 100.

## `maxItems` (type: `integer`):

Stop after this many ads in total. Example: 20.

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

Fallback proxy. Each request is first tried directly; if that fails twice, 2 more attempts go through this proxy, each from a different IP.

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "maxItemsPerQuery": 20,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Ads with advertiser, format, first and last shown dates and links.

# 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"
    ],
    "maxItemsPerQuery": 20,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("distinct_readjustment/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"],
    "maxItemsPerQuery": 20,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("distinct_readjustment/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"
  ],
  "maxItemsPerQuery": 20,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call distinct_readjustment/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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