Mi viaje con las computadoras comenzó en la infancia cuando mi padre, un científico de la computación, me presentó una computadora Amstrad. Esos primeros días despertaron una fascinación por la tecnología, llevándome a estudiar ciencias de la computación y especializarme en PNL durante mis estudios de posgrado. Fue durante este tiempo que me sumergí por primera vez en el rastreo web, construyendo herramientas para ayudar a los investigadores a organizar artículos y extraer información de publicaciones, una experiencia desafiante pero gratificante que perfeccionó mis habilidades en extracción de datos.

Avanzando rápidamente a 2023, estaba trabajando en una herramienta para un proyecto y necesitaba un rastreador para convertir una página web en markdown. Mientras exploraba soluciones, encontré una que afirmaba ser de código abierto pero requería crear una cuenta y generar un token de API. Peor aún, resultó ser un modelo SaaS que cobraba $16, y su calidad no cumplía con mis estándares. Frustrado, me di cuenta de que este era un problema más profundo. Esa frustración se convirtió en modo turbo de enojo, y decidí construir mi propia solución. En solo unos días, creé Crawl4AI. Para mi sorpresa, se volvió viral, ganando miles de estrellas en GitHub y resonando con una comunidad global.

Hice Crawl4AI de código abierto por dos razones. Primero, es mi manera de devolver a la comunidad de código abierto que me ha apoyado a lo largo de mi carrera. Segundo, creo que los datos deberían ser accesibles para todos, no bloqueados detrás de muros de pago o monopolizados por unos pocos. El acceso abierto a los datos sienta las bases para la democratización de la IA, una visión donde las personas pueden entrenar sus propios modelos y tomar posesión de su información. Esta biblioteca es el primer paso en un viaje más grande para crear la mejor herramienta de extracción y generación de datos de código abierto que el mundo haya visto, construida colaborativamente por una comunidad apasionada.

Gracias a todos los que han apoyado este proyecto, lo han usado y compartido comentarios. Su aliento me motiva a soñar aún más grande. Únanse, reporten problemas, envíen PRs o corran la voz. Juntos, podemos construir una herramienta que realmente empodere a las personas para acceder a sus propios datos y remodelar el futuro de la IA.

• 🧹 Markdown Limpio: Genera Markdown limpio y estructurado con formato preciso.
• 🎯 Markdown Ajustado: Filtrado basado en heurísticas para eliminar ruido y partes irrelevantes para un procesamiento amigable con IA.
• 🔗 Citas y Referencias: Convierte enlaces de página en una lista de referencias numerada con citas limpias.
• 🛠️ Estrategias Personalizadas: Los usuarios pueden crear sus propias estrategias de generación de Markdown adaptadas a necesidades específicas.
• 📚 Algoritmo BM25: Emplea filtrado basado en BM25 para extraer información central y eliminar contenido irrelevante.

• 🤖 Extracción Impulsada por LLM: Soporta todos los LLMs (de código abierto y propietarios) para extracción de datos estructurados.
• 🧱 Estrategias de Fragmentación: Implementa fragmentación (basada en temas, regex, nivel de oración) para procesamiento de contenido dirigido.
• 🌌 Similitud de Coseno: Encuentra fragmentos de contenido relevantes basados en consultas de usuario para extracción semántica.
• 🔎 Extracción Basada en CSS: Extracción rápida de datos basada en esquemas usando XPath y selectores CSS.
• 🔧 Definición de Esquema: Define esquemas personalizados para extraer JSON estructurado de patrones repetitivos.

• 🖥️ Navegador Gestionado: Usa navegadores propiedad del usuario con control total, evitando detección de bots.
• 🔄 Control Remoto del Navegador: Conéctate al Protocolo de Herramientas de Desarrollo de Chrome para extracción de datos remota a gran escala.
• 👤 Perfilador de Navegador: Crea y gestiona perfiles persistentes con estados de autenticación guardados, cookies y configuraciones.
• 🔒 Gestión de Sesiones: Preserva estados del navegador y reutilízalos para rastreo de múltiples pasos.
• 🧩 Soporte para Proxies: Conéctate sin problemas a proxies con autenticación para acceso seguro.
• ⚙️ Control Total del Navegador: Modifica encabezados, cookies, agentes de usuario y más para configuraciones de rastreo personalizadas.
• 🌍 Soporte para Múltiples Navegadores: Compatible con Chromium, Firefox y WebKit.
• 📐 Ajuste Dinámico de Viewport: Ajusta automáticamente el viewport del navegador para coincidir con el contenido de la página, asegurando renderizado completo y captura de todos los elementos.

• 🖼️ Soporte para Medios: Extrae imágenes, audio, videos y formatos de imagen responsivos como srcset y picture.
• 🚀 Rastreo Dinámico: Ejecuta JS y espera contenido asíncrono o síncrono para extracción dinámica.
• 📸 Capturas de Pantalla: Captura pantallas de página durante el rastreo para depuración o análisis.
• 📂 Rastreo de Datos Crudos: Procesa HTML crudo (raw:) o archivos locales (file://) directamente.
• 🔗 Extracción Completa de Enlaces: Extrae enlaces internos, externos y contenido de iframes incrustados.
• 🛠️ Hooks Personalizables: Define hooks en cada paso para personalizar el comportamiento del rastreo.
• 💾 Caché: Almacena datos en caché para mejorar la velocidad y evitar recuperaciones redundantes.
• 📄 Extracción de Metadatos: Recupera metadatos estructurados de páginas web.
• 📡 Extracción de Contenido de IFrames: Extracción fluida de contenido de iframes incrustados.
• 🕵️ Manejo de Carga Diferida: Espera a que las imágenes se carguen completamente, asegurando que no se pierda contenido debido a carga diferida.
• 🔄 Escaneo de Página Completa: Simula desplazamiento para cargar y capturar todo el contenido dinámico, perfecto para páginas con desplazamiento infinito.

• 🐳 Configuración Dockerizada: Imagen Docker optimizada con servidor FastAPI para despliegue fácil.
• 🔑 Autenticación Segura: Autenticación JWT integrada para seguridad de API.
• 🔄 Puerta de Enlace API: Despliegue con un clic con autenticación segura de token para flujos de trabajo basados en API.
• 🌐 Arquitectura Escalable: Diseñada para producción a gran escala y rendimiento optimizado del servidor.
• ☁️ Despliegue en la Nube: Configuraciones listas para desplegar en plataformas en la nube principales.

• 🕶️ Modo Sigiloso: Evita la detección de bots imitando usuarios reales.
• 🏷️ Extracción de Contenido Basada en Etiquetas: Refina el rastreo basado en etiquetas personalizadas, encabezados o metadatos.
• 🔗 Análisis de Enlaces: Extrae y analiza todos los enlaces para exploración detallada de datos.
• 🛡️ Manejo de Errores: Gestión robusta de errores para ejecución sin problemas.
• 🔐 CORS y Servicio Estático: Soporta caché basado en sistema de archivos y solicitudes cross-origin.
• 📖 Documentación Clara: Guías simplificadas y actualizadas para incorporación y uso avanzado.
• 🙌 Reconocimiento Comunitario: Reconoce contribuidores y pull requests para transparencia.

Elige la opción de instalación que mejor se adapte a tus necesidades:

Instalación Básica

Para tareas básicas de rastreo web y extracción:

pip install crawl4ai
crawl4ai-setup # Setup the browser

Por defecto, esto instalará la versión asíncrona de Crawl4AI, usando Playwright para rastreo web.

👉 Nota: Cuando instalas Crawl4AI, crawl4ai-setup debería instalar y configurar automáticamente Playwright. Sin embargo, si encuentras algún error relacionado con Playwright, puedes instalarlo manualmente usando uno de estos métodos:

1. A través de la línea de comandos:

   playwright install
   

2. Si lo anterior no funciona, prueba este comando más específico:

   python -m playwright install chromium
   

Este segundo método ha demostrado ser más confiable en algunos casos.

Instalación con Versión Síncrona

La versión síncrona está obsoleta y se eliminará en versiones futuras. Si necesitas la versión síncrona usando Selenium:

pip install crawl4ai[sync]

Instalación para Desarrollo

Para contribuidores que planean modificar el código fuente:

git clone https://github.com/unclecode/crawl4ai.git
cd crawl4ai
pip install -e .                    # Basic installation in editable mode

Instala características opcionales:

pip install -e ".[torch]"           # With PyTorch features
pip install -e ".[transformer]"     # With Transformer features
pip install -e ".[cosine]"          # With cosine similarity features
pip install -e ".[sync]"            # With synchronous crawling (Selenium)
pip install -e ".[all]"             # Install all optional features

🚀 ¡Ahora Disponible! ¡Nuestra implementación Docker completamente rediseñada está aquí! Esta nueva solución hace que el despliegue sea más eficiente y fluido que nunca.

Nuevas Características de Docker

La nueva implementación Docker incluye:

• Agrupación de navegadores con precalentamiento de páginas para tiempos de respuesta más rápidos
• Playground interactivo para probar y generar código de solicitud
• Integración MCP para conexión directa con herramientas de IA como Claude Code
• Puntos finales API completos incluyendo extracción HTML, capturas de pantalla, generación de PDF y ejecución de JavaScript
• Soporte multi-arquitectura con detección automática (AMD64/ARM64)
• Recursos optimizados con mejor gestión de memoria

Comenzando

# Pull and run the latest release candidate
docker pull unclecode/crawl4ai:0.6.0-rN # Use your favorite revision number
docker run -d -p 11235:11235 --name crawl4ai --shm-size=1g unclecode/crawl4ai:0.6.0-rN # Use your favorite revision number

# Visit the playground at http://localhost:11235/playground

Para documentación completa, consulta nuestra Guía de Despliegue Docker.

import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
from crawl4ai.content_filter_strategy import PruningContentFilter, BM25ContentFilter
from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator

async def main():
    browser_config = BrowserConfig(
        headless=True,  
        verbose=True,
    )
    run_config = CrawlerRunConfig(
        cache_mode=CacheMode.ENABLED,
        markdown_generator=DefaultMarkdownGenerator(
            content_filter=PruningContentFilter(threshold=0.48, threshold_type="fixed", min_word_threshold=0)
        ),
        # markdown_generator=DefaultMarkdownGenerator(
        #     content_filter=BM25ContentFilter(user_query="WHEN_WE_FOCUS_BASED_ON_A_USER_QUERY", bm25_threshold=1.0)
        # ),
    )
    
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result = await crawler.arun(
            url="https://docs.micronaut.io/4.7.6/guide/",
            config=run_config
        )
        print(len(result.markdown.raw_markdown))
        print(len(result.markdown.fit_markdown))

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
from crawl4ai.extraction_strategy import JsonCssExtractionStrategy
import json

async def main():
    schema = {
    "name": "KidoCode Courses",
    "baseSelector": "section.charge-methodology .w-tab-content > div",
    "fields": [
        {
            "name": "section_title",
            "selector": "h3.heading-50",
            "type": "text",
        },
        {
            "name": "section_description",
            "selector": ".charge-content",
            "type": "text",
        },
        {
            "name": "course_name",
            "selector": ".text-block-93",
            "type": "text",
        },
        {
            "name": "course_description",
            "selector": ".course-content-text",
            "type": "text",
        },
        {
            "name": "course_icon",
            "selector": ".image-92",
            "type": "attribute",
            "attribute": "src"
        }
    }
}

    extraction_strategy = JsonCssExtractionStrategy(schema, verbose=True)

    browser_config = BrowserConfig(
        headless=False,
        verbose=True
    )
    run_config = CrawlerRunConfig(
        extraction_strategy=extraction_strategy,
        js_code=["""(async () => {const tabs = document.querySelectorAll("section.charge-methodology .tabs-menu-3 > div");for(let tab of tabs) {tab.scrollIntoView();tab.click();await new Promise(r => setTimeout(r, 500));}})();"""],
        cache_mode=CacheMode.BYPASS
    )
        
    async with AsyncWebCrawler(config=browser_config) as crawler:
        
        result = await crawler.arun(
            url="https://www.kidocode.com/degrees/technology",
            config=run_config
        )

        companies = json.loads(result.extracted_content)
        print(f"Successfully extracted {len(companies)} companies")
        print(json.dumps(companies[0], indent=2))


if __name__ == "__main__":
    asyncio.run(main())

import os
import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode, LLMConfig
from crawl4ai.extraction_strategy import LLMExtractionStrategy
from pydantic import BaseModel, Field

class OpenAIModelFee(BaseModel):
    model_name: str = Field(..., description="Name of the OpenAI model.")
    input_fee: str = Field(..., description="Fee for input token for the OpenAI model.")
    output_fee: str = Field(..., description="Fee for output token for the OpenAI model.")

async def main():
    browser_config = BrowserConfig(verbose=True)
    run_config = CrawlerRunConfig(
        word_count_threshold=1,
        extraction_strategy=LLMExtractionStrategy(
            # Here you can use any provider that Litellm library supports, for instance: ollama/qwen2
            # provider="ollama/qwen2", api_token="no-token", 
            llm_config = LLMConfig(provider="openai/gpt-4o", api_token=os.getenv('OPENAI_API_KEY')), 
            schema=OpenAIModelFee.schema(),
            extraction_type="schema",
            instruction="""From the crawled content, extract all mentioned model names along with their fees for input and output tokens. 
            Do not miss any models in the entire content. One extracted model JSON format should look like this: 
            {"model_name": "GPT-4", "input_fee": "US$10.00 / 1M tokens", "output_fee": "US$30.00 / 1M tokens"}."""
        ),            
        cache_mode=CacheMode.BYPASS,
    )
    
    async with AsyncWebCrawler(config=browser_config) as crawler:
        result = await crawler.arun(
            url='https://openai.com/api/pricing/',
            config=run_config
        )
        print(result.extracted_content)

if __name__ == "__main__":
    asyncio.run(main())

import os, sys
from pathlib import Path
import asyncio, time
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode

async def test_news_crawl():
    # Create a persistent user data directory
    user_data_dir = os.path.join(Path.home(), ".crawl4ai", "browser_profile")
    os.makedirs(user_data_dir, exist_ok=True)

    browser_config = BrowserConfig(
        verbose=True,
        headless=True,
        user_data_dir=user_data_dir,
        use_persistent_context=True,
    )
    run_config = CrawlerRunConfig(
        cache_mode=CacheMode.BYPASS
    )
    
    async with AsyncWebCrawler(config=browser_config) as crawler:
        url = "ADDRESS_OF_A_CHALLENGING_WEBSITE"
        
        result = await crawler.arun(
            url,
            config=run_config,
            magic=True,
        )
        
        print(f"Successfully crawled {url}")
        print(f"Content length: {len(result.markdown)}")

• 0. Rastreador de Grafos: Navegación inteligente por sitios web usando algoritmos de búsqueda en grafos para extracción completa de páginas anidadas
• 1. Rastreador Basado en Preguntas: Descubrimiento web y extracción de contenido guiado por lenguaje natural
• 2. Rastreador de Conocimiento Óptimo: Rastreo inteligente que maximiza el conocimiento mientras minimiza la extracción de datos
• 3. Rastreador Agéntico: Sistema autónomo para operaciones complejas de rastreo multi-paso
• 4. Generador Automático de Esquemas: Convierte lenguaje natural en esquemas de extracción
• 5. Scrapers Específicos por Dominio: Extractores preconfigurados para plataformas comunes (académicas, e-commerce)
• 6. Índice de Incrustación Web: Infraestructura de búsqueda semántica para contenido rastreado
• 7. Entorno Interactivo: Interfaz web para probar y comparar estrategias con asistencia de IA
• 8. Monitor de Rendimiento: Información en tiempo real sobre operaciones del rastreador
• 9. Integración en la Nube: Soluciones de despliegue con un clic en proveedores cloud
• 10. Programa de Patrocinio: Sistema de soporte estructurado con beneficios por niveles
• 11. Contenido Educativo: Serie de videos "Cómo Rastrear" y tutoriales interactivos

• Capitalización de Datos: Transforma huellas digitales en activos medibles y valiosos.
• Datos Auténticos para IA: Proporciona a los sistemas de IA conocimientos humanos reales.
• Economía Compartida: Crea un mercado justo de datos que beneficie a los creadores.

1. Herramientas de Código Abierto: Plataformas impulsadas por la comunidad para extracción transparente de datos.
2. Estructuración de Activos Digitales: Herramientas para organizar y valorar conocimiento digital.
3. Mercado Ético de Datos: Una plataforma segura y justa para intercambiar datos estructurados.

Para más detalles, consulta nuestra declaración de misión completa.