# Keyword Research MCP: Autocomplete, Search Volume & Trends (`fairfetch/keyword-research-mcp`) Actor

MCP server for AI agents and SEO work: Google, YouTube & Bing autocomplete, keyword search volume, CPC, difficulty & intent, keyword ideas, Google Trends and trending searches. Pay per call: $0.002 per autocomplete query, $0.10 per 25 keywords, $0.02 per Trends call.

- **URL**: https://apify.com/fairfetch/keyword-research-mcp.md
- **Developed by:** [Naveen Raja](https://apify.com/fairfetch) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 autocomplete queries

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

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Keyword Research MCP: autocomplete, search volume, keyword difficulty and Google Trends for AI agents

A remote **MCP server** with six read-only keyword research tools that Claude, ChatGPT, Cursor and other MCP clients and AI agents can call:

- **Search autocomplete** from Google, YouTube and Bing, with A-Z and question expansion.
- **Keyword search volume**, CPC, competition, **keyword difficulty**, search intent and trend, for up to 200 keywords per call.
- **Keyword ideas** with the same metrics: long-tail keywords that contain your seed, or Google's related searches.
- **Google Trends**: interest over time for up to 5 terms, interest by region, related queries (top and rising), and today's trending searches.

You pay per call, with no subscription. You need only an Apify account: no Ahrefs, Semrush, Google Ads or DataForSEO account.

### Price

| Tool | What one call returns | Price |
|---|---|---|
| `search_suggestions` | Autocomplete suggestions per seed and engine | **$0.002 per query** (one seed on one engine = 1 query; A-Z expansion = 37) |
| `keyword_metrics` | Volume, CPC, competition, difficulty, intent, trend | **$0.10 per 25 keywords with data** (1-25 = $0.10, 26-50 = $0.20 ...) |
| `keyword_ideas` | Up to 200 keyword ideas with the same metrics | **$0.12 per 50 keywords returned** |
| `google_trends_interest` | Interest over time for 1-5 terms (+ regions) | **$0.02 per call** |
| `google_trends_related` | Top and rising related queries of one term | **$0.02 per call** |
| `google_trending_now` | Trending searches in a country right now | **$0.01 per call** |

Failed calls, invalid arguments and calls without data cost nothing. Keywords without data are not counted.

| Example | Charges |
|---|---|
| Autocomplete for 5 seeds on Google | 5 queries = $0.01 |
| Autocomplete for 1 seed on Google, YouTube and Bing with A-Z expansion | 111 queries = $0.22 |
| Search volume and difficulty for 20 keywords | $0.10 |
| Search volume and difficulty for 100 keywords | $0.40 |
| 50 keyword ideas for "standing desk" | $0.12 |
| Google Trends: compare 5 terms over 5 years | $0.02 |
| A research session: 3 autocomplete calls, 40 keywords checked, 50 ideas, one Trends comparison, related queries | about $0.37 |

**Platform usage.** The server runs in Apify's Standby mode, and for Standby Actors Apify bills your account for the server's platform usage on top of the prices above. The server starts when your MCP client connects to it, and most clients connect when they start or when a chat starts, even if no tool is used. It stops 5 minutes after the last request. At 256 MB each start comes to **about $0.005** in our tests, the 5-minute tail included. Each start also prepares Google Trends with one small request through Apify's residential proxy (about 13 KB, $0.0001), and every Google Trends call adds about $0.00015 of proxy traffic. If your client sends more than 8 requests at the same moment, Apify starts a second server, which adds its own 5-minute tail (about $0.0045). Remove or disable the server in clients and projects where you don't use it.

### Connect your MCP client

The endpoint is **`https://fairfetch--keyword-research-mcp.apify.actor/mcp`** (Streamable HTTP). You authenticate with your Apify account; no other credentials are needed.

**Through Apify's hosted MCP server (OAuth, works in Claude, ChatGPT, Cursor, VS Code):** add this URL as a remote MCP server or custom connector, then sign in to Apify when your client asks:

```
https://mcp.apify.com/?tools=fairfetch/keyword-research-mcp
```

The tools then appear as `fairfetch--keyword-research-mcp--search_suggestions` and so on.

**Directly, with your Apify API token** (Console > Settings > API & Integrations):

```json
{
  "mcpServers": {
    "keyword-research": {
      "url": "https://fairfetch--keyword-research-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Claude Code:

```bash
claude mcp add --transport http keyword-research https://fairfetch--keyword-research-mcp.apify.actor/mcp \
  --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Python (official MCP SDK):

```python
import asyncio, httpx
from mcp import ClientSession
from mcp.client.streamable_http import streamable_http_client

async def main():
    headers = {"Authorization": "Bearer YOUR_APIFY_TOKEN"}
    async with httpx.AsyncClient(headers=headers, timeout=120) as http:
        async with streamable_http_client("https://fairfetch--keyword-research-mcp.apify.actor/mcp", http_client=http) as (r, w, _):
            async with ClientSession(r, w) as session:
                await session.initialize()
                result = await session.call_tool("keyword_metrics", {"keywords": ["standing desk", "standing desk converter"]})
                print(result.structuredContent)

asyncio.run(main())
```

### Use cases

- **AI agents and assistants**: "Find long-tail keywords for my blog post about standing desks, check which ones have volume and low difficulty, and tell me if interest is growing." The agent combines autocomplete, keyword metrics, ideas and Trends in one conversation.
- **Content planning**: question-style keywords ("how", "what", "best", "vs") from autocomplete, then volumes to pick topics.
- **SEO and PPC research** without a monthly tool subscription: volume, CPC, competition and difficulty for a keyword list.
- **YouTube topics**: YouTube autocomplete plus Google Trends with `property: "youtube"`.
- **Trend checks**: is a product, brand or topic rising? Compare up to 5 terms on one scale and see where interest is highest.
- **Newsjacking**: what is trending in a country in the last 4 or 24 hours.

### Tools

Every tool is annotated read-only and returns compact JSON (`structuredContent`, with the same JSON as text). Arguments marked \* are required.

#### `search_suggestions`

| Argument | Description |
|---|---|
| `seeds`\* | 1-10 seed keywords, e.g. `["coffee maker"]` |
| `engines` | Any of `google`, `youtube`, `bing`. Default `["google"]` |
| `country` | Two-letter country code. Default `us` |
| `language` | Language code such as `en`, `de`, `pt-BR`. Default: the country's main language |
| `expand` | `none` (default), `alphabet` (seed + a..z, 0..9: 37 queries per seed and engine) or `questions` (how, what, why, best, vs, near me ... in the chosen language; about 20-30 queries) |

At most 120 queries per call. Returns the unique suggestions per seed and engine. Bing uses the country's Bing market (34 countries) and notes any change. Suggestions reflect what people type; engines may add local suggestions for the server's location (in the US).

#### `keyword_metrics`

| Argument | Description |
|---|---|
| `keywords`\* | 1-200 keywords. They are lower-cased; symbols Google Ads rejects are removed (listed in `changed`); unusable ones are listed in `invalid` |
| `country` | Country code or name: `us`, `gb`, `de`, `in` ... (94 countries). Default `us` |
| `language` | Default: the country's main language (the answer says which one was used) |
| `includeMonthlySearches` | Add the last 12 months per keyword. Default `false` |

Each keyword: `searchVolume` (average monthly Google searches), `cpc` (USD), `competition` (0-1) and `competitionLevel`, `keywordDifficulty` (0-100, how hard it is to reach the top 10), `intent` (informational, navigational, commercial, transactional) and `secondaryIntents`, `trend` (percent change vs the previous month, quarter and year), top-of-page bids. Keywords that aren't in the database for that country are listed in `noData` and not charged.

#### `keyword_ideas`

| Argument | Description |
|---|---|
| `seed`\* | One seed keyword |
| `method` | `suggestions` (default: longer keywords that contain the seed) or `related` (Google's "related searches", up to two steps away, with `depth`) |
| `country`, `language` | As above |
| `limit` | Keywords to fetch, 1-200. Default 50 |
| `minSearchVolume` | Only ideas with at least this volume. Default 0 |
| `includeMonthlySearches` | Default `false` |

Ideas come highest volume first. Close variants that Google Ads gives exactly the same numbers ("standing desk", "stand standing desk") are folded into one idea with a `variants` list; they count toward the 50-keyword price blocks like any returned keyword.

#### `google_trends_interest`

| Argument | Description |
|---|---|
| `terms`\* | 1-5 terms compared on one scale |
| `geo` | `US`, `GB`, `US-CA` ... or empty for worldwide (default) |
| `timeRange` | `now 1-H`, `now 4-H`, `now 1-d`, `now 7-d`, `today 1-m`, `today 3-m`, `today 12-m` (default), `today 5-y`, `all`, or `2024-01-01 2024-12-31` |
| `property` | `web` (default), `youtube`, `news`, `images`, `shopping` |
| `category` | Google Trends category ID, default 0 |
| `includeRegions`, `regionLimit` | Also return interest by region (top 25 by default) |

`timeline` points have `values` in the same order as `terms` (0-100, relative to the highest point). With several terms, region values are each term's share in percent.

#### `google_trends_related`

`term`\* (one term), `geo`, `timeRange`, `property`, `category`, `ranking` (`both`, `top`, `rising`), `limit` (up to 25 per list). `top` values are 0-100; `rising` values are the increase in percent, and `label` is `Breakout` above 5,000%.

#### `google_trending_now`

`geo` (country or region, default `US`), `hours` (4, 24, 48 or 168), `limit` (default 25, up to 100), `includeRelatedQueries`. Returns each trend's search volume bucket (e.g. `200K+`), growth, start time, whether it's still active and its categories.

### Output examples (real answers, 24 Oct 2026)

`keyword_metrics` with `["standing desk", "standing desk converter", "zzqx fake keyword 123"]`, United States (shortened):

```json
{
  "location": "United States",
  "locationCode": 2840,
  "language": "en",
  "keywords": [
    {
      "keyword": "standing desk",
      "searchVolume": 135000,
      "cpc": 5.16,
      "competition": 1.0,
      "competitionLevel": "HIGH",
      "keywordDifficulty": 38,
      "intent": "transactional",
      "secondaryIntents": [],
      "trend": { "monthly": -18, "quarterly": 0, "yearly": 0 },
      "lowTopOfPageBid": 0.89,
      "highTopOfPageBid": 6.92
    },
    {
      "keyword": "standing desk converter",
      "searchVolume": 18100,
      "cpc": 2.24,
      "competition": 1.0,
      "competitionLevel": "HIGH",
      "keywordDifficulty": 7,
      "intent": "transactional",
      "secondaryIntents": [],
      "trend": { "monthly": -18, "quarterly": 0, "yearly": -33 },
      "lowTopOfPageBid": 0.39,
      "highTopOfPageBid": 3.18
    }
  ],
  "noData": ["zzqx fake keyword 123"],
  "dataFetchedAt": "2026-10-24T07:06:04Z",
  "notes": ["1 keyword(s) are not in DataForSEO's database for this country (too rare, or not searched in this language); they are not charged."]
}
```

`search_suggestions` with `{"seeds": ["coffee maker"]}`:

```json
{
  "country": "us",
  "language": "en",
  "expand": "none",
  "results": [
    {
      "seed": "coffee maker",
      "engine": "google",
      "queries": 1,
      "suggestions": ["coffee maker with grinder", "coffee maker walmart", "coffee maker without plastic", "coffee makers on sale", "coffee maker keurig", "coffee maker near me", "..."]
    }
  ],
  "queriesSent": 1,
  "queriesWithSuggestions": 1
}
```

`google_trends_interest` with `{"terms": ["coffee", "tea"], "geo": "US"}` (first points):

```json
{
  "terms": ["coffee", "tea"],
  "geo": "US",
  "timeRange": "today 12-m",
  "resolution": "WEEK",
  "averages": [81, 38],
  "timeline": [
    { "date": "2025-10-19", "values": [67, 35] },
    { "date": "2025-10-26", "values": [62, 33] },
    { "date": "2025-11-02", "values": [69, 35] }
  ],
  "trendsUrl": "https://trends.google.com/trends/explore?date=today%2012-m&geo=US&q=coffee,tea&hl=en-US"
}
```

### Without an MCP client: normal runs and the API

You can also start the Actor like any other: choose a **Tool**, put its **Arguments** as JSON, and click Start. The answer is saved as one dataset item, at the same price as the MCP call:

```json
{ "tool": "keyword_metrics", "arguments": { "keywords": ["standing desk", "standing desk converter"], "country": "us" } }
```

```bash
curl -X POST "https://api.apify.com/v2/acts/fairfetch~keyword-research-mcp/run-sync-get-dataset-items" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" -H "Content-Type: application/json" \
  -d '{"tool": "search_suggestions", "arguments": {"seeds": ["coffee maker"], "engines": ["google", "youtube"]}}'
```

Each item has `tool`, `arguments`, `ok`, `result` (the tool's answer) or `error`, and `event` / `eventCount` (what the call is billed).

### Data sources

| Tool | Source |
|---|---|
| `search_suggestions` | Google's and YouTube's suggestion service (the one Chrome's address bar uses) and Bing's OpenSearch suggestions |
| `keyword_metrics`, `keyword_ideas` | DataForSEO Labs (Google): monthly Google Ads search volumes, CPC and bids from DataForSEO's keyword database, updated monthly; keyword difficulty and search intent are DataForSEO's estimates |
| Google Trends tools | Google Trends' public web endpoints, through Apify's residential proxy |

### FAQ

**Which countries work?** Autocomplete and Google Trends: any country (Bing: 34 markets). Keyword metrics and ideas: 94 countries (not China or Russia). The answer always says which country and language were used.

**How fresh is the keyword data?** Search volumes are Google Ads monthly averages over the last 12 months, refreshed monthly by DataForSEO. Identical lookups within 7 days are answered from a cache in your own Apify account (`keyword-research-mcp-cache` key-value store); they cost the same and are faster.

**Why does a keyword have no data?** It is too rare, or not searched in that language and country. It is listed in `noData` and not charged.

**Why are my keyword lookups paused?** A lookup in which no keyword has data is free for you, but the data provider still bills us for it. After 10 such lookups from your account within an hour (lookups still running count too), new keyword lookups are refused (free, with the time they resume) until the oldest one is an hour old. Lookups that you repeat are answered from the cache and keep working. Putting several keywords into one `keyword_metrics` call makes a lookup without any data unlikely.

**What if I misspell an argument?** You get a free error that names the unknown argument and lists the allowed ones; nothing is fetched or charged. Arguments set to `null` count as left out.

**Are Google Trends numbers absolute?** No. Google Trends shows relative interest (0-100) within the request; compare terms in one call to put them on one scale. Values can differ slightly between calls because Google samples its data.

**How much will my agent spend?** Each tool description includes its price, and an answer is billed only when it has data. Every run has a maximum charge: for the MCP server Apify sets it itself (in our test it matched the account's remaining usage limit), and for a normal run it is the maximum cost per run chosen at the start. A call that would go over it is refused before anything is fetched, and the error says how much is left. To allow more on a paid plan, raise your usage limit in Apify Console under **Billing > Limits** (Custom usage limit), up to your plan's maximum; on the Free plan the limit is your monthly free usage, so upgrade or wait for the next billing cycle. A running server keeps the maximum it started with: after raising the limit, close or disconnect your MCP client for 5 minutes so that a new server starts with the new limit. A connected client can also start the server (about $0.005) without calling any tool, so remove or disable the server where you don't use it.

**Can I use it without an MCP client?** Yes, see "Normal runs and the API" above.

### Limits

- At most 10 seeds and 120 autocomplete queries, 200 keywords, 200 ideas, or 5 Trends terms per call. Split bigger jobs into several calls. For bulk lists of thousands of keywords, our [Keyword Search Volume](https://apify.com/fairfetch/keyword-search-volume) Actor is cheaper per keyword.
- Keyword metrics and ideas are by country, not by city or region.
- Google Trends related topics are not offered: Google doesn't return them to automated requests. Google's "rising" lists sometimes contain generic searches that seem unrelated to the term; they come from Google as they are.
- Typical times on a running server: autocomplete 0.1-1 s for a few queries and up to about 8 s with A-Z or question expansion; keyword metrics 0.5-3 s and keyword ideas up to about 5 s; Google Trends 2-8 s, and up to about 15 s with `includeRegions`. When the server has stopped (5 minutes after the last request), the next request, usually your client connecting, waits 3-10 s more while it starts. A busy Google Trends can take longer; calls stop after 45-60 seconds without a charge.
- At most 10 keyword lookups without any data per account per hour (see the FAQ).
- Autocomplete, Google Trends and DataForSEO are external services; if one changes or is unavailable, its tools return a clear error and nothing is charged.

### Legal

The tools read public search suggestions and Google Trends statistics, and keyword statistics retrieved through the DataForSEO API. They do not log in anywhere or solve CAPTCHAs, and they collect no personal data. Suggestions and trending searches are generated from what many people search for and can include names of public figures and, rarely, other text you should handle with care.

**How the Google Trends tools reach Google.** Their requests go through Apify's residential proxy (Apify's datacenter proxy if residential isn't available) with a Chrome browser User-Agent, one at a time per IP address and about a second apart. When Google throttles a request (HTTP 429 or 403, or a redirect to its "unusual traffic" page), the request is retried from another IP address, up to 5 times. If neither proxy is available, the requests come from the server's own IP address instead, about 5 seconds apart, and a throttled request waits up to about a minute before each retry. Each IP address is also replaced after 30 requests, so that no single address carries a long series of requests. Google's cookies are kept when the IP address changes, and a connection whose cookie is still new can be given a cookie that Google has already accepted on another of the tools' connections. trends.google.com's robots.txt disallows only its /explore pages (`/explore?` and `/trends/explore?`), not the endpoints these tools use (`/trends/api/...`, `/_/TrendsUi/data/batchexecute` and `/trending/rss`).

Be aware that the services' terms restrict automated access and reuse:

- **Google and YouTube** (suggestqueries.google.com, which has no robots.txt; trends.google.com): Google's Terms of Service prohibit automated access that ignores machine-readable instructions such as robots.txt, and YouTube's Terms of Service prohibit automated access without YouTube's prior written permission (except for public search engines).
- **Bing** (api.bing.com, whose robots.txt does not load): the Microsoft Services Agreement says the text and other material available on Bing and MSN is for noncommercial, personal use only, and that using it to build your own products is allowed only as far as Microsoft or the rights holders specifically authorize (section 14.f.i, "Bing and MSN Materials"). It also prohibits circumventing restrictions on access to its services, including "impermissible scraping" (section 3.a.vi).

Amazon, eBay and DuckDuckGo autocomplete are not offered: their robots.txt or terms exclude automated or AI-agent access. You are responsible for how you use the data and for complying with the terms of these services and the laws that apply to you.

Not affiliated with or endorsed by Google, YouTube, Microsoft/Bing, DataForSEO or any other company or product named here. Names are trademarks of their owners and are used only to describe the data sources and compatible software.

# Actor input Schema

## `tool` (type: `string`):

Which tool to call. search_suggestions: autocomplete of Google, YouTube and Bing. keyword_metrics: search volume, CPC, difficulty and intent. keyword_ideas: ideas with volume for one seed. google_trends_interest: interest over time for 1-5 terms. google_trends_related: related queries of one term. google_trending_now: trending searches in a country.

## `arguments` (type: `object`):

The tool's arguments as JSON, exactly as an MCP client would send them. Examples: search_suggestions {"seeds": \["coffee maker"], "engines": \["google", "youtube"], "expand": "questions"}; keyword_metrics {"keywords": \["standing desk", "standing desk converter"], "country": "us"}; keyword_ideas {"seed": "standing desk", "limit": 50}; google_trends_interest {"terms": \["coffee", "tea"], "geo": "US", "timeRange": "today 12-m"}; google_trends_related {"term": "coffee", "geo": "US"}; google_trending_now {"geo": "US", "hours": 24}. The README lists every argument.

## Actor input object example

```json
{
  "tool": "search_suggestions",
  "arguments": {
    "seeds": [
      "coffee maker"
    ]
  }
}
```

# Actor output Schema

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

The tool call: tool, arguments, ok, the answer (result) or the error, and the events charged.

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

The same without the answer: tool, arguments, ok, error and charged events.

# 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 = {
    "tool": "search_suggestions",
    "arguments": {
        "seeds": [
            "coffee maker"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fairfetch/keyword-research-mcp").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 = {
    "tool": "search_suggestions",
    "arguments": { "seeds": ["coffee maker"] },
}

# Run the Actor and wait for it to finish
run = client.actor("fairfetch/keyword-research-mcp").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "tool": "search_suggestions",
  "arguments": {
    "seeds": [
      "coffee maker"
    ]
  }
}' |
apify call fairfetch/keyword-research-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fairfetch/keyword-research-mcp"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7E4cgA1mxnK0co30L/builds/JSSQtwmokWPNYsF3i/openapi.json