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

\[$1.00 / 1K] Every ad an advertiser or domain runs on Google, straight from the Ads Transparency Center. Pure HTTP against the site interface: no browser, no proxy bill, nothing to time out. Returns format, preview, first and last shown dates, impression ranges and creative variants.

- **URL**: https://apify.com/deriverge/google-ads-transparency-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (community)
- **Categories:** Marketing, Lead generation, Developer tools
- **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 returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Ads Transparency Scraper

### What does Google Ads Transparency Scraper do?

**Google Ads Transparency Scraper** pulls every ad an advertiser runs on Google from the Ads Transparency Center: search, display, YouTube and Shopping creatives, with the format, a preview link, the first and last dates the ad was shown, the regions it ran in, and a direct link back to the Center. Give it brand names, domains or advertiser IDs, and it returns the creatives in one clean table, ready for competitor research, creative libraries, agency reporting or ad-fraud checks.

No browser and no proxies: the actor talks to the same interface the Transparency Center website uses, which keeps runs fast, cheap and reliable.

### What you get here that the other actors do not

| Field | What it tells you | Elsewhere |
|---|---|---|
| `impressionsLow`, `impressionsHigh` | The impression range Google publishes for the ad, for example 3,500,000 to 4,000,000 | not returned by any competitor we measured |
| `regions[].impressionsLow/High` | The same range per country, with the first and last date the ad ran there | not returned |
| `variants` | How many creative variations sit behind one ad | not returned |
| `imageUrls`, `creativeHtml` | The creative markup and the image asset URL when Google exposes it | not returned |
| `probability of a timeout` | None. The actor is pure HTTP against the Transparency Center interface, with no browser and no proxy bill | the leading actor times out on roughly one run in sixteen |

### New ads only: a competitor creative feed

Turn on `newOnly`, give the run a watch name or save it as a task, and schedule it daily. Every run compares the Center with the snapshot from the previous run and returns only ads that appeared since. Ads that disappeared are counted in the `CHANGES` record. You pay for the new ads and nothing else.

### Input

```json
{
  "advertisers": [
    "nike.com",
    "Adidas",
    { "advertiserId": "AR18378488041124659201", "reference": "competitor-1" }
  ],
  "region": "US",
  "maxAdsPerAdvertiser": 200,
  "formats": ["image", "video"],
  "lastShownAfter": "2026-06-01",
  "includeDetails": false,
  "newOnly": true,
  "watchKey": "competitors"
}
```

A brand name is resolved through the Center's own advertiser suggestions. When several advertisers share a name, the exact match wins, then a verified advertiser; the choice and the alternatives are written to the log so you can switch to the advertiser ID next time.

### Output

```json
{
  "advertiserId": "AR18378488041124659201",
  "advertiserName": "Nike Retail BV",
  "creativeId": "CR15484838401940652033",
  "domain": "nike.com",
  "format": "image",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?...",
  "firstShown": "2025-10-23T09:39:38.000Z",
  "lastShown": "2026-09-02T14:47:42.000Z",
  "adUrl": "https://adstransparency.google.com/advertiser/AR18378488041124659201/creative/CR15484838401940652033?region=anywhere",
  "regions": null
}
```

With `includeDetails` on, `regions` lists every country the ad ran in with its own first and last shown dates and its impression range, and the row gains the total impression range, the number of creative variants and the creative markup.

### Pricing

| Event | Price |
|---|---|
| Ad returned | $0.002 ($2 per 1,000 ads) |
| Ads removed by format or date filters, ads already seen in new-only mode, advertisers that resolve to nothing | **free** |

No start fee. A run that returns nothing costs nothing.

### Frequently asked questions

**Where do I find an advertiser ID?** Open the advertiser in the Transparency Center; the URL contains it (AR followed by digits). Domains work just as well and are usually the safest input.

**Why are some dates missing?** The Center reports the first and last shown dates per ad; for a few very old creatives it reports nothing, and the actor leaves the field null rather than guessing.

**Can I get the ad text or the image itself?** The `previewUrl` renders the creative exactly as the Center shows it. Assets are served by Google and are not copied into the dataset.

**How fresh is the data?** It is read live from the Transparency Center at run time.

### How to use Google Ads Transparency Scraper

1. Open the actor and fill in `advertisers` in the input form, or paste the JSON input from the example above.
2. Click **Start**. The first rows appear in the **Output** tab within seconds; the run summary is in the **Storage** tab under the key `SUMMARY`.
3. Download the results as JSON, CSV or Excel from the Output tab, or read them through the API link shown there.
4. To run it on a schedule, click **Save as a task**, set the input once and add a schedule. Scheduled tasks keep their own change snapshot, so the new-only mode works without any extra setup.

### Integrations

The actor is available in the Apify apps for **Make**, **Zapier**, **n8n** and **Keboola**, where you pick it by name and map the input fields. It is also exposed to AI agents through the Apify MCP server, and callable from any language through the Apify API; the API tab on this page has ready-made snippets for Node.js, Python and curl. Every run can post its results to a webhook when it finishes.

### Support

Questions and problems go into the **Issues** tab of this actor. Each issue is answered by the maintainer, and fixes ship as new builds without any change on your side.

Built and operated by deriverge s.r.o. Same rules as our other actors: unified schema, honest billing, no charge for what you did not get.

# Actor input Schema

## `advertisers` (type: `array`):

One entry per advertiser: a brand name (Nike), a domain (nike.com) or an advertiser ID from the Transparency Center (AR18378488041124659201). Objects may carry a reference that is returned on every ad. Names are resolved through the Center's own suggestions; the chosen advertiser is logged.

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

Two-letter country code to keep only ads shown in that country (US, DE, GB...). Leave empty for anywhere.

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

Stop after this many ads for each advertiser. Big brands run thousands.

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

Keep only these ad formats. Leave empty for all.

## `lastShownAfter` (type: `string`):

Keep only ads still shown on or after this date, for example 2026-06-01. Leave empty for all.

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

One extra request per ad that adds the list of regions where the ad ran, each with its first and last shown date.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only ads that were not in the previous snapshot. Schedule it and you get a competitor creative feed: every new ad, once, the day it starts.

## `watchKey` (type: `string`):

Name of the snapshot used by new-only mode, for example "competitors". Runs from a saved task get a snapshot automatically.

## Actor input object example

```json
{
  "advertisers": [
    "nike.com",
    "Adidas",
    {
      "advertiserId": "AR18378488041124659201",
      "reference": "competitor-1"
    }
  ],
  "maxAdsPerAdvertiser": 200,
  "includeDetails": false,
  "newOnly": false
}
```

# Actor output Schema

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

One row per ad: advertiser, creative ID, format, preview, first and last shown, regions and the Transparency Center link.

## `changes` (type: `string`):

New ads, ads no longer listed and ads still running, compared with the previous snapshot of the same watch name or task.

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

Per-advertiser counts, how each name was resolved, and totals.

# 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 = {
    "advertisers": [
        "nike.com",
        "Adidas",
        {
            "advertiserId": "AR18378488041124659201",
            "reference": "competitor-1"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/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 = { "advertisers": [
        "nike.com",
        "Adidas",
        {
            "advertiserId": "AR18378488041124659201",
            "reference": "competitor-1",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deriverge/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 '{
  "advertisers": [
    "nike.com",
    "Adidas",
    {
      "advertiserId": "AR18378488041124659201",
      "reference": "competitor-1"
    }
  ]
}' |
apify call deriverge/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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