# Google Ads Transparency Scraper: Ad Library by Domain (`hirethomas/google-ads-transparency-scraper`) Actor

Google Ads Transparency Center scraper at $0.70 per 1,000 ads: export text, image and video ads for any domain, advertiser name or advertiser ID, with first and last shown dates, format, preview links and regions. A Google ad library API alternative. No login needed.

- **URL**: https://apify.com/hirethomas/google-ads-transparency-scraper.md
- **Developed by:** [Brindlewave Data](https://apify.com/hirethomas) (community)
- **Categories:** Marketing, Lead generation, SEO tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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 Center Scraper

Get the Google ads a company runs (text, image and video creatives) from the public [Google Ads Transparency Center](https://adstransparency.google.com/). Enter a domain, an advertiser name or an advertiser ID and get a clean table of ads with first and last shown dates, format, preview links and, optionally, the countries where each ad ran.

No Google account, no API key and no cookies needed. The actor reads the same public data the Transparency Center website shows.

### What you can use it for

- **Competitor ad research**: see which ads a competitor is running right now and which ones they kept running for months (usually the winners).
- **Agency pitches and audits**: pull a prospect's full ad history before a call.
- **Market monitoring**: schedule the actor daily or weekly and compare new creatives over time.
- **Lead generation**: find companies actively spending on Google Ads in a country.

### Input

| Field | What it does |
|---|---|
| `queries` | List of domains (`nike.com`), advertiser names (`Nike`) or advertiser IDs (starting with `AR`, as shown in Transparency Center URLs). Names are matched with the Transparency Center search; the run status shows which advertiser was used. |
| `region` | Only ads shown in one country, or `ANYWHERE`. |
| `adFormat` | `ALL`, `TEXT`, `IMAGE` or `VIDEO`. |
| `dateFrom` / `dateTo` | Optional date range (YYYY-MM-DD). |
| `maxResultsPerQuery` | Stop after this many ads per query (default 100). |
| `includeDetails` | Adds the countries where each ad ran (with last shown date per country) and the number of variations. One extra request per ad, so slower. |
| `proxyConfiguration` | Apify Proxy is on by default and helps with large runs. |

Example:

```json
{
  "queries": ["nike.com", "Adidas"],
  "region": "US",
  "adFormat": "ALL",
  "maxResultsPerQuery": 200
}
```

### Output

One row per ad creative. A real row from a test run (`nike.com`, region US):

```json
{
  "query": "nike.com",
  "advertiserId": "AR16735076323512287233",
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR14666120002126479361",
  "adFormat": "IMAGE",
  "targetDomain": "nike.com",
  "firstShown": "2023-05-01T15:13:53.000Z",
  "lastShown": "2026-10-08T00:51:35.000Z",
  "previewUrl": null,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/9111123928528335572",
  "adUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR14666120002126479361?region=US",
  "regionFilter": "US",
  "scrapedAt": "2026-10-08T01:10:17.795Z",
  "shownInRegions": ["US"],
  "variations": 5
}
```

`imageUrl` is a direct image link when Google serves the ad as an image. `previewUrl` is Google's preview script for text and video ads (open `adUrl` to see the rendered ad). `shownInRegions` (country codes where the ad ran) and `variations` are only added when `includeDetails` is on.

Download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

The run's key-value store has a `STATUS` record with the resolved advertiser for each query, ads saved per query, the approximate total Google reports, and any problems.

### Reliability

- Every row is checked before it is saved (advertiser and creative IDs, format, valid dates, a preview or image link). Rows that fail are dropped and counted in `STATUS`.
- If most rows fail the checks (for example after a Google format change) or nothing is found at all, the run is marked **failed** with a clear message instead of finishing "successfully" with an empty table.
- Requests are paced and retried with backoff. If Google rate-limits the connection, the actor waits and retries, then stops with a clear message. It never tries to solve CAPTCHAs. Ads saved before that point are kept.

### Limits

- Data is what Google publishes in the Transparency Center. Google does not publish spend or impressions for most commercial ads.
- `firstShown` / `lastShown` are dates as reported by Google, not exact times.
- Text inside ad creatives is not extracted yet; use `previewUrl`, `imageUrl` or `adUrl` to view the ad.
- Some advertisers are verified as individuals; their names are published by Google. Use the data in line with applicable law.

### Questions and issues

Open an issue on the Issues tab. Reports with the input you used get fixed fastest.

### Pricing

Pay per result: $0.70 per 1,000 ads, plus $0.00005 per run start. No monthly rental. You only pay for ads saved to the dataset.

#### FAQ

##### Is there a Google Ads Transparency Center API?

Google does not offer a public API for it. This Actor reads the public Transparency Center and returns the ads as JSON or CSV.

##### How do I see all Google ads a competitor is running?

Enter the competitor's domain (for example `nike.com`), brand name or advertiser ID (`AR...`) in `queries`. You get every text, image and video ad with first and last shown dates and preview links.

##### Can I filter by country, format or date?

Yes. Use `region` for a country, `adFormat` for text, image or video, and `dateFrom` / `dateTo` for the time window.

##### How is this different from the Meta (Facebook) Ad Library?

It covers ads on Google: Search, YouTube, Display, Shopping, Maps and Play. For Facebook and Instagram ads use a Meta Ad Library scraper.

# Actor input Schema

## `queries` (type: `array`):

One per line. Accepts a website domain (nike.com), an advertiser ID (AR...), or an advertiser name (Nike). Names are matched with the Transparency Center search, and the best matching verified advertiser is used.

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

Only ads shown in this country. Use ANYWHERE for all regions.

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

Filter by ad format.

## `dateFrom` (type: `string`):

Optional. Only ads shown on or after this date.

## `dateTo` (type: `string`):

Optional. Only ads shown on or before this date. Requires Shown from.

## `maxResultsPerQuery` (type: `integer`):

Stop after this many ads for each query.

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

Makes one extra request per ad to add the countries where it ran (with last shown date per country) and the number of variations. Slower.

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

Optional. Apify Proxy helps when running many queries.

## Actor input object example

```json
{
  "queries": [
    "nike.com"
  ],
  "region": "ANYWHERE",
  "adFormat": "ALL",
  "maxResultsPerQuery": 100,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per ad creative found in the Google Ads Transparency Center.

## `status` (type: `string`):

Per-query counts, resolved advertisers, request status and validation results.

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

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

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

```

## MCP server setup

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