# Google Ads Transparency Scraper – Competitor Ads by Website (`locomint/google-ads-transparency-scraper`) Actor

Google Ads Transparency scraper: give a website, an advertiser name or an ID and get every ad each advertiser runs - text, image and video - with first and last shown dates, days shown, the image and a link to the ad. Filter by country, platform, format and dates. No login.

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

## Pricing

from $0.80 / 1,000 result delivereds

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 Website

This Google Ads Transparency scraper reads the public Ads Transparency Center and hands you one
row per ad: who ran it, whether it is a text, image or video ad, when it was first and last shown,
how many days it ran, the website it promotes, the image where the listing carries one, and a link
to the ad on the Transparency Center. Search, YouTube, Shopping, Maps and Play ads are all there,
and you can narrow a run by country, platform, format and dates.

Give it a website, an advertiser's name, an advertiser ID or an Ads Transparency Center link.

### What it does

Every line of input is one search:

- **A website** such as `nike.com` returns every advertiser that promotes it. This is the best way
  to get a brand's ads: for `nike.com` in the United States the first page held Nike, Inc., Nike
  Retail BV and three resellers, which a search by one advertiser's name would never show.
- **An advertiser's name** such as `Nike, Inc.` is looked up on the Transparency Center and must
  match exactly, ignoring case and punctuation. The Transparency Center matches names loosely -
  its first answer for "nike" is a one-ad account in Kenya called "Nike" - so a name that matches
  nobody delivers nothing, costs nothing, and the log lists the advertisers whose names start that
  way, with their IDs. Where several accounts share the exact name (three are called "Nike, Inc."),
  all of them are searched.
- **An advertiser ID** (`AR` followed by digits) or **a Transparency Center link** is used as given.

Duplicates are removed: an ad is delivered, and charged for, once per run, under the first line
that found it - `nike.com` and `Nike, Inc.` return largely the same ads. Lines are read about a
hundred ads per request, and `maxAdsPerSearch` stops each line where you want it.

| Field | What goes in it |
|---|---|
| `advertiser_id`, `advertiser_name` | The account that ran the ad, as the Transparency Center publishes it. |
| `creative_id` | The ad's own ID (`CR` followed by digits). |
| `format` | `text`, `image` or `video`. |
| `first_shown`, `last_shown` | ISO 8601, UTC. A `last_shown` from today or yesterday means the ad is still running. |
| `days_shown` | Days on which the ad was shown, as the Transparency Center counts them. |
| `domain` | The website the ad promotes. Set when the line was a website. |
| `image_url`, `image_width`, `image_height` | The ad's image, when the listing itself carries a static one. `null` otherwise. |
| `preview_url` | The script the Transparency Center uses to draw the ad. |
| `ad_url` | The ad's own page on the Ads Transparency Center, where anyone can see it. |
| `search_term`, `search_type` | The line you gave and how it was read: `domain`, `advertiser` or `name`. |
| `region`, `platform` | The filters the run used (`anywhere`, `any` when none). |
| `total_ads_min`, `total_ads_max` | How many ads match the search in total, as a range - the Transparency Center's own count, across every page, not only the ones delivered. |
| `scraped_at` | ISO 8601 UTC, when the row was read. |

### Who it is for

- **Competitive research**: every ad a competitor is running now, and when each one started.
- **Agencies** building a creative library before a pitch, or watching a client's rivals.
- **Brand protection**: advertisers you do not know promoting your website - resellers and worse.
- **Market research**: how many ads a whole category of websites runs, by country and platform.

### How to use it

1. Put one website, name, advertiser ID or Transparency Center link per line in **Websites,
   advertisers or advertiser IDs**.
2. Choose a **Country**, **Platform** and **Ad format** if you want only some ads, and dates if you
   want a window.
3. Set **Maximum ads per search term** - a large brand runs thousands of ads.
4. Run it, and download the dataset as JSON, CSV or Excel.

### Input example

```json
{
  "searchTerms": ["nike.com", "Nike, Inc.", "AR16735076323512287233"],
  "region": "US",
  "platform": "youtube",
  "adFormat": "video",
  "startDate": "2026-08-01",
  "endDate": "2026-09-29",
  "maxAdsPerSearch": 200
}
```

### Output example

```json
{
  "search_term": "nike.com",
  "search_type": "domain",
  "advertiser_id": "AR16735076323512287233",
  "advertiser_name": "Nike, Inc.",
  "creative_id": "CR05867015907196272641",
  "format": "text",
  "first_shown": "2026-05-05T16:30:04Z",
  "last_shown": "2026-09-30T04:32:54Z",
  "days_shown": 120,
  "domain": "nike.com",
  "image_url": null,
  "image_width": null,
  "image_height": null,
  "preview_url": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&...",
  "ad_url": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR05867015907196272641?region=US",
  "region": "US",
  "platform": "any",
  "total_ads_min": 700,
  "total_ads_max": 800,
  "scraped_at": "2026-09-30T10:28:41+00:00"
}
```

### Pricing

| Event | Price |
|---|---|
| Ad delivered (one dataset row) | $0.001, which is $1.00 per 1,000 ads |
| Actor start | $0.00005 per GB of run memory, charged once per run |

Worked example: the most recent 500 ads for each of 10 competitors' websites is 5,000 ads, so
5,000 x $0.001 = $5.00 plus one start event. Users on paid Apify plans pay less per ad.

You pay only these event prices; Apify compute is not billed to you separately. A name that
matches no advertiser, a search with no ads, and a line the site could not answer produce no rows
and cost nothing. If you set a maximum cost per run, no row past that cost is ever delivered or
charged for.

### FAQ

#### Where does the data come from?

From the Ads Transparency Center, the public library where Google publishes the ads advertisers
run. The scraper reads the same logged-out pages anyone can open in a browser. No account, no
login, no API key.

#### Why did my name search return nothing?

Because no advertiser has exactly that name. The log lists the advertisers whose names start that
way, with their IDs - run again with the one you meant, or search the website instead, which
catches every account that promotes it.

#### Why is there no headline or body text for text and video ads?

The Transparency Center draws those ads with a separate script of about 170 KB per ad, and reading
it for every row would cost far more than the row. Each row links to the ad's own page instead
(`ad_url`), and carries the image wherever the listing has one.

#### What does `days_shown` count?

The days on which the ad was shown, as the Transparency Center reports them. It can be lower than
the gap between `first_shown` and `last_shown`, because an ad can pause and come back.

#### Why did my run stop early?

If the Ads Transparency Center answers with a CAPTCHA page, the run stops there. Every ad already
delivered is kept, and the rest is not retried from another address - that would be working around
a site's request to slow down, which this scraper never does. Run the remaining lines later.

### Limits

- 100 search terms per run and 10,000 ads per search term.
- Ads come about a hundred per request, and a run makes at most 30 requests a minute.
- Per-country breakdowns and impression ranges are not included; each ad's page on the
  Transparency Center shows them.
- A text or video ad's words are not decoded (see the FAQ). Image URLs are included when the
  listing carries a static image.
- Advertiser names must match exactly. Websites and advertiser IDs have no such limit.

### Compliance

Ads and advertiser names as the Ads Transparency Center publishes them, for anyone to see. You are
responsible for using the data lawfully.

Questions, bug reports and feature requests go on this actor's Issues tab. Business owners can send data-removal requests to info@locomint.io; that address is for removal requests only. This actor keeps no copy of what it reads between runs, so each run returns what the Transparency Center shows at that moment.

### Other Locomint actors

- [Google Maps Scraper & Email Extractor – Business Leads](https://apify.com/locomint/google-maps-scraper): Search terms and a city in, business records with website contacts out.
- [Google Maps Scraper – Multi-City Lead Lists with Emails](https://apify.com/locomint/google-maps-multi-city-scraper): Many categories across many cities in one deduplicated run.
- [Google Maps Place Details Scraper – Bulk Place ID Lookup](https://apify.com/locomint/google-maps-place-details-scraper): Place IDs or place-page links in, full records out.
- [Website Email Scraper – Contact Details, Socials & WhatsApp](https://apify.com/locomint/website-content-contact-extractor): Contact points from website URLs you supply.
- [Website Content Crawler – Markdown for AI, Emails & Contacts](https://apify.com/locomint/website-crawler-content-contacts): A whole site as Markdown, with its contact points.
- [Bulk Email Verifier & Validator – Mailbox-Level SMTP Check](https://apify.com/locomint/bulk-email-verifier): Checks whether addresses can receive mail.
- [Company Enrichment API – Domain to Emails, Socials & Tech](https://apify.com/locomint/company-enrichment): A domain in, its contacts and technologies out.
- [AI Crawler Checker – robots.txt Rules for GPTBot & ClaudeBot](https://apify.com/locomint/ai-crawler-checker): Which AI crawlers a site's robots.txt allows.
- [Schema Markup Validator & Generator – JSON-LD Checker](https://apify.com/locomint/schema-markup-validator): Checks and generates schema.org markup.
- [Career Site Job Scraper – Greenhouse, Lever, Ashby, Workable](https://apify.com/locomint/career-site-jobs-scraper): Open vacancies straight from an employer's own job feed.
- [Tech Stack Detector – 5,800 Technologies with Versions](https://apify.com/locomint/tech-stack-detector): What a list of websites runs, with versions.
- [Google Maps Email Extractor – Every Address Verified](https://apify.com/locomint/google-maps-email-extractor): Business leads whose email address the mail server confirmed.

# Actor input Schema

## `searchTerms` (type: `array`):

One per line. A website (nike.com) returns every advertiser that promotes it and is the best way to get a brand's ads. An advertiser's name must match the Ads Transparency Center exactly, ignoring case and punctuation (Nike, Inc.); a name that matches nobody costs nothing and the log lists the names that start that way. An advertiser ID (AR...) or an Ads Transparency Center link is used as given.

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

Only ads shown in this country.

## `platform` (type: `string`):

Only ads shown on one Google platform.

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

Only text, image or video ads.

## `startDate` (type: `string`):

Only ads shown on or after this day (YYYY-MM-DD). Empty: no limit.

## `endDate` (type: `string`):

Only ads shown on or before this day (YYYY-MM-DD). Empty: no limit.

## `maxAdsPerSearch` (type: `integer`):

Stop after this many ads for each line. A large brand runs thousands of ads; you pay only for the ads delivered.

## Actor input object example

```json
{
  "searchTerms": [
    "nike.com"
  ],
  "region": "anywhere",
  "platform": "any",
  "adFormat": "any",
  "maxAdsPerSearch": 100
}
```

# Actor output Schema

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

One row per ad: advertiser, format, first and last shown dates, days shown, the website it promotes, the image where there is one, and a link to the ad on the Ads Transparency Center.

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

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

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

```

## MCP server setup

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