# Google Ads Competitor Spy: Ad Copy, Landing Pages, Countries (`andinoworks/google-ads-competitor-spy`) Actor

See any competitor's Google ads from the public Ads Transparency Center: headlines, ad text, landing pages, videos, countries, dates and impressions, with alerts when a new ad appears.

- **URL**: https://apify.com/andinoworks/google-ads-competitor-spy.md
- **Developed by:** [Ignacio Andino](https://apify.com/andinoworks) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 ad delivereds

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 Competitor Spy: Ad Copy, Landing Pages, Countries

See the Google ads your competitors are running: their **headlines, ad text, landing pages, videos, countries and dates**. Enter a website, and get a clean table you can filter, export or feed into your own tools.

Use it to research a market before launching a campaign, find the angles and offers competitors keep using, build swipe files for clients, and get an alert when a competitor launches a new ad.

The data comes from Google's public **Ads Transparency Center**, where Google publishes the ads of verified advertisers. This Actor needs no login or Google Ads account.

### How to use it

1. In **Competitors**, enter one or more websites, such as `shopify.com`.
2. Optionally choose a country and ad formats.
3. Keep **Maximum ads in total** low on your first run, such as `20`, and press **Start**.
4. Open the **Output** tab. Ads appear while the run is working, so you can start reviewing right away.

Website domains give the most precise results. A company name also works, and the final message tells you which advertiser was searched.

### What you get

| Field | Example |
|---|---|
| `headline`, `longHeadline`, `description` | The words of the ad, when Google publishes them as text |
| `adText` | The words of a text ad, read from its image |
| `destinationUrl`, `visibleUrl` | Where the ad sends people |
| `imageUrl`, `youtubeUrl`, `videoDuration` | The creative |
| `format` | `text`, `image` or `video` |
| `firstShown`, `lastShown`, `daysRunning`, `isActive` | How long it has been running |
| `countries`, `countryCount` | Where it was shown, with dates per country |
| `impressions` | Impression ranges, where Google publishes them, mainly in the EU |
| `advertiserName`, `domain`, `adUrl` | Who runs it and the link to the original ad |
| `isNew`, `firstSeenAt` | For alerts on scheduled runs |

#### Sample result

```json
{
  "advertiserName": "Example Inc.",
  "format": "video",
  "headline": "Launch your brand today",
  "description": "Join brands that sell online with Example. Start for free.",
  "destinationUrl": "https://example.com/free-trial",
  "youtubeUrl": "https://www.youtube.com/watch?v=VIDEO_ID",
  "firstShown": "2026-09-09T00:00:00.000Z",
  "lastShown": "2026-11-03T00:00:00.000Z",
  "daysRunning": 56,
  "isActive": true,
  "countryCount": 6
}
```

This example shows the format. The values are illustrative.

### Common uses

**Find the ads a competitor keeps running.** Set **Running for at least (days)** to `30`. Advertisers tend to keep ads that work, so this is a useful shortlist. It is an indication, not proof of results.

**Get an alert when a competitor launches something new.** Turn on **Only ads not delivered before** and schedule the Actor weekly. Each run delivers only new ads, and you do not pay again for the old ones. Use Apify's integrations to send them to Slack, Google Sheets, Make, Zapier or n8n.

**Research a country.** Choose it in **Country where the ads are shown** to see what is running there.

### Pricing

You pay only for what you get. An ad whose details could not be read is delivered for free.

| Event | Price |
|---|---:|
| Ad delivered, including its copy, landing page, countries and dates | USD 0.0015 |
| Text ad read from its image, only when words were found | USD 0.0005 |
| Run started | Apify's default |

For example, 100 ads with 60 text ads read cost about USD 0.18. To avoid the extra charge, turn off **Read the words of text ads from their image**. Set a low maximum to control your spending. The run stops at your limit.

### Limits

- **Coverage:** it shows what Google publishes in its Transparency Center. It does not show keywords, budgets, clicks or conversions.
- **Copy:** some ads do not expose their words or landing page, and those fields stay empty.
- **Text ads:** their words are read automatically from a picture, and work best in English, so they can contain mistakes. The `imageUrl` field lets you check them. `copySource` tells you where the words came from.
- **Impressions:** Google publishes them only for some ads and countries.
- **Run size:** Google limits how fast its site can be read. In a test, one run read about 1,000 ads before Google slowed it down. The final message names any competitor that was not fully read, so split very large searches or run them again later.
- **Accuracy:** this tool reads Google's site automatically and Google can change it without notice. If something looks wrong, open **Issues** and it will be looked at.
- **Use:** you are responsible for how you use competitors' material. Ads are protected by copyright, so research them rather than copy them.

### FAQ

**Do I need a Google Ads account?** No.

**Why did a company name return another company?** Unrelated companies can share a name, and the final message lists the ones searched. Use the website domain for a precise result.

**Can I use the API?** Yes. Like every Apify Actor, it can be called through the API and returns JSON. Keep `maxResults` low while testing.

**Is this affiliated with Google?** No. It reads information Google publishes for the public.

# Changelog

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

# Actor input Schema

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

Website domains give the most precise results, such as shopify.com. You can also enter a company name or a Google Ads Transparency link.

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

Leave empty for all countries.

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

Leave empty for all formats.

## `shownFrom` (type: `string`):

Only ads shown on or after this date.

## `shownTo` (type: `string`):

Only ads shown on or before this date.

## `minDaysRunning` (type: `integer`):

Advertisers tend to keep ads that work, so long-running ads are a useful sign. This is an indication, not proof of results.

## `includeCopy` (type: `boolean`):

Headline, text, landing page and video, when Google publishes them.

## `readTextAds` (type: `boolean`):

Google publishes most text ads as pictures. This reads them automatically, at a small extra price per ad read, and works best in English. Words may be misread, so check the image.

## `includeCountries` (type: `boolean`):

Where each ad was shown, its dates there and, where Google publishes them, impression ranges.

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

For scheduled runs: returns only ads that earlier runs with the same monitor name have not delivered.

## `monitorName` (type: `string`):

Use a different name for each saved search so their histories stay separate.

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

Large advertisers can have thousands of ads.

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

You pay per ad delivered, so this also limits the cost. The search stops at this number.

## `maxRunSeconds` (type: `integer`):

Stops looking after this time. Ads already found stay in Output.

## Actor input object example

```json
{
  "targets": [
    "shopify.com"
  ],
  "includeCopy": true,
  "readTextAds": true,
  "includeCountries": true,
  "onlyNew": false,
  "monitorName": "default",
  "maxAdsPerTarget": 100,
  "maxResults": 200,
  "maxRunSeconds": 600
}
```

# Actor output Schema

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

No description

## `summary` (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": [
        "shopify.com"
    ]
};

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

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

```

## MCP server setup

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

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/sPKtdE6xtdAd4lLj8/builds/agoPh9GrHh6mJmcbS/openapi.json