# Google Ads Transparency Scraper — Competitor Ads & Creatives (`northbell/google-ads-transparency-scraper`) Actor

Every ad an advertiser runs on Google (Search, YouTube, Display) from the public Ads Transparency Center: format, first and last shown dates, days running and the ad image. Run it again or on a schedule to get only the new ads since the last run. By name, website, advertiser ID or link. No login.

- **URL**: https://apify.com/northbell/google-ads-transparency-scraper.md
- **Developed by:** [Northbell](https://apify.com/northbell) (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 $0.80 / 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 — Competitor Ads & Creatives

Give it advertisers — a company name, a website, an advertiser ID or an Ads Transparency Center link — and get every ad they run on Google (**Search, YouTube and Display**) as clean rows: **format, first and last shown date, days running, the ad image and a link to the ad**. Filter by country and format. **$1 per 1,000 ads**, no login, no API key, no cookies.

Run it again — or put it on a daily schedule — and every ad also says whether it is **new since the last run**. That turns the Transparency Center into a competitor ad alert: switch on *Only new ads* and each run returns just the creatives that started after the previous one (the first run saves the starting point and returns the advertiser summary only).

### What you get

Rows have a `type`. Every row has `input` (what you typed) and `observedAt`.

| Row `type` | One row per | Fields |
|---|---|---|
| `ad` | ad (creative) | `advertiser`, `advertiserId`, `creativeId`, `url`, `format` (`text`, `image` or `video`), `firstShown`, `lastShown` (dates), `daysRunning`, `lastShownDaysAgo`, `previewUrl`, `region`, `isNewSinceLastRun` |
| `advertiser` | input (free) | `advertiserName`, `advertiserId`, `advertisersFound`, `country`, `adsRead`, `adsTotalMin`, `adsTotalMax`, `newSinceLastRun`, `previousRunAt`, `region`, `formatFilter`, `complete`, `alternatives`, `note` |
| `error` | input that failed (free) | `message` |

- `format` is the ad type Google lists: `text`, `image` or `video`. Google shows most text ads as a picture of the ad, so `previewUrl` is that picture for text and image ads. It is empty for ads Google draws with a script (some image, video and rich ads): open `url` to see them.
- `daysRunning` counts calendar days from `firstShown` to `lastShown`, both included. `lastShownDaysAgo` of 0 or 1 means the ad is running now.
- `adsTotalMin` / `adsTotalMax` are Google's own range for how many ads the advertiser has under your filters (it only gives a range, for example 8,000 to 9,000), so you can see how much `maxAdsPerAdvertiser` left out.
- `alternatives` lists other advertisers that matched a company name, so you can pick the exact one by ID.

**Since the last run** (`null` on the first run):

| Field | On | What it is |
|---|---|---|
| `isNewSinceLastRun` | `ad` | `true` for an ad that was not in your previous run and started running after it, `false` otherwise |
| `newSinceLastRun`, `previousRunAt` | `advertiser` | how many ads are new and when your previous run of the same advertiser, region and format was |

### Use it for

- **Competitor ad alerts** — schedule it daily with *Only new ads* and see every new creative a competitor launches
- **Creative research** — what a brand runs on Search, YouTube and Display, how long each ad has been running (long-running ads usually work)
- **Agencies and sales** — show a prospect their competitors' ads, or check what ads run in a country before a pitch

### Input

```json
{ "advertisers": ["nike.com", "Adidas", "AR16735076323512287233"], "region": "US", "format": "all", "maxAdsPerAdvertiser": 100, "onlyNew": false }
```

- **Advertisers** — a company name (matched to the advertiser with the most ads), a website (ads whose landing page is on that site, from any advertiser: the summary row names the one with the most ads and `advertisersFound` counts them), an advertiser ID (`AR…`, the exact way) or an `adstransparency.google.com/advertiser/AR…` link.
- **Region** — `anywhere` or a country code (`US`, `GB`, `JP`, `DE`…): only ads shown in that country.
- **Format** — `all`, `text`, `image` or `video`.
- **Max ads per advertiser** — 1 to 2,000, most recently shown first.

What you saw is remembered per advertiser, region and format in a named key-value store in your Apify account, so the second run already shows what is new. Schedule it (Apify → Schedules) for a daily alert.

### Pricing

**$1 per 1,000 ads**, plus $0.01 per run. Advertiser summary rows and error rows are free. With *Only new ads* you pay only for the new ads: the first run of an advertiser only saves the starting point and costs nothing but the $0.01 run-start fee. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- Public data only: what anyone sees on adstransparency.google.com. Advertiser names are published by Google as shown there (companies, and some individuals and sole traders who run ads). The rows hold no ad text and no contact details: only IDs, dates, the format and the address of the ad image.
- **Order and "new".** Google lists the most recently shown ads first. A big advertiser (Nike has thousands) read with a small limit shows a different slice each day, so an ad counts as new only when its ID was not in your previous run **and** it first ran in the days around that run (two days of slack for Google's publishing delay). Raise *Max ads per advertiser* for large advertisers.
- **Region** is a real filter, not a hint: the same advertiser returns different ads and counts per country (checked on 8 October 2026 from one address, Nike, Inc.: about 7,000 to 8,000 text ads for `US`, 10 ads in total for `JP`). `region` on each row is the filter you used, not the list of countries an ad ran in.
- Google rate limits fast callers. The Actor asks for one page of 40 ads every 3 seconds (an advertiser with 2,000 ads takes about 2.5 minutes) and retries twice; if Google still refuses, you get the ads read so far (`complete: false`) and an error row, and you can run again later.
- With a **Format** other than `all`, the Actor also checks the format of every ad it gets back, so you never receive another format by mistake.
- A company name that Google cannot match gives an error row instead of a guess; use the advertiser ID from the Transparency Center link then.

For **keyword ideas** to bid on or write ads for, see [Keyword Suggestions — Google, YouTube & Amazon Autocomplete](https://apify.com/northbell/keyword-suggestions-autocomplete).

### For AI agents

`{"advertisers": ["nike.com"], "maxAdsPerAdvertiser": 5}` returns one `advertiser` summary row and up to 5 `ad` rows with format, first and last shown dates and the ad image. Rows have `type`: `ad`, `advertiser` or `error`. Run it again with `"onlyNew": true` to get only the ads that appeared since the previous run.

# Actor input Schema

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

One advertiser per line: a company name (Nike), a website (nike.com), an advertiser ID (AR…) or an adstransparency.google.com/advertiser/AR… link. A name or website is matched to the advertiser with the most ads; the ID is the exact way.

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

Only ads that were shown in this country. "Anywhere" returns ads from every region.

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

Only ads of this format. Text ads are Google Search ads, image ads are banners on the Display network, video ads run on YouTube.

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

How many ads to read for each advertiser, most recently shown first. Large advertisers have thousands: raise this to see the full list. Only ads you receive are charged. The advertiser row (adsTotalMin, adsTotalMax, complete) shows how much this cap left out.

## `onlyNew` (type: `boolean`):

Return only ads that appeared since your previous run (a competitor ad alert). The first run saves the starting point and returns no ad rows, only the advertiser summary.

## Actor input object example

```json
{
  "advertisers": [
    "nike.com"
  ],
  "region": "anywhere",
  "format": "all",
  "maxAdsPerAdvertiser": 100,
  "onlyNew": false
}
```

# Actor output Schema

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

Every ad read, with its advertiser, format, first and last shown dates and whether it is new since the last run.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/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"] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/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"
  ]
}' |
apify call northbell/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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