crawl4ai
1.0.0
Crawl4AI simplifica el rastreo web asincrónico y la extracción de datos, haciéndolo accesible para modelos de lenguajes grandes (LLM) y aplicaciones de inteligencia artificial. ?
CrawlResult .srcset , picture e imagen receptiva.file:// y HTML sin formato ( raw: :) directamente.Juega con esto
Visite nuestro sitio web de documentación
Crawl4AI ofrece opciones de instalación flexibles para adaptarse a diversos casos de uso. Puede instalarlo como un paquete de Python o utilizar Docker.
Elija la opción de instalación que mejor se adapte a sus necesidades:
Para tareas básicas de rastreo y raspado web:
pip install crawl4aiDe forma predeterminada, esto instalará la versión asincrónica de Crawl4AI, utilizando Playwright para el rastreo web.
Nota: Cuando instala Crawl4AI, el script de instalación debería instalar y configurar automáticamente Playwright. Sin embargo, si encuentra algún error relacionado con Playwright, puede instalarlo manualmente utilizando uno de estos métodos:
A través de la línea de comando:
playwright installSi lo anterior no funciona, prueba este comando más específico:
python -m playwright install chromiumEste segundo método ha demostrado ser más fiable en algunos casos.
Si necesita la versión síncrona usando Selenium:
pip install crawl4ai[sync]Para contribuyentes que planean modificar el código fuente:
git clone https://github.com/unclecode/crawl4ai.git
cd crawl4ai
pip install -e . Implemente su propia instancia de Crawl4AI con un clic:
Especificaciones recomendadas : 4 GB de RAM mínimo. Seleccione "professional-xs" o superior al implementar para una operación estable.
El despliegue:
Crawl4AI está disponible como imágenes de Docker para una fácil implementación. Puede extraerlo directamente desde Docker Hub (recomendado) o compilarlo desde el repositorio.
# 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:localPrueba rápida (funciona para ambas opciones):
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 configuración avanzada, variables de entorno y ejemplos de uso, consulte nuestra Guía de implementación de 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 ()) JsonCssExtractionStrategy permite la extracción precisa de datos estructurados de páginas web mediante selectores 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 obtener ejemplos de uso más avanzados, consulte nuestra sección de Ejemplos en la documentación.
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 se destaca en el manejo de escenarios complejos, como rastrear múltiples páginas con contenido dinámico cargado a través de JavaScript. A continuación se muestra un ejemplo de cómo rastrear confirmaciones de GitHub en varias 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 ejemplo demuestra la capacidad de Crawl4AI para manejar escenarios complejos donde el contenido se carga de forma asincrónica. Rastrea varias páginas de confirmaciones de GitHub, ejecuta JavaScript para cargar contenido nuevo y utiliza enlaces personalizados para garantizar que los datos se carguen antes de continuar.
Para obtener ejemplos de uso más avanzados, consulte nuestra sección de Ejemplos en la documentación.
Crawl4AI está diseñado con la velocidad como objetivo principal. Nuestro objetivo es brindar la respuesta más rápida posible con extracción de datos de alta calidad, minimizando las abstracciones entre los datos y el usuario.
Hemos realizado una comparación de velocidad entre Crawl4AI y Firecrawl, un servicio pago. Los resultados demuestran el rendimiento superior de 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 puede ver, Crawl4AI supera significativamente a Firecrawl:
Puede encontrar el código de comparación completo en nuestro repositorio en docs/examples/crawl4ai_vs_firecrawl.py .
Para obtener documentación detallada, incluidas instrucciones de instalación, funciones avanzadas y referencia de API, visite nuestro sitio web de documentación.
Para obtener información detallada sobre nuestros planes de desarrollo y próximas funciones, consulte nuestra hoja de ruta.
Agradecemos las contribuciones de la comunidad de código abierto. Consulte nuestras pautas de contribución para obtener más información.
Crawl4AI se publica bajo la licencia Apache 2.0.
Si tiene preguntas, sugerencias o comentarios, no dude en comunicarse con:
¡Feliz gateo! ?️
Nuestra misión es desbloquear el potencial sin explotar de los datos personales y empresariales en la era digital. En el mundo actual, los individuos y las organizaciones generan grandes cantidades de huellas digitales valiosas, pero estos datos siguen estando en gran medida descapitalizados como un verdadero activo.
Nuestra solución de código abierto permite a los desarrolladores e innovadores crear herramientas para la extracción y estructuración de datos, sentando las bases para una nueva era de propiedad de datos. Al transformar los datos personales y empresariales en activos estructurados y comercializables, estamos creando oportunidades para que las personas aprovechen sus huellas digitales y para que las organizaciones liberen el valor de su conocimiento colectivo.
Esta democratización de los datos representa el primer paso hacia una economía de datos compartidos, donde la participación voluntaria en el intercambio de datos impulsa el avance de la IA y al mismo tiempo garantiza que los beneficios retornen a los creadores de datos. A través de este enfoque, estamos construyendo un futuro en el que el desarrollo de la IA esté impulsado por conocimiento humano auténtico en lugar de alternativas sintéticas.
Para una exploración detallada de nuestra visión, oportunidades y camino a seguir, consulte nuestra declaración de misión completa.
Para una exploración detallada de nuestra visión, desafíos y soluciones, consulte nuestra declaración de misión completa.
