Mon parcours avec les ordinateurs a commencé dans l'enfance lorsque mon père, informaticien, m'a initié à un Amstrad. Ces premiers jours ont éveillé une fascination pour la technologie, me conduisant à étudier l'informatique et à me spécialiser en NLP pendant mes études postuniversitaires. C'est à cette époque que j'ai commencé à explorer le web crawling, construisant des outils pour aider les chercheurs à organiser des articles et extraire des informations de publications - une expérience exigeante mais enrichissante qui a affiné mes compétences en extraction de données.

En 2023, alors que je travaillais sur un outil pour un projet, j'avais besoin d'un crawler pour convertir une page web en markdown. En explorant les solutions, j'en ai trouvé une qui se disait open-source mais nécessitait la création d'un compte et la génération d'un token API. Pire, il s'agissait en réalité d'un modèle SaaS facturant 16$, et sa qualité ne répondait pas à mes attentes. Frustré, j'ai réalisé qu'il s'agissait d'un problème plus profond. Cette frustration s'est transformée en mode turbo colère, et j'ai décidé de construire ma propre solution. En quelques jours seulement, j'ai créé Crawl4AI. À ma grande surprise, il est devenu viral, gagnant des milliers d'étoiles GitHub et résonnant avec une communauté mondiale.

J'ai rendu Crawl4AI open-source pour deux raisons. Premièrement, c'est ma façon de redonner à la communauté open-source qui m'a soutenu tout au long de ma carrière. Deuxièmement, je crois que les données devraient être accessibles à tous, pas enfermées derrière des paywalls ou monopolisées par quelques-uns. L'accès ouvert aux données jette les bases de la démocratisation de l'IA, une vision où les individus peuvent entraîner leurs propres modèles et prendre possession de leurs informations. Cette bibliothèque est la première étape d'un voyage plus large pour créer le meilleur outil open-source d'extraction et de génération de données que le monde ait jamais vu, construit collaborativement par une communauté passionnée.

Merci à tous ceux qui ont soutenu ce projet, l'ont utilisé et partagé des retours. Votre encouragement me motive à rêver encore plus grand. Rejoignez-nous, signalez des problèmes, soumettez des PR ou faites passer le mot. Ensemble, nous pouvons construire un outil qui permet véritablement aux gens d'accéder à leurs propres données et de remodeler l'avenir de l'IA.

• 🧹 Markdown Propre : Génère un Markdown propre et structuré avec un formatage précis.
• � Markdown Adapté : Filtrage heuristique pour supprimer le bruit et les parties non pertinentes pour un traitement compatible IA.
• 🔗 Citations et Références : Convertit les liens de page en une liste de références numérotée avec des citations propres.
• 🛠️ Stratégies Personnalisées : Les utilisateurs peuvent créer leurs propres stratégies de génération Markdown adaptées à des besoins spécifiques.
• 📚 Algorithme BM25 : Utilise un filtrage basé sur BM25 pour extraire les informations principales et supprimer le contenu non pertinent.

• 🤖 Extraction Pilotée par LLM : Prend en charge tous les LLM (open-source et propriétaires) pour l'extraction de données structurées.
• 🧱 Stratégies de Découpage : Implémente le découpage (par sujet, regex, niveau phrase) pour un traitement ciblé du contenu.
• 🌌 Similarité Cosinus : Trouve des segments de contenu pertinents basés sur les requêtes utilisateur pour une extraction sémantique.
• 🔎 Extraction CSS : Extraction rapide de données basée sur des schémas utilisant XPath et les sélecteurs CSS.
• 🔧 Définition de Schéma : Définissez des schémas personnalisés pour extraire du JSON structuré à partir de motifs répétitifs.

• 🖥️ Navigateur Géré : Utilisez vos propres navigateurs avec un contrôle total, évitant la détection de bots.
• 🔄 Contrôle à Distance du Navigateur : Connectez-vous au Chrome Developer Tools Protocol pour une extraction de données à grande échelle.
• 👤 Profileur de Navigateur : Créez et gérez des profils persistants avec des états d'authentification sauvegardés, cookies et paramètres.
• 🔒 Gestion de Session : Préservez les états du navigateur et réutilisez-les pour un crawling en plusieurs étapes.
• 🧩 Support Proxy : Connectez-vous de manière transparente à des proxies avec authentification pour un accès sécurisé.
• ⚙️ Contrôle Complet du Navigateur : Modifiez les en-têtes, cookies, user agents et plus pour des configurations de crawling sur mesure.
• 🌍 Support Multi-Navigateurs : Compatible avec Chromium, Firefox et WebKit.
• 📐 Ajustement Dynamique de la Vue : Ajuste automatiquement la vue du navigateur pour correspondre au contenu de la page, assurant un rendu complet et la capture de tous les éléments.

• 🖼️ Support Média : Extrait images, audio, vidéos et formats d'image responsives comme srcset et picture.
• 🚀 Crawling Dynamique : Exécute JS et attend le contenu asynchrone ou synchrone pour une extraction dynamique.
• 📸 Captures d'Écran : Capture des screenshots pendant le crawling pour le débogage ou l'analyse.
• 📂 Crawling de Données Brutes : Traite directement le HTML brut (raw:) ou les fichiers locaux (file://).
• 🔗 Extraction Complète de Liens : Extrait les liens internes, externes et le contenu des iframes embarqués.
• 🛠️ Hooks Personnalisables : Définit des hooks à chaque étape pour personnaliser le comportement du crawling.
• 💾 Mise en Cache : Met en cache les données pour améliorer la vitesse et éviter les récupérations redondantes.
• 📄 Extraction de Métadonnées : Récupère des métadonnées structurées à partir des pages web.
• 📡 Extraction de Contenu IFrame : Extraction transparente à partir du contenu des iframes embarqués.
• 🕵️ Gestion du Chargement Paresseux : Attend que les images soient complètement chargées, assurant qu'aucun contenu n'est manqué à cause du lazy loading.
• 🔄 Balayage Complet de Page : Simule le défilement pour charger et capturer tout le contenu dynamique, idéal pour les pages à défilement infini.

• 🐳 Configuration Dockerisée : Image Docker optimisée avec serveur FastAPI pour un déploiement facile.
• 🔑 Authentification Sécurisée : Authentification JWT intégrée pour la sécurité de l'API.
• 🔄 Passerelle API : Déploiement en un clic avec authentification par token sécurisé pour les workflows basés sur API.
• 🌐 Architecture Scalable : Conçue pour une production à grande échelle et des performances serveur optimisées.
• ☁️ Déploiement Cloud : Configurations prêtes à déployer pour les principales plateformes cloud.

• 🕶️ Mode Furtif : Évite la détection de bots en imitant les utilisateurs réels.
• 🏷️ Extraction de Contenu par Tags : Affine le crawling basé sur des tags personnalisés, en-têtes ou métadonnées.
• 🔗 Analyse de Liens : Extrait et analyse tous les liens pour une exploration détaillée des données.
• 🛡️ Gestion des Erreurs : Gestion robuste des erreurs pour une exécution transparente.
• 🔐 CORS & Service Statique : Prend en charge la mise en cache basée sur le système de fichiers et les requêtes cross-origin.
• 📖 Documentation Claire : Guides simplifiés et mis à jour pour l'onboarding et l'utilisation avancée.
• 🙌 Reconnaissance Communautaire : Reconnaît les contributeurs et les pull requests pour la transparence.

Choisissez l'option d'installation qui correspond le mieux à vos besoins :

Installation Basique

Pour les tâches de base de crawling et scraping web :

pip install crawl4ai
crawl4ai-setup # Setup the browser

Par défaut, cela installera la version asynchrone de Crawl4AI, utilisant Playwright pour le crawling web.

👉 Note : Lorsque vous installez Crawl4AI, crawl4ai-setup devrait automatiquement installer et configurer Playwright. Cependant, si vous rencontrez des erreurs liées à Playwright, vous pouvez l'installer manuellement en utilisant l'une de ces méthodes :

1. Via la ligne de commande :

   playwright install
   

2. Si la méthode ci-dessus ne fonctionne pas, essayez cette commande plus spécifique :

   python -m playwright install chromium
   

Cette deuxième méthode s'est avérée plus fiable dans certains cas.

Installation avec Version Synchrone

La version synchrone est dépréciée et sera supprimée dans les futures versions. Si vous avez besoin de la version synchrone utilisant Selenium :

pip install crawl4ai[sync]

Installation pour Développement

Pour les contributeurs qui prévoient de modifier le code source :

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

Installez les fonctionnalités optionnelles :

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

🚀 Maintenant Disponible ! Notre implémentation Docker complètement repensée est là ! Cette nouvelle solution rend le déploiement plus efficace et transparent que jamais.

Nouvelles Fonctionnalités Docker

La nouvelle implémentation Docker inclut :

• Pooling de navigateurs avec préchauffage des pages pour des temps de réponse plus rapides
• Playground interactif pour tester et générer du code de requête
• Intégration MCP pour une connexion directe aux outils IA comme Claude Code
• Points d'API complets incluant l'extraction HTML, screenshots, génération PDF et exécution JavaScript
• Support multi-architecture avec détection automatique (AMD64/ARM64)
• Ressources optimisées avec une meilleure gestion de la mémoire

Pour Commencer

# 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

Pour une documentation complète, consultez notre Guide de Déploiement 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. Graph Crawler : Parcours intelligent de sites web avec des algorithmes de recherche en graphe pour une extraction complète de pages imbriquées
• 1. Crawler Basé sur Questions : Découverte web et extraction de contenu pilotée par langage naturel
• 2. Crawler à Connaissance Optimale : Crawling intelligent maximisant la connaissance tout en minimisant l'extraction de données
• 3. Crawler Agentique : Système autonome pour des opérations de crawling multi-étapes complexes
• 4. Générateur Automatique de Schémas : Conversion de langage naturel en schémas d'extraction
• 5. Scrapers Spécifiques à un Domaine : Extracteurs préconfigurés pour des plateformes courantes (académique, e-commerce)
• 6. Index d'Embedding Web : Infrastructure de recherche sémantique pour le contenu crawlé
• 7. Playground Interactif : Interface web pour tester et comparer des stratégies avec assistance IA
• 8. Moniteur de Performance : Insights en temps réel sur les opérations de crawling
• 9. Intégration Cloud : Solutions de déploiement en un clic sur différents fournisseurs cloud
• 10. Programme de Sponsoring : Système de support structuré avec avantages par niveaux
• 11. Contenu Éducatif : Série vidéo "Comment Crawler" et tutoriels interactifs

• Capitalisation des Données : Transformez les empreintes digitales en actifs mesurables et valorisables.
• Données IA Authentiques : Fournissez aux systèmes IA de vraies connaissances humaines.
• Économie Partagée : Créez un marché de données équitable profitant aux créateurs de données.

1. Outils Open-Source : Plateformes communautaires pour une extraction transparente de données.
2. Structuration d'Actifs Digitaux : Outils pour organiser et valoriser la connaissance digitale.
3. Marché de Données Éthique : Une plateforme sécurisée et équitable pour échanger des données structurées.

Pour plus de détails, voir notre déclaration de mission complète.