Firecrawl: convertí la web en datos para tu IA

Firecrawl es una herramienta open-source que agarra cualquier página web y la devuelve como markdown limpio o como datos estructurados, listos para que tu IA los lea sin ahogarse en HTML, banners y menús. Es de código abierto —podés ver y correr el código desde firecrawl/firecrawl— y además ofrece una versión en la nube si no querés instalar nada.

Por qué esto importa para poner la IA a trabajar

El cuello de botella de casi cualquier proyecto serio de IA no es el modelo: son los datos. Un modelo de lenguaje es bueno razonando sobre el texto que le pasás, pero no sabe nada de tu mundo —los precios de tu competencia, la documentación de una API, las novedades de un proveedor— a menos que se lo des en el contexto. Y la web está llena de esa información, solo que envuelta en HTML pensado para humanos, no para máquinas.

Ahí entra Firecrawl. Si alguna vez intentaste pegarle el HTML crudo de una página a un modelo, ya sabés lo que pasa: se gastan miles de tokens en <div>, scripts y avisos de cookies, y la señal queda enterrada entre el ruido. Firecrawl hace el trabajo sucio —rota proxies, ejecuta el JavaScript de las páginas dinámicas, esquiva los bloqueos y limpia la basura— y te devuelve solo el contenido que importa, en markdown.

Esto se vuelve clave en dos escenarios muy concretos:

• RAG (búsqueda aumentada con recuperación): si querés que tu IA responda usando tus fuentes reales, necesitás esas fuentes en texto limpio para indexarlas. Markdown ordenado entra mejor a una base vectorial y rinde mejor en las respuestas que un volcado de HTML.
• Agentes: un agente que tiene que investigar, comparar precios o leer documentación necesita "ver" la web como texto utilizable. Firecrawl es esa puerta de entrada.

La regla mental es simple: datos limpios adentro, mejores respuestas afuera. Y gastás menos tokens en el camino.

Las operaciones principales

Firecrawl tiene varias operaciones, pero con tres ya cubrís el 90% de los casos: scrape (una página), crawl (un sitio entero) y extract / agent (datos estructurados). Vamos una por una.

Scrape: una página a markdown

Es la operación más básica y la que más vas a usar. Le pasás una URL y te devuelve esa página convertida a markdown (o a JSON, captura de pantalla, etc.). Probémosla primero con curl, así ves la forma cruda de la API:

curl -X POST 'https://api.firecrawl.dev/v2/scrape' \
  -H 'Authorization: Bearer fc-YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://firecrawl.dev",
    "formats": ["markdown"]
  }'

La respuesta trae el markdown de la página más algunos metadatos (título, URL de origen). Eso ya lo podés guardar, indexar o pasarle directo a un modelo.

Si trabajás en Python, el SDK te ahorra los headers y el JSON a mano:

from firecrawl import Firecrawl

app = Firecrawl(api_key="fc-YOUR_API_KEY")

# Convertí una página a markdown limpio
doc = app.scrape("https://firecrawl.dev", formats=["markdown"])
print(doc.markdown)

Y lo mismo en Node/JavaScript:

import { Firecrawl } from 'firecrawl';

const app = new Firecrawl({ apiKey: 'fc-YOUR_API_KEY' });

// Convertí una página a markdown limpio
const doc = await app.scrape('https://firecrawl.dev', { formats: ['markdown'] });
console.log(doc.markdown);

Tres líneas y ya tenés una página web hecha texto. Esa es la pieza que después conectás a tu base de datos vectorial o le pasás como contexto a tu agente.

Crawl: un sitio entero de una

Scrape resuelve una página. Pero muchas veces lo que querés es todo un sitio: la documentación completa de una herramienta, todas las entradas de un blog, todas las páginas de un producto. Para eso está crawl: le das una URL inicial y Firecrawl recorre el sitio siguiendo los links, scrapeando cada página que encuentra.

Como recorrer un sitio entero puede tardar, crawl funciona de forma asincrónica: arranca un trabajo y te devuelve un ID para consultar el progreso.

curl -X POST 'https://api.firecrawl.dev/v2/crawl' \
  -H 'Authorization: Bearer fc-YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "url": "https://docs.firecrawl.dev",
    "limit": 100,
    "scrapeOptions": {
      "formats": ["markdown"]
    }
  }'

Eso te devuelve un ID de trabajo. Con ese ID consultás el estado hasta que termine:

curl -X GET 'https://api.firecrawl.dev/v2/crawl/123-456-789' \
  -H 'Authorization: Bearer fc-YOUR_API_KEY'

Cuando el estado es completed, en el campo data viene el markdown de todas las páginas. Un detalle importante: si usás los SDK (Python, Node), no tenés que andar consultando el estado vos mismo —se encargan solos de esperar a que el trabajo termine. Por eso en código queda tan limpio:

from firecrawl import Firecrawl

app = Firecrawl(api_key="fc-YOUR_API_KEY")

# Recorré un sitio entero (el SDK espera a que termine solo)
docs = app.crawl("https://docs.firecrawl.dev", limit=50)
for doc in docs.data:
    print(doc.metadata.source_url, doc.markdown[:100])

El parámetro limit es tu amigo: te marca cuántas páginas como máximo querés traer. Empezá con un número chico (10 o 20) para probar que estás trayendo lo que esperabas antes de soltarlo sobre un sitio de mil páginas.

Un primo cercano de crawl es map: si no querés el contenido todavía sino solo descubrir qué URLs existen en un sitio, map te las lista al instante. Sirve para explorar antes de decidir qué scrapear.

Extract: datos estructurados, no solo texto

Hasta acá traemos texto. Pero a veces no querés un párrafo, querés un dato puntual y ordenado: el precio de un plan, los integrantes de un equipo, la ficha técnica de un producto. Para eso Firecrawl tiene la capacidad de extracción estructurada, expuesta a través del endpoint agent (la evolución de lo que antes era /extract).

La idea es potente: en vez de pedir "traeme la página", le describís en lenguaje natural qué necesitás, y opcionalmente le pasás un esquema de cómo querés que salgan los datos. Firecrawl navega, busca y te devuelve un JSON que cumple ese esquema.

En su forma más simple, le das un pedido en texto:

curl -X POST 'https://api.firecrawl.dev/v2/agent' \
  -H 'Authorization: Bearer fc-YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "Encontrá los planes de precios de Notion"
  }'

Pero la jugada de verdad es pasarle un esquema, así los datos salen siempre con la misma forma y los podés meter directo en tu base de datos o tu app. En Python esto se hace con Pydantic:

from firecrawl import Firecrawl
from pydantic import BaseModel, Field
from typing import List, Optional

app = Firecrawl(api_key="fc-YOUR_API_KEY")

# Definí la forma exacta que querés que tengan los datos
class Fundador(BaseModel):
    nombre: str = Field(description="Nombre completo del fundador")
    rol: Optional[str] = Field(None, description="Rol o cargo")

class EsquemaFundadores(BaseModel):
    fundadores: List[Fundador] = Field(description="Lista de fundadores")

# Pedí los datos describiendo qué buscás + el esquema
result = app.agent(
    prompt="Encontrá los fundadores de Firecrawl",
    schema=EsquemaFundadores
)

print(result.data)

La diferencia entre esto y scrapear a mano es enorme. Sin esquema, te toca a vos escribir el código que parsea el texto y saca el dato. Con esquema, le delegás esa tarea a Firecrawl y recibís el JSON listo. Para llenar una tabla de tu sistema con información de la web, es justo lo que necesitás.

Self-hosted vs. nube: cuál te conviene

Firecrawl es open-source bajo licencia AGPL-3.0, así que tenés dos caminos y ninguno es "el correcto" —depende de tu caso.

La versión en la nube (en firecrawl.dev) es la vía rápida: te registrás, sacás una API key y empezás. Ellos se encargan de los proxies, la infraestructura, los límites de uso y las páginas difíciles. Es lo que conviene si querés resultados hoy y no tenés ganas de mantener servidores. La nube además incluye algunas funciones extra que no vienen en la versión abierta.

El self-hosted es montar Firecrawl en tu propia infraestructura. Tiene sentido cuando los datos no pueden salir de tu empresa por políticas de privacidad, cuando necesitás control total, o cuando el volumen es tan grande que te conviene operarlo vos. El costo es el mantenimiento: te hacés cargo de los proxies y de que todo siga funcionando. Si vas por este lado, la documentación tiene una guía de self-hosting.

Recomendación práctica para empezar: arrancá con la nube para validar que Firecrawl resuelve tu problema. Si más adelante el volumen o la privacidad lo justifican, migrás a self-hosted con la tranquilidad de que ya sabés que la herramienta te sirve.

Cómo sacar tu API key

Si vas por la nube, conseguir la credencial es directo:

1. Entrá a firecrawl.dev y registrate.
2. En el panel vas a encontrar tu API key. Empieza con el prefijo fc-.
3. Antes de programar nada, probala en el playground: pegás una URL y ves el markdown que sale, sin escribir una línea de código.

Una buena práctica de seguridad: no pegues la key directo en tu código ni la subas a un repositorio. Guardala en una variable de entorno y leéla desde ahí. Por ejemplo, exportás FIRECRAWL_API_KEY en tu sistema y en el código la levantás así:

import os
from firecrawl import Firecrawl

# Leé la key desde una variable de entorno, nunca la hardcodees
app = Firecrawl(api_key=os.environ["FIRECRAWL_API_KEY"])

doc = app.scrape("https://firecrawl.dev", formats=["markdown"])
print(doc.markdown)

Así, si compartís el código, la credencial no viaja con él.

Una nota sobre el uso responsable

Firecrawl te da una herramienta potente, y con eso viene una responsabilidad: respetar las reglas de los sitios que scrapeás. Por defecto Firecrawl respeta el archivo robots.txt (la forma en que un sitio indica qué se puede recorrer y qué no), y queda de tu lado cumplir con los términos de uso y las políticas de privacidad de cada sitio. Scrapear no es lo mismo que tener permiso para usar todo lo que encontrás: usá la cabeza, sobre todo si los datos son de terceros o personales.

Próximo paso

Sacá tu API key en firecrawl.dev y hacé la prueba más chica posible: scrapeá una sola página que te importe —la doc de una herramienta que usás, el blog de un competidor— y mirá el markdown que sale. En cinco minutos vas a entender por qué esto cambia lo que tu IA puede hacer.

Si querés que veamos juntos cómo conectar datos reales de la web a tu RAG o a tus agentes —con tus fuentes, tu caso y tu stack— reservá una llamada en /agenda y lo armamos en vivo.