# Google Ads Transparency Scraper – Advertiser Ads (`simple.actor/google-ads-transparency`) Actor

Scrape Google's Ads Transparency Center: every ad an advertiser or domain runs, with format, first and last shown dates, days shown, image or preview, a link to the ad and Google's ad count. Look up by name, domain or advertiser ID; filter by country, format and date. No login. Unofficial.

- **URL**: https://apify.com/simple.actor/google-ads-transparency.md
- **Developed by:** [Simple Actor](https://apify.com/simple.actor) (community)
- **Categories:** Marketing, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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 – Advertiser Ads

Scrape Google's Ads Transparency Center as structured data. Give it a
website, an advertiser or a link from the Center, and every ad Google shows
for it comes back as a row: the ad's format, when it was first and last
shown, how many days it has run, a picture of the ad or its preview, the
advertiser behind it and where they are based, and a link to the ad's own
page — newest-shown first.

Built for competitor research, ad monitoring, agency pitches and brand
safety: see what a competitor is running right now, what they launched this
month, and which countries each ad reached.

**No login, no API key, no browser, no account of yours involved.** A hundred
ads arrive in one request.

**$0.50 per 1,000 ads** — $0.05 for a typical 100-ad lookup. Apify platform
usage included, nothing else to pay. A line that cannot be looked up is never
charged.

*Unofficial. Not affiliated with, endorsed by, or sponsored by Google.*

### Features

- **Look up anything you have** — a website (`nike.com`, or any link to it), an advertiser ID
  (`AR16735076323512287233`), an advertiser name (`Nike`), or a link copied from
  the Transparency Center.
- **A website finds every advertiser behind it** — a brand's own accounts, its
  regional entities and its agencies. `nike.com` returns ads from 30-odd
  advertisers.
- **Google's own count on every row** — `googleAdCountMin`/`googleAdCountMax`
  say how many ads Google holds for the lookup, so you can see how complete your
  pull is before asking for all of them.
- **Country filter, or anywhere** — ads shown in one country, or in any.
- **Format filter** — text, image or video ads only.
- **Date windows that work** — `shownSince` for what is running now,
  `firstShownSince` for what was launched recently. Both are applied exactly on
  each ad's own dates.
- **Where each ad ran** — optional per-ad list of every country it was shown in,
  with the last date it ran there, and its number of variations.
- **The advertiser's country on every ad row**, not only in a separate lookup.
- **Runs stay green.** A line that cannot be looked up becomes an error row, so
  one bad line never costs the rest of the job.

### Input

```json
{
  "targets": ["nike.com", "AR16735076323512287233", "Nike"],  // one per line
  "maxAds": 100,               // ads per line, newest-shown first (up to 50,000)
  "region": "anywhere",        // a two-letter country code, or anywhere
  "adFormat": "any",           // any | text | image | video
  "shownSince": "30 days",     // optional: only ads shown in this window
  "firstShownSince": "",       // optional: only ads first shown in this window
  "includeAdDetails": false    // add the countries each ad ran in
}
```

| Field | Type | Default | What it does |
|---|---|---|---|
| `targets` | array | — | Websites (or links to them), advertiser IDs, advertiser names, or Transparency Center links, one per line. |
| `maxAds` | integer | `100` | Ads per line, up to 50,000. A hundred arrive per request. |
| `region` | string | `anywhere` | Two-letter country code (`US`, `GB`, `DE`…), or `anywhere`. |
| `adFormat` | string | `any` | `text`, `image` or `video`. |
| `shownSince` | string | — | Only ads shown on or after this date: `2026-08-01`, or a window like `30 days`. |
| `firstShownSince` | string | — | Only ads first shown on or after this date — new ads. |
| `includeAdDetails` | boolean | `false` | Add each country the ad ran in, with its last date there, and its variation count. One extra request per ad. |

#### Website, advertiser or name?

- **A website** (`nike.com`) is the widest net and the right choice for a brand:
  it finds every advertiser whose ads point at that site, agencies included.
- **An advertiser ID** (`AR…`, from an advertiser's page in the Center) is exact:
  one account's ads.
- **A name** (`Nike`) is looked up among Google's suggestions, and the matching
  advertiser with the most ads is used — `Nike` means Nike, Inc., not the
  one-ad account called "Nike". Every row names the advertiser, so you can see
  which one was used.
- **A pasted link** keeps its own country, because it is the view you were
  looking at.

#### How many ads

Ads come a hundred per request, newest-shown first, and every row carries
Google's own count for the lookup. Big brands hold thousands; `maxAds` decides
how far to read. `shownSince` stops reading as soon as older ads begin, so
"what are they running this month" is fast even for a brand with 10,000 ads.

### Output

One item per ad, in the run's dataset:

```json
{
  "type": "ad",
  "position": 1,
  "adId": "CR03243835622955155457",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "advertiserCountry": "US",
  "format": "text",
  "firstShown": "2022-11-30T14:48:56.165Z",
  "lastShown": "2026-09-11T00:28:36.454Z",
  "daysShown": 1371,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/5268894407758702852",
  "imageWidth": 348,
  "imageHeight": 275,
  "previewUrl": null,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR03243835622955155457?region=anywhere",
  "domain": null,
  "regions": null,
  "variations": null,
  "googleAdCountMin": 7000,
  "googleAdCountMax": 8000,
  "target": "AR16735076323512287233",
  "targetType": "advertiser",
  "region": "anywhere",
  "retrievedAt": "2026-09-11T08:00:00.000Z"
}
```

| Field | What it is |
|---|---|
| `adId`, `advertiserId` | Google's IDs for the ad and the advertiser — stable, for deduplicating across runs. |
| `advertiserName`, `advertiserCountry` | Who runs the ad, and the country they are based in. |
| `format` | `text`, `image` or `video`. |
| `firstShown`, `lastShown`, `daysShown` | When Google first and last showed the ad, and for how many days. `lastShown` is today for an ad still running. |
| `imageUrl`, `imageWidth`, `imageHeight` | A picture of the ad as Google archived it — how Google keeps nearly every text ad. |
| `previewUrl` | Google's preview script that renders the ad, for video ads and ads without a picture. |
| `adUrl` | The ad's page in the Transparency Center. |
| `domain` | On a website lookup, the site Google files the ad under. |
| `regions`, `variations` | With `includeAdDetails`: each country the ad ran in with its last date there, and how many variations it has. |
| `googleAdCountMin`, `googleAdCountMax` | Google's own count of ads for this lookup, as the range it states. |
| `position` | The ad's place in Google's newest-shown-first order. With a date filter, skipped ads leave gaps. |
| `target`, `targetType`, `region` | The line it answered, how that line was read, and the country it was limited to. |

A line that could not be looked up is its own row with `type: "error"`, an
`error` code (`bad_input`, `not_found` or `read_failed`) and an
`errorDescription`. The run itself stays green either way, and its status
message says how many lines could not be looked up — so if you run on a
schedule, check for `type: "error"` rows rather than trusting the run status.

An empty dataset means every line was looked up and Google shows no ads for
it. An advertiser ID that does not exist comes back as a `not_found` row, not
as silence.

### How to use

#### From Apify Console

1. Open the Actor and click **Try for free** / **Start**.
2. Put one website, advertiser ID or name per line into **Advertisers or
   websites**. For a brand, the website finds the most.
3. Set **Ads per advertiser or website**. Every row shows Google's own count,
   so a first run of 100 tells you how many there are.
4. Optionally narrow by **Country**, **Format**, or a date window.
5. Click **Start**, then open the **Dataset** tab — the Ads view shows a
   picture of each — and export as JSON, CSV or Excel.

#### From the API

```bash
curl -s "https://api.apify.com/v2/acts/simple.actor~google-ads-transparency/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"targets": ["nike.com"], "shownSince": "30 days", "maxAds": 200}'
```

Monitoring a competitor's new ads with the JavaScript client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('simple.actor/google-ads-transparency').call({
    targets: ['competitor.com'],
    firstShownSince: '7 days',
    maxAds: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
// Deduplicate across scheduled runs on `adId`, which is stable.
```

### Use cases

- **Competitor research** — everything a rival is running, by format and
  country, with how long each ad has lasted.
- **New-ad monitoring** — a weekly run with `firstShownSince` catches every
  ad a competitor launches.
- **Agency pitches and audits** — pull a prospect's full ad history before
  the meeting.
- **Brand safety** — find advertisers running ads that point at your domain.
- **Market mapping** — which advertisers and agencies are active in a
  category, and where.

### Pricing

Simple pay-per-result pricing — no subscription and no start fee.

| Event | Price |
|---|---|
| Ad returned | $0.0005 |
| Ad details added (countries it ran in, variations) | $0.0005 |

What that comes to:

- A lookup at the default depth, 100 ads: **$0.05**.
- 1,000 ads: **$0.50** — or **$1.00** with details on.
- A big brand's whole list, around 8,000 ads: **about $4**.

Error rows are never charged, and a lookup Google has no ads for costs nothing.

### Limits worth knowing

- **Most text ads are pictures.** Google archives text ads as an image of the
  ad, so their words come as a picture (`imageUrl`), not as text.
- **No platform filter.** The Center does not reliably filter by Search,
  YouTube, Shopping or Maps, so it is not offered.
- **Political ads are not covered.** They live in a separate part of the Center.
- **Google's count is a range** ("8,000–9,000"), as the Center itself shows it.

### FAQ

**Is scraping the Google Ads Transparency Center legal?**
The Center is a public transparency tool Google publishes so anyone can see who
is advertising and what. This Actor reads the same data the Center's own page
loads. Check the platform's terms and your own use before relying on it.

**Do I need a Google account, cookies or an API key?**
No. There is no login, no cookie and no key.

**Why did a name give me a different advertiser than I expected?**
A name is matched among Google's suggestions and the matching advertiser with
the most ads is used. Every row names the advertiser; for an exact account,
use its advertiser ID from the Center, and for a whole brand, its website.

**How do I know a lookup failed if the run stays green?**
Check for rows with `type: "error"` — that is the failure channel by design, so
one bad line never costs the rest of the job. The run's status message also
counts how many lines could not be looked up.

Data comes from Google's Ads Transparency Center and is subject to Google's
terms. Unofficial, and not affiliated with Google.

# Actor input Schema

## `targets` (type: `array`):

Who to look up, one per line. Each line can be a website (nike.com, or any link to it — every ad pointing at that site, from every advertiser, agencies and regional entities included), an advertiser ID (AR16735076323512287233), an advertiser name (Nike — the matching advertiser with the most ads is used), or a link copied from the Ads Transparency Center. For a brand, the website usually finds the most ads.

## `maxAds` (type: `integer`):

How many ads to return for each line. Ads come newest-shown first, a hundred per request. Every row also carries Google's own count of the advertiser's ads, so you can see how many there are before asking for all of them.

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

Only ads shown in this country, as a two-letter code: US, GB, DE, IN… Leave it at "anywhere" for ads shown in any country — the Transparency Center's own default, and the one that finds the most.

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

Only ads of this format. Text ads are mostly kept by Google as a picture of the ad, so their rows carry an image.

## `shownSince` (type: `string`):

Keep only ads Google showed on or after this date — what an advertiser is running now, or ran recently. Takes a date such as 2026-08-01, or a window like "30 days". Ads come newest-shown first, so reading stops as soon as older ones begin.

## `firstShownSince` (type: `string`):

Keep only ads Google first showed on or after this date — new ads, for monitoring what an advertiser launches. Takes a date or a window. Unlike the filter above, this one has to look through the advertiser's list to find them, so it can take longer on a big advertiser.

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

On, every ad row also lists each country the ad was shown in with the last date it ran there, and how many variations of the ad exist. It costs one extra request per ad, so it is slower and charged separately.

## Actor input object example

```json
{
  "targets": [
    "nike.com",
    "AR16735076323512287233",
    "Nike"
  ],
  "maxAds": 100,
  "region": "US",
  "adFormat": "any",
  "shownSince": "30 days",
  "firstShownSince": "7 days",
  "includeAdDetails": false
}
```

# Actor output Schema

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

One row per ad: picture, advertiser, format, first and last shown, days shown and the line it answered.

## `links` (type: `string`):

Each ad's Transparency Center page, archived picture and preview script.

## `raw` (type: `string`):

Every field of every item, exactly as pushed.

# 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 = {
    "targets": [
        "nike.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("simple.actor/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 = { "targets": ["nike.com"] }

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

```

## MCP server setup

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