# Google Ads Transparency Scraper: Competitor Ads by Advertiser (`fulox/google-ads-transparency-scraper`) Actor

Google Ads Transparency Center scraper with a new-ads-only mode: schedule it weekly and get only the ads first seen since your last run. Search by name, domain or advertiser ID. $1.40 per 1,000 ads; lookups, empty results and failed requests are free. No login or cookies.

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

## Pricing

from $1.00 / 1,000 ad creatives

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 by Advertiser

Type a competitor's name, domain or Google advertiser id and get every ad creative Google's Ads Transparency Center lists for it, as flat rows with format, first and last shown dates, an image or preview link and the ad page link. For performance marketers, agencies and competitive-intel teams who check what a competitor runs on Google every week or before a pitch.

### What you get

- New-ads-only mode: turn on `onlyNewSinceLastRun` and a weekly run returns only the ads first seen since your last run, each flagged `isNew`; the first run of an advertiser is the baseline.
- One input for name, domain or id: type `nike`, `nike.com` or `AR16735076323512287233`; a domain returns every ad that links to that website (Google's own website filter, so `nike.com` gets Nike's ads, not a look-alike name); a name resolves to the largest matching advertiser, and the other matches are listed in a free advertiser record so you can pick another.
- $1.40 per 1,000 ads, 30% under the Store leader, and advertiser lookups, empty results and failed requests are free.
- One flat row per ad: advertiser, creative id, format (`image`, `text`, `video` or `unknown`), first and last shown date, image URL with width and height, preview URL and a link to the ad on adstransparency.google.com. No login, no cookies, no API key.

### Example output

An `ad` row (charged):

```json
{
  "type": "ad",
  "input": "nike",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR14279383245370949633",
  "format": "image",
  "formatCode": 2,
  "firstShown": "2023-11-16",
  "lastShown": "2026-10-17",
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/4454334368022254950",
  "previewUrl": null,
  "width": 348,
  "height": 455,
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR14279383245370949633",
  "isNew": true,
  "runAt": "2026-10-18T09:00:00.000Z"
}
```

Each input entry also gets one free `advertiser` row, written after its ads: `status` (`ok`, `not_found`, `invalid`, `duplicate`, `error` or `skipped`), the matched advertiser and country, Google's estimated ad count (`estimatedAdsMin`, `estimatedAdsMax`), the other matches in `alternatives`, how many ads were fetched, delivered and new, whether the run was the `baseline`, and a `reason` for anything but `ok`. If nothing could be written at all, one free `run` row says why, so the dataset is never empty.

### How to use it

1. Enter one or more advertisers: a name, a domain or an id (up to 50 per run).
2. Pick how many ads per advertiser you want and click Start.
3. Download the dataset as JSON, CSV or Excel, or connect it to Google Sheets, Make, Zapier or n8n. To watch a competitor, schedule the Actor weekly with `onlyNewSinceLastRun` on.

### Input

| Field | What it does | Default |
|---|---|---|
| `advertisers` | Names, domains or ids (`AR` followed by 20 digits), one per advertiser, up to 50 | `["hubspot.com"]` |
| `maxAdsPerAdvertiser` | Ads to fetch per advertiser, 1 to 2,000, in pages of 40 | 40 |
| `onlyNewSinceLastRun` | Deliver and charge only ads not seen in an earlier run of this account | off |
| `format` | `all`, `image` or `text` | `all` |
| `resetState` | Forget earlier runs for these advertisers, so every ad counts as new once | off |
| `proxyConfiguration` | Apify Proxy settings; datacenter by default, residential if runs get blocked | Apify Proxy on |

A run makes at most 200 requests in total. Names use one lookup request each, and each page of 40 ads is one request.

### Pricing

$1.40 per 1,000 ads ($0.0014 per `ad` row). Volume discounts apply on higher Apify plans: $1.20 per 1,000 on Silver, $1.00 per 1,000 on Gold and above. You pay only for ad rows delivered. Advertiser lookups, `advertiser` and `run` rows, empty results, entries that are not found, invalid or skipped, and failed requests are free. The default run (40 ads) costs $0.056. A weekly new-only check of a quiet advertiser costs nothing. Set a maximum cost per run to stay in control: the run stops when it is reached, its status message says `Stopped early: user_budget`, and advertisers not yet processed get no rows and cost nothing.

### Limitations

- New-ads-only mode compares the first `maxAdsPerAdvertiser` ads Google returns. Google does not list ads newest first and the order is not by date, so for an advertiser with more ads than that limit, new ads beyond it appear when you raise the limit. The `estimatedAdsMax` field shows how many ads Google reports for the advertiser. The first run of an advertiser returns all fetched ads, flagged `isNew`, as the baseline.
- A domain returns ads from every advertiser that links to it (resellers and agencies too); each ad row has its own `advertiserId`. Names resolve to the advertiser with the most ads. If that is not the one you meant, take an id from `alternatives` and run again. Names of private persons are returned exactly as Google publishes them; nothing else is joined to them.
- Google's endpoint can stall requests from a single address. The Actor waits at most 20 seconds per request, paces itself at one request per second, and routes requests through Apify Proxy by default. If Google stops answering three times in a row, the run stops with an explanation in a `run` row and nothing is charged for ads it did not deliver; try again later or switch the proxy group to residential.
- Video ads come out as `video` and other formats as `unknown` with Google's `formatCode`; they are returned only with `format` set to `all`.
- Region and date filters are not offered yet. Data is what Google's public Ads Transparency Center shows; this Actor is not affiliated with Google.

### FAQ

**Do I need a Google account or API key?** No. The Actor reads the public Ads Transparency Center, with no login.

**Does it download the ad images?** No. It returns the image URL and the preview link; you can open or download them from there.

**How is the new-ads memory kept?** In a named key-value store of your Apify account, one entry per advertiser with the creative ids already delivered. Turn on `resetState` to start over.

**What if two inputs are the same advertiser?** The second one gets a free `duplicate` row.

**What does a failed request cost?** Nothing. Only delivered `ad` rows are charged.

### Changelog

- 1.0.5 (2026-10-24): fixed swapped ad formats. Google's code 1 is text and 2 is image; the Actor had them the other way round, so `format: image` returned and charged text ads. Video ads are now labelled `video`.
- 1.0.4 (2026-10-21): a domain now uses Google's website filter. Before, `nike.com` could match a look-alike advertiser name. With "Only ads new since the last run" on, a domain's first run on 1.0.4 is a new baseline, so its current ads are delivered (and charged) once more.
- 1.0 (2026-10-18): first release. Name, domain and id lookup, new-ads-only mode, format filter, Apify Proxy support, pay per ad.

# Actor input Schema

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

One entry per advertiser: a name (nike), a domain (nike.com) or a Google advertiser id (AR followed by 20 digits). A domain returns every ad that links to that website (Google's website filter); a name uses the largest matching advertiser, and the other matches are listed in the free advertiser row. Up to 50 per run.

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

Ads are fetched in pages of 40. Each delivered ad is charged once. A run makes at most 200 requests in total.

## `onlyNewSinceLastRun` (type: `boolean`):

Deliver and charge only ads not seen in an earlier run of this account. The first run of an advertiser is the baseline: all its ads, flagged as new. Compares the first 'Maximum ads per advertiser' ads; for advertisers with more ads than that, new ads beyond the limit appear when you raise it.

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

Keep only image ads or only text ads. Other formats are only returned with 'all'.

## `resetState` (type: `boolean`):

Forget what earlier runs saw for these advertisers, so every ad counts as new once.

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

Requests go through Apify Proxy by default, because Google's endpoint can stall requests from a single address. Datacenter proxy is enough for most runs; pick residential if runs stop with a 'stopped answering' message.

## Actor input object example

```json
{
  "advertisers": [
    "hubspot.com"
  ],
  "maxAdsPerAdvertiser": 40,
  "onlyNewSinceLastRun": false,
  "format": "all",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

One row per ad creative (advertiser, format, first and last shown dates, preview link, isNew), one free advertiser row per input entry, and a run row when nothing was delivered.

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

Counts for the run: advertisers processed, ads charged, calls made, stop reason.

# 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": [
        "hubspot.com"
    ],
    "maxAdsPerAdvertiser": 40,
    "onlyNewSinceLastRun": false,
    "format": "all",
    "resetState": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fulox/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": ["hubspot.com"],
    "maxAdsPerAdvertiser": 40,
    "onlyNewSinceLastRun": False,
    "format": "all",
    "resetState": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fulox/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": [
    "hubspot.com"
  ],
  "maxAdsPerAdvertiser": 40,
  "onlyNewSinceLastRun": false,
  "format": "all",
  "resetState": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fulox/google-ads-transparency-scraper --silent --output-dataset

```

## MCP server setup

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