DataForSEO MCP Server

Instructions

Implementation Reference

• src/core/modules/dataforseo-labs/tools/google/competitor-research/google-subdomains.ts:5-107 (handler)

  The GoogleSubdomainsTool class implements the tool, including name, description, input schema (getParams), and the handle method that makes the DataForSEO API request to '/v3/dataforseo_labs/google/subdomains/live'.

  export class GoogleSubdomainsTool extends BaseTool {
    constructor(private client: DataForSEOClient) {
      super(client);
    }
  
    getName(): string {
      return 'dataforseo_labs_google_subdomains';
    }
  
    getDescription(): string {
      return `This endpoint will provide you with a list of subdomains of the specified domain, along with the ranking distribution across organic and paid search. In addition to that, you will also get the estimated traffic volume of subdomains based on search volume.`;
    }
  
    getParams(): z.ZodRawShape {
      return {
        target: z.string().describe(`target domain`),
        location_name: z.string().default("United States").describe(`full name of the location
  required field
  in format "Country"
  example:
  United Kingdom`),
        language_code: z.string().default("en").describe(
          `language code
          required field
          example:
          en`),
        ignore_synonyms: z.boolean().default(true).describe(
            `ignore highly similar keywords, if set to true, results will be more accurate`),
        limit: z.number().min(1).max(1000).default(10).optional().describe("Maximum number of keywords to return"),
        offset: z.number().min(0).optional().describe(
          `offset in the results array of returned keywords
          optional field
          default value: 0
          if you specify the 10 value, the first ten keywords in the results array will be omitted and the data will be provided for the successive keywords`
        ),
        filters: z.array(
          z.union([
            z.array(z.union([z.string(), z.number(), z.boolean()])).length(3),
            z.enum(["and", "or"])
          ])
        ).max(8).optional().describe(
          `you can add several filters at once (8 filters maximum)
          you should set a logical operator and, or between the conditions
          the following operators are supported:
          regex, not_regex, <, <=, >, >=, =, <>, in, not_in, match, not_match, ilike, not_ilike, like, not_like
          you can use the % operator with like and not_like, as well as ilike and not_ilike to match any string of zero or more characters
          merge operator must be a string and connect two other arrays, availible values: or, and.
          example:
          ["metrics.organic.count",">",50]
          [["metrics.organic.pos_1","<>",0],"and",["metrics.organic.impressions_etv",">=","10"]]
          [[["metrics.organic.count",">=",50],"and",["metrics.organic.pos_1","in",[1,5]]],"or",["metrics.organic.etv",">=","100"]]`
        ),
        order_by: z.array(z.string()).optional().describe(
          `results sorting rules
  optional field
  you can use the same values as in the filters array to sort the results
  possible sorting types:
  asc – results will be sorted in the ascending order
  desc – results will be sorted in the descending order
  you should use a comma to specify a sorting type
  example:
  ["metrics.paid.etv,asc"]
  Note: you can set no more than three sorting rules in a single request
  you should use a comma to separate several sorting rules
  example:
  ["metrics.organic.etv,desc","metrics.paid.count,asc"]
  default rule:
  ["metrics.organic.count,desc"]`
        ),
        item_types: z.array(z.string()).optional().describe(
          `item types to return
          optional field
          default: ['organic']
          possible values:
          organic
          paid`
        ),
        include_clickstream_data: z.boolean().optional().default(false).describe(
          `Include or exclude data from clickstream-based metrics in the result`)
  
      };
    }
  
    async handle(params: any): Promise<any> {
      try {
        const response = await this.client.makeRequest('/v3/dataforseo_labs/google/subdomains/live', 'POST', [{
          target: params.target,
          location_name: params.location_name,
          language_code: params.language_code,
          ignore_synonyms: params.ignore_synonyms,
          filters: this.formatFilters(params.filters),
          order_by: this.formatOrderBy(params.order_by),
          exclude_top_domains: params.exclude_top_domains,
          item_types: params.item_types,
          include_clickstream_data: params.include_clickstream_data,
          limit: params.limit,
          offset: params.offset
        }]);
        return this.validateAndFormatResponse(response);
      } catch (error) {
        return this.formatErrorResponse(error);
      }
    }

• src/core/modules/dataforseo-labs/dataforseo-labs-api.module.ts:29-62 (registration)

  The DataForSEOLabsApi module registers the GoogleSubdomainsTool by instantiating it and adding to the tools record returned by getTools(), mapping name to description, params, and handler.

  getTools(): Record<string, ToolDefinition> {
    const tools = [
      new GoogleRankedKeywordsTool(this.dataForSEOClient),
      new GoogleDomainCompetitorsTool(this.dataForSEOClient),
      new GoogleDomainRankOverviewTool(this.dataForSEOClient),
      new GoogleKeywordsIdeasTool(this.dataForSEOClient),
      new GoogleRelatedKeywordsTool(this.dataForSEOClient),
      new GoogleKeywordsSuggestionsTool(this.dataForSEOClient),
      new GoogleHistoricalSERP(this.dataForSEOClient),
      new GoogleSERPCompetitorsTool(this.dataForSEOClient),
      new GoogleBulkKeywordDifficultyTool(this.dataForSEOClient),
      new GoogleSubdomainsTool(this.dataForSEOClient),
      new GoogleKeywordOverviewTool(this.dataForSEOClient),
      new GoogleTopSearchesTool(this.dataForSEOClient),
      new GoogleSearchIntentTool(this.dataForSEOClient),
      new GoogleKeywordsForSiteTool(this.dataForSEOClient),
      new GoogleDomainIntersectionsTool(this.dataForSEOClient),
      new GoogleHistoricalDomainRankOverviewTool(this.dataForSEOClient),
      new GooglePageIntersectionsTool(this.dataForSEOClient),
      new GoogleBulkTrafficEstimationTool(this.dataForSEOClient),
      new DataForSeoLabsFilterTool(this.dataForSEOClient),
      new GoogleHistoricalKeywordDataTool(this.dataForSEOClient),
      // Add more tools here
    ];
  
    return tools.reduce((acc, tool) => ({
      ...acc,
      [tool.getName()]: {
        description: tool.getDescription(),
        params: tool.getParams(),
        handler: (params: any) => tool.handle(params),
      },
    }), {});
  }

• src/core/modules/dataforseo-labs/tools/labs-filters.tool.ts:24-56 (helper)

  Mapping of the tool name to its filter path 'subdomains.google' used in the labs filters tool for providing filter information.

  private static readonly TOOL_TO_FILTER_MAP: { [key: string]: string } = {
    'dataforseo_labs_google_ranked_keywords': 'ranked_keywords.google',
    'dataforseo_labs_google_keyword_ideas': 'keyword_ideas.google',
    'dataforseo_labs_google_keywords_for_site': 'keywords_for_site.google',
    'dataforseo_labs_google_competitors_domain': 'competitors_domain.google',
    'dataforseo_labs_google_serp_competitors': 'serp_competitors.google',
    'dataforseo_labs_google_subdomains': 'subdomains.google',
    'dataforseo_labs_google_domain_intersection': 'domain_intersection.google',
    'dataforseo_labs_google_page_intersection': 'page_intersection.google',
    'dataforseo_labs_google_historical_serp': 'historical_serp.google',
    'dataforseo_labs_google_historical_rank_overview': 'domain_rank_overview.google',
    'dataforseo_labs_google_relevant_pages': 'relevant_pages.google',
    'dataforseo_labs_google_top_searches': 'top_searches.google',
    'dataforseo_labs_google_keyword_overview': 'keyword_overview.google',
    'dataforseo_labs_google_search_intent': 'search_intent.google',
    'dataforseo_labs_google_bulk_keyword_difficulty': 'bulk_keyword_difficulty.google',
    'dataforseo_labs_google_related_keywords': 'related_keywords.google',
    'dataforseo_labs_google_keyword_suggestions': 'keyword_suggestions.google',
    'dataforseo_labs_google_domain_rank_overview': 'domain_rank_overview.google',
    'dataforseo_labs_google_domain_metrics_by_categories': 'domain_metrics_by_categories.google',
    'dataforseo_labs_google_domain_whois_overview': 'domain_whois_overview.google',
    'dataforseo_labs_google_categories_for_domain': 'categories_for_domain.google',
    'dataforseo_labs_google_keywords_for_categories': 'keywords_for_categories.google',
    'dataforseo_labs_amazon_product_competitors': 'product_competitors.amazon',
    'dataforseo_labs_amazon_product_keyword_intersections': 'product_keyword_intersections.amazon',
    'dataforseo_labs_google_app_competitors': 'app_competitors.google',
    'dataforseo_labs_apple_app_competitors': 'app_competitors.apple',
    'dataforseo_labs_google_app_intersection': 'app_intersection.google',
    'dataforseo_labs_apple_app_intersection': 'app_intersection.apple',
    'dataforseo_labs_google_keywords_for_app': 'keywords_for_app.google',
    'dataforseo_labs_apple_keywords_for_app': 'keywords_for_app.apple',
    'dataforseo_labs_database_rows_count': 'database_rows_count'
  };