# Google Ads Scraper: Competitor Ads by Domain (`pulsedata/google-ads-scraper`) Actor

Scrape every Google ad that points to a domain: text, image and video ads on Search, YouTube, Shopping, Maps and Play, with first and last shown dates, days active, countries, EU impressions and creative previews. Data from the Google Ads Transparency Center. No login. $1.90 per 1,000 ads.

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

## Pricing

$1.90 / 1,000 ad scrapeds

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 Scraper: Competitor Ads by Domain

This Google Ads scraper returns every ad that points to a website domain. You enter one or more domains such as `nike.com`, and it returns one item per ad from the public [Google Ads Transparency Center](https://adstransparency.google.com/): format, first and last shown dates, days shown, countries, EU impression ranges, targeting flags, YouTube video IDs and creative images. Ads from every advertiser account that promotes the domain are included, which is how agencies, resellers and regional subsidiaries show up next to the brand itself.

No Google account, login or cookies are needed, and no browser runs. PulseData is not affiliated with Google.

Price: $1.90 per 1,000 ads, with details and previews included. There is no start fee.

### What you can do with it

- **Scrape Google ads of a competitor's website.** Enter the domain, get every text, image and video ad Google has on record for it.
- **Export Google Search text ads** by setting `platform` to `SEARCH` and `format` to `TEXT`.
- **Find a brand's YouTube video ads** with `platform` `YOUTUBE` and `format` `VIDEO`. Each item carries the YouTube video ID and URL.
- **Monitor Google Shopping ads** of an online store with `platform` `SHOPPING`.
- **See which Google ads run in one country** by setting `region` to an ISO code such as `DE` or `US`.
- **Check how long an ad has been running.** `firstShown`, `lastShown` and `daysShown` tell you which creatives a competitor keeps paying for.
- **Get EU impression ranges and targeting** for ads shown in the European Union, per country and per Google platform.
- **Compare the Google ads of several competitors** in one run by listing several domains.
- **Download the results as CSV, JSON or Excel**, or read them through the Apify API.

### Who uses it

- **Performance marketers and PPC agencies** checking what a competitor is advertising before a pitch or a campaign launch.
- **Brand protection teams** looking for resellers and affiliates that run ads pointing to the brand's domain.
- **Market researchers** tracking ad activity of a category over time, for example all travel or fashion retailers in one country.
- **Creative teams** collecting image and video references from long-running ads.
- **Developers and AI agents** that need structured Google ad data inside a pipeline, a scheduled job or an MCP tool call.

### Quick start

```json
{ "domains": ["nike.com"], "maxAdsPerQuery": 100 }
```

Add more lines to `domains` to compare several competitors in one run. Full URLs such as `https://www.nike.com/de/` are accepted and trimmed to `nike.com`. An entry that does not look like a domain is searched as an advertiser name instead, and the log says so.

A filtered run, YouTube video ads shown in Germany since the start of 2026:

```json
{
  "domains": ["adidas.com"],
  "region": "DE",
  "platform": "YOUTUBE",
  "format": "VIDEO",
  "startDate": "2026-01-01",
  "maxAdsPerQuery": 200
}
```

### Input

| Field | Default | Meaning |
|---|---|---|
| `domains` | (required) | Website domains, one per line |
| `region` | `anywhere` | `anywhere` or an ISO country code (`US`, `DE`, `GB`). Common country names such as `Germany` or `UK` are also understood |
| `platform` | `ALL` | `ALL`, `SEARCH`, `YOUTUBE`, `MAPS`, `PLAY`, `SHOPPING` |
| `format` | `ALL` | `ALL`, `TEXT`, `IMAGE`, `VIDEO` |
| `startDate`, `endDate` | empty | Only ads shown in this range (`YYYY-MM-DD`) |
| `maxAdsPerQuery` | 100 | Maximum ads per domain, `0` means no limit |
| `includeDetails` | true | Per-ad regions, EU impressions and targeting |
| `proxyConfiguration` | Apify residential | Keep residential, Google blocks shared datacenter IPs |

An unknown region or a date the scraper cannot read produces a warning in the log and the filter is skipped, so the run still finishes.

### Output

One item per ad:

```json
{
  "query": "shopify.com",
  "advertiserId": "AR01625195283841286145",
  "advertiserName": "Shopify Inc.",
  "creativeId": "CR03427811071065325569",
  "url": "https://adstransparency.google.com/advertiser/AR01625195283841286145/creative/CR03427811071065325569?region=anywhere",
  "format": "VIDEO",
  "firstShown": "2025-12-23T17:40:45.903Z",
  "lastShown": "2026-09-25T12:25:30.972Z",
  "daysShown": 277,
  "youtubeVideoId": "fe_ZvGJQlDs",
  "youtubeUrl": "https://www.youtube.com/watch?v=fe_ZvGJQlDs",
  "destinationUrl": "https://www.shopify.com/fr/demarrer",
  "regionsShownIn": "FR",
  "regions": [{ "regionCode": "FR", "regionName": "France", "impressionsLow": 2000000, "impressionsHigh": 2250000,
    "firstShown": "2025-12-23", "lastShown": "2026-09-25",
    "platforms": [{ "platform": "YOUTUBE", "impressionsLow": 2000000, "impressionsHigh": 2250000 }] }],
  "targeting": { "demographic": { "included": true, "excluded": false },
    "geographic": { "included": true, "excluded": false }, "contextual": { "included": true, "excluded": true } },
  "variationsCount": 4,
  "scrapedAt": "2026-09-25T12:48:15.976Z"
}
```

Items also carry `advertiserUrl`, `previewUrl`, `previewImageUrl`, `imageUrls`, `euTotals`, `appId` and `topicId` where Google publishes them. The default dataset view shows advertiser, format, dates, days shown, preview image and YouTube ID in one table, which is the view most people export to a spreadsheet.

### Pricing

Pay per event: $0.0019 per ad returned (`ad-scraped`), so 1,000 ads cost $1.90. Details and preview data are included in that price. You pay nothing for domains with no ads, and there is no start fee.

Some sizes for planning: the default of 100 ads per domain costs $0.19, a comparison of five competitors at 200 ads each costs $1.90, and a full export of a large retailer with 20,000 ads costs $38. Set a maximum cost per run in the Apify Console if you want a hard ceiling; the scraper stops cleanly before it is reached.

### Example pages

Each of these opens a ready-made run with a real input:

- [Scrape Google ads of nike.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-nike-com)
- [Scrape Google ads of amazon.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-amazon-com)
- [Scrape Google ads of temu.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-temu-com)
- [Scrape Google ads of booking.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-booking-com)
- [Scrape Google ads of shopify.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-shopify-com)
- [Scrape YouTube video ads of adidas.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-youtube-ads-adidas-com)
- [Scrape Google Search text ads of hubspot.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-search-text-ads-hubspot-com)
- [Scrape Google Shopping ads of wayfair.com](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-shopping-ads-wayfair-com)
- [Scrape Google ads of zalando.de shown in Germany](https://apify.com/pulsedata/google-ads-scraper/examples/scrape-google-ads-zalando-de-germany)
- [Compare the Google ads of nike.com and adidas.com](https://apify.com/pulsedata/google-ads-scraper/examples/compare-google-ads-nike-adidas)

### FAQ

**Why do I get fewer ads than the Transparency Center shows?**
`maxAdsPerQuery` defaults to 100 per domain. Set it to `0` for everything, and split very large advertisers by `region`, `platform`, `format` or dates.

**Why are impressions and targeting empty for some ads?**
Google publishes impression ranges and targeting only for ads shown in the EU (Digital Services Act). For ads shown only outside the EU you get format, dates, regions and creative data.

**Does it return the ad text and landing page?**
It returns what the Transparency Center publishes: the creative preview (`previewUrl`, `previewImageUrl`, `imageUrls`), the YouTube video for video ads and a `destinationUrl` where Google exposes one. It does not return keywords, bids, spend or click data, because Google does not publish them.

**Why do ads from other advertisers appear for my domain?**
The Transparency Center links ads to the domain they point to. Agencies, resellers, affiliates and country subsidiaries that advertise the same domain are included, each with its own `advertiserName` and `advertiserId`.

**Can I search by advertiser name or advertiser ID instead?**
Use the [Google Ads Transparency Center Scraper](https://apify.com/pulsedata/google-ads-transparency-scraper), which takes names, domains, `AR…` IDs and Transparency Center URLs.

**Can I run it on a schedule?**
Yes. Save your input as a task in the Apify Console and add a schedule, for example weekly. Compare `lastShown` between runs to see which ads are new or stopped.

**Do I need my own proxy?**
No. The default Apify residential proxy is used for the small JSON requests, about 3 KB per ad. Creative previews are fetched without the proxy.

**Is it legal?**
It reads only what Google publishes in the Transparency Center for transparency and research, and collects no personal data. Follow Google's terms and applicable law when using the data.

### Related actors

- [Google Ads Transparency Center Scraper](https://apify.com/pulsedata/google-ads-transparency-scraper): the same data by advertiser name, ID or domain.
- [YouTube Ads Scraper](https://apify.com/pulsedata/youtube-ads-scraper): only the YouTube video ads of a brand.
- [LinkedIn Ad Library Scraper](https://apify.com/pulsedata/linkedin-ad-library-scraper): competitor ads on LinkedIn.
- [TikTok Ad Library Scraper](https://apify.com/pulsedata/tiktok-ad-library-scraper): TikTok video ads shown in Europe.

# Actor input Schema

## `domains` (type: `array`):

Website domains whose ads you want, one per line, for example `nike.com`. Full URLs such as `https://www.nike.com/de/` are accepted and trimmed to the domain. The scraper returns every ad in the Google Ads Transparency Center that points to that domain, whoever the advertiser is.

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

Only ads shown in this country. Use `anywhere` for all countries or an ISO 3166-1 alpha-2 code (`US`, `DE`, `GB`, `FR`, …).

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

Filter by the Google surface where the ad was shown.

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

Filter by creative format.

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

Only ads shown on/after this date, format `YYYY-MM-DD`.

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

Only ads shown on/before this date, format `YYYY-MM-DD`.

## `maxAdsPerQuery` (type: `integer`):

Stop after this many ads for each domain. Set 0 for no limit (large brands can have tens of thousands of ads).

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

Fetches the detail page of every ad: per-country first/last shown dates, EU impression ranges per country and platform, targeting flags and creative variations. One extra request per ad.

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

Google blocks shared datacenter IPs quickly – keep Apify residential proxies (default). Only the small JSON API calls go through the proxy; creative previews are fetched directly, so proxy traffic stays tiny (~3 KB per ad).

## Actor input object example

```json
{
  "domains": [
    "nike.com"
  ],
  "region": "anywhere",
  "platform": "ALL",
  "format": "ALL",
  "maxAdsPerQuery": 100,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Results stored in the default dataset (JSON/CSV/Excel via the dataset API).

# 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 = {
    "domains": [
        "nike.com"
    ],
    "region": "anywhere",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("pulsedata/google-ads-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 = {
    "domains": ["nike.com"],
    "region": "anywhere",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("pulsedata/google-ads-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 '{
  "domains": [
    "nike.com"
  ],
  "region": "anywhere",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call pulsedata/google-ads-scraper --silent --output-dataset

```

## MCP server setup

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