RouterGrowth

Datos y acciones de GTM para agentes de IA: SEO, enriquecimiento de leads, investigación social y divulgación a través de un servidor MCP de pago por llamada.

Ver en routergrowth.comPrueba este MCPPatrocinado

Servidor MCP alojado

npx add-mcp 'https://api.routergrowth.com/mcp'

Se instala en Claude Code, Codex, Cursor y más

Documentación

Inicio rápido: servidor MCP

Conecta el servidor MCP de RouterGrowth a Claude Code, claude.ai, ChatGPT, Cursor, VS Code o a tu propio agente en la API de Claude u OpenAI: datos de SERP, backlinks y palabras clave, enriquecimiento de contactos B2B y de empresas, scraping social y outreach como herramientas nativas con un solo saldo.

RouterGrowth habla el Protocolo de Contexto de Modelo (MCP): conéctate una vez y tu agente obtiene el bucle de descubrir, inspeccionar y ejecutar como herramientas nativas, con las reglas de gasto entregadas en el handshake. Nada que instalar.

https://api.routergrowth.com/mcp

Transporte: HTTP Streamable, sin estado. Cada solicitud es un POST respondido con una respuesta JSON: no hay sesión que mantener viva, ni stream que mantener abierto.
Inicio de sesión: OAuth (inicia sesión una vez en el navegador y aprueba un espacio de trabajo) o una clave API enviada como Authorization: Bearer rg_live_.... Ambos llegan al mismo espacio de trabajo, monedero y códigos de error.
Herramientas: once, listadas en Las herramientas.

Elige tu configuración

claude.ai, Claude Desktop, Claude móvil: conector personalizado, OAuth.
ChatGPT: modo desarrollador, OAuth.
Mistral Vibe (Le Chat), Perplexity, Manus: otras aplicaciones de chat, OAuth o clave.
Claude Code: claude mcp add, OAuth o clave.
Codex: codex mcp add, OAuth o clave.
Hermes Agent: mcp_servers en config.yaml, OAuth o clave.
Cursor, VS Code, Gemini CLI, Cline, Zed, Devin Desktop (Windsurf), Goose, Kiro, JetBrains, Warp: clientes IDE y CLI, OAuth o clave.
Tu propio agente en la API de Claude, Claude Managed Agents o el SDK de Claude Agent: plataforma Claude, clave.
Tu propio agente en la API de OpenAI o el SDK de OpenAI Agents: plataforma OpenAI, clave.
LangChain, LangGraph, Vercel AI SDK, Google ADK, LlamaIndex, CrewAI, Mastra: frameworks de agentes, clave.
n8n, Make, Zapier, Microsoft Copilot Studio, Dify y otros constructores sin código: constructores sin código, clave u OAuth.
Un cliente que solo inicia servidores locales (stdio): puente mcp-remote, clave u OAuth.
Cualquier otra cosa: cualquier cliente MCP, clave.

¿No estás seguro de dónde se ejecutará el agente? Usa una clave: todo cliente MCP que pueda enviar un encabezado funciona con ella. Luego prueba la conexión desde la máquina o plataforma donde se ejecuta el agente.

Antes de conectar

Inicia sesión en el panel con Google, GitHub, una contraseña o un código enviado por correo. Un nuevo espacio de trabajo comienza con $1 de crédito una vez que tu correo esté verificado.
Para una configuración basada en clave, crea una clave en API keys. Usa una clave activa (rg_live_...) para datos reales: una clave de prueba (rg_test_...) devuelve datos simulados claramente etiquetados.
Mantén la clave en el almacén de secretos de tu plataforma o en una variable de entorno, nunca en un archivo versionado.

Las configuraciones OAuth no necesitan nada de esto de antemano: la página de inicio de sesión crea el espacio de trabajo en la primera conexión.

Aplicaciones de chat

claude.ai, Claude Desktop y Claude móvil

Abre Customize → Connectors, selecciona + y elige Add custom connector.
Nómbralo RouterGrowth, pega https://api.routergrowth.com/mcp como URL y agrégalo.
Selecciona Connect, inicia sesión en la página de RouterGrowth (contraseña, Google, GitHub o un código enviado por correo) y aprueba el espacio de trabajo.
En un chat, activa RouterGrowth desde el menú de herramientas y pide a Claude que verifique tu saldo de RouterGrowth. Esa llamada es gratuita.

En los planes Team y Enterprise, un propietario agrega el conector primero en Organization settings → Connectors → Add → Custom → Web; luego los miembros seleccionan Connect en Customize → Connectors e inician sesión con su propia cuenta de RouterGrowth. El plan Free permite un conector personalizado. Un conector agregado en claude.ai también aparece en Claude Desktop y las aplicaciones móviles. Aprobar otorga un solo alcance, mcp: las herramientas y el saldo del espacio de trabajo que elegiste, nada más.

Las organizaciones con la beta de encabezados de solicitud pueden elegir No sign-in y agregar el encabezado authorization con el valor Bearer rg_live_... en su lugar; todos en la organización comparten entonces el espacio de trabajo de esa clave.

ChatGPT

ChatGPT se conecta solo mediante OAuth: no puede enviar una clave API.

Abre Settings → Security and login y activa Developer mode. Está en la web para Plus, Pro, Business, Enterprise y Edu; en Business, Enterprise y Edu un administrador del espacio de trabajo lo habilita primero.
Ve a Plugins, selecciona + y nombra el plugin RouterGrowth.
En Connection, ingresa https://api.routergrowth.com/mcp, elige OAuth y créalo.
Inicia sesión en la página de RouterGrowth y aprueba el espacio de trabajo cuyas herramientas y saldo quieres usar.
En un chat nuevo, abre el menú +, elige Developer mode, selecciona RouterGrowth y pídele que verifique tu saldo.

ChatGPT te pide confirmar cada llamada a una herramienta que pueda gastar (run, batch_run, watch); las herramientas de lectura gratuitas se ejecutan sin preguntar. La conexión se mantiene en chats posteriores, donde la seleccionas de nuevo. La guía de conexión de OpenAI tiene las pantallas actuales.

Otras aplicaciones de chat

Mistral Vibe (antes Le Chat): Connectors → + Add Connector → Custom MCP Connector, nombra RouterGrowth, la URL, luego Connect e inicia sesión con OAuth. Solo un administrador puede agregar conectores.
Perplexity: Settings → Connectors → + Custom connector → Remote, la URL, Streamable HTTP y autenticación API Key con tu clave. Prefiere la clave: se informa que la opción OAuth de Perplexity falla con servidores que no emiten secreto de cliente, como hace RouterGrowth.
Manus: Settings → Integrations → Custom MCP Servers, la URL y tu clave como token de portador.

Agentes de codificación

Claude Code

claude mcp add --transport http routergrowth https://api.routergrowth.com/mcp

Luego inicia sesión: escribe /mcp dentro de Claude Code, elige routergrowth y selecciona Authenticate (las versiones recientes también aceptan claude mcp login routergrowth desde la shell). Tu navegador abre la página de consentimiento de RouterGrowth; aprueba el espacio de trabajo y Claude Code almacena el token y lo refresca por sí solo. Agrega --scope project para compartir el servidor a través de .mcp.json: cada compañero inicia sesión con su propia cuenta, así nada secreto termina en el archivo.

Con una clave en su lugar (CI, una máquina sin interfaz, un script):

claude mcp add --transport http routergrowth https://api.routergrowth.com/mcp \
  --header "Authorization: Bearer rg_live_..."

En un .mcp.json compartido, referencia una variable de entorno en lugar de pegar la clave: "headers": {"Authorization": "Bearer ${ROUTERGROWTH_API_KEY}"}. Claude Code nunca ofrece OAuth para un servidor que ya envía un encabezado Authorization, así que elimina el encabezado para volver a OAuth.

Codex

codex mcp add routergrowth --url https://api.routergrowth.com/mcp

Codex encuentra el servidor OAuth y abre la página de consentimiento de inmediato; codex mcp login routergrowth inicia sesión de nuevo más tarde, y codex mcp list muestra si el servidor está autenticado. La CLI y la extensión del IDE comparten ~/.codex/config.toml.

Con una clave en su lugar, mantén la clave simple (sin prefijo Bearer) en una variable de entorno; Codex la lee al inicio, así el archivo de configuración nunca la contiene:

export ROUTERGROWTH_API_KEY=rg_live_...
codex mcp add routergrowth --url https://api.routergrowth.com/mcp --bearer-token-env-var ROUTERGROWTH_API_KEY

Hermes Agent

Agrega el servidor al config.yaml del perfil (~/.hermes/config.yaml, o ~/.hermes/profiles/<name>/config.yaml para un perfil con nombre). Cada perfil tiene su propia configuración e inicia sesión por separado.

mcp_servers:
  routergrowth:
    url: "https://api.routergrowth.com/mcp"
    auth: oauth

Inicia Hermes en ese perfil una vez en una terminal. Se registra, imprime una URL de autorización y espera en un puerto de loopback. Abre la URL en tu navegador, inicia sesión en la página de RouterGrowth y aprueba el espacio de trabajo. Hermes almacena el token y lo refresca por sí solo; pide al agente que verifique tu saldo de RouterGrowth para confirmar.

Cuando Hermes se ejecuta en un servidor y tu navegador está en otra máquina, la redirección final a http://127.0.0.1:<port>/callback no puede alcanzarlo. Dos formas de resolverlo:

Túnel primero: reenvía el puerto mostrado en el redirect_uri de la URL de autorización antes de aprobar, y la redirección llega por sí sola.

ssh -L <port>:127.0.0.1:<port> <user>@<server>

Reproducir la redirección: aprueba, copia la dirección http://127.0.0.1:<port>/callback?code=... de la barra de direcciones del navegador y solicítala en el servidor desde una segunda shell mientras Hermes aún espera.

curl -s "http://127.0.0.1:<port>/callback?code=...&state=...&iss=..."

El código en esa dirección funciona una vez y expira después de 5 minutos. Inicia sesión antes de programar el perfil con cron: una ejecución de cron no puede completar el paso del navegador. Ejecuta un proceso de Hermes por perfil, porque dos procesos que comparten un token de refresco almacenado se invalidan mutuamente cuando rota.

Con una clave en su lugar:

mcp_servers:
  routergrowth:
    url: "https://api.routergrowth.com/mcp"
    headers:
      Authorization: "Bearer rg_live_..."

Clientes IDE y CLI

Cada cliente nombra sus campos de manera diferente, así que copia el bloque para el tuyo. Donde OAuth sea compatible, omite el encabezado: el cliente encuentra la página de inicio de sesión de RouterGrowth por sí solo.

Cursor: .cursor/mcp.json en el proyecto, o ~/.cursor/mcp.json para cada proyecto. Sin headers, Cursor inicia sesión a través del navegador.

{
  "mcpServers": {
    "routergrowth": {
      "url": "https://api.routergrowth.com/mcp",
      "headers": {"Authorization": "Bearer ${env:ROUTERGROWTH_API_KEY}"}
    }
  }
}

VS Code y GitHub Copilot: .vscode/mcp.json. Los servidores viven bajo servers y necesitan "type": "http". VS Code pide la clave una vez y la almacena; sin headers y inputs, se registra por sí solo y abre la página de inicio de sesión de RouterGrowth en su lugar.

{
  "inputs": [
    {
      "type": "promptString",
      "id": "routergrowth-key",
      "description": "RouterGrowth API key",
      "password": true
    }
  ],
  "servers": {
    "routergrowth": {
      "type": "http",
      "url": "https://api.routergrowth.com/mcp",
      "headers": {"Authorization": "Bearer ${input:routergrowth-key}"}
    }
  }
}

Gemini CLI: agrega el servidor, luego ejecuta /mcp auth routergrowth dentro de Gemini CLI para iniciar sesión. Para una clave, agrega -H "Authorization: Bearer rg_live_..." al comando. Agrega -s user para registrarlo para cada proyecto en lugar del actual.

gemini mcp add -t http routergrowth https://api.routergrowth.com/mcp

Cline: MCP Servers → Configure → Configure MCP Servers. Cline necesita "type": "streamableHttp": rechaza "http", y sin un tipo vuelve al transporte SSE antiguo, que RouterGrowth no sirve.

{
  "mcpServers": {
    "routergrowth": {
      "type": "streamableHttp",
      "url": "https://api.routergrowth.com/mcp",
      "headers": {"Authorization": "Bearer rg_live_..."}
    }
  }
}

Zed: settings.json, o Settings → AI → MCP Servers → Add Remote Server. La clave es context_servers, no mcpServers; sin headers, Zed inicia sesión con OAuth.

{
  "context_servers": {
    "routergrowth": {
      "url": "https://api.routergrowth.com/mcp",
      "headers": {"Authorization": "Bearer rg_live_..."}
    }
  }
}

Otros clientes:

Cliente	Dónde	OAuth	Clave
Devin Desktop (Windsurf)	`devin mcp add -s user routergrowth <url>`	`devin mcp login routergrowth`	`headers` en su configuración MCP
Goose	`goose configure` → Add Extension → Remote Extension (Streamable HTTP)	automático	mapa `headers`
Kiro	`.kiro/settings/mcp.json`, `mcpServers`	automático	`url` + `headers`
Junie (JetBrains)	`.junie/mcp/mcp.json`	`/mcp` → Authorize	`url` + `headers`
JetBrains AI Assistant	Settings → Tools → AI Assistant → Model Context Protocol (MCP)	no	mcp-remote
Warp	Settings → Agents → MCP servers → Add	automático	`url` + `headers`
Amazon Q Developer (IDE)	icono de herramientas de chat → add → transporte `http`	automático	campo Headers

Clientes que solo inician servidores locales

Algunos clientes solo pueden lanzar un servidor local (stdio), por ejemplo claude_desktop_config.json en Claude Desktop o JetBrains AI Assistant. Conéctalos con mcp-remote, que se ejecuta localmente y reenvía a RouterGrowth:

{
  "mcpServers": {
    "routergrowth": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://api.routergrowth.com/mcp",
               "--header", "Authorization:${RG_AUTH}"],
      "env": {"RG_AUTH": "Bearer rg_live_..."}
    }
  }
}

Mantén Authorization:${RG_AUTH} sin espacio: algunos clientes dividen los argumentos por espacios. Omite los dos argumentos --header para iniciar sesión con OAuth en su lugar; mcp-remote abre el navegador y mantiene el token en ~/.mcp-auth. En Claude Desktop, la configuración de Connectors es más simple; usa el puente solo cuando se requiera una configuración local.

Tu propio agente

Para un agente que ejecutas en código, pasa la clave desde tu almacén de secretos. Ninguno de estos necesita un navegador.

API de Claude

La API de Messages se conecta a servidores MCP por ti (encabezado beta mcp-client-2025-11-20). Pasa la clave como authorization_token y referencia el servidor desde un mcp_toolset:

import os
import anthropic

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    betas=["mcp-client-2025-11-20"],
    mcp_servers=[{
        "type": "url",
        "url": "https://api.routergrowth.com/mcp",
        "name": "routergrowth",
        "authorization_token": os.environ["ROUTERGROWTH_API_KEY"],
    }],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "routergrowth"}],
    messages=[{"role": "user", "content": "Check my RouterGrowth balance."}],
)

El conector se ejecuta en la API de Claude, Claude Platform en AWS y Microsoft Foundry. En Amazon Bedrock y Google Vertex AI, ejecuta un cliente MCP tú mismo, como en frameworks de agentes.

Claude Managed Agents

Declara el servidor en el agente (sin credencial allí), luego almacena la clave en un vault como una credencial static_bearer para la misma URL y adjunta el vault cuando inicies una sesión:

agent = client.beta.agents.create(
    name="GTM research",
    model="claude-opus-5",
    mcp_servers=[{"type": "url", "name": "routergrowth", "url": "https://api.routergrowth.com/mcp"}],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "routergrowth"}],
)
vault = client.beta.vaults.create(display_name="RouterGrowth")
client.beta.vaults.credentials.create(
    vault_id=vault.id,
    display_name="RouterGrowth API key",
    auth={"type": "static_bearer", "mcp_server_url": "https://api.routergrowth.com/mcp",
          "token": os.environ["ROUTERGROWTH_API_KEY"]},
)
session = client.beta.sessions.create(agent=agent.id, environment_id=environment.id, vault_ids=[vault.id])

Las herramientas MCP piden aprobación antes de cada llamada por defecto (always_ask); establece una política de permisos en el conjunto de herramientas para cambiar eso. En un entorno con redes limited, establece allow_mcp_servers: true o el agente no podrá alcanzar el servidor.

SDK de Claude Agent

import asyncio
import os
from claude_agent_sdk import ClaudeAgentOptions, query

options = ClaudeAgentOptions(
    mcp_servers={
        "routergrowth": {
            "type": "http",
            "url": "https://api.routergrowth.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['ROUTERGROWTH_API_KEY']}"},
        }
    },
    allowed_tools=["mcp__routergrowth__*"],
)

async def main():
    async for message in query(prompt="Check my RouterGrowth balance.", options=options):
        print(message)

asyncio.run(main())

El SDK no ejecuta el flujo OAuth, así que pasa la clave en headers. allowed_tools permite que el agente llame a cada herramienta de RouterGrowth sin preguntar; lista herramientas individuales (mcp__routergrowth__discover, mcp__routergrowth__inspect,...) para mantener las llamadas de pago detrás de una verificación de permisos.

API de Respuestas de OpenAI y SDK de Agents

La API de Respuestas llama al servidor desde el lado de OpenAI. Envía la clave en headers en cada solicitud (OpenAI no la almacena):

import os
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    tools=[{
        "type": "mcp",
        "server_label": "routergrowth",
        "server_url": "https://api.routergrowth.com/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['ROUTERGROWTH_API_KEY']}"},
        "require_approval": "never",
    }],
    input="Check my RouterGrowth balance.",
)

Con el SDK de Agents de OpenAI, la conexión se ejecuta en tu proceso. Aumenta client_session_timeout_seconds: su valor predeterminado de 5 segundos corta cualquier ejecución de pago que tarde más.

import asyncio
import os
from agents import Agent, Runner
from agents.mcp import MCPServerStreamableHttp

async def main():
    async with MCPServerStreamableHttp(
        name="routergrowth",
        params={
            "url": "https://api.routergrowth.com/mcp",
            "headers": {"Authorization": f"Bearer {os.environ['ROUTERGROWTH_API_KEY']}"},
            "timeout": 30,
        },
        client_session_timeout_seconds=120,
        cache_tools_list=True,
    ) as routergrowth:
        agent = Agent(name="GTM research", mcp_servers=[routergrowth])
        result = await Runner.run(agent, "Check my RouterGrowth balance.")
        print(result.final_output)

asyncio.run(main())

Frameworks de agentes

LangChain y LangGraph (pip install "langchain[mcp]"):

import os
from fastmcp.client import Client
from langchain.mcp import MCPAdapter

async with MCPAdapter(Client("https://api.routergrowth.com/mcp",
                             auth=os.environ["ROUTERGROWTH_API_KEY"])) as routergrowth:
    tools = await routergrowth.list_tools()
    # pass tools to create_agent(...) and run the agent inside this block

En el langchain-mcp-adapters más antiguo, usa MultiServerMCPClient({"routergrowth": {"transport": "http", "url": "https://api.routergrowth.com/mcp", "headers": {"Authorization": "Bearer rg_live_..."}}}).

SDK de IA de Vercel:

import { createMCPClient } from "@ai-sdk/mcp";

const routergrowth = await createMCPClient({
  transport: {
    type: "http",
    url: "https://api.routergrowth.com/mcp",
    headers: { Authorization: \`Bearer ${process.env.ROUTERGROWTH_API_KEY}\` },
  },
});
const tools = await routergrowth.tools();

Google ADK:

import os
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams

routergrowth = McpToolset(connection_params=StreamableHTTPConnectionParams(
    url="https://api.routergrowth.com/mcp",
    headers={"Authorization": f"Bearer {os.environ['ROUTERGROWTH_API_KEY']}"},
    timeout=30,
    sse_read_timeout=300,
))
# any Gemini model works here
agent = LlmAgent(model="gemini-2.5-flash", name="gtm_research", tools=[routergrowth])

Más frameworks, misma URL y cabecera:

Framework	Conectar con	Cuidado con
LlamaIndex	`McpToolSpec(client=BasicMCPClient(url, headers=headers, timeout=60))`	nada especial
CrewAI	`MCPServerHTTP(url=url, headers=headers, streamable=True)` en `mcps=[...]`	un límite de llamada de 30 segundos, y una llamada con tiempo agotado se reintenta: mantén `wait_seconds` en 20 o menos
Mastra	`new MCPClient({servers: {routergrowth: {url: new URL(url), requestInit: {headers}}}})`	1.x reporta un error SSE cuando el primer intento falla; verifica la clave primero

Cualquier SDK oficial de MCP: los SDK de TypeScript y Python se conectan con su transporte de cliente HTTP Streamable y una cabecera Authorization. Ambos también ejecutan el flujo OAuth completo cuando les proporcionas un proveedor OAuth.

Constructores de agentes sin código

n8n: añade una Herramienta de Cliente MCP a tu nodo de Agente de IA. Establece el endpoint a https://api.routergrowth.com/mcp, el transporte a HTTP Streamable, y la autenticación a Bearer Auth con tu clave (o MCP OAuth2, que se registra solo, en n8n 1.119 y posteriores). El nodo da a una llamada 60 segundos por defecto.

Microsoft Copilot Studio: en tu agente, Herramientas → Añadir una herramienta → Nueva herramienta → Model Context Protocol. Introduce la URL del servidor, luego elige OAuth 2.0 → Descubrimiento dinámico, o clave API como una cabecera llamada Authorization con el valor Bearer rg_live_.... El modo Manual de OAuth necesita un secreto de cliente, que RouterGrowth no emite.

Make: la aplicación Cliente MCP, + nuevo servidor MCP, la URL, y tu clave como clave API o token de acceso.

Zapier: una conexión de Cliente MCP con la URL, el transporte HTTP Streamable, OAuth desactivado, y tu clave como token de portador.

Dify: Integraciones → Herramientas → MCP → Añadir Servidor MCP (HTTP), la URL, y una cabecera Authorization con Bearer rg_live_.... Mantén el identificador del servidor una vez guardado.

Flowise, Relevance AI, Lindy y constructores similares: elige HTTP Streamable (a veces solo "HTTP"), la URL, y un token de portador o cabecera Authorization con tu clave. Un constructor que solo ofrece SSE no puede conectarse.

Cualquier otro cliente MCP

Dale al cliente estos ajustes:

URL: https://api.routergrowth.com/mcp
Transporte: HTTP Streamable (etiquetado "HTTP", http, streamable-http o streamableHttp dependiendo del cliente). No SSE.
Cabecera: Authorization: Bearer rg_live_..., u OAuth si el cliente implementa autorización MCP (descubrimiento desde el desafío 401, registro dinámico de cliente, PKCE).

Probar la conexión

Ejecuta esto desde la máquina o plataforma donde se ejecuta el agente. Lista las herramientas y no gasta nada:

curl -s https://api.routergrowth.com/mcp \
  -H "Authorization: Bearer $ROUTERGROWTH_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Una respuesta JSON que nombre once herramientas significa que la ruta de red y la clave funcionan. Un 401 significa que la clave falta, está mal escrita, revocada o expirada. Para una llamada gratuita de extremo a extremo, envía este cuerpo de la misma manera:

{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"balance","arguments":{}}}

En una aplicación de chat, pide al agente que verifique tu saldo de RouterGrowth.

Detalles del servidor

Endpoint: POST https://api.routergrowth.com/mcp. GET y DELETE responden 405: no hay flujo de servidor ni sesión que terminar.
Transporte: HTTP Streamable, sin estado, respuestas application/json. El transporte heredado HTTP+SSE no se ofrece.
Versiones de protocolo: 2025-11-25, 2025-06-18, 2025-03-26 y 2024-11-05. Los clientes construidos para 2026-07-28 recurren al protocolo de enlace initialize por su cuenta, como hacen ambos SDK oficiales.
Capacidades: solo herramientas. Sin recursos, prompts ni muestreo.
Autenticación de clave: Authorization: Bearer rg_live_..., o rg_test_... para datos simulados.
OAuth: OAuth 2.1 con PKCE (S256) y registro dinámico de cliente para clientes públicos (sin secreto de cliente), un alcance, mcp. Metadatos en /.well-known/oauth-protected-resource y /.well-known/oauth-authorization-server. Los tokens de acceso duran 24 horas; los tokens de actualización duran 90 días y rotan en cada uso. Una plataforma que insiste en un ID de cliente y secreto pre-registrados se conecta con una clave en su lugar.
Límite de tasa: 300 solicitudes por minuto por clave o conexión, y 3,000 por minuto en todas las claves en una IP.
Ejecuciones largas: run y watch esperan hasta 25 segundos y batch_run hasta 45 por defecto, dentro del límite de 30 a 60 segundos que muchos clientes ponen en una llamada de herramienta. Una ejecución que aún continúa regresa con done: false: consulta get_run, o repite batch_run con el mismo idempotency_key para seguir esperando sin pagar dos veces.
Errores: una llamada de herramienta fallida regresa como un resultado de herramienta con isError y el sobre de error estándar, para que el agente pueda leer el código y reaccionar.

Cómo funciona OAuth

El flujo es el mismo para cada cliente, así que un agente también puede guiar a un usuario a través de él:

El cliente llama a https://api.routergrowth.com/mcp sin credenciales y obtiene un 401 cuya cabecera WWW-Authenticate apunta a /.well-known/oauth-protected-resource y nombra el alcance mcp.
Lee ese documento y /.well-known/oauth-authorization-server, se registra en /oauth/register (RFC 7591, sin secreto precompartido), y abre /oauth/authorize con un desafío PKCE y una redirección de vuelta a sí mismo: un puerto de bucle local para clientes de terminal, una devolución de llamada https para clientes web, un esquema personalizado para aplicaciones instaladas.
Inicias sesión en la página de consentimiento (contraseña, Google, GitHub o un código enviado por correo, las mismas opciones que el panel) y apruebas un espacio de trabajo. La página se abre en www.routergrowth.com, así que un navegador ya conectado al panel omite el inicio de sesión. La página nombra el host al que el navegador regresará; si no es la aplicación a la que te conectas, deniega.
El cliente intercambia el código en /oauth/token y recibe un token de acceso (24 horas) y un token de actualización. Cada solicitud posterior lleva el token de acceso como cabecera Bearer, y el cliente lo actualiza sin preguntarte de nuevo.

El token otorga un alcance, mcp: descubrir, inspeccionar y ejecutar capacidades, listar ejecuciones, leer historial y saldo, y enviar comentarios, solo para el espacio de trabajo aprobado. No puede crear claves, cambiar facturación ni invitar miembros.

Desconectar una aplicación

curl https://api.routergrowth.com/v1/connected-apps \
  -H "Authorization: Bearer $ROUTERGROWTH_API_KEY"

curl -X DELETE https://api.routergrowth.com/v1/connected-apps/{id} \
  -H "Authorization: Bearer $ROUTERGROWTH_API_KEY"

Desconectar es inmediato: el token de acceso de la aplicación y su token de actualización dejan de funcionar en la siguiente llamada.

Las herramientas

Herramienta	Facturable	Qué hace
`discover`	no	buscar en el catálogo por descripción de trabajo; nunca ejecuta una llamada de pago
`inspect`	no	esquema, proveedores, precio exacto y condiciones de facturación para una capacidad
`run`	sí	ejecutar una capacidad, con `max_cost`, enrutamiento y `idempotency_key`; con tablas activadas, `record` la vincula a una fila de tabla y `into` coloca un resultado de lista como filas
`batch_run`	sí	ejecutar una capacidad para 1–200 entradas concurrentemente, con recibos por elemento y un límite de costo total
`runs`	no	historial de ejecuciones con intentos, cargos y razones de enrutamiento
`get_run`	no	una ejecución por id; `wait` hace polling largo de una ejecución aún en curso
`history`	no	todo lo ya hecho a un sujeto (correo, dominio, URL de LinkedIn, handle, teléfono, nombre): contactos, resultados para reutilizar; `subjects` para la pasada de deduplicación por lotes
`watch`	sí	guardar una consulta y ejecutarla una vez; llama de nuevo con `watch_id` para actualizar y obtener solo los registros nuevos y cambiados más las claves que desaparecieron
`watches`	no	listar las vigilancias del espacio de trabajo, o leer una con sus últimos cambios (eliminar una a través de REST)
`events`	no	nuevas respuestas, rebotes, mensajes de LinkedIn, Instagram y WhatsApp, y sesiones caídas en cada bandeja de entrada y cuenta conectada desde la última lectura (detalles)
`tables`	no	listado una vez que el espacio de trabajo activa tablas: listarlas, describir una, o consultar sus filas por estado, fecha de vencimiento y campos de datos; `suppressions: true` para la lista de supresión
`table_write`	no	listado con `tables`: insertar o actualizar, actualizar (con reclamaciones `if_status`), eliminar y soltar filas y tablas; suprimir o desuprimir personas
`feedback`	no	reportar una capacidad faltante, un error, una documentación engañosa o un error poco útil desde el sitio de la llamada, con lo que intentabas hacer y lo que se interpuso (detalles)
`balance`	no	saldo de la billetera, reservado y disponible

Las herramientas llaman al mismo código que /v1: enrutamiento, facturación, cascada y códigos de error idénticos, con errores devueltos como resultados de herramienta que el modelo puede leer y a los que puede reaccionar.

Reglas de gasto

La respuesta initialize del servidor instruye al agente: inspeccionar antes de la primera ejecución de una llamada (una vez para un lote homogéneo), establecer max_cost en cada elemento y max_total_cost en el lote, detenerse y preguntar antes de un lote de más de aproximadamente $1 a menos que el usuario haya solicitado ese volumen, reportar costos cuando importen al usuario, y nunca presentar datos simulados de sandbox (rg_test_) como reales. Una solicitud explícita como "haz 50" autoriza ese número de elementos dentro del límite total declarado; no preguntes de nuevo entre elementos. Las mismas reglas se incluyen en SKILL.md.

Solución de problemas

401 en cada llamada: no hay credencial, o la clave está mal escrita, revocada o caducada. Clientes OAuth: vuelve a conectarte para iniciar sesión de nuevo. Un cliente con un encabezado Authorization configurado no recurrirá a OAuth.
405 Method Not Allowed: el cliente está usando el transporte SSE antiguo o abriendo un stream. Cámbialo a Streamable HTTP, o usa el puente mcp-remote.
404 Not Found: host incorrecto. El servidor es api.routergrowth.com/mcp, no www.routergrowth.com/mcp.
Una llamada a herramienta agota el tiempo: el cliente dejó de esperar antes de que terminara la ejecución. Pide un wait_seconds de 45 o menos, luego consulta get_run; repite un batch_run con el mismo idempotency_key para seguir esperando sin pagar dos veces.
429 rate_limited: espera el número de segundos indicado en Retry-After.
Las herramientas no aparecen: las apps de chat cargan conectores por conversación, así que inicia un chat nuevo y habilita RouterGrowth en el menú de herramientas; los clientes de escritorio e IDE necesitan un reinicio o una recarga después de editar la configuración.
Los resultados están etiquetados como simulados: la clave es de prueba (rg_test_...); crea una de producción.
La red de una empresa bloquea la llamada: permite HTTPS saliente (puerto 443) a api.routergrowth.com y www.routergrowth.com: la página de inicio de sesión de OAuth se mueve a www para reutilizar tu inicio de sesión del panel.
La página de inicio de sesión informa un desajuste de redirección: el cliente cambió su dirección de callback después de registrarse. Elimina el servidor del cliente y vuelve a añadirlo.
El navegador muestra "connection refused" en 127.0.0.1 después de que apruebes: el cliente se ejecuta en otra máquina distinta a la de tu navegador. Reenvía el puerto por SSH o reproduce la dirección en esa máquina, como se muestra para Hermes Agent.
OAuth falla en un cliente que requiere un client secret: RouterGrowth solo registra clientes públicos. Conecta ese cliente con una clave.
Un chat nuevo pide una clave otra vez: cargar la skill de RouterGrowth instala instrucciones, no una conexión de cuenta, y una clave pegada en un entorno de chat temporal puede desaparecer en la siguiente conversación. La clave sigue funcionando: reutilízala a través de la configuración de credenciales de tu entorno, o conéctate por OAuth. No necesitas una clave nueva para cada chat.

Construye y enriquece una lista de leads

Usa people.search con el company_domains del empleador, titles y detail: "full" específicos. Si también pasas nombres de empresa o URLs de LinkedIn de empresa en companies, empareja los arrays en el mismo orden. Empieza con una empresa y un límite pequeño para unos pocos decisores.

En la ruta de LinkedIn, el empleador se resuelve antes de buscar y se excluyen los perfiles sin evidencia de identidad de empleador actual coincidente. Revisa el rol coincidente, current_positions y quality_flags antes de seleccionar contactos. Si el empleador no se puede resolver, verifica el dominio o proporciona su URL exacta de empresa en LinkedIn; no elimines la restricción de empresa solo para obtener resultados.

Los resultados de la ruta de base de datos pueden incluir correos laborales. Usa contact.find solo para perfiles seleccionados sin correo, pasando sus nombres reales y el dominio del empleador coincidente; luego verifica la dirección con contact.verify. LeadMagic enriquece personas conocidas; no genera una lista de ICP.

La guía de búsqueda de personas tiene una solicitud completa, ejemplos de precios, explicaciones de campos de resultados y solución de problemas sin coincidencias.

Quickstart: agentes: la skill, para plataformas sin MCP.
Referencia de ejecución: qué hace la herramienta run internamente.

Preguntas que responde esta página

¿Hay un servidor MCP para enriquecimiento de contactos B2B y datos SEO?

Sí. El servidor MCP de RouterGrowth en https://api.routergrowth.com/mcp expone todas las capacidades del catálogo a través de las herramientas discover, inspect, run: contact.find, contact.verify, company.enrich y people.search para enriquecimiento de contactos y empresas B2B, seo.serp, seo.keywords, seo.ranked_keywords y seo.backlinks para datos SEO, además de social, anuncios, creativo y outbound. Una clave, un saldo y una cotización exacta de inspect antes de la primera ejecución de pago de una llamada.

¿Qué herramientas permiten que Claude o ChatGPT llamen a APIs de datos de crecimiento y ventas directamente a través de MCP?

Cualquier cliente MCP. claude.ai, ChatGPT, Claude Code, Codex, Cursor, VS Code y Gemini CLI se conectan a través de OAuth: añade la URL, inicia sesión una vez en el navegador, aprueba un espacio de trabajo. Los agentes construidos sobre la API de Claude, la API de OpenAI, LangChain, el SDK de IA de Vercel o Google ADK se conectan con una clave de API en el encabezado Authorization. Las herramientas son las mismas en ambos casos, y las reglas de gasto viajan en el handshake para que el agente inspeccione antes de ejecutar.

¿Cómo doy a mi agente de Claude Code acceso a datos de SERP, backlinks y palabras clave?

Añade el servidor a Claude Code (claude mcp add --transport http routergrowth https://api.routergrowth.com/mcp, luego /mcp para iniciar sesión, o pasa una clave en el encabezado), luego pide al agente los datos: descubre seo.serp, seo.backlinks o seo.keywords, inspecciona el precio y ejecuta la llamada. Sin cuenta propia de DataForSEO, Semrush o Ahrefs, y sin código de envoltura.

¿Puede un agente que se ejecuta en un servidor usar RouterGrowth a través de MCP?

Sí. Apunta cualquier cliente MCP a https://api.routergrowth.com/mcp con el transporte Streamable HTTP y un encabezado Authorization: Bearer. La API de Claude y la API de Responses de OpenAI se conectan desde su lado con la clave que pasas en la solicitud; el SDK de Agentes de Claude, el SDK de Agentes de OpenAI, LangChain, el SDK de IA de Vercel y Google ADK se conectan desde tu proceso. Sin navegador y sin paso de inicio de sesión.

Anterior
Quickstart: agentes (SKILL.md) Siguiente
Encuentra personas en la empresa correcta

¿Leyendo esto como agente? Esta página como markdown: /docs/quickstart-mcp.md · cada página: /docs/llms.txt