# Google Ads Transparency Creative Lookup by Domain (`vexaloom-labs/google-ads-transparency-creative-lookup-by-domain`) Actor

Look up an advertiser's live and recent Google ads by landing-page domain or advertiser ID, with ad format, preview creative, and first/last shown dates, filterable by region, platform, and date.

- **URL**: https://apify.com/vexaloom-labs/google-ads-transparency-creative-lookup-by-domain.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Automation, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Creative Lookup by Domain

Research the ads a company runs through Google without a Google Ads account. Search the public [Ads Transparency Center](https://adstransparency.google.com) by landing-page domain, brand name, exact advertiser ID, or pasted URL, and export creatives with run dates, destination domains, variants, per-country activity, EU impression ranges, audience targeting, and verified advertiser identity. No login, no API key, no cookies.

### What this actor does

- **Search by domain, brand, advertiser ID, or URL** in one batch — paste `nike.com`, `Nike`, `AR16735076323512287233`, or a Transparency Center link
- **Full result sets, not the first page** — follows Google's continuation cursor to the end of the result set or your chosen limit
- **Ad details on demand** — every creative variation, per-country run dates, EU impression ranges by country and platform, audience-selection categories, and advertiser country, legal name (when published), and verification
- **Ad-check mode** — turn a domain or brand into one row per advertiser found, with verification status and, for exact advertiser-ID lookups, Google's approximate ad-count range
- **Filters:** 249 countries plus Anywhere, text/image/video, Search/Maps/Shopping/Play/YouTube, and a shown-during date window
- **Empty fields are omitted** — no nulls or placeholder strings

### Output per ad

- `advertiserId`, `advertiserName`, `advertiserCountry`, `advertiserLegalName`, `advertiserVerified`
- `creativeId`, `format` — `Text`, `Image`, or `Video`
- `firstShownAt`, `lastShownAt` — Google's search-index first/last activity in ISO-8601 UTC, plus epoch timestamps; per-country dates are in `regions[]`. Direct creative URLs omit `firstShownAt` because the detail endpoint has no first-shown date
- `daysShown` — Google's count of days the creative has been active (omitted for direct creative URLs)
- `destinationDomain`, `destinationUrl` — where the ad clicks through to, when Google exposes it
- `headline`, `description`, `callToAction` — when the creative stores readable copy
- `youtubeVideoId`, `youtubeUrl`, `videoThumbnailUrl` — for video creatives
- `previewImageUrl`, `previewWidth`, `previewHeight`, `previewContentUrl` — static image or rendered preview
- `variationCount`, `variations[]` — every image/content variation Google returns
- `regions[]` — per-country last-shown dates for every ad, plus first-shown dates, impression ranges, and platform breakdown where Google publishes them (mostly EU/EEA and Turkey)
- `impressionsLow`, `impressionsHigh`, `platformsShown` — Google's EU/EEA totals; Turkey and other per-country figures are in `regions[]`. Google sometimes omits a bound, so each bound is returned only when published
- `audienceSelection` — demographics, geographic locations, contextual signals, customer lists, and topics, each marked included/excluded
- `creativeUrl`, `advertiserUrl`, `region`, `searchTerm`, `matchedVia`
- `recordType: "ad"`, `scrapedAt`

### Output per advertiser (mode = `advertisers`)

- `advertiserId`, `advertiserName`, `advertiserCountry`, `advertiserLegalName`, `advertiserVerified`
- `approxAdCountLow`, `approxAdCountHigh` — Google's stated range for exact advertiser-ID lookups; omitted for domain/brand ad-check scans, which inspect up to 500 ads
- `scannedAds` — how many ads were inspected to find the advertisers in domain/brand ad-check mode; omitted for exact advertiser-ID lookups
- `matchedTerm`, `matchedVia`, `matchedDomain`
- `advertiserUrl`, `region`, `recordType: "advertiser"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` for ad records; `advertisers` for one row per advertiser |
| `searchTerms` | array | – | Domains, brand names, advertiser IDs, or Transparency Center URLs |
| `region` | string | `US` | Country code or `ANYWHERE` |
| `adFormat` | string | `ALL` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `platform` | string | `ALL` | `ALL`, `SEARCH`, `MAPS`, `SHOPPING`, `PLAY`, `YOUTUBE` |
| `dateFrom` | string | – | Start of the shown-during window (`YYYY-MM-DD`) |
| `dateTo` | string | – | End of the shown-during window (`YYYY-MM-DD`); an ad qualifies if it ran at any point in the window, so ads still running after this date are not excluded |
| `maxItems` | integer | `100` | Total records to return (1–100,000) |
| `maxItemsPerTerm` | integer | `0` | Per-term cap; 0 = no per-term cap |
| `includeDetails` | boolean | `true` | Fetch variants, per-country reach, EU impressions, targeting, advertiser identity, and available copy |

#### Example: recent ads for a domain

```json
{
  "mode": "search",
  "searchTerms": ["nike.com"],
  "region": "US",
  "maxItems": 100,
  "includeDetails": true
}
```

#### Example: brand ads in Germany, video only

```json
{
  "mode": "search",
  "searchTerms": ["Zalando"],
  "region": "DE",
  "adFormat": "VIDEO",
  "dateFrom": "2026-01-01",
  "maxItems": 50
}
```

#### Example: exact advertiser IDs across every region

```json
{
  "mode": "search",
  "searchTerms": ["AR16735076323512287233", "AR15589870916631265281"],
  "region": "ANYWHERE",
  "maxItemsPerTerm": 200,
  "maxItems": 500
}
```

#### Example: ad-check a list of competitors

```json
{
  "mode": "advertisers",
  "searchTerms": ["nike.com", "adidas.com", "hellofresh.com"],
  "region": "US",
  "maxItems": 30
}
```

### Use cases

- **Competitive creative research** — collect a swipe file of live and recent ads, with run dates and destination pages
- **Ad-check and lead generation** — find which advertisers send clicks to a domain, with legal names and verification badges
- **EU reach analysis** — compare impression ranges by country and platform for DSA-covered ads
- **Campaign longevity** — use `daysShown` and `lastShownAt` to separate long-running winners from short tests
- **Brand safety and compliance** — verify who is paying for ads that point at your domain
- **Market expansion** — compare a brand's creative set across countries

### FAQ

**Is this the official Google Ads API?** No. It reads the public Ads Transparency Center, the same data any visitor can browse, without a Google Ads account, developer project, or API key.

**Do I need to paste a domain, a brand name, or an advertiser ID?** Any of the three works. Brand names are resolved to the brand's website first because Google's advertiser-name lookup often leads with small regional accounts that share the name. Use an exact `AR...` ID when you need one specific account.

**Why does one domain return ads from several advertisers?** A domain search returns every ad that points at that domain, including partners, resellers, and agencies. Use `mode=advertisers` to see the accounts involved, or search an `AR...` ID to isolate one account.

**Why are headline, description, or CTA missing on some ads?** Google stores many search text ads only as a picture of the ad. The actor returns readable copy when Google exposes it, and omits the field when the creative has no machine-readable text.

**Why are impressions missing for some ads?** Google publishes impression ranges for some ads shown in the EU/EEA and Turkey, after a delay. Coverage is partial and varies by market and ad: some ads have run dates but no impression figures even after three months. Per-country figures are in `regions[]`; the top-level totals cover the EU/EEA only.

**What does `advertiserVerified` mean?** It reflects Google's advertiser identity verification badge and is returned whenever the advertiser lookup succeeds. `false` means Google shows the advertiser as not verified.

**Why is `destinationUrl` sometimes missing?** Google does not expose a landing URL on every creative. `destinationDomain` comes from the search result when you search by domain; the full URL is added when the creative preview contains it.

**Can I search all countries at once?** Yes — set `region` to `ANYWHERE`. Per-ad `regions[]` then shows where each creative ran, with EU impression data where Google publishes it.

**Does the actor include age-restricted ads?** No. Google requires a signed-in account to show age-restricted creatives, and this actor never uses cookies or logins.

**Is this affiliated with Google?** No. It is an independent tool that reads public transparency data and is not endorsed by Google.

# Actor input Schema

## `mode` (type: `string`):

Search individual ads, or build one row per advertiser for a domain/brand (ad-check).

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

Examples: `nike.com`, `Nike`, `AR16735076323512287233`, or an `adstransparency.google.com` URL. Brand names are resolved to the brand's website first.

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

Country/market to search. `Anywhere` searches all regions.

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

Restrict to one creative format.

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

Restrict to one Google surface. Platform filtering applies to ads shown from September 2023 onward.

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

Only ads shown on or after this date. Leave empty for no lower bound.

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

Only ads shown on or before this date. Leave empty for no upper bound.

## `maxItems` (type: `integer`):

Total records to return across all search terms.

## `maxItemsPerTerm` (type: `integer`):

Optional per-term cap. Set to 0 for no per-term cap.

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

Fetch every creative's variants, per-country run dates, EU impression ranges, targeting, advertiser identity, and any available ad copy. Adds one or two requests per ad.

## Actor input object example

```json
{
  "mode": "search",
  "searchTerms": [
    "nike.com"
  ],
  "region": "US",
  "adFormat": "ALL",
  "platform": "ALL",
  "maxItems": 3,
  "maxItemsPerTerm": 0,
  "includeDetails": true
}
```

# Actor output Schema

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

Dataset containing ad creative records and, in ad-check mode, advertiser summary records.

# 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 = {
    "mode": "search",
    "searchTerms": [
        "nike.com"
    ],
    "region": "US",
    "adFormat": "ALL",
    "platform": "ALL",
    "maxItems": 3,
    "maxItemsPerTerm": 0,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/google-ads-transparency-creative-lookup-by-domain").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 = {
    "mode": "search",
    "searchTerms": ["nike.com"],
    "region": "US",
    "adFormat": "ALL",
    "platform": "ALL",
    "maxItems": 3,
    "maxItemsPerTerm": 0,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/google-ads-transparency-creative-lookup-by-domain").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 '{
  "mode": "search",
  "searchTerms": [
    "nike.com"
  ],
  "region": "US",
  "adFormat": "ALL",
  "platform": "ALL",
  "maxItems": 3,
  "maxItemsPerTerm": 0,
  "includeDetails": false
}' |
apify call vexaloom-labs/google-ads-transparency-creative-lookup-by-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/google-ads-transparency-creative-lookup-by-domain"
        }
    }
}
```

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/RY95C50o6LTAaUcaH/builds/QYKqbZf5c4yCTduA0/openapi.json