Minha jornada com computadores começou na infância, quando meu pai, cientista da computação, me apresentou um computador Amstrad. Aqueles primeiros dias despertaram uma fascinação pela tecnologia, levando-me a estudar ciência da computação e me especializar em PLN durante meus estudos de pós-graduação. Foi nessa época que mergulhei no rastreamento web, construindo ferramentas para ajudar pesquisadores a organizar artigos e extrair informações de publicações - uma experiência desafiadora, mas gratificante, que aprimorou minhas habilidades em extração de dados.

Avançando para 2023, eu estava trabalhando em uma ferramenta para um projeto e precisava de um rastreador para converter uma página web em markdown. Ao explorar soluções, encontrei uma que alegava ser de código aberto, mas exigia criar uma conta e gerar um token de API. Pior, acabou sendo um modelo SaaS cobrando $16, e sua qualidade não atendia aos meus padrões. Frustrado, percebi que isso era um problema mais profundo. Essa frustração se transformou em modo turbo de raiva, e decidi construir minha própria solução. Em apenas alguns dias, criei o Crawl4AI. Para minha surpresa, ele se tornou viral, ganhando milhares de estrelas no GitHub e ressoando com uma comunidade global.

Tornei o Crawl4AI de código aberto por dois motivos. Primeiro, é minha forma de retribuir à comunidade de código aberto que me apoiou ao longo da minha carreira. Segundo, acredito que os dados devem ser acessíveis a todos, não trancados atrás de paywalls ou monopolizados por poucos. O acesso aberto aos dados estabelece a base para a democratização da IA, uma visão onde indivíduos podem treinar seus próprios modelos e assumir a propriedade de suas informações. Esta biblioteca é o primeiro passo em uma jornada maior para criar a melhor ferramenta de extração e geração de dados de código aberto que o mundo já viu, construída colaborativamente por uma comunidade apaixonada.

Agradeço a todos que apoiaram este projeto, usaram-no e compartilharam feedback. Seu incentivo me motiva a sonhar ainda maior. Junte-se a nós, registre problemas, envie PRs ou espalhe a palavra. Juntos, podemos construir uma ferramenta que realmente capacite as pessoas a acessar seus próprios dados e remodelar o futuro da IA.

• 🧹 Markdown Limpo: Gera Markdown limpo e estruturado com formatação precisa.
• 🎯 Markdown Ajustado: Filtragem baseada em heurística para remover ruídos e partes irrelevantes para processamento amigável à IA.
• 🔗 Citações e Referências: Converte links de página em uma lista de referências numeradas com citações limpas.
• 🛠️ Estratégias Personalizadas: Os usuários podem criar suas próprias estratégias de geração de Markdown adaptadas a necessidades específicas.
• 📚 Algoritmo BM25: Emprega filtragem baseada em BM25 para extrair informações principais e remover conteúdo irrelevante.

• 🤖 Extração Dirigida por LLM: Suporta todos os LLMs (código aberto e proprietários) para extração de dados estruturados.
• 🧱 Estratégias de Chunking: Implementa chunking (baseado em tópico, regex, nível de frase) para processamento de conteúdo direcionado.
• 🌌 Similaridade de Cosseno: Encontra chunks de conteúdo relevantes com base em consultas do usuário para extração semântica.
• 🔎 Extração Baseada em CSS: Extração rápida de dados baseada em esquema usando XPath e seletores CSS.
• 🔧 Definição de Esquema: Defina esquemas personalizados para extrair JSON estruturado de padrões repetitivos.

• 🖥️ Navegador Gerenciado: Use navegadores de propriedade do usuário com controle total, evitando detecção de bots.
• 🔄 Controle Remoto do Navegador: Conecte-se ao Chrome Developer Tools Protocol para extração de dados remota em larga escala.
• 👤 Perfil do Navegador: Crie e gerencie perfis persistentes com estados de autenticação salvos, cookies e configurações.
• 🔒 Gerenciamento de Sessão: Preserve estados do navegador e reutilize-os para rastreamento em várias etapas.
• 🧩 Suporte a Proxy: Conecte-se perfeitamente a proxies com autenticação para acesso seguro.
• ⚙️ Controle Total do Navegador: Modifique cabeçalhos, cookies, user agents e mais para configurações de rastreamento personalizadas.
• 🌍 Suporte a Múltiplos Navegadores: Compatível com Chromium, Firefox e WebKit.
• 📐 Ajuste Dinâmico de Viewport: Ajusta automaticamente a viewport do navegador para corresponder ao conteúdo da página, garantindo renderização completa e captura de todos os elementos.

• 🖼️ Suporte a Mídia: Extrai imagens, áudio, vídeos e formatos de imagem responsivos como srcset e picture.
• 🚀 Rastreamento Dinâmico: Executa JS e aguarda conteúdo assíncrono ou síncrono para extração dinâmica.
• 📸 Capturas de Tela: Captura screenshots da página durante o rastreamento para depuração ou análise.
• 📂 Rastreamento de Dados Brutos: Processa diretamente HTML bruto (raw:) ou arquivos locais (file://).
• 🔗 Extração Abrangente de Links: Extrai links internos, externos e conteúdo incorporado de iframes.
• 🛠️ Hooks Personalizáveis: Define hooks em cada etapa para personalizar o comportamento de rastreamento.
• 💾 Cache: Armazena dados em cache para melhorar a velocidade e evitar buscas redundantes.
• 📄 Extração de Metadados: Recupera metadados estruturados de páginas web.
• 📡 Extração de Conteúdo de IFrame: Extração contínua de conteúdo incorporado em iframes.
• 🕵️ Tratamento de Carregamento Preguiçoso: Aguarda o carregamento completo de imagens, garantindo que nenhum conteúdo seja perdido devido ao lazy loading.
• 🔄 Varredura Completa da Página: Simula rolagem para carregar e capturar todo o conteúdo dinâmico, perfeito para páginas com rolagem infinita.

• 🐳 Configuração Dockerizada: Imagem Docker otimizada com servidor FastAPI para implantação fácil.
• 🔑 Autenticação Segura: Autenticação JWT integrada para segurança da API.
• 🔄 Gateway de API: Implantação com um clique com autenticação por token segura para fluxos de trabalho baseados em API.
• 🌐 Arquitetura Escalável: Projetada para produção em massa e desempenho otimizado do servidor.
• ☁️ Implantação em Nuvem: Configurações prontas para implantação nas principais plataformas de nuvem.

• 🕶️ Modo Furtivo: Evita detecção de bots imitando usuários reais.
• 🏷️ Extração de Conteúdo Baseada em Tags: Refina o rastreamento com base em tags personalizadas, cabeçalhos ou metadados.
• 🔗 Análise de Links: Extrai e analisa todos os links para exploração detalhada de dados.
• 🛡️ Tratamento de Erros: Gerenciamento robusto de erros para execução contínua.
• 🔐 CORS & Serviço Estático: Suporta cache baseado em sistema de arquivos e requisições cross-origin.
• 📖 Documentação Clara: Guias simplificados e atualizados para onboarding e uso avançado.
• 🙌 Reconhecimento da Comunidade: Reconhece contribuidores e pull requests para transparência.

Escolha a opção de instalação que melhor atenda às suas necessidades:

Instalação Básica

Para tarefas básicas de rastreamento e extração web:

pip install crawl4ai
crawl4ai-setup # Setup the browser

Por padrão, isso instalará a versão assíncrona do Crawl4AI, usando Playwright para rastreamento web.

👉 Nota: Ao instalar o Crawl4AI, o crawl4ai-setup deve instalar e configurar automaticamente o Playwright. No entanto, se encontrar erros relacionados ao Playwright, você pode instalá-lo manualmente usando um destes métodos:

1. Pela linha de comando:

   playwright install
   

2. Se o acima não funcionar, tente este comando mais específico:

   python -m playwright install chromium
   

Este segundo método provou ser mais confiável em alguns casos.

Instalação com Versão Síncrona

A versão síncrona está obsoleta e será removida em versões futuras. Se precisar da versão síncrona usando Selenium:

pip install crawl4ai[sync]

Instalação para Desenvolvimento

Para contribuidores que planejam modificar o código-fonte:

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

Instale recursos opcionais:

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

🚀 Agora Disponível! Nossa implementação Docker completamente redesenhada está aqui! Esta nova solução torna a implantação mais eficiente e contínua do que nunca.

Novos Recursos Docker

A nova implementação Docker inclui:

• Pool de navegadores com pré-aquecimento de páginas para tempos de resposta mais rápidos
• Playground interativo para testar e gerar código de requisição
• Integração MCP para conexão direta com ferramentas de IA como Claude Code
• Endpoints abrangentes de API incluindo extração HTML, screenshots, geração de PDF e execução de JavaScript
• Suporte a múltiplas arquiteturas com detecção automática (AMD64/ARM64)
• Recursos otimizados com gerenciamento de memória aprimorado

Começando

# 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 documentação completa, consulte nosso Guia de Implantação 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 em Grafo: Navegação inteligente em sites usando algoritmos de busca em grafo para extração abrangente de páginas aninhadas
• 1. Rastreador Baseado em Perguntas: Descoberta e extração de conteúdo na web orientada por linguagem natural
• 2. Rastreador de Conhecimento Ótimo: Rastreamento inteligente que maximiza conhecimento enquanto minimiza extração de dados
• 3. Rastreador Agente: Sistema autônomo para operações complexas de rastreamento em múltiplos passos
• 4. Gerador Automático de Esquema: Converte linguagem natural em esquemas de extração
• 5. Raspadores Específicos por Domínio: Extratores pré-configurados para plataformas comuns (acadêmicas, e-commerce)
• 6. Índice de Incorporação Web: Infraestrutura de busca semântica para conteúdo rastreado
• 7. Playground Interativo: Interface web para testar e comparar estratégias com assistência de IA
• 8. Monitor de Performance: Insights em tempo real sobre operações do rastreador
• 9. Integração com Nuvem: Soluções de implantação com um clique em provedores de nuvem
• 10. Programa de Patrocínio: Sistema de suporte estruturado com benefícios em camadas
• 11. Conteúdo Educacional: Série de vídeos "Como Rastrear" e tutoriais interativos

• Capitalização de Dados: Transforme pegadas digitais em ativos mensuráveis e valiosos.
• Dados Autênticos para IA: Forneça aos sistemas de IA insights humanos reais.
• Economia Compartilhada: Crie um mercado de dados justo que beneficie criadores de dados.

1. Ferramentas de Código Aberto: Plataformas dirigidas pela comunidade para extração transparente de dados.
2. Estruturação de Ativos Digitais: Ferramentas para organizar e valorar conhecimento digital.
3. Mercado de Dados Ético: Uma plataforma segura e justa para troca de dados estruturados.

Para mais detalhes, veja nossa declaração de missão completa.