# Google Keyword Suggestions Generator (`opspilot.cc/keyword-suggestions-generator`) Actor

Get keyword suggestions based on a seed keyword. Returns search volume, CPC, competition, trends, and more. Results always contain the seed keyword.

- **URL**: https://apify.com/opspilot.cc/keyword-suggestions-generator.md
- **Developed by:** [wang wei](https://apify.com/opspilot.cc) (community)
- **Categories:** E-commerce, SEO tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Keyword Suggestions Generator

Get keyword suggestions from Google based on a seed keyword. Results always contain the seed keyword. Returns search volume, CPC, competition data, 12-month trends, and more.

### Features

- **Results contain seed keyword** - every suggestion includes the seed phrase
- **Search volume** data with 12-month trends
- **CPC & competition** metrics
- **SERP info** (optional)
- **Seed keyword data** (optional)
- **Fuzzy location/language matching** - type "USA" or "United States"
- **Free tier**: 5 runs per day

### How It Works

Based on the official description, the Keyword Suggestions endpoint returns search queries that contain the specified seed keyword (including additional words before, after, or within the key phrase, and even with different word order). It uses a full‑text search algorithm.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | string (textfield) | Seed keyword (single, required) |
| `location_name` | textfield | Target location (e.g., "United States", "UK") |
| `language_name` | textfield | Target language (e.g., "English", "Spanish") |
| `limit` | number | Max results (1-1000, default 100) |
| `include_serp_info` | checkbox | Include SERP data |
| `include_seed_keyword` | checkbox | Include seed keyword data |
| `exact_match` | checkbox | Search for exact phrase |

### Location Support

Fuzzy matching supports:
- Full names: "United States", "United Kingdom"
- Abbreviations: "USA", "UK", "GB", "US"
- Common names: "Holland" → Netherlands

### Language Support

Fuzzy matching supports:
- Full names: "English", "Spanish", "German"
- Abbreviations: "ENG", "SPA", "DEU"

### Output

| Field | Type | Description |
|-------|------|-------------|
| `keyword` | string | Keyword suggestion |
| `search_volume` | integer | Monthly search volume |
| `cpc` | number | Cost per click (USD) |
| `competition` | number | Competition index (0-1) |
| `competition_level` | string | low/medium/high |
| `low_top_of_page_bid` | number | Low bid for top of page (USD) |
| `high_top_of_page_bid` | number | High bid for top of page (USD) |
| `monthly_trend` | integer | Monthly trend indicator |
| `search_intent` | string | informational/navigational/commercial/transactional |
| `word_count` | integer | Number of words |
| `keyword_difficulty` | integer | Keyword difficulty score (0-100) |
| `core_keyword` | string | Core keyword |

### Primary Use Cases

| Scenario | Description |
|---------|-------------|
| Long‑Tail Keyword Expansion | Take a seed keyword (e.g., "project management") and generate all possible long‑tail variations that still explicitly contain that phrase, such as "best project management software for remote teams", "project management certification online". |
| Question‑Based Content Creation | For informational seeds (e.g., "how to", "what is"), get all natural language question variants that include the core phrase, perfect for FAQ sections or blog posts targeting voice search. |
| Prefix & Suffix Discovery | Discover what users commonly add before or after your seed keyword (e.g., "free", "cheap", "best", "near me", "review", "2025"). This helps optimize for modifiers that convert. |
| Ad Group Structuring | Build tightly themed Google Ads ad groups where every keyword must contain the exact phrase. Suggestions ensure all terms stay relevant to the ad copy. |
| Internal Site Search Optimisation | Analyse what users type into your site's search bar when looking for a product or category. Use suggestions to improve navigation and content matching. |
| Local SEO Expansion | For a seed like "plumber" + location, get all phrases that keep "plumber" plus neighbourhood or service‑specific terms (e.g. "emergency plumber Brooklyn", "plumber for leak repair"). |
| Content Silo Filling | When you have a core page about a topic (e.g. "keto diet"), use suggestions to generate supporting articles that all contain the exact seed phrase, keeping the silo tightly relevant. |

### Target Audience

| Persona | Why They Use It |
|---------|-----------------|
| SEO Content Writers | Need concrete long‑tail variations of a main keyword to write multiple articles or FAQs that directly answer user queries without drifting off‑topic. |
| PPC Specialists | Build precise keyword lists for exact match or phrase match campaigns where the seed phrase must appear – avoiding wasted spend on irrelevant broad match terms. |
| E‑commerce Product Managers | Discover how shoppers modify the core product name (e.g., "men's leather wallet" → "thin leather wallet men", "leather wallet with coin pocket") to optimise product titles and descriptions. |
| Blog Owners / Affiliate Marketers | Find buyer‑intent long‑tail phrases (e.g., "best running shoes for flat feet") that include a core commercial keyword, often with lower competition. |
| Local Business Owners | Generate location‑specific variations of their main service (e.g., "dentist open Saturday Chicago") to target hyper‑local search traffic. |
| SEO Tool Builders | Provide a "keyword suggestions" feature inside their platforms – the endpoint returns ready‑to‑use data with search volume, CPC, and competition. |
| Agency Keyword Researchers | Quickly create large, clean lists of phrase‑containing keywords for client reports, without manually adding modifiers or rearranging word order. |

### Comparison with Keyword Ideas

Use **Keyword Suggestions** when you need explicit inclusion of the seed phrase – every returned keyword contains the seed (word order may vary).

Use **Keyword Ideas** when you want category‑based semantic discovery – results may not contain the seed at all, but belong to the same product/service category.

### Practical Example

**Input:**
```json
{
  "keyword": "keyword research",
  "location_name": "United States",
  "language_name": "English",
  "limit": 10
}
````

**Output (all suggestions contain "keyword research"):**

- "google research keyword" (word order changed)
- "how to do keyword research" (words before)
- "keyword competitor research" (words after)
- "how to do keyword research for content marketing" (words before and after)

# Actor input Schema

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

A single seed keyword to generate suggestions for. Results will contain this keyword.

## `location_name` (type: `string`):

Target location (e.g., 'United States', 'UK', 'Germany'). Supports fuzzy matching.

## `language_name` (type: `string`):

Target language (e.g., 'English', 'Spanish', 'French'). Supports fuzzy matching.

## `limit` (type: `integer`):

Maximum number of keyword suggestions to return (1-1000, default 100).

## `include_serp_info` (type: `boolean`):

Include SERP info for each keyword.

## `include_seed_keyword` (type: `boolean`):

Include data for the seed keyword itself.

## `exact_match` (type: `boolean`):

If true, results include the exact keyword phrase with other words before or after.

## Actor input object example

```json
{
  "keyword": "keyword research",
  "location_name": "United States",
  "language_name": "English",
  "limit": 100,
  "include_serp_info": false,
  "include_seed_keyword": false,
  "exact_match": false
}
```

# Actor output Schema

## `serpData` (type: `string`):

Dataset containing keyword suggestions with search volume, CPC, competition, and trends

# 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 = {
    "keyword": "keyword research"
};

// Run the Actor and wait for it to finish
const run = await client.actor("opspilot.cc/keyword-suggestions-generator").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 = { "keyword": "keyword research" }

# Run the Actor and wait for it to finish
run = client.actor("opspilot.cc/keyword-suggestions-generator").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 '{
  "keyword": "keyword research"
}' |
apify call opspilot.cc/keyword-suggestions-generator --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Keyword Suggestions Generator",
        "description": "Get keyword suggestions based on a seed keyword. Returns search volume, CPC, competition, trends, and more. Results always contain the seed keyword.",
        "version": "0.1",
        "x-build-id": "6J1ZauASFsdyEhtlB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/opspilot.cc~keyword-suggestions-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-opspilot.cc-keyword-suggestions-generator",
                "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~keyword-suggestions-generator/runs": {
            "post": {
                "operationId": "runs-sync-opspilot.cc-keyword-suggestions-generator",
                "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~keyword-suggestions-generator/run-sync": {
            "post": {
                "operationId": "run-sync-opspilot.cc-keyword-suggestions-generator",
                "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"
                ],
                "properties": {
                    "keyword": {
                        "title": "Seed Keyword",
                        "type": "string",
                        "description": "A single seed keyword to generate suggestions for. Results will contain this keyword."
                    },
                    "location_name": {
                        "title": "Location",
                        "type": "string",
                        "description": "Target location (e.g., 'United States', 'UK', 'Germany'). Supports fuzzy matching.",
                        "default": "United States"
                    },
                    "language_name": {
                        "title": "Language",
                        "type": "string",
                        "description": "Target language (e.g., 'English', 'Spanish', 'French'). Supports fuzzy matching.",
                        "default": "English"
                    },
                    "limit": {
                        "title": "Results Limit",
                        "type": "integer",
                        "description": "Maximum number of keyword suggestions to return (1-1000, default 100).",
                        "default": 100
                    },
                    "include_serp_info": {
                        "title": "Include SERP Data",
                        "type": "boolean",
                        "description": "Include SERP info for each keyword.",
                        "default": false
                    },
                    "include_seed_keyword": {
                        "title": "Include Seed Keyword Data",
                        "type": "boolean",
                        "description": "Include data for the seed keyword itself.",
                        "default": false
                    },
                    "exact_match": {
                        "title": "Exact Match",
                        "type": "boolean",
                        "description": "If true, results include the exact keyword phrase with other words before or after.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```