Cómo hacer un análisis de brecha de palabras clave con un MCP server

La mayoría de las herramientas de investigación de keywords responden a la pregunta equivocada. Te dicen lo difícil que es un término en una escala del 1 al 100, que es el resumen de un resumen. Lo que de verdad necesitas saber es quién ocupa el top ten y qué tipo de páginas son, porque eso determina si la posición se puede tomar siquiera.

Esta guía monta ese análisis como un pipeline reproducible sobre una conexión MCP. Es el método exacto detrás de nuestro estudio SERP de web scraping de 2026, incluido el error que invalida casi toda la investigación de keywords casera.

Tabla de contenidos

• Las tres fases
• El error que convierte la investigación de keywords en ficción
• Fase 1: descubrir términos candidatos
• Fase 2: extraer posiciones orgánicas reales
• Fase 3: clasificar los tipos de página
• Puntuar la brecha
• Comprobar la intención antes de comprometerte
• Coste en credits y tiempo de ejecución
• Ejecutarlo desde la API REST
• Preguntas frecuentes

Las tres fases

La fase 3 suele ser criterio propio más que una llamada a una tool: estás etiquetando nueve URLs, y eso va más rápido a ojo que por API.

El error que convierte la investigación de keywords en ficción

Empieza por aquí, porque invalida todo lo que viene después.

El orden de resultados de una API de búsqueda no es el ranking de Google. Las herramientas de búsqueda recuperan resultados y luego los reordenan. El search_web de CrawlForge reordena lo que recupera con pesos de BM25, similitud semántica, autoridad y frescura, y lo reporta exactamente así en su respuesta:

{
  "processing": {
    "ranking": {
      "algorithmsUsed": ["bm25", "semantic", "authority", "freshness"],
      "weightsApplied": { "bm25": 0.4, "semantic": 0.3, "authority": 0.2, "freshness": 0.1 }
    }
  }
}

Ese reordenamiento hace que los resultados sean mejores para investigar e inservibles como medición de ranking. Si lees la posición 1 de una API de búsqueda y la registras como un ranking de Google, toda conclusión construida encima está mal.

Usa search_web para saber qué dominios están en juego. Usa serp_rank — que devuelve el propio valor rank_group de Google — para cualquier cosa que vayas a llamar posición.

Fase 1: descubrir términos candidatos

Abre mucho el foco primero. Estás buscando el vocabulario de la categoría, todavía no rankings.

import { Client } from '@modelcontextprotocol/sdk/client/index.js';

const client = new Client({ name: 'keyword-gap', version: '1.0.0' });

interface Candidate {
  keyword: string;
  indexedPages: number;
  domains: string[];
}

async function discover(keyword: string): Promise<Candidate> {
  const res = await client.callTool({
    name: 'search_web',
    arguments: { query: keyword, limit: 20 },
  });

  const data = JSON.parse(res.content[0].text);

  return {
    keyword,
    // Google's rough index estimate -- a crowding signal, NOT search volume.
    indexedPages: parseInt(data.total_results ?? '0', 10),
    // Presence only. This order is re-ranked and is not a Google ranking.
    domains: [...new Set(data.results.map((r) => r.displayLink))],
  };
}

Importan dos campos. total_results es el recuento aproximado de Google de páginas que compiten: una señal de saturación, no de volumen. La lista de dominios te dice quién está en la conversación.

Fase 2: extraer posiciones orgánicas reales

Ahora mide. serp_rank lanza una consulta en vivo a Google y devuelve posiciones orgánicas reales, además del listado de competidores.

interface RankResult {
  keyword: string;
  found: boolean;
  position: number | null;
  competitors: Array<{ position: number; domain: string; url: string }>;
}

async function measure(keyword: string, target: string): Promise<RankResult> {
  const res = await client.callTool({
    name: 'serp_rank',
    arguments: {
      keyword,
      target,
      location_name: 'United States',
      device: 'desktop',
      depth: 10,
    },
  });

  const data = JSON.parse(res.content[0].text);

  // Unconfigured deployments return configured:false rather than a fake rank.
  if (data.configured === false) {
    throw new Error('serp_rank is not configured on this server');
  }

  return {
    keyword,
    found: data.found,
    position: data.position,
    competitors: (data.results ?? []).map((r) => ({
      position: r.position,
      domain: r.domain,
      url: r.url,
    })),
  };
}

Ejecútalas de forma secuencial, no en paralelo. El endpoint SERP en vivo lanza una consulta real a Google; disparar varias a la vez produce timeouts de forma fiable, no resultados más rápidos.

depth: 10 es el valor por defecto correcto. Escanear más hondo cuesta más y, para un análisis de brecha, las posiciones de la 11 en adelante rara vez cambian la decisión.

Fase 3: clasificar los tipos de página

Esta es la fase que produce el hallazgo de verdad, y es sobre todo criterio.

Para cada uno de los nueve o diez resultados, etiqueta qué tipo de página es:

• Comercial — home, página de producto, página de precios
• Contenido de proveedor — artículo de blog o documentación de una empresa
• Independiente — directorio, hilo de foro, repositorio de código, noticia

Después cuenta los resultados comerciales. Ese único número te dice más que cualquier puntuación de dificultad:

type PageType = 'commercial' | 'vendor-content' | 'independent';

function gapScore(labels: PageType[]): 'closed' | 'contested' | 'open' {
  const commercial = labels.filter((l) => l === 'commercial').length;
  if (commercial >= 4) return 'closed';
  if (commercial >= 1) return 'contested';
  return 'open';
}

Aplicado a datos reales de nuestro estudio:

"web scraping api" está cerrado: seis homes y páginas de producto de proveedores, cada una respaldada por años de construcción de enlaces. Ninguna cantidad de calidad de contenido mueve eso.

"firecrawl alternative" cae en medio. Solo dos resultados son landings comerciales, la página de alternativas de Apify y una página de comparación de Context, pero el resto está denso de artículos de blog de proveedores persiguiendo todos a los mismos clientes que se van. Ganable, saturado, y merece el esfuerzo solo si tienes algo concreto que decir.

"mcp scraping" puntúa como abierto, y la composición explica por qué: dos directorios, un hilo de Reddit, un repositorio de GitHub, tres blogs ajenos y una página de documentación. Nadie ha publicado una página comercial para él.

Puntuar la brecha

Combina las dos señales. Un término merece la pena cuando la SERP está abierta y la saturación es manejable:

interface Scored {
  keyword: string;
  verdict: 'closed' | 'contested' | 'open';
  indexedPages: number;
  priority: 'high' | 'medium' | 'skip';
}

function prioritise(c: Candidate, verdict: Scored['verdict']): Scored['priority'] {
  if (verdict === 'closed') return 'skip';
  if (verdict === 'open' && c.indexedPages < 2_000_000) return 'high';
  return 'medium';
}

El umbral es una decisión de criterio, no una ley. Lo que importa es el orden: una SERP abierta con saturación moderada le gana a una SERP disputada con saturación baja, siempre.

Comprobar la intención antes de comprometerte

Un último filtro, y no se puede automatizar.

Lee los títulos del top ten y pregúntate si esa gente quiere comprar lo que vendes. En nuestro estudio, "llm scraper" pasó todos los filtros numéricos — 329.000 páginas compitiendo, claramente del tema — y falló al contacto con los resultados. Buena parte era gente intentando bloquear scrapers: un hilo de YunoHost titulado "Prevent LLM scrapers/trawlers?", un hilo de r/sysadmin sobre cómo combatirlos, Akamai sobre gestión de bots.

Las mismas palabras, la intención opuesta. Posicionar ahí te gana tráfico que nunca convierte y una tasa de rebote que le enseña a Google que tu página es una mala respuesta.

Treinta segundos de lectura pillan lo que ninguna puntuación puede.

Coste en credits y tiempo de ejecución

Un estudio de diez keywords:

Eso es una décima parte de los 1.000 credits de un solo uso del plan Free.

El tiempo de ejecución es la restricción real. Las consultas SERP en vivo tardaron entre 10 y 41 segundos cada una en nuestras mediciones — la misma keyword varió de 11 a 28 segundos entre ejecuciones consecutivas, porque el endpoint lanza una consulta real a Google cuya latencia depende de la capacidad del proveedor. Diez keywords en secuencia son entre cinco y diez minutos. Pon un timeout de cliente de al menos 60 segundos y ejecuta el trabajo en segundo plano.

Ejecutarlo desde la API REST

Si no estás dentro de un cliente MCP, la misma consulta funciona sobre HTTP:

curl -X POST https://www.crawlforge.dev/api/v1/tools/serp_rank \
  -H "X-API-Key: $CRAWLFORGE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "mcp scraping",
    "target": "crawlforge.dev",
    "location_name": "United States",
    "depth": 10
  }'

La respuesta REST usa rank y all_positions donde la tool MCP devuelve position; ambas reportan la misma posición orgánica de Google por debajo. Las consultas fallidas — un proveedor inalcanzable, un timeout — devuelven un error y no se cobran.

Hacia dónde seguir

Una vez sabes qué términos están abiertos, el trabajo siguiente es técnico: asegurarte de que las páginas que publiques para ellos sean rastreables y estén bien marcadas. Nuestra guía para automatizar auditorías SEO con CrawlForge cubre esa mitad, y la referencia de la API de serp_rank documenta todos los parámetros usados arriba.

Empieza gratis con 1.000 credits — suficiente para unas 200 comprobaciones de posición.