# Google Keyword Gap - Competitor SEO Keywords (`mostafa-ennadi/google-keyword-gap-competitor-seo`) Actor

Find Google keyword gaps between your domain and a competitor with search volume, CPC, competition, ranking positions, and search intent. Built for competitor SEO research, content planning, local SEO, and PPC analysis.

- **URL**: https://apify.com/mostafa-ennadi/google-keyword-gap-competitor-seo.md
- **Developed by:** [mostafa ennadi](https://apify.com/mostafa-ennadi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 keyword results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Keyword Gap - Competitor SEO Keywords** compares your website with a competitor and returns Google keywords with **search volume, CPC, competition, ranking positions, and search intent** in a clean Apify dataset.

Use it to find keywords your competitor ranks for but your site does not, review keywords both domains share, and prioritize SEO or PPC opportunities by demand and intent.

**Intended Store pricing:** $1.00 per 1,000 keyword results when pay-per-event monetization is enabled. One dataset item equals one keyword result.

### What does Google Keyword Gap do?

Google Keyword Gap runs a competitor keyword comparison for one domain against another in a selected Google country database. It returns individual keyword rows with ranking positions plus available search volume, CPC, competition, and four search-intent scores.

The Actor is designed for Apify workflows: run it manually, call it through the Apify API, schedule recurring competitor checks, or connect the dataset to integrations and data pipelines.

Two gap types are returned:

- `missing` — the competitor has a ranking position for the keyword while your domain has no ranking position in the comparison data.
- `shared` — both domains have ranking data for the keyword.

### Why use Google Keyword Gap?

Instead of reviewing competitor keywords manually, you get a structured dataset ready for filtering, sorting, spreadsheets, dashboards, or automation. This is useful for SEO agencies, affiliate and lead-generation sites, local businesses, content teams, and PPC specialists.

Typical use cases include competitor SEO research, content-gap planning, local SEO opportunity discovery, landing-page ideation, commercial keyword prioritization, PPC keyword research, and building reusable keyword databases.

### How to use Google Keyword Gap

1. Open the Actor's **Input** tab.
2. Select the Google country database you want to analyze.
3. Enter **Your domain** and a **Competitor domain**.
4. Set **Max keyword results**. Start with a small number for a quick test.
5. Click **Start**.
6. Open the **Dataset** when the run finishes and filter or export the keyword rows you need.

For repeatable workflows, the same input can be sent through the Apify API or saved in a task.

### Input

| Field | Type | Required | Description |
|---|---|---:|---|
| `country` | string | No | Google country database used for rankings and localized keyword metrics. Defaults to `Google.com`. |
| `your_domain` | string | Yes | The domain you want to compare and improve. |
| `competitor_domain` | string | Yes | Competitor domain to compare against your site. |
| `max_keywords` | integer | No | Maximum total dataset rows. Default `1000`, minimum `1`, maximum `10000`. |

Example input:

```json
{
  "country": "Google.fr",
  "your_domain": "trouveartisan.fr",
  "competitor_domain": "plombierparis.org",
  "max_keywords": 100
}
```

### Output

Each keyword is saved as a separate dataset item. A representative result looks like this:

```json
{
  "keyword": "plombier dépannage paris",
  "searchEngine": "Google.fr",
  "searchVolume": 880,
  "cpc": 2.95,
  "competition": 0.16,
  "yourDomain": "trouveartisan.fr",
  "yourPosition": null,
  "competitor": "plombierparis.org",
  "competitorPosition": 47,
  "gapType": "missing",
  "commercialIntent": 57,
  "transactionalIntent": 0,
  "informationalIntent": 0,
  "navigationalIntent": 0
}
```

You can download the dataset in formats supported by Apify, including JSON, CSV, Excel, XML, HTML, and RSS, or consume it directly through the dataset API.

### Data table

| Field | Description |
|---|---|
| `keyword` | Google keyword returned by the comparison. |
| `searchEngine` | Selected Google country database. |
| `searchVolume` | Estimated monthly search volume when available. |
| `cpc` | Estimated cost per click when available. |
| `competition` | Keyword competition value when available. |
| `yourDomain` | Domain supplied in `your_domain`. |
| `yourPosition` | Ranking position for your domain, or `null` when no position is present. |
| `competitor` | Domain supplied in `competitor_domain`. |
| `competitorPosition` | Ranking position for the competitor, or `null` when no position is present. |
| `gapType` | `missing` or `shared`. |
| `commercialIntent` | Commercial search-intent score when available. |
| `transactionalIntent` | Transactional search-intent score when available. |
| `informationalIntent` | Informational search-intent score when available. |
| `navigationalIntent` | Navigational search-intent score when available. |

SEO metric values are estimates and may be `null` when the upstream comparison data does not provide a value.

### How much does Google Keyword Gap cost?

The intended pay-per-event price is **$0.001 per dataset keyword result**, equivalent to **$1.00 per 1,000 results**, once that Store monetization configuration is enabled for the Actor.

`max_keywords` gives you direct control over the maximum number of rows a run can return. For example, setting it to `100` limits the dataset to at most 100 keyword results.

Whether Apify platform usage is included in the event price or passed through separately is controlled by the Actor monetization settings. Check the Pricing section shown on the Actor page before starting a paid run.

### Tips and best practices

- Start with `max_keywords` between 50 and 100 when testing a new domain pair.
- Compare close organic competitors rather than unrelated large websites for more actionable gaps.
- Use the country database that matches the market you actually target.
- Filter `gapType = missing` first when you want net-new SEO content opportunities.
- Sort missing keywords by `searchVolume` to identify higher-demand opportunities.
- Combine CPC with commercial and transactional intent to prioritize keywords with stronger business value.
- Review `shared` keywords where the competitor position is materially better than yours to find optimization opportunities on existing topics.

### Search intent explained

The Actor may return four intent scores for a keyword. **Informational** intent usually reflects research or learning queries. **Navigational** intent reflects searches aimed at a specific brand or destination. **Commercial** intent indicates comparison or purchase research, while **transactional** intent indicates stronger action or purchase behavior.

Intent scores are signals, not guarantees. Use them together with rankings, volume, CPC, competition, and your own business context.

### FAQ, limitations, and support

#### Does this Actor connect to Google Search Console?

No. It performs a competitor keyword comparison using the selected Google country database. You do not need to connect a Google Search Console property.

#### Why is a ranking position `null`?

`null` means no ranking position was present for that domain in the returned comparison data. This is expected for `missing` keyword gaps on your domain side.

#### Can one run compare multiple competitors?

The public input currently compares your domain with one competitor per run. For multiple competitors, run the Actor once per competitor or automate several runs through Apify tasks/API.

#### Are the metrics exact Google Ads or Search Console values?

No. Search volume, CPC, competition, rankings, and intent values should be treated as SEO research estimates. They can change over time and may differ from values shown by other data providers.

#### What if a run cannot complete the comparison?

The Actor fails rather than publishing a successful empty result when the underlying comparison job reports that it did not complete successfully. Retry later or try a different valid domain pair.

Use the Actor's **Issues** tab on Apify for reproducible bug reports or feature requests. Include the public run ID and non-sensitive input values when possible; never post private API tokens or credentials.

### Summary

Google Keyword Gap turns a domain-vs-competitor comparison into a clean keyword dataset with ranking positions, search volume, CPC, competition, and search-intent signals. Use `missing` rows to discover new SEO opportunities and `shared` rows to identify topics where your competitor may be outperforming your site.

# Actor input Schema

## `country` (type: `string`):

Choose the Google country database used for keyword rankings and localized search metrics.

## `your_domain` (type: `string`):

Domain you want to improve. Enter the hostname without a path, for example `trouveartisan.fr`.

## `competitor_domain` (type: `string`):

Competitor hostname whose ranking keywords will be compared with your domain, for example `plombierparis.org`.

## `max_keywords` (type: `integer`):

Maximum total number of keyword rows saved to the dataset. Use a small value for quick tests and increase it for larger exports.

## Actor input object example

```json
{
  "country": "Google.com",
  "your_domain": "trouveartisan.fr",
  "competitor_domain": "plombierparis.org",
  "max_keywords": 1000
}
```

# Actor output Schema

## `dataset` (type: `string`):

One keyword result per dataset item, including rankings and available SEO metrics.

# 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 = {
    "your_domain": "trouveartisan.fr",
    "competitor_domain": "plombierparis.org"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mostafa-ennadi/google-keyword-gap-competitor-seo").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 = {
    "your_domain": "trouveartisan.fr",
    "competitor_domain": "plombierparis.org",
}

# Run the Actor and wait for it to finish
run = client.actor("mostafa-ennadi/google-keyword-gap-competitor-seo").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 '{
  "your_domain": "trouveartisan.fr",
  "competitor_domain": "plombierparis.org"
}' |
apify call mostafa-ennadi/google-keyword-gap-competitor-seo --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mostafa-ennadi/google-keyword-gap-competitor-seo"
        }
    }
}
```

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/ar9LKx9JCfRY5aQlA/builds/8BDx6dOAHQkExmIba/openapi.json