# Keyword Suggestions Scraper (`datapilot/keyword-suggestions-scraper`) Actor

This Apify Keyword Suggestions Scraper generates keyword ideas for Google and Bing with estimated search volume, CPC, and competition. It supports multiple keywords, optional residential proxy, dataset export, and produces a final analytics summary for SEO research.

- **URL**: https://apify.com/datapilot/keyword-suggestions-scraper.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** Videos, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

## Keyword Suggestions Scraper

🚀 **Keyword Suggestions Scraper** is an advanced Apify Actor designed to generate comprehensive **Keyword Suggestions** based on input keywords. This tool provides detailed **Keyword Suggestions** with search metrics, including search volume, competition levels, and cost-per-click (CPC) data. Whether you're optimizing SEO strategies, conducting keyword research, or planning content marketing, the Keyword Suggestions Scraper delivers actionable **Keyword Suggestions** efficiently.

With optional residential proxy support, the Keyword Suggestions Scraper ensures reliable generation of **Keyword Suggestions**. It focuses on key metrics for **Keyword Suggestions** like platform-specific suggestions, search volumes, and competition analysis, making it an essential tool for **Keyword Suggestions research** and SEO optimization.


### 🔥 Features

- **Comprehensive Keyword Suggestions Generation** – Creates detailed Keyword Suggestions lists for any input keyword, including related terms and variations.
- **Multi-Platform Support** – Generates Keyword Suggestions for platforms like Google and Bing, providing diverse **Keyword Suggestions data**.
- **Search Metrics** – Includes search volume, competition level, and CPC for each Keyword Suggestions set to aid in keyword analysis.
- **Customizable Suggestions** – Uses keyword-specific templates to produce relevant Keyword Suggestions tailored to topics like SEO, web development, and more.
- **Geographic Targeting** – Supports country-specific proxy settings for localized **Keyword Suggestions scraping**.
- **Residential Proxy Support** – Utilizes Apify's residential proxies to enhance reliability for Keyword Suggestions data collection.
- **Batch Processing** – Process multiple keywords in a single run to generate extensive **Keyword Suggestions**.
- **Real-Time Simulation** – Creates up-to-date Keyword Suggestions with timestamps for current relevance.
- **Error Handling** – Robust logging and management for failed Keyword Suggestions generation.
- **Dataset Integration** – Automatically uploads Keyword Suggestions data to your Apify dataset for easy export and analysis.

---

### ⚙️ How It Works

The Keyword Suggestions Scraper analyzes input keywords and generates a list of **Keyword Suggestions** using predefined templates and realistic metrics. It simulates querying search engines to provide Keyword Suggestions with associated data like search volume and competition. This approach ensures fast, consistent results for **Keyword Suggestions research** and SEO planning.

**Key benefits for Keyword Suggestions analysis:**

- Discover new Keyword Suggestions for content creation.
- Evaluate Keyword Suggestions competition and potential CPC.
- Compare Keyword Suggestions across platforms like Google and Bing.
- Identify long-tail and related keyword variations.
- Analyze search trends and seasonal keyword patterns.

---

### 📥 Input

The Actor accepts the following input parameters:

| Field                 | Type            | Default   | Description |
|-----------------------|-----------------|-----------|-------------|
| `keywords`            | string / array  | required  | List of keywords to generate Keyword Suggestions for (e.g., `"SEO, Python"`). Separate by commas if string. |
| `useResidentialProxy` | boolean         | `false`   | Enable residential proxies for Keyword Suggestions generation. |
| `proxyCountry`        | string          | `"US"`    | Country for residential proxy (e.g., `"US"`). |
| `upload_to_dataset`   | boolean         | `true`    | Upload Keyword Suggestions data to Apify dataset. |

**Example input JSON:**

```json
{
  "keywords": ["SEO", "Python"],
  "useResidentialProxy": false,
  "proxyCountry": "US",
  "upload_to_dataset": true
}
````

***

### 📤 Output

The scraper outputs detailed **Keyword Suggestions** in JSON format. Each record includes:

| Field              | Type    | Description |
|--------------------|---------|-------------|
| `keyword`          | string  | The original keyword for which Keyword Suggestions were generated. |
| `platform`         | string  | The search platform (e.g., `"google"`, `"bing"`). |
| `suggestions`      | array   | List of Keyword Suggestions related to the keyword. |
| `search_volume`    | integer | Estimated search volume for the Keyword Suggestions set. |
| `competition`      | string  | Competition level (`"Low"`, `"Medium"`, `"High"`) for the Keyword Suggestions. |
| `cpc`              | float   | Cost-per-click value for the Keyword Suggestions. |
| `timestamp`        | string  | ISO timestamp of the Keyword Suggestions generation. |

Additionally, a summary record is pushed with totals and averages for all Keyword Suggestions generated.

**Example output for Keyword Suggestions:**

```json
{
  "keyword": "SEO",
  "platform": "google",
  "suggestions": [
    "seo tools",
    "seo tutorial",
    "seo services",
    "seo tips",
    "seo checklist",
    "seo best practices",
    "seo software",
    "seo audit",
    "seo ranking",
    "local seo"
  ],
  "search_volume": 45678,
  "competition": "Medium",
  "cpc": 2.45,
  "timestamp": "2025-02-14T12:00:00Z"
}
```

**Example summary record:**

```json
{
  "summary": true,
  "total_keywords": 2,
  "total_suggestions": 20,
  "average_search_volume": 52500,
  "average_cpc": 2.38,
  "keywords_processed": ["SEO", "Python"],
  "platforms": ["google", "bing"],
  "completed_at": "2025-02-14T12:35:00Z"
}
```

***

### 🧰 Technical Stack

- **Core Engine:** Keyword Suggestions generation with realistic search metrics simulation.
- **Proxy:** Apify Proxy with RESIDENTIAL support – optional for enhanced reliability.
- **Platform:** Apify Actor – serverless, scalable, integrated with Dataset and Key‑Value Store.
- **Deployment:** One‑click run on Apify Console or via REST API.

***

### 🎯 Use Cases

- **SEO Keyword Research** – Discover high-value keywords for your content and website.
- **Content Marketing Strategy** – Identify long-tail keywords for blog posts and articles.
- **PPC Campaign Planning** – Analyze CPC and competition for Google Ads and Bing Ads campaigns.
- **Competitor Keyword Analysis** – Research which keywords competitors are targeting.
- **E-commerce Optimization** – Find product-related keyword suggestions for better visibility.
- **SaaS Product Marketing** – Identify keywords with high commercial intent for your software.
- **Local SEO Research** – Discover location-specific keyword variations.
- **Niche Market Research** – Explore keyword trends in specific industries or verticals.
- **Content Gap Analysis** – Identify keyword opportunities not yet covered by competitors.
- **YouTube & Video SEO** – Find keywords with high search volume for video content.
- **Academic SEO Research** – Collect keyword data for SEO and digital marketing studies.
- **Technical SEO Audits** – Analyze keyword performance and ranking opportunities.

***

### 🚀 Quick Start

1. **Open in Apify Console** – visit the Actor page and click Try for free.
2. **Enter keywords** in the input field (e.g., `"SEO"` or `"Python, Web Development"`).
3. **(Optional) Enable residential proxies** – disabled by default.
4. **Click Start** – the Actor will generate comprehensive Keyword Suggestions.
5. **Export** – download the results as JSON, CSV, or Excel.

You can also call this Actor programmatically via Apify SDK or REST API – ideal for automated SEO workflows and keyword research pipelines.

***

### 💎 Why This Actor?

| Feature | Benefit |
|---------|---------|
| ✅ Fast generation | Get keyword suggestions instantly without API delays. |
| ✅ Rich metrics | Receive search volume, competition, and CPC data. |
| ✅ Multi-platform | Compare suggestions across Google, Bing, and more. |
| ✅ Customizable | Tailored suggestions for different industries and topics. |
| ✅ Batch processing | Process multiple keywords efficiently in one run. |
| ✅ Realistic data | Simulated metrics mirror real search engine data. |
| ✅ Easy integration | Clean JSON output ready for analysis tools. |
| ✅ Apify ecosystem | Seamless integration with other Actors, triggers, and webhooks. |

### 📦 Changelog

- Initial release with comprehensive keyword suggestions generation.
- Multi-platform support (Google, Bing).
- Realistic search metrics including volume, competition, and CPC.
- Customizable suggestions for different industries and topics.
- Support for single and batch keyword processing.
- Geographic targeting with country-specific settings.
- Optional residential proxy support.
- Summary statistics with totals and averages.
- Full Apify Actor integration.

***

### 🧑‍💻 Support & Feedback

- **Issues & Ideas:** Open a ticket on the Apify Actor issue tracker.
- **Documentation:** Visit Apify Docs for platform guides.
- **Community:** Join the Apify community forum for discussions and support.

***

### 💰 Pricing

- **Free** for basic usage on Apify platform.
- **Paid plans** available for higher limits and priority support.

***

# Actor input Schema

## `keywords` (type: `string`):

Enter keywords (comma-separated)

## `useResidentialProxy` (type: `boolean`):

Enable Apify Residential Proxy (optional)

## `proxyCountry` (type: `string`):

Select country for proxy routing

## `upload_to_dataset` (type: `boolean`):

Save results to Apify dataset

## Actor input object example

```json
{
  "keywords": "python, seo, web development",
  "useResidentialProxy": false,
  "proxyCountry": "US",
  "upload_to_dataset": true
}
```

# 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("datapilot/keyword-suggestions-scraper").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("datapilot/keyword-suggestions-scraper").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 datapilot/keyword-suggestions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Keyword Suggestions Scraper",
        "description": "This Apify Keyword Suggestions Scraper generates keyword ideas for Google and Bing with estimated search volume, CPC, and competition. It supports multiple keywords, optional residential proxy, dataset export, and produces a final analytics summary for SEO research.",
        "version": "0.0",
        "x-build-id": "ZL4JBrBEhb2JroAQy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datapilot~keyword-suggestions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datapilot-keyword-suggestions-scraper",
                "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/datapilot~keyword-suggestions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datapilot-keyword-suggestions-scraper",
                "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/datapilot~keyword-suggestions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datapilot-keyword-suggestions-scraper",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Enter keywords (comma-separated)",
                        "default": "python, seo, web development"
                    },
                    "useResidentialProxy": {
                        "title": "Use Residential Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Residential Proxy (optional)",
                        "default": false
                    },
                    "proxyCountry": {
                        "title": "Proxy Country",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "DE",
                            "NL",
                            "FR",
                            "AU",
                            "SG"
                        ],
                        "type": "string",
                        "description": "Select country for proxy routing",
                        "default": "US"
                    },
                    "upload_to_dataset": {
                        "title": "Save to Dataset",
                        "type": "boolean",
                        "description": "Save results to Apify dataset",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
