Skip to main content
Glama
fetchSERP

FetchSERP MCP Server

Official
by fetchSERP

get_keywords_search_volume

Retrieve search volume data for specific keywords in a chosen country to optimize SEO strategies and keyword research using FetchSERP MCP Server.

Instructions

Get search volume for given keywords

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
countryNoThe country code to search for
keywordsYesThe keywords to search

Implementation Reference

  • Handler logic for get_keywords_search_volume tool: calls the FetchSERP API endpoint /api/v1/keywords_search_volume with GET request using provided arguments.
    case 'get_keywords_search_volume':
      return await this.makeRequest('/api/v1/keywords_search_volume', 'GET', args, null, token);
  • Input schema definition for the get_keywords_search_volume tool in the listTools response.
    {
      name: 'get_keywords_search_volume',
      description: 'Get search volume for given keywords',
      inputSchema: {
        type: 'object',
        properties: {
          keywords: {
            type: 'array',
            items: { type: 'string' },
            description: 'The keywords to search',
          },
          country: {
            type: 'string',
            description: 'The country code to search for',
          },
        },
        required: ['keywords'],
      },
    },
  • index.js:37-538 (registration)
    Registration of all tools via the ListToolsRequestSchema handler, which includes get_keywords_search_volume in the tools list.
    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return {
        tools: [
          {
            name: 'get_backlinks',
            description: 'Get backlinks for a given domain',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to search for backlinks',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 15',
                  default: 15,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['domain'],
            },
          },
          {
            name: 'get_domain_emails',
            description: 'Retrieve emails from a given domain',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to search emails from',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 1',
                  default: 1,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['domain'],
            },
          },
          {
            name: 'get_domain_info',
            description: 'Get domain info including DNS records, WHOIS data, SSL certificates, and technology stack',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to check',
                },
              },
              required: ['domain'],
            },
          },
          {
            name: 'get_keywords_search_volume',
            description: 'Get search volume for given keywords',
            inputSchema: {
              type: 'object',
              properties: {
                keywords: {
                  type: 'array',
                  items: { type: 'string' },
                  description: 'The keywords to search',
                },
                country: {
                  type: 'string',
                  description: 'The country code to search for',
                },
              },
              required: ['keywords'],
            },
          },
          {
            name: 'get_keywords_suggestions',
            description: 'Get keyword suggestions based on a url or a list of keywords',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to search (optional if keywords provided)',
                },
                keywords: {
                  type: 'array',
                  items: { type: 'string' },
                  description: 'The keywords to search (optional if url provided)',
                },
                country: {
                  type: 'string',
                  description: 'The country code to search for',
                },
              },
            },
          },
          {
            name: 'get_long_tail_keywords',
            description: 'Generate long-tail keywords for a given keyword',
            inputSchema: {
              type: 'object',
              properties: {
                keyword: {
                  type: 'string',
                  description: 'The seed keyword to generate long-tail keywords from',
                },
                search_intent: {
                  type: 'string',
                  description: 'The search intent (informational, commercial, transactional, navigational). Default: informational',
                  default: 'informational',
                },
                count: {
                  type: 'integer',
                  description: 'The number of long-tail keywords to generate (1-500). Default: 10',
                  default: 10,
                  minimum: 1,
                  maximum: 500,
                },
              },
              required: ['keyword'],
            },
          },
          {
            name: 'get_moz_analysis',
            description: 'Get Moz domain analysis data',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to analyze',
                },
              },
              required: ['domain'],
            },
          },
          {
            name: 'check_page_indexation',
            description: 'Check if a domain is indexed for a given keyword',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to check',
                },
                keyword: {
                  type: 'string',
                  description: 'The keyword to check',
                },
              },
              required: ['domain', 'keyword'],
            },
          },
          {
            name: 'get_domain_ranking',
            description: 'Get domain ranking for a given keyword',
            inputSchema: {
              type: 'object',
              properties: {
                keyword: {
                  type: 'string',
                  description: 'The keyword to search',
                },
                domain: {
                  type: 'string',
                  description: 'The domain to search',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 10',
                  default: 10,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['keyword', 'domain'],
            },
          },
          {
            name: 'scrape_webpage',
            description: 'Scrape a web page without JS',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to scrape',
                },
              },
              required: ['url'],
            },
          },
          {
            name: 'scrape_domain',
            description: 'Scrape a domain',
            inputSchema: {
              type: 'object',
              properties: {
                domain: {
                  type: 'string',
                  description: 'The domain to scrape',
                },
                max_pages: {
                  type: 'integer',
                  description: 'The maximum number of pages to scrape (up to 200). Default: 10',
                  default: 10,
                  maximum: 200,
                },
              },
              required: ['domain'],
            },
          },
          {
            name: 'scrape_webpage_js',
            description: 'Scrape a web page with custom JS',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to scrape',
                },
                js_script: {
                  type: 'string',
                  description: 'The javascript code to execute on the page',
                },
              },
              required: ['url', 'js_script'],
            },
          },
          {
            name: 'scrape_webpage_js_proxy',
            description: 'Scrape a web page with JS and proxy',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to scrape',
                },
                country: {
                  type: 'string',
                  description: 'The country to use for the proxy',
                },
                js_script: {
                  type: 'string',
                  description: 'The javascript code to execute on the page',
                },
              },
              required: ['url', 'country', 'js_script'],
            },
          },
          {
            name: 'get_serp_results',
            description: 'Get search engine results',
            inputSchema: {
              type: 'object',
              properties: {
                query: {
                  type: 'string',
                  description: 'The query to search',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 1',
                  default: 1,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['query'],
            },
          },
          {
            name: 'get_serp_html',
            description: 'Get search engine results with HTML content',
            inputSchema: {
              type: 'object',
              properties: {
                query: {
                  type: 'string',
                  description: 'The query to search',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 1',
                  default: 1,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['query'],
            },
          },
          {
            name: 'get_serp_ai_mode',
            description: 'Get SERP with AI Overview and AI Mode response. Returns AI overview and AI mode response for the query. Less reliable than the 2-step process but returns results in under 30 seconds.',
            inputSchema: {
              type: 'object',
              properties: {
                query: {
                  type: 'string',
                  description: 'The query to search',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
              },
              required: ['query'],
            },
          },
          {
            name: 'get_serp_text',
            description: 'Get search engine results with text content',
            inputSchema: {
              type: 'object',
              properties: {
                query: {
                  type: 'string',
                  description: 'The query to search',
                },
                search_engine: {
                  type: 'string',
                  description: 'The search engine to use (google, bing, yahoo, duckduckgo). Default: google',
                  default: 'google',
                },
                country: {
                  type: 'string',
                  description: 'The country to search from. Default: us',
                  default: 'us',
                },
                pages_number: {
                  type: 'integer',
                  description: 'The number of pages to search (1-30). Default: 1',
                  default: 1,
                  minimum: 1,
                  maximum: 30,
                },
              },
              required: ['query'],
            },
          },
          {
            name: 'get_user_info',
            description: 'Get user information including API credit',
            inputSchema: {
              type: 'object',
              properties: {},
            },
          },
          {
            name: 'get_webpage_ai_analysis',
            description: 'Analyze a web page with AI',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to analyze',
                },
                prompt: {
                  type: 'string',
                  description: 'The prompt to use for the analysis',
                },
              },
              required: ['url', 'prompt'],
            },
          },
          {
            name: 'generate_wordpress_content',
            description: 'Generate WordPress content using AI with customizable prompts and models',
            inputSchema: {
              type: 'object',
              properties: {
                user_prompt: {
                  type: 'string',
                  description: 'The user prompt',
                },
                system_prompt: {
                  type: 'string',
                  description: 'The system prompt',
                },
                ai_model: {
                  type: 'string',
                  description: 'The AI model (default: gpt-4.1-nano)',
                  default: 'gpt-4.1-nano',
                },
              },
              required: ['user_prompt', 'system_prompt'],
            },
          },
          {
            name: 'generate_social_content',
            description: 'Generate social media content using AI with customizable prompts and models',
            inputSchema: {
              type: 'object',
              properties: {
                user_prompt: {
                  type: 'string',
                  description: 'The user prompt',
                },
                system_prompt: {
                  type: 'string',
                  description: 'The system prompt',
                },
                ai_model: {
                  type: 'string',
                  description: 'The AI model (default: gpt-4.1-nano)',
                  default: 'gpt-4.1-nano',
                },
              },
              required: ['user_prompt', 'system_prompt'],
            },
          },
          {
            name: 'get_playwright_mcp',
            description: 'Use GPT-4.1 to remote control a browser via a Playwright MCP server',
            inputSchema: {
              type: 'object',
              properties: {
                prompt: {
                  type: 'string',
                  description: 'The prompt to use for remote control of the browser',
                },
              },
              required: ['prompt'],
            },
          },
          {
            name: 'get_webpage_seo_analysis',
            description: 'Get SEO analysis for a given url',
            inputSchema: {
              type: 'object',
              properties: {
                url: {
                  type: 'string',
                  description: 'The url to analyze',
                },
              },
              required: ['url'],
            },
          },
        ],
      };
    });
  • Shared helper method makeRequest that performs authenticated API calls to FetchSERP, used by the get_keywords_search_volume handler.
    async makeRequest(endpoint, method = 'GET', params = {}, body = null, token = null) {
      const fetchserpToken = token || process.env.FETCHSERP_API_TOKEN;
      
      if (!fetchserpToken) {
        throw new McpError(
          ErrorCode.InvalidRequest,
          'FETCHSERP_API_TOKEN is required'
        );
      }
    
      const url = new URL(`${API_BASE_URL}${endpoint}`);
      
      // Add query parameters for GET requests
      if (method === 'GET' && Object.keys(params).length > 0) {
        Object.entries(params).forEach(([key, value]) => {
          if (value !== undefined && value !== null) {
            if (Array.isArray(value)) {
              value.forEach(v => url.searchParams.append(`${key}[]`, v));
            } else {
              url.searchParams.append(key, value.toString());
            }
          }
        });
      }
    
      const fetchOptions = {
        method,
        headers: {
          'Authorization': `Bearer ${fetchserpToken}`,
          'Content-Type': 'application/json',
        },
      };
    
      if (body && method !== 'GET') {
        fetchOptions.body = JSON.stringify(body);
      }
    
      const response = await fetch(url.toString(), fetchOptions);
      
      if (!response.ok) {
        const errorText = await response.text();
        throw new McpError(
          ErrorCode.InternalError,
          `API request failed: ${response.status} ${response.statusText} - ${errorText}`
        );
      }
    
      return await response.json();
    }
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool 'gets' data, implying a read-only operation, but doesn't specify whether it requires authentication, has rate limits, returns structured data, or handles errors. For a tool with zero annotation coverage, this leaves significant behavioral gaps, though it at least correctly implies a read operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose ('Get search volume'), making it easy to parse. Every word contributes directly to understanding the tool's function, achieving optimal conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'search volume' entails (e.g., monthly searches, trends), the format of the returned data, or any limitations. For a tool with two parameters and no structured output information, more context is needed to guide effective use, resulting in a low score.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description mentions 'keywords' and implies 'search volume', aligning with the 'keywords' parameter in the schema. However, it doesn't address the 'country' parameter or provide additional context beyond what the schema already describes (schema coverage is 100%). Since the schema fully documents both parameters, the description adds minimal value, meeting the baseline score of 3 for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Get search volume for given keywords' clearly states the verb 'Get' and resource 'search volume', specifying what the tool does. It distinguishes from some siblings like 'get_keywords_suggestions' or 'get_long_tail_keywords' by focusing on volume metrics rather than keyword generation or analysis. However, it doesn't explicitly differentiate from all potential overlaps (e.g., 'get_serp_results' might also provide volume data), keeping it at a 4 rather than a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this tool is appropriate, when to choose other keyword-related tools like 'get_keywords_suggestions' or 'get_long_tail_keywords', or any prerequisites. The agent must infer usage from the name and context alone, which is insufficient for clear decision-making.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Related Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/fetchSERP/fetchserp-mcp-server-node'

If you have feedback or need assistance with the MCP directory API, please join our Discord server