# Google Ads Scraper & Competitor Ad Monitor (`ironlabs/google-ads-competitor-monitor`) Actor

See every Google ad your competitors run: text, image and video ads from the Ads Transparency Center with dates and days running, plus a competitor report of new, stopped and longest-running ads since your last check. Search by website, advertiser name or ID.

- **URL**: https://apify.com/ironlabs/google-ads-competitor-monitor.md
- **Developed by:** [Iron Labs](https://apify.com/ironlabs) (community)
- **Categories:** SEO tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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 Scraper & Competitor Ad Monitor (Ads Transparency Center)

**See every Google ad your competitors run, and what changed since last week.** Give this Actor a competitor's verified advertiser name (`Hubspot, Inc.`), Google advertiser ID or website (`nike.com`). It returns their text, image and video ads from the [Google Ads Transparency Center](https://adstransparency.google.com/), with the date each ad was first and last shown and how many days it has run. It also adds a **competitor report**: active ads, **new and stopped ads since your last run**, and the **longest-running ads**. Advertisers rarely keep paying for an ad that doesn't work, so long runners are your competitor's likely winners.

> **▶️ Try it in one click:** the example input pulls Nike's latest ads plus a competitor report (100 ads) in under a minute, for about $0.80. Just press **Start**.

#### What you get

| Output | What's in it |
|---|---|
| One row per ad | advertiser, creative ID, format (text, image or video), first shown, last shown, days shown, still running?, new since last run?, ad image, link to the ad in Google |
| One comparison per run | all competitors ranked side by side: new and stopped ads, ad library growth, format shifts since last run, plus plain-English highlights such as *"acme.com is running more video ads (+25 points)"* |
| One report per competitor | Google's total ad count, ads collected, ads by format, ads by advertiser, running ads, new and stopped ads since last run, median days shown, top 5 longest-running ads, top 5 newest ads |

Example ad row:

```json
{
  "advertiserName": "Nike, Inc.",
  "creativeId": "CR14341155732764753921",
  "format": "text",
  "firstShown": "2023-11-16T21:43:52Z",
  "lastShown": "2026-11-01T01:05:26Z",
  "daysShown": 915,
  "isActive": true,
  "imageUrl": "https://tpc.googlesyndication.com/archive/simgad/4833806977914735092",
  "transparencyUrl": "https://adstransparency.google.com/advertiser/AR16735076323512287233/creative/CR14341155732764753921"
}
```

#### Use cases

- **Competitor ad monitoring.** Schedule weekly runs with *Only new ads since last run* and get each competitor's fresh creatives in your inbox, Slack or Google Sheet.
- **Find winning ads.** Sort by *days shown*. Ads running 90+ days are the ones a competitor keeps paying for.
- **Weekly client briefings.** The comparison row ranks every competitor and writes the headlines for you: who launched the most ads, whose ad library is growing, who switched to video.
- **Agency pitches and audits.** Show a prospect every ad their rivals run, in minutes.
- **Market research.** Compare how many ads each brand runs and in which formats.
- **Find resellers and agencies.** A website search shows every advertiser sending Google ads traffic to that site.
- **AI agents.** Clean JSON your agent can call through the Apify API or MCP server to answer "what is X advertising right now?"

#### How to use it

1. Add competitors, one per line:
   - **A verified advertiser name, advertiser ID (`AR…`) or Transparency Center link** gives that one company's ads.
   - **A website (`nike.com`)** gives every ad that links to that site. That includes the brand's regional companies, resellers and agencies (the report lists them).
2. Optional: limit formats, keep only running ads, or set *Shown since*.
3. Click **Start**. Download as Excel, CSV or JSON, or connect it to Make, Zapier, n8n or Google Sheets.

For monitoring, turn on **Only new ads since last run** and create a **Schedule** (daily or weekly). The first run is your baseline. After that you only pay for ads you haven't seen.

#### Pricing

Pay per result: you pay only for what you get.

- **$3 per 1,000 ads**
- **$0.50 per competitor report**: new, stopped and longest-running ads, summarised
- **$1 per competitor comparison**: one per run, only when you track 2+ competitors

Higher Apify plans pay less automatically: on Business, ads cost $2 per 1,000, reports $0.35 and comparisons $0.70.

Example: a weekly check of 10 competitors that finds 50 new ads costs about $0.15 + $5.00 + $1.00 = **$6.15**, roughly $25 a month. That's well below typical ad-spy subscriptions ($49–99/month). Turn off *Competitor report* and *Competitor comparison* if you only want the raw ads.

#### FAQ

**Is this data public?** Yes. Google publishes it for transparency. The Actor collects what anyone can see on the Transparency Center without logging in. It doesn't collect personal contact details.

**How is this different from other Google Ads Transparency scrapers?** Others give you a pile of ads. This Actor remembers what it saw last run and tells you **what's new and what stopped**, and it summarises each competitor in one row.

**Why don't I see ad text?** Google shows many ads, including older text ads, as images. You get the image link plus a link to open the ad in Google.

**What does "days shown" mean?** It's the number of days Google reports the ad as shown. "Running" means Google showed it in the last 2 days.

**Why did I get fewer ads than Google's count?** Your *max ads* limit and filters cut the list. Google's own count is a range.

**I typed a name and got the wrong company. What now?** Names can be ambiguous: regional companies or look-alikes. When the match isn't exact, the report says `"nameMatch": "closest"` and lists `otherMatchingAdvertisers` with their IDs. Paste the right advertiser ID (`AR…`) instead.

**Can I filter by country?** Not yet. Ads come from all countries. Country filtering is on the roadmap.

**How is "new" decided?** An ad counts as new if Google first showed it after your previous run. "Stopped" means Google stopped showing an ad that was running at your previous run. With *Only new ads* on, you're never charged twice for the same ad.

**Can it get ads from Facebook, LinkedIn or TikTok?** No. Those sites ask automated tools not to collect their ad libraries, and we respect that.

**What if Google says "too many requests"?** Google limits how fast one connection can ask. The Actor slows down, waits as long as Google asks, and carries on in the same run. You'll see *"Google asked us to slow down, continuing automatically"* in the status. Only if Google keeps refusing for about 10 minutes does the run pause. Everything collected is saved, and the next run with the same list (started by you or a schedule) **continues with the competitors it didn't reach**. Nothing is fetched or charged twice, and the comparison covers the whole list once it's finished.

**What does the proxy cost?** Requests go through Apify Proxy using one IP for the whole run. Apify bills proxy traffic by usage: residential proxy is about $8 per GB, and a typical 40-competitor run uses roughly 6-12 MB, so **about 5-10 cents**. Weekly monitor runs use far less, because they read only the newest page.

**How do repeat runs stay fast?** The Actor remembers which advertiser each name belongs to (for 30 days). With *Only new ads* on, it reads only the newest page of ads, because that's where new ads appear. A weekly check uses about a third of the requests of the first run.

**Something broke?** Open an issue on the Issues tab. We usually fix things within a day.

# Actor input Schema

## `targets` (type: `array`):

One per line. An advertiser's verified name ("Nike, Inc."), Google advertiser ID (AR…) or Transparency Center link gives that one company's ads. A website domain (nike.com) gives every ad that links to that site, including resellers and agencies. Works best with up to about 40 competitors per run. Google limits how fast one connection can ask, so bigger lists are finished automatically over several runs (see "Finish unfinished lists").

## `maxAdsPerTarget` (type: `integer`):

Stop after this many ads for each competitor (after filters). Google lists the most recent ads first.

## `adFormats` (type: `array`):

Which ad formats to keep.

## `activeOnly` (type: `boolean`):

Keep only ads Google showed in the last 2 days.

## `shownSince` (type: `string`):

Keep only ads last shown on or after this date (YYYY-MM-DD).

## `onlyNewAds` (type: `boolean`):

Schedule the Actor daily or weekly and get only ads you haven't seen before. The first run returns everything as a baseline. The competitor report always shows new and stopped ads.

## `includeReport` (type: `boolean`):

Add one summary row per competitor: ad formats, active/new/stopped ads, the longest-running ads (likely winners) and the newest ads.

## `includeComparison` (type: `boolean`):

With 2 or more competitors, add one row that ranks them side by side: new and stopped ads, ad library growth, format shifts since your last run, plus plain-English highlights for client updates.

## `resumeUnfinished` (type: `boolean`):

If an earlier run with the same competitor list stopped early (Google's request limit or your spending limit), continue with the competitors it didn't reach instead of starting over. The comparison is charged once, when the whole list is done.

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

Network route for requests. The run uses one IP from start to finish. It never switches IPs to get around Google's request limits: if Google says "too many requests", the run slows down, waits, or pauses and keeps what it collected. Residential proxy is billed by Apify at about $8 per GB, roughly 5-10 cents for a 40-competitor run.

## Actor input object example

```json
{
  "targets": [
    "nike.com"
  ],
  "maxAdsPerTarget": 100,
  "adFormats": [
    "text",
    "image",
    "video"
  ],
  "activeOnly": false,
  "onlyNewAds": false,
  "includeReport": true,
  "includeComparison": true,
  "resumeUnfinished": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

## `reports` (type: `string`):

No description

## `comparison` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("ironlabs/google-ads-competitor-monitor").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 = { "targets": ["nike.com"] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ironlabs/google-ads-competitor-monitor"
        }
    }
}
```

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/1OEyLJ6XsubKbEHUj/builds/Hxth666GCaJbnPnjM/openapi.json
