The Jackpot Keywords MCP server provides AI-powered keyword research, SEO auditing, and AI-visibility scanning for products and websites.
Check Credit Balance (jackpotkeywords_credit_balance): Verify your API account's current credit balance — no arguments required.
Keyword Research (jackpotkeywords_recommend): Run a full keyword research pipeline for a product (via URL or description), returning ranked recommendations scored by volume, CPC, competition, trend, cluster strength, and AI relevance — backed by real Google Ads Keyword Planner data ($0.10/call).
Deep Keyword Research (jackpotkeywords_recommend_deep): Same as standard keyword research but also runs parallel competitor discovery and surfaces keyword clusters, category distributions, and competitor brand aggregates ($0.30/call).
SEO Audit (jackpotkeywords_audit): Crawl and audit a URL across technical, content, crawlability, structured data, local, and social-sharing categories — returns scores, failing checks, keyword gaps, and prioritized fix recommendations ($0.50/audit).
AI Visibility Scan (jackpotkeywords_aeo_scan): Assess your product's visibility in AI-powered search by simulating 10 buyer-intent queries through Gemini's grounded search, reporting whether your URL was cited, mentioned, or absent — plus which sources the AI cited instead ($1.00/scan).
Provides tools for keyword research and AI-visibility scanning using real Google Ads Keyword Planner data, enabling AI agents to get keyword recommendations, credit balance checks, and AEO scans.
Allows top-up of account credits via Stripe checkout for continued usage of keyword research and scanning tools.
MCP (Model Context Protocol) server for JackpotKeywords — AI-powered keyword research, SEO audits, and AI-visibility scanning. Lets Claude Code, Claude Desktop, Cursor, Windsurf, and other MCP-compatible clients call JackpotKeywords directly.
Five tools available: jackpotkeywords_credit_balance, jackpotkeywords_recommend, jackpotkeywords_recommend_deep, jackpotkeywords_audit, jackpotkeywords_aeo_scan.
A JackpotKeywords API key — generate one at https://jackpotkeywords.web.app/developers (instant, self-serve, $2 starter credit, no card required).
Node.js 18 or newer (only if installing locally; npx doesn't require a local Node.js if your MCP client bundles one).
Related MCP server: seocrawl-mcp
Recommended — use the CLI:
claude mcp add -s user jackpotkeywords \
-e JACKPOTKEYWORDS_API_KEY=jk_live_... \
-- npx -y jackpotkeywords-mcp-serverThat writes the server to your user-scope config (~/.claude.json) so it's available in every Claude Code session, in every project. Verify with claude mcp list.
Or hand-edit ~/.claude.json (user scope) or .mcp.json in the project root (project scope), adding to the mcpServers object:
{
"mcpServers": {
"jackpotkeywords": {
"command": "npx",
"args": ["-y", "jackpotkeywords-mcp-server"],
"env": {
"JACKPOTKEYWORDS_API_KEY": "jk_live_..."
}
}
}
}Important: Claude Code does not read ~/.claude/mcp.json (with the slash). The real user-scope path is ~/.claude.json (with the dot). Use the CLI to avoid this trap.
Restart any open Claude Code session to pick up the new tools — MCP servers load at session start, not dynamically.
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"jackpotkeywords": {
"command": "npx",
"args": ["-y", "jackpotkeywords-mcp-server"],
"env": {
"JACKPOTKEYWORDS_API_KEY": "jk_live_..."
}
}
}
}Cursor uses the same JSON shape. Settings → MCP → Add Server:
{
"mcpServers": {
"jackpotkeywords": {
"command": "npx",
"args": ["-y", "jackpotkeywords-mcp-server"],
"env": { "JACKPOTKEYWORDS_API_KEY": "jk_live_..." }
}
}
}jackpotkeywords_credit_balanceReturns the current credit balance for your API account.
No arguments. Use it to verify your key works and to check credits before calling the paid tools.
jackpotkeywords_recommendRuns the full keyword research pipeline for a product and returns ranked recommendations by composite Jackpot Score (volume, CPC, competition, trend, cluster strength, AI relevance). Backed by real Google Ads Keyword Planner data.
Cost: $0.10 per call (flat — regardless of limit). Refunded on pipeline failure. Latency ~60–180s.
Argument | Type | Required | Description |
| string | one-of | Product URL to extract context from |
| string | one-of | Plain-English product description |
| number | no | Max recommendations to return. Default 50, max 200. |
| number | no | Daily ad budget in USD (influences AI scoring) |
| string | no | Location for local-intent boosting |
Returns: top 25 recommendations as a readable table in content, with the full ranked list in structuredContent.recommendations.
Example prompt (in Claude Code):
Use jackpotkeywords_recommend on https://bulklistingpro.com — find keywords I should target for SEO and Google Ads for an eBay bulk listing tool. Limit 50.
jackpotkeywords_recommend_deepSame inputs as jackpotkeywords_recommend, with two server-side additions: competitor discovery runs in parallel with autocomplete (broadens the keyword set with competitor-derived seeds), and the response surfaces the cluster + category + competitor-brand aggregates that the standard recommend tool discards.
Cost: $0.30 per call (flat — regardless of limit). Refunded on pipeline failure. Latency ~75–200s.
Argument | Type | Required | Description |
| string | one-of | Product URL to extract context from |
| string | one-of | Plain-English product description |
| number | no | Max recommendations to return. Default 50, max 200. Clusters/categories/competitors not truncated. |
| number | no | Daily ad budget in USD (influences AI scoring) |
| string | no | Location for local-intent boosting |
Returns: top 25 recommendations + top 8 clusters + category distribution + competitor brands in content, with full data in structuredContent.
Example prompt:
Use jackpotkeywords_recommend_deep on https://markitup.app — show me the keyword clusters and competitor brands.
jackpotkeywords_auditRuns an SEO audit on a URL. Crawls the primary page plus up to 8 priority secondary pages, runs deterministic checks across technical / content / crawlability / structured data / local / social-sharing categories, and uses Gemini for keyword-gap identification + prioritized recommendations. AEO data is not bundled — use jackpotkeywords_aeo_scan for that.
Cost: $0.50 per audit (refunded on failure). Latency ~20–60s.
Argument | Type | Required | Description |
| string | yes | URL to audit |
Returns: overall score + per-category scores + top failing/warning checks + top keyword gaps + top recommendations in content. Full check list, per-page results, and all gaps/recs in structuredContent.
Example prompt:
Run jackpotkeywords_audit on https://markitup.app and tell me the top 3 things I should fix.
jackpotkeywords_aeo_scanRuns an AI-visibility scan. Asks 10 buyer-intent queries about your product through Gemini's grounded search and reports, per query: whether the URL was cited as a source, mentioned in the answer text, or absent — plus the top sources the AI did cite.
Cost: $1.00 per scan (refunded on failure). Latency ~30–120s.
Argument | Type | Required | Description |
| string | yes | Product URL to scan |
| object | no | Pre-extracted product context (skip extraction step) |
Returns: visibility score + per-query results in content, full structured data in structuredContent.queries.
Example prompt:
Run jackpotkeywords_aeo_scan on https://markitup.app and tell me which queries we're missing from.
Var | Required | Description |
| yes | API key from https://jackpotkeywords.web.app/developers |
| no | Override the API base URL. Default: |
$2 starter credit on signup (no card, no expiration)
/v1/recommend — $0.10/call
/v1/recommend-deep — $0.30/call (adds clusters + categories + competitors)
/v1/audit — $0.50/audit (SEO only; pair with /v1/aeo-scan for AI-visibility)
/v1/aeo-scan — $1.00/scan
Topup via Stripe checkout (POST /v1/topup) in $5 / $25 / $100 / $500 packs or custom ≥ $5
Rate limit: 60 requests/min, 1000/hr per key
git clone https://github.com/smythmyke/jackpotkeywords-mcp-server.git
cd jackpotkeywords-mcp-server
npm install
npm run build
# Point your MCP client config at the local build:
{
"command": "node",
"args": ["/absolute/path/to/jackpotkeywords-mcp-server/dist/index.js"],
"env": { "JACKPOTKEYWORDS_API_KEY": "jk_live_..." }
}Never commit JACKPOTKEYWORDS_API_KEY to source control.
If you accidentally expose a key, revoke it at https://jackpotkeywords.web.app/developers and create a new one (POST /v1/keys + DELETE /v1/keys/:keyId).
Keys are SHA-256 hashed on the server; the raw key is shown only once at creation.
The server surfaces clean human-readable errors for the common cases:
Invalid or missing JACKPOTKEYWORDS_API_KEY — set or rotate the key.
Insufficient balance — top up at https://jackpotkeywords.web.app/developers.
Rate limit exceeded — wait briefly and retry.
MIT
Run an AI-visibility scan for a product URL. Asks 10 buyer-intent queries against Gemini's grounded search and reports, per query: whether the URL was cited as a source, mentioned in the answer text, or absent — plus the top sources the AI did cite. Costs $1.00 per scan (100¢). Refunded automatically on failure. Latency ~30–120 seconds.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Product URL to scan (e.g., https://yourproduct.com). Required. | |
| productContext | No | Optional pre-extracted product context. If omitted we run extraction internally (free for caller, $1.00 flat). Pass this only if you've already called /v1/recommend or have a known-good ProductContext. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description effectively discloses key behaviors: costs $1.00 per scan, automatic refund on failure, latency 30–120 seconds, and details the query process. It does not mention auth or rate limits but covers essential operation traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at three sentences, front-loaded with the core purpose, then details, then cost/latency. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the outcome per query (cited, mentioned, absent, top sources) despite no output schema. However, it lacks explicit return value structure or format, and could mention whether results are returned as JSON or text. Still sufficient for a paid tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds significant value for productContext: explains internal extraction as default, cost implication ($1.00 flat), and when to pre-pass it (only if already called /v1/recommend). This goes beyond the schema's minimal description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Run an AI-visibility scan for a product URL' and specifies it involves asking 10 buyer-intent queries against Gemini's grounded search. It distinguishes from sibling tools (audit, credit balance, recommend) by focusing on a specific scan functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide guidance on when to use this tool versus alternatives like jackpotkeywords_audit or jackpotkeywords_recommend. It only describes what it does without contextual comparison, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run an SEO audit on a URL. Crawls the primary page plus up to 8 priority secondary pages, checks technical / content / crawlability / structured-data / local / social-sharing categories, and returns scored checks, per-page issues, keyword gaps, and prioritized recommendations. AEO (AI-visibility) data is intentionally NOT bundled — call jackpotkeywords_aeo_scan for that. Costs $0.50 per audit (50¢). Refunded automatically on failure. Latency ~20–60 seconds.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | URL to audit (e.g., https://yourproduct.com or yourproduct.com). Required. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: cost, refund policy on failure, latency (20-60s), scope of crawling (primary + up to 8 secondary pages), and what returns (checks, issues, gaps, recommendations).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise, front-loaded with purpose, structured with bullet-worthy details (cost, latency, refund). Every sentence adds essential information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Complete given the tool's simplicity (1 param) and presence of siblings. Covers purpose, exclusions, cost, latency, failure behavior, and output components. No output schema, but description sufficiently describes returns.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single 'url' parameter, providing baseline of 3. Description adds minimal value beyond the schema: gives examples of acceptable URL formats but does not add new semantic constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Run an SEO audit on a URL' and lists specific categories checked (technical, content, etc.) and outputs (scored checks, issues, recommendations). It explicitly differentiates from sibling jackpotkeywords_aeo_scan by noting that AEO data is intentionally omitted.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (for SEO audit) and when not to (for AI-visibility, directing to jackpotkeywords_aeo_scan). Also mentions cost ($0.50), latency, and automatic refund on failure, providing clear decision-making context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the current JackpotKeywords credit balance for the authenticated account. Use this before calling /recommend or /aeo-scan to verify the account has credits available.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the tool returns the credit balance and implies it is a read operation. It does not detail any authentication requirements, rate limits, or error states, but for a simple balance check this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no wasted words. The first sentence states the purpose, the second gives usage guidance. Information is front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with no parameters and no output schema, the description covers the essential aspects: what it does, that it requires authentication (implied by 'authenticated account'), and when to use it. It could mention the expected output format, but it is complete enough for the use case.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so schema coverage is 100%. With no parameters, the description does not need to add param semantics. The baseline for 0 parameters is 4, and the description adds context about the return value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns the current credit balance for the authenticated account, using specific verbs and resource. It distinguishes itself from sibling tools by mentioning it should be used before calls like /recommend and /aeo-scan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs using this tool before /recommend or /aeo-scan to verify credit availability, providing clear context. However, it does not mention when not to use it or list alternatives beyond the implied prerequisite relationship.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run the full keyword research pipeline for a product and return ranked keyword recommendations by composite Jackpot Score (volume, CPC, competition, trend, cluster strength, AI relevance). Backed by real Google Ads Keyword Planner data. Costs $0.10 per call (10¢, regardless of limit). Refunded automatically on pipeline failure. Latency ~60–180 seconds — agents should set generous timeouts.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Product URL to extract context from (e.g., https://yourproduct.com). At least one of url/description required. | |
| description | No | Plain-English description of the product (e.g., 'AI keyword research tool for indie makers'). At least one of url/description required. | |
| limit | No | Maximum recommendations to return. Default 50, max 200. Cost is flat regardless. | |
| budget | No | Optional daily ad budget in USD. Influences AI scoring/intent classification. | |
| location | No | Optional location for local-intent boosting (e.g., 'San Francisco, CA'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses important behavioral traits: cost structure ($0.10 flat), automatic refunds on failure, latency range (60-180 seconds), and reliance on real data. It does not cover authentication, rate limits, or error handling, but the provided details are valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences, each serving a distinct purpose: core function, data source, pricing, and latency. Front-loaded with the main verb and resource. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters with full schema descriptions, no output schema, and no annotations, the description covers the tool's purpose and key execution details (cost, latency). However, it lacks information about the return format or how agents should handle the output, which is a gap for autonomous use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description does not add extra meaning beyond the schema; it lists composite score components but does not explain how parameters like 'budget' or 'location' influence results. No additional parameter insights.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool runs a full keyword research pipeline, returns ranked recommendations by Jackpot Score, specifies the data source (Google Ads Keyword Planner), and mentions key output criteria. This distinguishes it from sibling tools like the deep version.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions cost and latency but provides no explicit guidance on when to use this tool vs siblings (e.g., jackpotkeywords_recommend_deep) or alternatives. It does not state prerequisites or context for optimal use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run the deep keyword research pipeline for a product. Same inputs as jackpotkeywords_recommend, but also runs parallel competitor discovery (broadens the keyword set) and returns the cluster + category + competitor-brand aggregates that the standard recommend tool discards. Use this when you need to see WHICH keyword clusters matter and WHO else is ranking, in one call. Costs $0.30 per call (30¢, regardless of limit). Refunded automatically on pipeline failure. Latency ~75–200 seconds — agents should set generous timeouts.
| Name | Required | Description | Default |
|---|---|---|---|
| url | No | Product URL to extract context from (e.g., https://yourproduct.com). At least one of url/description required. | |
| description | No | Plain-English description of the product. At least one of url/description required. | |
| limit | No | Maximum recommendations to return. Default 50, max 200. Clusters/categories/competitors are not truncated. | |
| budget | No | Optional daily ad budget in USD. Influences AI scoring/intent classification. | |
| location | No | Optional location for local-intent boosting (e.g., 'San Francisco, CA'). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries full burden. It fully discloses: cost ($0.30), refund policy on failure, latency (75-200 seconds), and suggests generous timeouts. Also mentions parallel competitor discovery and what additional data is returned. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured paragraph. Every sentence serves a purpose: purpose, differentiation, usage guidance, cost, refund, latency, timeout. No redundancy or fluff. Front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters (all described in schema) and no output schema, the description explains what return values include (cluster, category, competitor-brand aggregates) but lacks detailed format. However, it covers cost, latency, refund policy, and use-case, making it fairly complete for the complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so baseline is 3. The description adds value by stating 'Same inputs as jackpotkeywords_recommend' and clarifying that the limit does not affect clusters/categories/competitors, which is not in the schema. This extra context elevates the score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'Run the deep keyword research pipeline for a product' which clearly states the verb and resource. It explicitly distinguishes from the sibling tool jackpotkeywords_recommend by noting additional outputs (clusters, categories, competitor aggregates), making the tool's unique scope clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance: 'Use this when you need to see WHICH keyword clusters matter and WHO else is ranking, in one call.' It implies that for simpler needs, the sibling recommend tool is appropriate. Also provides critical usage details (cost, latency, timeout advice).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.2.0jackpotkeywords_auditjackpotkeywords_recommend_deepv0.1.0jackpotkeywords_aeo_scanjackpotkeywords_credit_balancejackpotkeywords_recommendScored across 5 tools
Each tool has a clearly distinct purpose: AI visibility scan, SEO audit, credit balance check, basic keyword recommendation, and deep keyword recommendation. The descriptions clearly delineate boundaries, especially between recommend and recommend_deep, avoiding confusion.
All tools share the consistent 'jackpotkeywords_' prefix. Most names use a verb-like action (aeo_scan, audit, recommend), but 'credit_balance' is a noun phrase, creating a slight pattern deviation. Still, names are clear and predictable.
Five tools cover the core functionality well without being excessive. Each tool earns its place for a keyword research and SEO audit service, providing a focused yet complete set.
The set covers key actions: AI visibility scanning, SEO auditing, credit management, and keyword research at two depths. There are no major gaps for typical workflows, though a tool to list history or manage exports is absent but not critical.
SEO MCP server for keyword research, SERP analysis, audits, and Search Console workflows.
Open-source AI SEO over MCP: audits, ranks, keywords, backlinks + AI visibility (GEO).
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Your agent needs to know what people actually search — volume, ideas, how hard the term is, and whether interest is rising or was a spike last March. **What you can ask for** • "What is the monthly volume and difficulty for these 200 keywords?" • "Give me keyword ideas around this seed, with questions people ask." • "Which keywords does this competitor rank for that we do not?" • "Is interest in this term growing, and where?" • "What does this page already rank for?" **How to use it** Point any MCP client at https://mcp.aisa.one/seo-keywords/mcp and sign in with OAuth — there is no key to create or paste. 49 tools: Google and Bing volume and suggestions, keywords for a site or a URL, clickstream volumes, Google Trends and Ads traffic estimates, plus Semrush difficulty, question keywords, broad match and paid keywords, and Similarweb's keyword and landing page sets. **Why this rather than the source** Three sources for the same number, so a suspicious volume can be checked rather than believed. **It is also a door to the rest** The same login reaches 26 sources and 580+ operations. Size the demand here, then ask the same agent who ranks for it and who links to them — without adding a second server. **What it costs** Finding and inspecting an operation is free. Running one is billed per call at API prices, with no seat and no monthly minimum, and every call takes max_price_usd so an agent cannot overspend by accident. **Where else it reaches** https://mcp.aisa.one/seo/mcp for all of it at once — rankings, keywords, backlinks, site health and AI-answer visibility across DataForSEO, Semrush and Ahrefs.
