> ## Documentation Index
> Fetch the complete documentation index at: https://docs.firecrawl.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Servidor MCP de Firecrawl
> Utiliza la API de Firecrawl a través del Model Context Protocol
Una implementación de servidor del Model Context Protocol (MCP) que integra [Firecrawl](https://github.com/firecrawl/firecrawl) para buscar, hacer scraping e interactuar con la web. Nuestro servidor MCP es de código abierto y está disponible en [GitHub](https://github.com/firecrawl/firecrawl-mcp-server).
## Características
* Buscar en la web y obtener el contenido completo de la página
* Convertir cualquier URL en datos estructurados y limpios mediante scraping
* Procesar archivos locales como PDF, DOCX, XLSX y HTML
* Interactuar con páginas — hacer clic, navegar y operar
* Investigación avanzada con un agente autónomo
* Compatibilidad en la nube y autogestionado
* Compatibilidad con HTTP por streaming
## Instalación
Puedes usar nuestra URL alojada remotamente o ejecutar el servidor localmente. Obtén tu clave de API en [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
**¿No tienes clave de API?** Conéctate a `https://mcp.firecrawl.dev/v2/mcp` para usar el plan Free remoto sin clave. Es gratis y tiene límite de tasa por IP; consulta [Límites de tasa](/es/rate-limits#keyless-no-api-key) para ver la lista actual de herramientas sin clave. Configura `FIRECRAWL_API_KEY` para desbloquear todas las herramientas MCP y límites más altos.
### URL alojada remotamente
Conéctate sin una clave de API para empezar con el plan Free remoto sin clave (limitado por IP; consulta [Límites de tasa](/es/rate-limits#keyless-no-api-key) para ver la lista actual de herramientas):
```bash theme={null}
https://mcp.firecrawl.dev/v2/mcp
```
Con una clave de API, envíala como una cabecera `Authorization` para desbloquear todas las herramientas y ofrecer límites superiores:
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp",
"headers": {
"Authorization": "Bearer fc-YOUR_API_KEY"
}
}
}
}
```
### Ejecutar con npx
```bash theme={null}
env FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp
```
### Instalación manual
```bash theme={null}
npm install -g firecrawl-mcp
```
### Ejecutar en Cursor
Instala el servidor alojado sin clave con un solo clic (no se requiere clave de API):
O añádelo manualmente a `~/.cursor/mcp.json`:
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp"
}
}
}
```
#### Ejecución local con una clave de API
Nota: Requiere Cursor versión 0.45.6+
Para ver las instrucciones de configuración más actualizadas, consulta la documentación oficial de Cursor sobre cómo configurar MCP Servers:
[Guía de configuración de MCP Servers de Cursor](https://cursor.com/docs/context/mcp)
Para configurar Firecrawl MCP en Cursor **v0.48.6**
1. Abre la configuración de Cursor
2. Ve a Features > MCP Servers
3. Haz clic en "+ Add new global MCP server"
4. Ingresa el siguiente código:
```json theme={null}
{
"mcpServers": {
"firecrawl-mcp": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR-API-KEY"
}
}
}
}
```
Para configurar Firecrawl MCP en Cursor **v0.45.6**
1. Abre la configuración de Cursor
2. Ve a Features > MCP Servers
3. Haz clic en "+ Add New MCP Server"
4. Ingresa lo siguiente:
* Name: "firecrawl-mcp" (o el nombre que prefieras)
* Type: "command"
* Command: `env FIRECRAWL_API_KEY=your-api-key npx -y firecrawl-mcp`
> Si usas Windows y tienes problemas, prueba `cmd /c "set FIRECRAWL_API_KEY=your-api-key && npx -y firecrawl-mcp"`
Reemplaza `your-api-key` por tu clave de API de Firecrawl. Si aún no tienes una, puedes crear una cuenta y obtenerla en [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
Después de agregarlo, actualiza la lista de MCP Servers para ver las nuevas tools. El Composer Agent usará Firecrawl MCP automáticamente cuando corresponda, pero puedes solicitarlo explícitamente describiendo tus necesidades de datos web. Accede al Composer con Command+L (Mac), selecciona "Agent" junto al botón de envío e ingresa tu consulta.
### Ejecutar en Windsurf
Añade esto a tu `./codeium/windsurf/model_config.json`:
```json theme={null}
{
"mcpServers": {
"mcp-server-firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "TU_CLAVE_API"
}
}
}
}
```
### Ejecución en modo HTTP con streaming
Para ejecutar el servidor localmente usando transporte HTTP con streaming en lugar del transporte `stdio` predeterminado:
```bash theme={null}
env HTTP_STREAMABLE_SERVER=true FIRECRAWL_API_KEY=fc-YOUR_API_KEY npx -y firecrawl-mcp
```
Utiliza la URL: [http://localhost:3000/v2/mcp](http://localhost:3000/v2/mcp) localmente, o la versión alojada [https://mcp.firecrawl.dev/v2/mcp](https://mcp.firecrawl.dev/v2/mcp)
### Instalación con Smithery (versión anterior)
Para instalar Firecrawl para Claude Desktop automáticamente mediante [Smithery](https://smithery.ai/server/@mendableai/mcp-server-firecrawl):
```bash theme={null}
npx -y @smithery/cli install @mendableai/mcp-server-firecrawl --client claude
```
### Ejecutar en VS Code
Para una instalación con un solo clic, haz clic en uno de los botones de instalación de abajo...
[](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl\&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D\&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D) [](https://insiders.vscode.dev/redirect/mcp/install?name=firecrawl\&inputs=%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22apiKey%22%2C%22description%22%3A%22Firecrawl%20API%20Key%22%2C%22password%22%3Atrue%7D%5D\&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22firecrawl-mcp%22%5D%2C%22env%22%3A%7B%22FIRECRAWL_API_KEY%22%3A%22%24%7Binput%3AapiKey%7D%22%7D%7D\&quality=insiders)
Para una instalación manual, añade el siguiente bloque JSON a tu archivo de configuración de usuario (JSON) en VS Code. Puedes hacerlo pulsando `Ctrl + Shift + P` y escribiendo `Preferences: Open User Settings (JSON)`.
```json theme={null}
{
"mcp": {
"inputs": [
{
"type": "promptString",
"id": "apiKey",
"description": "Clave de API de Firecrawl",
"password": true
}
],
"servers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "${input:apiKey}"
}
}
}
}
}
```
Opcionalmente, también puedes añadirlo a un archivo llamado `.vscode/mcp.json` en tu espacio de trabajo. Esto te permitirá compartir la configuración con otras personas:
```json theme={null}
{
"inputs": [
{
"type": "promptString",
"id": "apiKey",
"description": "Clave de API de Firecrawl",
"password": true
}
],
"servers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "${input:apiKey}"
}
}
}
}
```
**Nota:** Algunos usuarios han informado de problemas al añadir el servidor MCP a VS Code debido a cómo valida JSON con un formato de esquema obsoleto ([microsoft/vscode#155379](https://github.com/microsoft/vscode/issues/155379)).
Esto afecta a varias herramientas MCP, incluida Firecrawl.
**Solución alternativa:** Desactiva la validación de JSON en VS Code para permitir que el servidor MCP se cargue correctamente.
Consulta la referencia: [directus/directus#25906 (comment)](https://github.com/directus/directus/issues/25906#issuecomment-3369169513).
El servidor MCP sigue funcionando correctamente cuando se invoca a través de otras extensiones, pero el problema se produce específicamente al registrarlo directamente en la lista de servidores MCP. Planeamos añadir instrucciones una vez que VS Code actualice su validación de esquemas.
### Ejecutar en Claude Desktop
Añade lo siguiente al archivo de configuración de Claude:
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"url": "https://mcp.firecrawl.dev/v2/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}
```
Si aparece el error "Couldn't reach the MCP Server", es posible que tu versión de Claude Desktop no sea compatible con el transporte HTTP en streaming. Usa en su lugar el enfoque local con npx (requiere [Node.js](https://nodejs.org)):
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_API_KEY"
}
}
}
}
```
Si aparece un error `spawn npx ENOENT`, Node.js no está instalado o no está en el PATH del sistema. Instala Node.js desde [nodejs.org](https://nodejs.org) (versión LTS) y luego reinicia por completo Claude Desktop. En Windows, también puedes ejecutar `where npx` en el Símbolo del sistema y usar la ruta completa (por ejemplo, `C:\\Program Files\\nodejs\\npx.cmd`) como valor de `command`.
### Ejecutar en Claude Code
Agrega el MCP Server de Firecrawl usando la CLI de Claude Code. Puedes usar la URL alojada remotamente o ejecutarlo localmente:
```bash theme={null}
# URL alojada remotamente (recomendado, funciona sin una clave de API)
claude mcp add --transport http firecrawl https://mcp.firecrawl.dev/v2/mcp
# Con una clave de API, envíala como cabecera Authorization
claude mcp add --transport http firecrawl https://mcp.firecrawl.dev/v2/mcp --header "Authorization: Bearer fc-your-api-key"
# O ejecutarlo localmente mediante npx
claude mcp add firecrawl -e FIRECRAWL_API_KEY=fc-your-api-key -- npx -y firecrawl-mcp
```
### Ejecutar en Google Antigravity
Google Antigravity te permite configurar servidores MCP directamente a través de la interfaz de Agent.
1. Abre el panel lateral de Agent en el Editor o en la vista de Agent Manager
2. Haz clic en el menú "..." (Más acciones) y selecciona **MCP Servers**
3. Selecciona **View raw config** para abrir tu archivo local `mcp_config.json`
4. Añade la siguiente configuración:
```json theme={null}
{
"mcpServers": {
"firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_FIRECRAWL_API_KEY"
}
}
}
}
```
5. Guarda el archivo y haz clic en **Refresh** en la interfaz de Antigravity MCP para ver las nuevas herramientas
Reemplaza `YOUR_FIRECRAWL_API_KEY` con tu clave de API de [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).
### Ejecución en n8n
Para conectar el servidor MCP de Firecrawl en n8n:
1. Obtén tu clave de API de Firecrawl en [https://firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys)
2. En tu flujo de trabajo de n8n, agrega un nodo **AI Agent**
3. En la configuración de **AI Agent**, agrega una nueva **Tool**
4. Selecciona **MCP Client Tool** como tipo de herramienta
5. Ingresa el endpoint del servidor MCP:
```
https://mcp.firecrawl.dev/v2/mcp
```
6. Configura **Server Transport** en **HTTP Streamable**
7. Configura **Authentication** en **Bearer** y pega tu clave de API de Firecrawl, o déjalo en **None** para usar el plan Free sin clave
8. En **Tools to include**, puedes seleccionar **All**, **Selected** o **All Except**: esto pondrá a disposición las herramientas de Firecrawl (`scrape`, `crawl`, `map`, `search`, `extract`, etc.)
Para implementaciones autogestionadas, ejecuta el servidor MCP con npx y habilita el modo de transporte HTTP:
```bash theme={null}
env HTTP_STREAMABLE_SERVER=true \
FIRECRAWL_API_KEY=fc-YOUR_API_KEY \
FIRECRAWL_API_URL=YOUR_FIRECRAWL_INSTANCE \
npx -y firecrawl-mcp
```
Esto iniciará el servidor en `http://localhost:3000/v2/mcp`, que puedes usar en tu flujo de trabajo de n8n como endpoint. La variable de entorno `HTTP_STREAMABLE_SERVER=true` es necesaria, ya que n8n requiere transporte HTTP.
## Configuración
### Variables de entorno
#### API en la nube y autogestionada
* `FIRECRAWL_API_KEY`: Tu clave de API de Firecrawl
* Requerida al usar la API en la nube (por defecto)
* Opcional al usar una instancia autogestionada con `FIRECRAWL_API_URL`
* `FIRECRAWL_API_URL` (opcional): Endpoint de API personalizado para instancias autogestionadas
* Ejemplo: `https://firecrawl.your-domain.com`
* Si no se proporciona, se usará la API en la nube (requiere clave de API)
### Ejemplos de configuración
Para usar la API en la nube:
```bash theme={null}
export FIRECRAWL_API_KEY=your-api-key
```
Para instancias autogestionadas:
```bash theme={null}
export FIRECRAWL_API_URL=https://firecrawl.your-domain.com
export FIRECRAWL_API_KEY=your-api-key # Si tu instancia requiere autenticación
```
### Configuración personalizada con Claude Desktop
Añade lo siguiente a tu `claude_desktop_config.json`:
```json theme={null}
{
"mcpServers": {
"mcp-server-firecrawl": {
"command": "npx",
"args": ["-y", "firecrawl-mcp"],
"env": {
"FIRECRAWL_API_KEY": "YOUR_API_KEY_HERE"
}
}
}
}
```
### MCP alojado vs. MCP local
El MCP Server alojado está optimizado para un uso remoto seguro. Algunas opciones que están disponibles al ejecutar el MCP Server localmente están restringidas o no están disponibles de forma remota:
* El modo keyless alojado expone solo las herramientas compatibles con keyless y está sujeto a límites de tasa por IP.
* La lectura de archivos locales solo está disponible cuando ejecutas el MCP Server localmente.
* Los webhooks y las rutas de archivos locales deben configurarse desde un MCP Server local o autogestionado cuando el agente necesita acceso a recursos locales.
### Límites de tasa
Firecrawl aplica límites de tasa. Usa una API key para obtener límites más altos y acceder al conjunto completo de herramientas.
## Herramientas disponibles
### 1. Herramienta de scraping (`firecrawl_scrape`)
Extrae contenido de una única URL con opciones avanzadas.
```json theme={null}
{
"name": "firecrawl_scrape",
"arguments": {
"url": "https://example.com",
"formats": ["markdown"],
"onlyMainContent": true,
"waitFor": 1000,
"mobile": false,
"includeTags": ["article", "main"],
"excludeTags": ["nav", "footer"],
"skipTlsVerification": false
}
}
```
Para ocultar la información personal identificable, incluye `redactPII` en los argumentos de la herramienta de scraping.
```json theme={null}
{
"name": "firecrawl_scrape",
"arguments": {
"url": "https://example.com/contact",
"formats": ["markdown"],
"redactPII": true
}
}
```
### 2. Herramienta de mapeo (`firecrawl_map`)
Mapea un sitio web para descubrir todas las URL indexadas del sitio.
```json theme={null}
{
"name": "firecrawl_map",
"arguments": {
"url": "https://example.com",
"search": "blog",
"sitemap": "include",
"includeSubdomains": false,
"limit": 100,
"ignoreQueryParameters": true
}
}
```
#### Opciones de Map Tool:
* `url`: La URL base del sitio web a mapear
* `search`: Término de búsqueda opcional para filtrar URL
* `sitemap`: Controla el uso del sitemap: "include", "skip" o "only"
* `includeSubdomains`: Indica si se deben incluir subdominios en el mapeo
* `limit`: Número máximo de URL a devolver
* `ignoreQueryParameters`: Indica si se deben ignorar los parámetros de consulta al mapear
**Mejor para:** Descubrir URL en un sitio web antes de decidir qué datos extraer; encontrar secciones específicas de un sitio web.
**Devuelve:** Array de URL encontradas en el sitio.
### 3. Search Tool (`firecrawl_search`)
Busca en la web y, opcionalmente, extrae contenido de los resultados de búsqueda.
```json theme={null}
{
"name": "firecrawl_search",
"arguments": {
"query": "tu consulta de búsqueda",
"limit": 5,
"location": "United States",
"tbs": "qdr:m",
"scrapeOptions": {
"formats": ["markdown"],
"onlyMainContent": true
}
}
}
```
#### Opciones de la herramienta de búsqueda:
* `query`: La cadena de consulta (obligatorio)
* `limit`: Número máximo de resultados a devolver
* `location`: Ubicación geográfica para los resultados de búsqueda
* `tbs`: Filtro de búsqueda basado en tiempo (por ejemplo, `qdr:d` para el último día, `qdr:w` para la última semana, `qdr:m` para el último mes)
* `filter`: Filtro de búsqueda adicional
* `sources`: Array de tipos de fuentes a buscar (`web`, `images`, `news`)
* `scrapeOptions`: Opciones de scraping de las páginas de resultados de búsqueda
* `enterprise`: Array de opciones de enterprise (`default`, `anon`, `zdr`)
### 4. Herramienta para procesar (`firecrawl_parse`)
Procesa un archivo local, como un documento PDF, DOCX, XLSX o HTML, y conviértelo en datos limpios y listos para LLM.
```json theme={null}
{
"name": "firecrawl_parse",
"arguments": {
"filePath": "/absolute/path/to/report.pdf",
"formats": ["markdown"]
}
}
```
Cuando ejecutas Firecrawl MCP localmente con una instancia de la API de Firecrawl mediante `FIRECRAWL_API_URL`, el servidor MCP puede leer `filePath` directamente y envía los bytes del archivo a `/v2/parse`.
Cuando usas el servidor MCP remoto alojado, ese servidor no puede leer archivos de tu máquina. En ese caso, `firecrawl_parse` usa un flujo de transferencia en dos pasos que también funciona con la URL remota sin clave:
1. Llama a `firecrawl_parse` con `filePath`. La herramienta devuelve un comando de carga precompletado y un `nextToolCall` que contiene un `uploadRef`.
2. Ejecuta el comando de carga en la máquina que puede leer el archivo y, después, vuelve a llamar a `firecrawl_parse` con el `uploadRef` devuelto.
El comando de carga envía los bytes del archivo a un destino de carga firmado de corta duración. No incluye tu Firecrawl API key.
#### Opciones de la herramienta Parse:
* `filePath`: Ruta local del archivo que quieres procesar. Úsalo para la primera llamada.
* `uploadRef`: Referencia devuelta por la primera llamada a hosted-MCP. Úsala para la segunda llamada después de que la carga se complete correctamente.
* `formats`: Formatos de salida. El valor predeterminado es `markdown`.
* `parsers`: Controles del analizador, como las opciones de procesamiento de PDF.
* `contentType`: Anulación opcional del tipo MIME del archivo.
* `declaredSizeBytes`: Tamaño declarado opcional del archivo. Los archivos están limitados a 50 MB.
**Ideal para:** Documentos locales o no públicos que no estén disponibles en una URL pública.
**No recomendado para:** URL públicas de documentos. Usa `firecrawl_scrape` en su lugar; detectará y procesará documentos desde URL.
### 5. Herramienta de rastreo (`firecrawl_crawl`)
Inicia un rastreo asíncrono con opciones avanzadas.
```json theme={null}
{
"name": "firecrawl_crawl",
"arguments": {
"url": "https://example.com",
"maxDiscoveryDepth": 2,
"limit": 100,
"allowExternalLinks": false,
"deduplicateSimilarURLs": true
}
}
```
### 6. Comprobar el estado del rastreo (`firecrawl_check_crawl_status`)
Comprueba el estado de una tarea de rastreo.
```json theme={null}
{
"name": "firecrawl_check_crawl_status",
"arguments": {
"id": "550e8400-e29b-41d4-a716-446655440000"
}
}
```
**Devuelve:** Estado y progreso de la tarea de rastreo, incluidos los resultados si están disponibles.
Extrae información estructurada de páginas web usando capacidades de LLM. Es compatible tanto con extracción mediante IA en la nube como con LLM autogestionados.
```json theme={null}
{
"name": "firecrawl_extract",
"arguments": {
"urls": ["https://example.com/page1", "https://example.com/page2"],
"prompt": "Extract product information including name, price, and description",
"schema": {
"type": "object",
"properties": {
"name": { "type": "string" },
"price": { "type": "number" },
"description": { "type": "string" }
},
"required": ["name", "price"]
},
"allowExternalLinks": false,
"enableWebSearch": false,
"includeSubdomains": false
}
}
```
Ejemplo de respuesta:
```json theme={null}
{
"content": [
{
"type": "text",
"text": {
"name": "Example Product",
"price": 99.99,
"description": "This is an example product description"
}
}
],
"isError": false
}
```
* `urls`: Matriz de URLs de las que extraer información
* `prompt`: Prompt personalizado para la extracción con el LLM
* `schema`: Esquema JSON para la extracción de datos estructurados
* `allowExternalLinks`: Permite la extracción desde enlaces externos
* `enableWebSearch`: Habilita la búsqueda web para obtener contexto adicional
* `includeSubdomains`: Incluye subdominios en la extracción
Al usar una instancia autogestionada (self-hosted), la extracción utilizará tu LLM configurado. Para la API en la nube, se usa el servicio de LLM gestionado de Firecrawl.
### 8. Herramienta del agente (`firecrawl_agent`)
Agente autónomo de investigación web que navega de forma independiente por internet, busca información, recorre páginas y extrae datos estructurados a partir de tu consulta. Se ejecuta de forma asíncrona: devuelve inmediatamente un ID de tarea y haces *polling* a `firecrawl_agent_status` para comprobar cuándo se completa y recuperar los resultados.
```json theme={null}
{
"name": "firecrawl_agent",
"arguments": {
"prompt": "Find the top 5 AI startups founded in 2024 and their funding amounts",
"schema": {
"type": "object",
"properties": {
"startups": {
"type": "array",
"items": {
"type": "object",
"properties": {
"name": { "type": "string" },
"funding": { "type": "string" },
"founded": { "type": "string" }
}
}
}
}
}
}
}
```
También puedes proporcionar URL específicas para que el agente se centre en ellas:
```json theme={null}
{
"name": "firecrawl_agent",
"arguments": {
"urls": ["https://docs.firecrawl.dev", "https://firecrawl.dev/pricing"],
"prompt": "Compare the features and pricing information from these pages"
}
}
```
#### Opciones de la herramienta del agente:
* `prompt`: Descripción en lenguaje natural de los datos que quieres (obligatorio, máximo 10.000 caracteres)
* `urls`: Matriz opcional de URLs para enfocar el agente en páginas específicas
* `schema`: Esquema JSON opcional para una salida estructurada
**Mejor para:** Tareas de investigación complejas donde no conoces las URLs exactas; recopilación de datos desde múltiples fuentes; encontrar información dispersa en la web; extraer datos de aplicaciones de una sola página (SPA) con mucho JavaScript que fallan con el `scrape` normal.
**Devuelve:** ID de la tarea para comprobación del estado. Usa `firecrawl_agent_status` para consultar periódicamente los resultados.
### 9. Comprobar el estado del agente (`firecrawl_agent_status`)
Comprueba el estado de una tarea de agente y recupera los resultados cuando haya finalizado. Realiza consultas (polling) cada 15-30 segundos y sigue haciéndolas durante al menos 2-3 minutos antes de considerar que la solicitud ha fallado.
```json theme={null}
{
"name": "firecrawl_agent_status",
"arguments": {
"id": "550e8400-e29b-41d4-a716-446655440000"
}
}
```
#### Opciones de estado del agente:
* `id`: El ID del trabajo del agente devuelto por `firecrawl_agent` (obligatorio)
**Posibles estados:**
* `processing`: El agente sigue investigando; continúa consultando
* `completed`: Investigación finalizada; la respuesta incluye los datos extraídos
* `failed`: Se produjo un error
**Devuelve:** Estado, progreso y resultados (si está completado) del trabajo del agente.
### 10. Interact con una página (`firecrawl_interact`)
Interact con una página en una sesión activa del navegador: haz clic en botones, completa formularios, extrae contenido dinámico o navega a mayor profundidad.
Usa uno de estos dos modos de selección:
* Pasa `url` para abrir e interactuar con una página nueva en una sola llamada a MCP.
* Pasa `scrapeId` de una llamada anterior a `firecrawl_scrape` para reutilizar la página ya cargada.
No pases `url` y `scrapeId` a la vez. Proporciona `prompt` o `code`. `scrapeOptions` solo puede usarse con el modo `url`.
**Ejemplo del modo URL:**
```json theme={null}
{
"name": "firecrawl_interact",
"arguments": {
"url": "https://example.com/products",
"prompt": "Click on the first product and tell me its price"
}
}
```
**Ejemplo de reutilización del scraping:**
```json theme={null}
{
"name": "firecrawl_interact",
"arguments": {
"scrapeId": "scrape-id-from-previous-scrape",
"prompt": "Click the Sign In button"
}
}
```
#### Opciones de la herramienta Interact:
* `url`: Página con la que interactuar; abre la sesión por ti. Usa esto o `scrapeId`.
* `scrapeId`: El ID del trabajo de scraping de una llamada previa a `firecrawl_scrape`. Usa esto o `url`.
* `prompt`: Instrucción en lenguaje natural que describe la acción que se debe realizar. Indica `prompt` o `code`.
* `code`: Código que se ejecutará en la sesión del navegador. Indica `code` o `prompt`.
* `language`: `bash`, `python` o `node` (opcional; el valor predeterminado es `node`; solo se usa con `code`)
* `timeout`: Tiempo de espera de ejecución en segundos, 1–300 (opcional; el valor predeterminado es 30)
* `scrapeOptions`: Controles de scraping opcionales que se usan solo con el modo `url`.
**Ideal para:** Flujos de trabajo de varios pasos en una sola página: buscar en un sitio, hacer clic en los resultados, completar formularios y extraer datos que requieren interacción.
**Devuelve:** El resultado de la interacción, incluida la salida y las URL de vista en vivo.
### 11. Detener una sesión de Interact (`firecrawl_interact_stop`)
Detiene una sesión de Interact para una página extraída. Usa esta función cuando hayas terminado de interactuar para liberar recursos.
```json theme={null}
{
"name": "firecrawl_interact_stop",
"arguments": {
"scrapeId": "scrape-id-from-previous-scrape"
}
}
```
#### Opciones para detener Interact:
* `scrapeId`: El ID de scraping de la sesión que se va a detener (obligatorio)
**Devuelve:** Confirmación de que la sesión se ha detenido.
## Sistema de registro
El servidor incluye un sistema de registro completo:
* Estado y progreso de las operaciones
* Métricas de rendimiento
* Monitoreo del uso de créditos
* Seguimiento de los límites de tasa
* Condiciones de error
Ejemplos de mensajes de registro:
```
[INFO] Servidor MCP de Firecrawl inicializado correctamente
[INFO] Starting scrape for URL: https://example.com
[INFO] Starting crawl for URL: https://example.com
[WARNING] Credit usage has reached warning threshold
[ERROR] Rate limit exceeded, retrying in 2s...
```
## Manejo de errores
El servidor ofrece un manejo de errores sólido:
* Reintentos automáticos para errores transitorios
* Manejo de límites de solicitudes con backoff
* Mensajes de error detallados
* Avisos sobre consumo de créditos
* Resiliencia ante errores de red
Ejemplo de respuesta de error:
```json theme={null}
{
"content": [
{
"type": "text",
"text": "Error: Límite de velocidad excedido. Reintentando en 2 segundos..."
}
],
"isError": true
}
```
## Desarrollo
```bash theme={null}
# Instalar dependencias
npm install
# Construir
npm run build
# Ejecutar tests
npm test
```
### Cómo contribuir
1. Haz un fork del repositorio
2. Crea una rama para tu funcionalidad
3. Ejecuta las pruebas: `npm test`
4. Envía un pull request
### Gracias a los colaboradores
Gracias a [@vrknetha](https://github.com/vrknetha) y [@cawstudios](https://caw.tech) por la implementación inicial.
Gracias a MCP.so y Klavis AI por alojar el servicio, y a [@gstarwd](https://github.com/gstarwd), [@xiangkaiz](https://github.com/xiangkaiz) y [@zihaolin96](https://github.com/zihaolin96) por integrar nuestro servidor.
## Licencia
Licencia MIT: consulta el archivo LICENSE para más detalles