# Google Ads Transparency Scraper (Only New Ads, No Login) (`locaihost/google-ads-transparency`) Actor

Scrape Google Ads Transparency Center ads by brand name, website or advertiser ID: format, first and last shown dates, landing website, image and video links, ad text and countries shown. Advertiser summary rows and only-new-ads mode for weekly competitor tracking. No login. $1 per 1,000 ads.

- **URL**: https://apify.com/locaihost/google-ads-transparency.md
- **Developed by:** [locaihost data](https://apify.com/locaihost) (community)
- **Categories:** Marketing, 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.55 / 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.
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 (Only New Ads, No Login)

See every ad a competitor runs on Google: type a brand name, a website or an advertiser ID and get one row per ad from the Google Ads Transparency Center, with its format, first and last shown dates, landing website, image or video, and a summary row per advertiser. No login, no API key.

- **Watch competitors' ads:** schedule a weekly run with **Only new ads** and get just the ads they launched since last time.
- **Research a market before you advertise:** see which formats, messages and landing pages the leaders in your niche use, and how long they keep each ad running.
- **Find out who advertises a website:** one domain returns every verified advertiser running ads for it, including resellers and regional entities.
- **Check a brand's footprint by country:** filter by region and dates, or open each ad for the countries it ran in and its impression ranges.
- **Feed creative libraries and dashboards:** image links, YouTube links and ad text in a table you can export to CSV, Excel or Google Sheets.

### Quick start

Paste this into the **JSON** tab of the input and click **Start**:

```json
{"queries": ["hubspot.com"], "region": "US", "maxAdsPerAdvertiser": 20}
```

You get about 20 of HubSpot's most recently shown US ads plus one summary row per advertiser, usually in about 15 seconds.

Every video ad a brand ran in the UK in the last 30 days, opened for details (ad text, YouTube link, countries):

```json
{"queries": ["Nike"], "region": "GB", "formats": ["video"], "dateFrom": "30 days", "includeDetails": true}
```

A weekly competitor watch that returns only new ads:

```json
{"queries": ["competitor-one.com", "competitor-two.com"], "maxAdsPerAdvertiser": 200, "onlyNew": true}
```

### What data can I get?

| Group | Fields |
|---|---|
| The advertiser | `advertiserName`, `advertiserId` (AR…), `advertiserCountry` (where Google verified it), `advertiserType` |
| The ad | `creativeId` (CR…), `format` (text, image or video), `firstShown`, `lastShown`, `daysShown`, `landingDomain` |
| Media | `imageUrl` (with `imageWidth`, `imageHeight`), `previewUrl`, `adUrl` (the ad's page in the Transparency Center) |
| With **Ad details ($)** | `adText` (visible lines: headline, description, product title, sitelinks), `videoId`, `videoUrl`, `imageUrls`, `variants`, `regionsShown` (each country with first and last shown dates and impression range), `impressionsMin`, `impressionsMax` |
| Advertiser summary rows | `googleAdCountMin` / `googleAdCountMax` (Google's count of the advertiser's ads matching your filters), `adsReturned`, `newAds`, `formats`, `firstShown`, `lastShown`, `landingDomains`, `advertiserUrl` |
| Run | `type` (ad or advertiser), `query`, `regionFilter`, `scrapedAt` |

One real ad row (run on 2026-11-01 with **Ad details ($)**, preview link shortened):

```json
{
  "type": "ad",
  "query": "hubspot.com",
  "advertiserId": "AR10072600183532683265",
  "advertiserName": "Hubspot, Inc.",
  "advertiserType": "business",
  "advertiserCountry": "US",
  "creativeId": "CR10821117815340138497",
  "format": "video",
  "firstShown": "2026-06-17T15:27:13.310Z",
  "lastShown": "2026-11-01T13:43:30.527Z",
  "daysShown": 128,
  "landingDomain": "hubspot.com",
  "imageUrl": "https://i.ytimg.com/vi/v8gzzJDTdYs/hqdefault.jpg",
  "previewUrl": "https://displayads-formats.googleusercontent.com/ads/preview/content.js?client=ads-integrity-transparency&...",
  "adUrl": "https://adstransparency.google.com/advertiser/AR10072600183532683265/creative/CR10821117815340138497?region=US",
  "regionFilter": "US",
  "detailsIncluded": true,
  "adText": null,
  "videoId": "v8gzzJDTdYs",
  "videoUrl": "https://www.youtube.com/watch?v=v8gzzJDTdYs",
  "variants": 4,
  "regionsShown": [
    {"region": "CA", "firstShown": null, "lastShown": "2026-11-01", "impressionsMin": null, "impressionsMax": null},
    {"region": "US", "firstShown": null, "lastShown": "2026-11-01", "impressionsMin": null, "impressionsMax": null}
  ],
  "scrapedAt": "2026-11-01T14:13:35.703Z"
}
```

The dataset has three views (**Ads**, **Advertiser summaries**, **Ads with details**) and exports to JSON, CSV, Excel or HTML. The run's `SUMMARY` record shows what each query found and anything skipped.

### How much does it cost?

You pay per row returned. There is no charge for Apify platform usage on top.

| Row | Free and Starter | Scale | Business |
|---|---|---|---|
| Ad | $1 per 1,000 | $0.75 per 1,000 | $0.55 per 1,000 |
| Ad with details (instead of Ad) | $2.50 per 1,000 | $1.875 per 1,000 | $1.375 per 1,000 |
| Advertiser summary | $1 per 1,000 | $0.75 per 1,000 | $0.55 per 1,000 |

Plus $0.00005 per run start. **Apify's free $5 monthly credit covers about 5,000 ads.** Free-plan runs stop at 1,000 rows each; any paid Apify plan removes the cap.

**What's free:** advertisers that can't be found, searches with no matching ads, input mistakes, ads skipped by **Only new ads**, the same ad found by two of your queries (charged once per run), and ads found but not delivered before the run's time limit. To cap a run's spend, set **Maximum cost per run** in the run options, or use **Max results**.

### Limits, stated up front

- **Ad text comes with details only, and not for every ad.** Google archives most search (text) ads as a picture of the ad: those rows have `imageUrl` and no `adText`. Ads Google shows as live previews (local, shopping and many newer search ads) return their text.
- **Landing websites** come from Google's own listing and are usually filled for website searches; for advertiser searches Google often leaves them out.
- **Impression ranges and per-country dates** are published by Google for ads shown in the EU and a few other regions; elsewhere `regionsShown` lists the countries with their last shown date.
- **Brand names are matched to verified advertisers.** "Nike" returns Nike, Inc., NIKE SRL and the like (biggest first, see **Advertisers per brand name**), not lookalikes such as "Nikesh". For an exact match use the website or the advertiser ID from the advertiser's Transparency Center page.
- **Private persons are never named.** When Google verified an advertiser as an individual, the row says "Individual advertiser" and leaves out the ad text.
- **Political ads** are not a separate mode here; Google publishes those in its free political ads dataset.
- Google lists ads newest first; **Max ads per advertiser** reads that many of the most recently shown.

### Only new ads, and schedules

Turn on **Only new ads** and the Actor remembers which ads it returned for the same advertisers, region and formats (date filters can change between runs). The next run returns only ads it hasn't returned before, and summary rows only for advertisers with something new. Skipped ads cost nothing. Set up a weekly schedule under **Schedules** in Apify Console to get a competitor ad digest.

### Integrations: API, n8n, Make and AI agents

**API.** Run it and get the rows back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/locaihost~google-ads-transparency/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["hubspot.com"], "region": "US", "maxAdsPerAdvertiser": 20}'
```

Apify's API clients for Python and JavaScript work the same way.

**n8n, Make, Zapier, Google Sheets, Slack, webhooks.** Apify's built-in integrations send each run's dataset wherever you need it, for example a Slack message whenever a weekly **Only new ads** run finds something.

**AI agents (MCP).** Add this Actor to Claude, Cursor or any MCP client with `https://mcp.apify.com/?tools=locaihost/google-ads-transparency`, then ask something like *"Which video ads has Nike started running in the UK this month?"*

### FAQ

#### How much does it cost to scrape the Google Ads Transparency Center?

$1 per 1,000 ads on the Free and Starter plans, $0.75 on Scale and $0.55 on Business; ads opened for details cost $2.50 per 1,000 instead. Apify's free $5 monthly credit covers about 5,000 ads.

#### Can I use it through the API or from Python?

Yes. Use the `run-sync-get-dataset-items` call above, or Apify's Python and JavaScript clients. Every run's data is also available as JSON, CSV or Excel from its dataset.

#### Can I use it from an AI agent?

Yes. Through the Apify MCP server any MCP client can call it with brand names, websites or advertiser IDs and read the rows back.

#### Is it legal to scrape the Google Ads Transparency Center?

The Actor reads the information Google publishes in the Ads Transparency Center for logged-out visitors, and only advertiser and ad information: no personal contact details, and private persons are never named. Google's terms for the Transparency Center limit commercial reuse of its content, and the ads themselves belong to the advertisers, so use the data for your own research and check the terms before you republish anything. You are responsible for how you use the data and for the laws that apply to you. If you are an advertiser and want something changed, open an issue and we will act on it promptly.

#### What can I put in "Advertisers"?

Brand names (HubSpot), websites (hubspot.com, with or without https:// and www), advertiser IDs (AR10072600183532683265) or links copied from adstransparency.google.com (an advertiser, an ad or a website search). One per line, up to 100 per run.

#### Why are some fields empty?

`adText`, `videoUrl`, `regionsShown` and the impression ranges are filled only with **Ad details ($)**, and only when Google publishes them (see Limits). `landingDomain` is empty when Google doesn't list it. `advertiserCountry` is empty when Google's advertiser page doesn't answer in time. Summary rows have no `googleAdCountMin` / `googleAdCountMax` for website searches, because Google's count then covers the whole website.

### More from locaihost data

- [Website Traffic Checker](https://apify.com/locaihost/website-traffic): visits, sources and top countries for the websites your competitors' ads point to.
- [Website Tech Stack Checker](https://apify.com/locaihost/domain-intel): the tech stack, email provider and DNS set-up behind a website.
- [Google Trends Scraper](https://apify.com/locaihost/google-trends): search interest for the products and brands in the ads.

### Did it help?

If this saved you time, a quick rating on the Store helps other people find it.

### Support

Something not working, a missing field or an ad that reads wrong? Open an issue on the **Issues** tab: we answer issues within 24 hours.

# Changelog

This Actor's version history is a separate document: https://apify.com/locaihost/google-ads-transparency/changelog.md

# Actor input Schema

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

One per line: a brand name (HubSpot), a website (hubspot.com) or a Google advertiser ID (AR10072600183532683265). A link from adstransparency.google.com works too. A website returns every advertiser running ads for it; a brand name returns the advertisers verified under that name (see "Advertisers per brand name").

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

Only ads shown in this country. Anywhere returns ads from all regions.

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

Optional. Only ads shown on or after this date, like 2026-09-01, or a period back from today like 30 days.

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

Optional. Only ads shown on or before this date. Leave empty for up to today.

## `formats` (type: `array`):

Which ad formats to return. Leave empty for all three.

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

The most recently shown ads first. For a website, this is the limit for the whole website. Default 100.

## `maxAdvertisersPerName` (type: `integer`):

A brand often advertises under several verified names (Nike, Inc., NIKE SRL...). How many of them to read for each brand name, biggest first. Default 3.

## `maxResults` (type: `integer`):

Optional overall limit on rows for the run (0 = no limit).

## `includeAdvertiserSummary` (type: `boolean`):

Adds one row per advertiser: Google's total ad count, formats, first and last shown dates and landing websites of the ads read.

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

Opens each ad for the ad text, YouTube video link, product images, and every country it ran in with dates and impression ranges. Charged as an ad with details instead of an ad, and slower (two extra requests per ad).

## `onlyNew` (type: `boolean`):

Return only ads you haven't had from an earlier run with the same advertisers, region and formats. Use it on a schedule to see what a competitor launched since last time. Ads left out are not charged.

## Actor input object example

```json
{
  "queries": [
    "hubspot.com",
    "Nike",
    "AR10072600183532683265"
  ],
  "region": "US",
  "formats": [
    "video"
  ],
  "maxAdsPerAdvertiser": 20,
  "maxAdvertisersPerName": 3,
  "maxResults": 0,
  "includeAdvertiserSummary": true,
  "includeDetails": false,
  "onlyNew": false
}
```

# Actor output Schema

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

One row per ad: advertiser, format, first and last shown, website, image and ad page link.

## `advertisers` (type: `string`):

One row per advertiser: Google's ad count, formats, dates and websites.

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

What each query found, anything skipped and the run's cost.

# 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": [
        "hubspot.com"
    ],
    "region": "US",
    "maxAdsPerAdvertiser": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("locaihost/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 = {
    "queries": ["hubspot.com"],
    "region": "US",
    "maxAdsPerAdvertiser": 20,
}

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

```

## MCP server setup

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