# Seobility Keyword Research (`maximedupre/seobility-keyword-research`) Actor

Run Seobility keyword research from seed terms. Get keyword ideas with search volume, CPC, competition, intent signals, market context, and SERP URLs when Seobility returns them.

- **URL**: https://apify.com/maximedupre/seobility-keyword-research.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 keyword ideas

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

### 🔎 Seobility keyword research scraper for SEO ideas

Seobility Keyword Research runs public [Seobility](https://www.seobility.net/en/keyword-research-tool/) keyword research from the seed terms you submit. Add keywords such as `content marketing`, `SEO tools`, or `keyword research`, choose a Google search market, and get Seobility keyword ideas with search volume, CPC, competition, intent signals, and SERP URL evidence when the source returns it.

Use this Seobility keyword research scraper for SEO briefs, content planning, keyword list expansion, competitor-adjacent research, paid search prep, and repeatable exports. The Actor saves clean rows to an Apify dataset, so you can download results as JSON, CSV, Excel, XML, RSS, or HTML, or use them through the Apify API, schedules, webhooks, and integrations.

You do not need a Seobility login, cookies, a source API key, or a paid Seobility account. For a first run, keep the prefilled seeds and the default limit of `75` keyword ideas per seed. That gives you a useful sample while keeping output size and pay-per-event charges predictable.

### ✅ What this Actor does

- Accepts one or more seed keywords.
- Sends each seed to Seobility keyword research.
- Supports Google search markets such as `Google.com`, `Google.co.uk`, `Google.ca`, `Google.com.au`, `Google.de`, `Google.fr`, and `Google.es`.
- Saves one dataset row per accepted keyword idea.
- Returns source-backed search volume, CPC, competition, and intent signals when available.
- Keeps the original seed keyword and source position on every row.
- Adds SERP URL evidence when Seobility returns ranking-page data.
- Stops at your `Maximum keyword ideas per seed` limit, so a low limit does not silently become a larger charged dataset.
- Continues through recoverable no-data or source-side issues without saving misleading rows.

This Actor is focused on public Seobility keyword ideas and metrics. It does not scrape logged-in Seobility dashboards, rank tracking projects, private reports, downloadable PDFs, AI-written SEO recommendations, or ongoing position monitoring.

### 📊 Seobility keyword data you can extract

Each output item is one accepted Seobility keyword idea. Fields include:

- `seedKeyword` - the seed term that produced this keyword idea.
- `keyword` - the keyword idea returned by Seobility.
- `searchMarket` - the Google market used for the source request.
- `languageCode` - the language code used for the run.
- `sourcePosition` - one-based order in Seobility's returned keyword list.
- `searchVolume` - monthly search volume when Seobility returns it.
- `keywordDifficulty` - keyword difficulty when Seobility returns it. This is `null` when the public source does not expose it.
- `competition` - source-backed competition index.
- `cpc` - source-backed cost-per-click value.
- `intent` - informational, transactional, navigational, and commercial intent signals.
- `serpResults` - ranked SERP URL evidence with position, nullable title, and URL.

Missing metrics use `null`, not `0`, so you can tell the difference between "not returned" and a real zero value. If Seobility does not return SERP evidence for a keyword, `serpResults` is an empty array.

### 🧭 Common use cases

#### 📝 Content planning

Start with a topic such as `email marketing`, `home workout`, or `AI tools`, then export related keyword ideas with search volume and intent signals for content briefs.

#### 🔍 SEO keyword research

Build keyword lists from several seed terms, compare search markets, and keep source position so analysts can sort or filter in a spreadsheet.

#### 💸 Paid search prep

Use CPC and competition fields to spot expensive or competitive terms before moving ideas into ad planning tools.

#### 📈 SERP evidence review

Use `serpResults` to see ranking-page URL evidence for keyword ideas when Seobility exposes it. This is helpful when you want a quick source-backed check before deeper manual research.

### 🚀 How to run it

1. Add one or more seed terms in **Seed keywords**.
2. Choose a **Search market** such as `Google.com`.
3. Keep **Language code** as `en`, or set the language code that matches your market.
4. Set **Maximum keyword ideas per seed** to control output size and spend.
5. Run the Actor and open the dataset.

The Actor pushes each accepted keyword idea as soon as it is saved. You can watch rows appear during the run, export the dataset, or read the same data through the Apify API.

### 🛠️ Input

```json
{
  "seedKeywords": [
    "content marketing",
    "SEO tools",
    "keyword research"
  ],
  "searchMarket": "Google.com",
  "languageCode": "en",
  "maxKeywordIdeasPerSeed": 75
}
````

#### 🎯 Input fields

| Field | What it does |
| --- | --- |
| `seedKeywords` | Seed terms to expand with Seobility keyword research. |
| `searchMarket` | Google market used for keyword metrics, such as `Google.com` or `Google.de`. |
| `languageCode` | Language code used for the keyword research market. |
| `maxKeywordIdeasPerSeed` | Maximum accepted keyword idea rows to save for each seed. |

### 📦 Output example

```json
{
  "seedKeyword": "content marketing",
  "keyword": "content marketing strategy",
  "searchMarket": "Google.com",
  "languageCode": "en",
  "sourcePosition": 2,
  "searchVolume": 8100,
  "keywordDifficulty": null,
  "competition": 0.42,
  "cpc": 4.25,
  "intent": {
    "informational": 76,
    "transactional": 4,
    "navigational": 0,
    "commercial": 20
  },
  "serpResults": [
    {
      "position": 1,
      "title": null,
      "url": "https://contentmarketinginstitute.com/what-is-content-marketing/"
    }
  ]
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged only for each accepted keyword idea saved to the dataset through the `seobility-keyword-result` event.

Rows are charged after a keyword idea is accepted and before it is saved. No charge is made for seeds that return no usable keyword ideas, unsupported source responses, or rows skipped because your run has reached its charge limit.

### ⚠️ Limits and caveats

- The public Seobility keyword research source may not expose every metric for every keyword.
- `keywordDifficulty` stays `null` unless Seobility returns a difficulty value for that keyword.
- SERP result titles can be `null` because the public SERP helper returns ranked URLs but may not return page titles.
- Search market support depends on Seobility's public Google market options.
- This Actor is not a rank tracker and does not monitor keyword positions over time.

### ❓ FAQ

#### Do I need a Seobility account?

No. The Actor uses public Seobility keyword research surfaces and does not ask for Seobility credentials, cookies, or a source API key.

#### Can I control how many rows are charged?

Yes. Set `maxKeywordIdeasPerSeed`. The Actor saves and charges only up to that many accepted keyword ideas per seed.

#### Why is keyword difficulty sometimes null?

The public Seobility keyword research responses used by this Actor do not always expose difficulty. The Actor keeps the field as `null` instead of guessing.

#### Can I use the output in spreadsheets or API workflows?

Yes. The dataset can be exported from Apify or consumed through the Apify API, schedules, webhooks, and integrations.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~seobility-keyword-research/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Seobility SEO Checker ↗](https://apify.com/maximedupre/seobility-seo-checker) - run public Seobility SEO checks for websites and pages.
- [Ahrefs Free Website Stats Scraper ↗](https://apify.com/maximedupre/ahrefs-free-website-stats-scraper) - collect public Ahrefs website metrics for domains.
- [SEMrush Free Website Stats Scraper ↗](https://apify.com/maximedupre/semrush-free-website-stats-scraper) - collect public SEMrush overview metrics for domains.
- [Youtube Keywords Discovery Tool ↗](https://apify.com/maximedupre/youtube-keywords-discovery-tool) - collect YouTube autocomplete keyword suggestions.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - collect Pinterest autocomplete keyword ideas.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `seedKeywords` (type: `array`):

Enter the seed keywords you want to expand with Seobility metrics.

## `searchMarket` (type: `string`):

Choose the Google market used for keyword metrics.

## `languageCode` (type: `string`):

Use the two-letter language code for the keyword research market.

## `maxKeywordIdeasPerSeed` (type: `integer`):

Set the most keyword idea rows to save for each seed term.

## Actor input object example

```json
{
  "seedKeywords": [
    "content marketing",
    "SEO tools",
    "keyword research"
  ],
  "searchMarket": "Google.com",
  "languageCode": "en",
  "maxKeywordIdeasPerSeed": 75
}
```

# Actor output Schema

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

Dataset items contain one accepted Seobility keyword idea per row.

# 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 = {
    "seedKeywords": [
        "content marketing",
        "SEO tools",
        "keyword research"
    ],
    "searchMarket": "Google.com",
    "languageCode": "en",
    "maxKeywordIdeasPerSeed": 75
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/seobility-keyword-research").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 = {
    "seedKeywords": [
        "content marketing",
        "SEO tools",
        "keyword research",
    ],
    "searchMarket": "Google.com",
    "languageCode": "en",
    "maxKeywordIdeasPerSeed": 75,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/seobility-keyword-research").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 '{
  "seedKeywords": [
    "content marketing",
    "SEO tools",
    "keyword research"
  ],
  "searchMarket": "Google.com",
  "languageCode": "en",
  "maxKeywordIdeasPerSeed": 75
}' |
apify call maximedupre/seobility-keyword-research --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seobility Keyword Research",
        "description": "Run Seobility keyword research from seed terms. Get keyword ideas with search volume, CPC, competition, intent signals, market context, and SERP URLs when Seobility returns them.",
        "version": "0.1",
        "x-build-id": "wfG94EwxBPerj9k45"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~seobility-keyword-research/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-seobility-keyword-research",
                "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/maximedupre~seobility-keyword-research/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-seobility-keyword-research",
                "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/maximedupre~seobility-keyword-research/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-seobility-keyword-research",
                "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": [
                    "seedKeywords"
                ],
                "properties": {
                    "seedKeywords": {
                        "title": "Seed keywords",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Enter the seed keywords you want to expand with Seobility metrics.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchMarket": {
                        "title": "Search market",
                        "type": "string",
                        "description": "Choose the Google market used for keyword metrics.",
                        "default": "Google.com"
                    },
                    "languageCode": {
                        "title": "Language code",
                        "minLength": 2,
                        "maxLength": 8,
                        "type": "string",
                        "description": "Use the two-letter language code for the keyword research market.",
                        "default": "en"
                    },
                    "maxKeywordIdeasPerSeed": {
                        "title": "Maximum keyword ideas per seed",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set the most keyword idea rows to save for each seed term.",
                        "default": 75
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```