# Google Ads Advertiser Discovery (`opspilot.cc/google-ads-advertiser-discovery`) Actor

Discover Google Ads advertiser accounts and domains by keyword and country. Export advertiser names, IDs, verification status, locations, approximate ad counts, associated accounts, and domains.

- **URL**: https://apify.com/opspilot.cc/google-ads-advertiser-discovery.md
- **Developed by:** [wang wei](https://apify.com/opspilot.cc) (community)
- **Categories:** SEO tools, E-commerce
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.50 / actor start

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Ads Advertiser Discovery — Find Advertisers by Keyword & Country

Discover companies, advertiser accounts, and domains associated with Google Ads activity for a specific keyword and country. Export advertiser names, account IDs, verification status, locations, approximate ad counts, related accounts, advertiser domains, and result rankings.

### What This Actor Does

Enter one commercial keyword, select one country, and receive advertiser intelligence connected to that search market.

The Actor can return three result types:

- **Advertiser account** — a specific advertiser with name, ID, location, verification status, and approximate ad count.
- **Grouped advertiser** — a brand or company connected to multiple advertiser accounts.
- **Advertiser domain** — a domain identified as an advertiser for the selected keyword.

This Actor discovers advertisers and domains. It does **not** export complete ad creative text, images, videos, or campaign history.

### Common Use Cases

- **Competitor discovery** — find companies advertising for your core keywords.
- **PPC market research** — estimate how crowded a paid-search niche is.
- **Lead generation** — identify businesses actively investing in advertising.
- **Agency prospecting** — discover advertisers that may need PPC, creative, landing-page, or analytics services.
- **Affiliate research** — find merchants promoting products in a niche.
- **Brand monitoring** — identify domains and advertiser accounts associated with branded terms.
- **Market-entry analysis** — compare advertiser presence across countries by running separate searches.

### Quick Start

```json
{
  "keyword": "marketing software",
  "location": "United States"
}
````

All fields have defaults, so empty API or Apify automated-test input runs safely.

### Input Reference

#### Search Keyword

Enter exactly one keyword or phrase per run. Maximum length: 700 characters. Default: `marketing software`.

Examples:

- `email marketing software`
- `business insurance`
- `buy running shoes`
- `shopify agency`
- `solar panels`

Multiple newline-separated keywords are rejected before any paid search request is sent.

#### Target Location

Choose one major country from the dropdown. The curated list covers 39 important advertising markets, including the United States, United Kingdom, Germany, France, Canada, Australia, Japan, India, China, Brazil, South Korea, Singapore, United Arab Emirates, Saudi Arabia, and South Africa.

Default: United States.

Target Location identifies the advertiser-search market. Advertiser Location in the output describes the advertiser account itself and may differ.

### Cost Protection

- Exactly **one keyword** per run.
- Exactly **one country** per run.
- Exactly **one advertiser-search request** per run.
- Execution priority is permanently fixed to normal.
- High-priority search, coordinates, raw location codes, batching, and multiple tasks are not exposed.
- Free users can run the Actor **5 times per day**.

These restrictions prevent input combinations from multiplying paid requests.

### Output Fields

Each Dataset row has a consistent structure:

| Field | Type | Description |
|---|---|---|
| `keyword` | string | Input search keyword |
| `target_location` | string | Selected country market |
| `result_type` | string | `ads_advertiser`, `ads_multi_account_advertiser`, or `ads_domain` |
| `rank` | integer/null | Absolute result position |
| `advertiser_name` | string/null | Advertiser or grouped advertiser name |
| `advertiser_id` | string/null | Unique advertiser account identifier |
| `advertiser_location` | string/null | Country code or location associated with the advertiser account |
| `verified` | boolean/null | Whether Google verified the advertiser account |
| `approximate_ads_count` | integer/null | Approximate number of ads across supported Google Ads platforms |
| `domain` | string/null | Advertiser domain for domain-type results |
| `associated_accounts` | array | Queryable account objects belonging to a grouped advertiser |

#### Associated Accounts

Grouped advertiser results preserve account details as structured data:

```json
{
  "associated_accounts": [
    {
      "advertiser_id": "AR123456789",
      "location": "US",
      "verified": true,
      "approximate_ads_count": 120
    }
  ]
}
```

Users do not need to guess array contents or parse opaque text.

Internal task IDs, response codes, request paths, search-engine codes, raw location codes, processing time, internal costs, and provider metadata are hidden.

### Defaults

| Field | Default |
|---|---|
| Search Keyword | `marketing software` |
| Target Location | United States |
| Priority | Normal, fixed internally |

Runtime defaults cover Console runs, API calls, schedules, integrations, and Apify automated tests.

### Pricing & Limits

| Tier or setting | Limit |
|---|---|
| Free users | **5 runs per day** |
| Paid Apify users | Unlimited daily runs |
| Keywords | Exactly 1 per run |
| Countries | Exactly 1 per run |
| Search requests | Exactly 1 per run |
| Priority | Normal only |

Usage is billed through the Actor's configured Apify events.

### FAQ

**Does this return the actual ad creatives?**\
No. It returns advertiser accounts, grouped accounts, and advertiser domains. It is designed for advertiser and competitive discovery rather than complete creative-library extraction.

**What does Verified mean?**\
It indicates whether the advertiser account is marked as verified by Google Ads.

**Why can one company have multiple advertiser IDs?**\
Large brands, agencies, regional entities, and subsidiaries may advertise through several accounts. Grouped results preserve these accounts in `associated_accounts`.

**Is approximate ad count limited to search ads?**\
It represents an approximate number of ads run by the advertiser across available Google Ads platforms, not only the single keyword result page.

**Can I search multiple countries at once?**\
No. The Actor intentionally accepts one country per run to keep costs predictable. Run separate searches when comparing markets.

**Why do some fields contain null?**\
Different result types provide different information. Domain results do not include advertiser IDs, while account results may not include a domain.

**Where can I inspect run totals?**\
Open the default Key-Value Store and read the `SUMMARY` record.

### Support

Open an issue from the Actor page and include the run ID plus the `SUMMARY` record. Never include credentials.

# Actor input Schema

## `keyword` (type: `string`):

Enter exactly one keyword or phrase. The Actor finds advertisers associated with this search term.

## `location` (type: `string`):

Choose one major country. One paid advertiser-search request is sent per run.

## Actor input object example

```json
{
  "keyword": "marketing software",
  "location": "United States"
}
```

# Actor output Schema

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

Structured advertiser records with name, advertiser ID, location, verification status, approximate ad count, domain, rank, and associated accounts.

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

Keyword, target location, item types, raw/exported counts, duplicates, errors, and user tier.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("opspilot.cc/google-ads-advertiser-discovery").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("opspilot.cc/google-ads-advertiser-discovery").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call opspilot.cc/google-ads-advertiser-discovery --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=opspilot.cc/google-ads-advertiser-discovery",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Ads Advertiser Discovery",
        "description": "Discover Google Ads advertiser accounts and domains by keyword and country. Export advertiser names, IDs, verification status, locations, approximate ad counts, associated accounts, and domains.",
        "version": "1.0",
        "x-build-id": "4ryTejjh14RBU3JUc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/opspilot.cc~google-ads-advertiser-discovery/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-opspilot.cc-google-ads-advertiser-discovery",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/opspilot.cc~google-ads-advertiser-discovery/runs": {
            "post": {
                "operationId": "runs-sync-opspilot.cc-google-ads-advertiser-discovery",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/opspilot.cc~google-ads-advertiser-discovery/run-sync": {
            "post": {
                "operationId": "run-sync-opspilot.cc-google-ads-advertiser-discovery",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keyword",
                    "location"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "maxLength": 700,
                        "type": "string",
                        "description": "Enter exactly one keyword or phrase. The Actor finds advertisers associated with this search term.",
                        "default": "marketing software"
                    },
                    "location": {
                        "title": "Target Location",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Germany",
                            "France",
                            "Canada",
                            "Australia",
                            "Japan",
                            "India",
                            "China",
                            "Brazil",
                            "Italy",
                            "Spain",
                            "Netherlands",
                            "South Korea",
                            "Mexico",
                            "Indonesia",
                            "Turkiye",
                            "Switzerland",
                            "Sweden",
                            "Poland",
                            "Belgium",
                            "Austria",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Ireland",
                            "Singapore",
                            "New Zealand",
                            "Israel",
                            "United Arab Emirates",
                            "Saudi Arabia",
                            "South Africa",
                            "Philippines",
                            "Thailand",
                            "Vietnam",
                            "Malaysia",
                            "Argentina",
                            "Chile",
                            "Colombia"
                        ],
                        "type": "string",
                        "description": "Choose one major country. One paid advertiser-search request is sent per run.",
                        "default": "United States"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
