crawl4ai
1.0.0
Crawl4AI simplifica o rastreamento assíncrono da web e a extração de dados, tornando-os acessíveis para grandes modelos de linguagem (LLMs) e aplicativos de IA. ?
CrawlResult .srcset , picture e responsivo.file:// e HTML bruto ( raw: ) diretamente.Brinque com isso
Visite nosso site de documentação
Crawl4AI oferece opções de instalação flexíveis para atender a vários casos de uso. Você pode instalá-lo como um pacote Python ou usar o Docker.
Escolha a opção de instalação que melhor atende às suas necessidades:
Para tarefas básicas de rastreamento e raspagem da web:
pip install crawl4aiPor padrão, isso instalará a versão assíncrona do Crawl4AI, usando o Playwright para rastreamento da web.
Nota: Ao instalar o Crawl4AI, o script de configuração deve instalar e configurar automaticamente o Playwright. No entanto, se você encontrar algum erro relacionado ao Playwright, poderá instalá-lo manualmente usando um destes métodos:
Através da linha de comando:
playwright installSe o procedimento acima não funcionar, tente este comando mais específico:
python -m playwright install chromiumEste segundo método provou ser mais confiável em alguns casos.
Se você precisar da versão síncrona usando Selenium:
pip install crawl4ai[sync]Para contribuidores que planejam modificar o código-fonte:
git clone https://github.com/unclecode/crawl4ai.git
cd crawl4ai
pip install -e . Implante sua própria instância do Crawl4AI com um clique:
Especificações recomendadas : mínimo de 4 GB de RAM. Selecione "professional-xs" ou superior ao implantar para operação estável.
A implantação irá:
Crawl4AI está disponível como imagens Docker para fácil implantação. Você pode extrair diretamente do Docker Hub (recomendado) ou compilar a partir do repositório.
# Pull and run from Docker Hub (choose one):
docker pull unclecode/crawl4ai:basic # Basic crawling features
docker pull unclecode/crawl4ai:all # Full installation (ML, LLM support)
docker pull unclecode/crawl4ai:gpu # GPU-enabled version
# Run the container
docker run -p 11235:11235 unclecode/crawl4ai:basic # Replace 'basic' with your chosen version
# In case you want to set platform to arm64
docker run --platform linux/arm64 -p 11235:11235 unclecode/crawl4ai:basic
# In case to allocate more shared memory for the container
docker run --shm-size=2gb -p 11235:11235 unclecode/crawl4ai:basic # Clone the repository
git clone https://github.com/unclecode/crawl4ai.git
cd crawl4ai
# Build the image
docker build -t crawl4ai:local
--build-arg INSTALL_TYPE=basic # Options: basic, all
.
# In case you want to set platform to arm64
docker build -t crawl4ai:local
--build-arg INSTALL_TYPE=basic # Options: basic, all
--platform linux/arm64
.
# Run your local build
docker run -p 11235:11235 crawl4ai:localTeste rápido (funciona para ambas as opções):
import requests
# Submit a crawl job
response = requests . post (
"http://localhost:11235/crawl" ,
json = { "urls" : "https://example.com" , "priority" : 10 }
)
task_id = response . json ()[ "task_id" ]
# Get results
result = requests . get ( f"http://localhost:11235/task/ { task_id } " )Para configuração avançada, variáveis de ambiente e exemplos de uso, consulte nosso Guia de implantação do Docker.
import asyncio
from crawl4ai import AsyncWebCrawler
async def main ():
async with AsyncWebCrawler ( verbose = True ) as crawler :
result = await crawler . arun ( url = "https://www.nbcnews.com/business" )
print ( result . markdown )
if __name__ == "__main__" :
asyncio . run ( main ()) import asyncio
from crawl4ai import AsyncWebCrawler
async def main ():
async with AsyncWebCrawler ( verbose = True ) as crawler :
js_code = [ "const loadMoreButton = Array.from(document.querySelectorAll('button')).find(button => button.textContent.includes('Load More')); loadMoreButton && loadMoreButton.click();" ]
result = await crawler . arun (
url = "https://www.nbcnews.com/business" ,
js_code = js_code ,
css_selector = ".wide-tease-item__description" ,
bypass_cache = True
)
print ( result . extracted_content )
if __name__ == "__main__" :
asyncio . run ( main ()) import asyncio
from crawl4ai import AsyncWebCrawler
async def main ():
async with AsyncWebCrawler ( verbose = True , proxy = "http://127.0.0.1:7890" ) as crawler :
result = await crawler . arun (
url = "https://www.nbcnews.com/business" ,
bypass_cache = True
)
print ( result . markdown )
if __name__ == "__main__" :
asyncio . run ( main ()) O JsonCssExtractionStrategy permite a extração precisa de dados estruturados de páginas da web usando seletores CSS.
import asyncio
import json
from crawl4ai import AsyncWebCrawler
from crawl4ai . extraction_strategy import JsonCssExtractionStrategy
async def extract_news_teasers ():
schema = {
"name" : "News Teaser Extractor" ,
"baseSelector" : ".wide-tease-item__wrapper" ,
"fields" : [
{
"name" : "category" ,
"selector" : ".unibrow span[data-testid='unibrow-text']" ,
"type" : "text" ,
},
{
"name" : "headline" ,
"selector" : ".wide-tease-item__headline" ,
"type" : "text" ,
},
{
"name" : "summary" ,
"selector" : ".wide-tease-item__description" ,
"type" : "text" ,
},
{
"name" : "time" ,
"selector" : "[data-testid='wide-tease-date']" ,
"type" : "text" ,
},
{
"name" : "image" ,
"type" : "nested" ,
"selector" : "picture.teasePicture img" ,
"fields" : [
{ "name" : "src" , "type" : "attribute" , "attribute" : "src" },
{ "name" : "alt" , "type" : "attribute" , "attribute" : "alt" },
],
},
{
"name" : "link" ,
"selector" : "a[href]" ,
"type" : "attribute" ,
"attribute" : "href" ,
},
],
}
extraction_strategy = JsonCssExtractionStrategy ( schema , verbose = True )
async with AsyncWebCrawler ( verbose = True ) as crawler :
result = await crawler . arun (
url = "https://www.nbcnews.com/business" ,
extraction_strategy = extraction_strategy ,
bypass_cache = True ,
)
assert result . success , "Failed to crawl the page"
news_teasers = json . loads ( result . extracted_content )
print ( f"Successfully extracted { len ( news_teasers ) } news teasers" )
print ( json . dumps ( news_teasers [ 0 ], indent = 2 ))
if __name__ == "__main__" :
asyncio . run ( extract_news_teasers ())Para exemplos de uso mais avançados, confira nossa seção Exemplos na documentação.
import os
import asyncio
from crawl4ai import AsyncWebCrawler
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 ():
async with AsyncWebCrawler ( verbose = True ) as crawler :
result = await crawler . arun (
url = 'https://openai.com/api/pricing/' ,
word_count_threshold = 1 ,
extraction_strategy = LLMExtractionStrategy (
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"}."""
),
bypass_cache = True ,
)
print ( result . extracted_content )
if __name__ == "__main__" :
asyncio . run ( main ())Crawl4AI é excelente no tratamento de cenários complexos, como rastreamento de múltiplas páginas com conteúdo dinâmico carregado via JavaScript. Aqui está um exemplo de rastreamento de commits do GitHub em várias páginas:
import asyncio
import re
from bs4 import BeautifulSoup
from crawl4ai import AsyncWebCrawler
async def crawl_typescript_commits ():
first_commit = ""
async def on_execution_started ( page ):
nonlocal first_commit
try :
while True :
await page . wait_for_selector ( 'li.Box-sc-g0xbh4-0 h4' )
commit = await page . query_selector ( 'li.Box-sc-g0xbh4-0 h4' )
commit = await commit . evaluate ( '(element) => element.textContent' )
commit = re . sub ( r's+' , '' , commit )
if commit and commit != first_commit :
first_commit = commit
break
await asyncio . sleep ( 0.5 )
except Exception as e :
print ( f"Warning: New content didn't appear after JavaScript execution: { e } " )
async with AsyncWebCrawler ( verbose = True ) as crawler :
crawler . crawler_strategy . set_hook ( 'on_execution_started' , on_execution_started )
url = "https://github.com/microsoft/TypeScript/commits/main"
session_id = "typescript_commits_session"
all_commits = []
js_next_page = """
const button = document.querySelector('a[data-testid="pagination-next-button"]');
if (button) button.click();
"""
for page in range ( 3 ): # Crawl 3 pages
result = await crawler . arun (
url = url ,
session_id = session_id ,
css_selector = "li.Box-sc-g0xbh4-0" ,
js = js_next_page if page > 0 else None ,
bypass_cache = True ,
js_only = page > 0
)
assert result . success , f"Failed to crawl page { page + 1 } "
soup = BeautifulSoup ( result . cleaned_html , 'html.parser' )
commits = soup . select ( "li" )
all_commits . extend ( commits )
print ( f"Page { page + 1 } : Found { len ( commits ) } commits" )
await crawler . crawler_strategy . kill_session ( session_id )
print ( f"Successfully crawled { len ( all_commits ) } commits across 3 pages" )
if __name__ == "__main__" :
asyncio . run ( crawl_typescript_commits ())Este exemplo demonstra a capacidade do Crawl4AI de lidar com cenários complexos onde o conteúdo é carregado de forma assíncrona. Ele rastreia várias páginas de commits do GitHub, executando JavaScript para carregar novo conteúdo e usando ganchos personalizados para garantir que os dados sejam carregados antes de continuar.
Para exemplos de uso mais avançados, confira nossa seção Exemplos na documentação.
Crawl4AI foi projetado tendo a velocidade como foco principal. Nosso objetivo é fornecer a resposta mais rápida possível com extração de dados de alta qualidade, minimizando abstrações entre os dados e o usuário.
Realizamos uma comparação de velocidade entre Crawl4AI e Firecrawl, um serviço pago. Os resultados demonstram o desempenho superior do Crawl4AI:
Firecrawl:
Time taken: 7.02 seconds
Content length: 42074 characters
Images found: 49
Crawl4AI (simple crawl):
Time taken: 1.60 seconds
Content length: 18238 characters
Images found: 49
Crawl4AI (with JavaScript execution):
Time taken: 4.64 seconds
Content length: 40869 characters
Images found: 89Como você pode ver, Crawl4AI supera significativamente o Firecrawl:
Você pode encontrar o código de comparação completo em nosso repositório em docs/examples/crawl4ai_vs_firecrawl.py .
Para obter documentação detalhada, incluindo instruções de instalação, recursos avançados e referência de API, visite nosso site de documentação.
Para obter informações detalhadas sobre nossos planos de desenvolvimento e recursos futuros, confira nosso Roteiro.
Aceitamos contribuições da comunidade de código aberto. Confira nossas diretrizes de contribuição para obter mais informações.
Crawl4AI é lançado sob a licença Apache 2.0.
Para dúvidas, sugestões ou comentários, sinta-se à vontade para entrar em contato:
Feliz rastreamento! ?️
Nossa missão é desbloquear o potencial inexplorado dos dados pessoais e empresariais na era digital. No mundo de hoje, indivíduos e organizações geram grandes quantidades de pegadas digitais valiosas, mas estes dados permanecem em grande parte não capitalizados como um verdadeiro activo.
Nossa solução de código aberto capacita desenvolvedores e inovadores a criar ferramentas para extração e estruturação de dados, estabelecendo as bases para uma nova era de propriedade de dados. Ao transformar dados pessoais e empresariais em ativos estruturados e negociáveis, estamos a criar oportunidades para os indivíduos capitalizarem as suas pegadas digitais e para as organizações desbloquearem o valor do seu conhecimento coletivo.
Esta democratização dos dados representa o primeiro passo em direção a uma economia de dados partilhada, onde a participação voluntária na partilha de dados impulsiona o avanço da IA, assegurando ao mesmo tempo que os benefícios fluem de volta para os criadores de dados. Através desta abordagem, estamos a construir um futuro onde o desenvolvimento da IA é impulsionado pelo conhecimento humano autêntico, em vez de alternativas sintéticas.
Para uma exploração detalhada de nossa visão, oportunidades e caminho a seguir, consulte nossa declaração de missão completa.
Para uma exploração detalhada de nossa visão, desafios e soluções, consulte nossa declaração de missão completa.
