Meine Reise mit Computern begann in der Kindheit, als mein Vater, ein Informatiker, mir einen Amstrad-Computer vorstellte. Diese frühen Tage weckten eine Faszination für Technologie, die mich dazu brachte, Informatik zu studieren und mich während meines Postgraduiertenstudiums auf NLP zu spezialisieren. Damals begann ich erstmals mit Web-Crawling, indem ich Tools für Forscher baute, um Publikationen zu organisieren und Informationen aus Veröffentlichungen zu extrahieren – eine herausfordernde, aber lohnende Erfahrung, die meine Fähigkeiten in der Datenextraktion schärfte.

Schneller Vorlauf ins Jahr 2023: Ich arbeitete an einem Tool für ein Projekt und benötigte einen Crawler, um Webseiten in Markdown zu konvertieren. Bei der Suche nach Lösungen fand ich eine angeblich Open-Source-Lösung, die jedoch die Erstellung eines Kontos und die Generierung eines API-Tokens erforderte. Schlimmer noch, es stellte sich als SaaS-Modell heraus, das $16 kostete, und die Qualität entsprach nicht meinen Standards. Frustriert erkannte ich, dass dies ein tieferliegendes Problem war. Dieser Frust versetzte mich in einen Turbo-Ärger-Modus, und ich beschloss, meine eigene Lösung zu bauen. In nur wenigen Tagen entstand Crawl4AI. Zu meiner Überraschung wurde es viral und erhielt Tausende von GitHub-Sternen, wobei es eine globale Community begeisterte.

Ich habe Crawl4AI aus zwei Gründen als Open Source veröffentlicht. Erstens ist es meine Art, der Open-Source-Community etwas zurückzugeben, die mich während meiner gesamten Karriere unterstützt hat. Zweitens glaube ich, dass Daten für alle zugänglich sein sollten, nicht hinter Paywalls verschlossen oder von einigen wenigen monopolisiert. Offener Zugang zu Daten legt den Grundstein für die Demokratisierung der KI, eine Vision, in der Einzelpersonen ihre eigenen Modelle trainieren und die Kontrolle über ihre Informationen behalten können. Diese Bibliothek ist der erste Schritt auf einer größeren Reise, um das beste Open-Source-Datenextraktions- und -generierungstool zu schaffen, das die Welt je gesehen hat – gemeinsam entwickelt von einer leidenschaftlichen Community.

Danke an alle, die dieses Projekt unterstützt, genutzt und Feedback gegeben haben. Eure Ermutigung motiviert mich, noch größer zu träumen. Macht mit, meldet Probleme, reicht PRs ein oder verbreitet die Nachricht. Gemeinsam können wir ein Tool schaffen, das Menschen wirklich befähigt, auf ihre eigenen Daten zuzugreifen und die Zukunft der KI zu gestalten.

• 🧹 Sauberes Markdown: Erzeugt sauberes, strukturiertes Markdown mit genauer Formatierung.
• 🎯 Optimiertes Markdown: Heuristikbasierte Filterung zur Entfernung von Rauschen und irrelevanten Teilen für KI-freundliche Verarbeitung.
• 🔗 Zitate und Referenzen: Konvertiert Seitenlinks in eine nummerierte Referenzliste mit sauberen Zitaten.
• 🛠️ Benutzerdefinierte Strategien: Benutzer können eigene Markdown-Generierungsstrategien für spezifische Anforderungen erstellen.
• 📚 BM25-Algorithmus: Verwendet BM25-basierte Filterung zur Extraktion von Kerninformationen und Entfernung irrelevanter Inhalte.

• 🤖 LLM-gesteuerte Extraktion: Unterstützt alle LLMs (Open Source und proprietär) für strukturierte Datenextraktion.
• � Chunking-Strategien: Implementiert Chunking (themenbasiert, regex, satzweise) für gezielte Inhaltsverarbeitung.
• 🌌 Kosinus-Ähnlichkeit: Findet relevante Inhaltsblöcke basierend auf Benutzeranfragen für semantische Extraktion.
• 🔎 CSS-basierte Extraktion: Schnelle schema-basierte Datenextraktion mit XPath und CSS-Selektoren.
• 🔧 Schema-Definition: Definiert benutzerdefinierte Schemata für die Extraktion von strukturiertem JSON aus sich wiederholenden Mustern.

• 🖥️ Verwalteter Browser: Verwendet benutzereigene Browser mit voller Kontrolle, um Bot-Erkennung zu vermeiden.
• 🔄 Remote-Browsersteuerung: Verbindung zum Chrome Developer Tools Protocol für Remote-Datenextraktion im großen Maßstab.
• 👤 Browser-Profilierung: Erstellt und verwaltet persistente Profile mit gespeicherten Authentifizierungszuständen, Cookies und Einstellungen.
• 🔒 Sitzungsverwaltung: Bewahrt Browserzustände und wiederverwendet sie für mehrstufiges Crawling.
• 🧩 Proxy-Unterstützung: Nahtlose Verbindung zu Proxys mit Authentifizierung für sicheren Zugriff.
• ⚙️ Vollständige Browserkontrolle: Modifiziert Header, Cookies, User Agents und mehr für maßgeschneiderte Crawling-Setups.
• 🌍 Multi-Browser-Unterstützung: Kompatibel mit Chromium, Firefox und WebKit.
• 📐 Dynamische Viewport-Anpassung: Passt den Browser-Viewport automatisch an den Seiteninhalt an, um vollständiges Rendering und Erfassung aller Elemente zu gewährleisten.

• 🖼️ Medienunterstützung: Extrahiert Bilder, Audio, Videos und responsive Bildformate wie srcset und picture.
• 🚀 Dynamisches Crawling: Führt JS aus und wartet auf asynchrone oder synchrone Inhalte für dynamische Extraktion.
• 📸 Screenshots: Erfasst Seiten-Screenshots während des Crawlings für Debugging oder Analyse.
• 📂 Rohdaten-Crawling: Verarbeitet direkt rohes HTML (raw:) oder lokale Dateien (file://).
• 🔗 Umfassende Linkextraktion: Extrahiert interne, externe Links und eingebettete Iframe-Inhalte.
• 🛠️ Anpassbare Hooks: Definiert Hooks für jeden Schritt zur Anpassung des Crawling-Verhaltens.
• 💾 Caching: Speichert Daten für verbesserte Geschwindigkeit und vermeidet redundante Abfragen.
• 📄 Metadatenextraktion: Ruft strukturierte Metadaten von Webseiten ab.
• 📡 Iframe-Inhaltsextraktion: Nahtlose Extraktion aus eingebetteten Iframe-Inhalten.
• 🕵️ Lazy-Load-Handling: Wartet auf vollständiges Laden von Bildern, um sicherzustellen, dass keine Inhalte aufgrund von Lazy Loading verpasst werden.
• 🔄 Ganzseitiges Scannen: Simuliert Scrollen, um alle dynamischen Inhalte zu laden und zu erfassen, perfekt für Seiten mit unendlichem Scroll.

• 🐳 Dockerisiertes Setup: Optimiertes Docker-Image mit FastAPI-Server für einfache Bereitstellung.
• 🔑 Sichere Authentifizierung: Integrierte JWT-Token-Authentifizierung für API-Sicherheit.
• 🔄 API-Gateway: Ein-Klick-Bereitstellung mit sicherer Token-Authentifizierung für API-basierte Workflows.
• 🌐 Skalierbare Architektur: Für Massenproduktion und optimierte Serverleistung konzipiert.
• ☁️ Cloud-Bereitstellung: Bereit-zu-deploy-Konfigurationen für große Cloud-Plattformen.

• 🕶️ Stealth-Modus: Vermeidet Bot-Erkennung durch Nachahmung echter Nutzer.
• 🏷️ Tag-basierte Inhaltsextraktion: Verfeinert Crawling basierend auf benutzerdefinierten Tags, Headern oder Metadaten.
• 🔗 Linkanalyse: Extrahiert und analysiert alle Links für detaillierte Datenexploration.
• 🛡️ Fehlerbehandlung: Robuste Fehlerverwaltung für nahtlose Ausführung.
• 🔐 CORS & statisches Servieren: Unterstützt dateisystembasiertes Caching und Cross-Origin-Anfragen.
• 📖 Klar dokumentiert: Vereinfachte und aktualisierte Anleitungen für Onboarding und fortgeschrittene Nutzung.
• 🙌 Community-Anerkennung: Würdigt Mitwirkende und Pull Requests für Transparenz.

Wähle die Installationsoption, die am besten zu deinen Anforderungen passt:

Grundinstallation

Für grundlegende Web-Crawling- und Scraping-Aufgaben:

pip install crawl4ai
crawl4ai-setup # Setup the browser

Standardmäßig wird die asynchrone Version von Crawl4AI installiert, die Playwright für Web-Crawling verwendet.

👉 Hinweis: Bei der Installation von Crawl4AI sollte crawl4ai-setup Playwright automatisch installieren und einrichten. Falls jedoch Playwright-bezogene Fehler auftreten, kann es manuell mit einer dieser Methoden installiert werden:

1. Über die Kommandozeile:

   playwright install
   

2. Falls das nicht funktioniert, versuche diesen spezifischeren Befehl:

   python -m playwright install chromium
   

Diese zweite Methode hat sich in einigen Fällen als zuverlässiger erwiesen.

Installation mit synchroner Version

Die synchrone Version ist veraltet und wird in zukünftigen Versionen entfernt. Falls die synchrone Version mit Selenium benötigt wird:

pip install crawl4ai[sync]

Entwicklungsinstallation

Für Mitwirkende, die den Quellcode modifizieren möchten:

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

Optionale Features installieren:

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

🚀 Jetzt verfügbar! Unsere komplett neu gestaltete Docker-Implementierung ist da! Diese neue Lösung macht die Bereitstellung effizienter und nahtloser denn je.

Neue Docker-Funktionen

Die neue Docker-Implementierung beinhaltet:

• Browser-Pooling mit Seitenvorwärmung für schnellere Antwortzeiten
• Interaktiven Playground zum Testen und Generieren von Anfragecode
• MCP-Integration für direkte Verbindung zu KI-Tools wie Claude Code
• Umfassende API-Endpunkte inklusive HTML-Extraktion, Screenshots, PDF-Generierung und JavaScript-Ausführung
• Multi-Architektur-Unterstützung mit automatischer Erkennung (AMD64/ARM64)
• Optimierte Ressourcen mit verbessertem Speichermanagement

Erste Schritte

# 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

Für vollständige Dokumentation siehe unseren Docker-Bereitstellungsleitfaden.

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: Intelligente Website-Durchquerung mit Graph-Suchalgorithmen für umfassende Extraktion verschachtelter Seiten
• 1. Frage-basierter Crawler: Natürlichsprachlich gesteuerte Web-Entdeckung und Inhalts-Extraktion
• 2. Wissens-optimaler Crawler: Intelligentes Crawling, das Wissen maximiert während Datenextraktion minimiert wird
• 3. Agentischer Crawler: Autonomes System für komplexe mehrstufige Crawling-Operationen
• 4. Automatisierter Schema-Generator: Umwandlung natürlicher Sprache in Extraktions-Schemata
• 5. Domänenspezifische Scraper: Vorkonfigurierte Extraktoren für gängige Plattformen (akademisch, E-Commerce)
• 6. Web-Embedding-Index: Semantische Suchinfrastruktur für gecrawlte Inhalte
• 7. Interaktiver Playground: Web-UI zum Testen, Vergleichen von Strategien mit KI-Unterstützung
• 8. Performance-Monitor: Echtzeit-Einblicke in Crawler-Operationen
• 9. Cloud-Integration: One-Click-Deployment-Lösungen über Cloud-Anbieter
• 10. Sponsorenprogramm: Strukturiertes Unterstützungssystem mit abgestuften Vorteilen
• 11. Lehrinhalte: "How to Crawl"-Videoserie und interaktive Tutorials

• Datenkapitalisierung: Digitale Fußabdrücke in messbare, wertvolle Assets verwandeln.
• Authentische KI-Daten: KI-Systeme mit echten menschlichen Erkenntnissen versorgen.
• Gemeinschaftsökonomie: Einen fairen Datenmarktplatz schaffen, der Datenproduzenten nützt.

1. Open-Source-Tools: Gemeinschaftsgetriebene Plattformen für transparente Datenextraktion.
2. Strukturierung digitaler Assets: Tools zur Organisation und Bewertung digitalen Wissens.
3. Ethischer Datenmarktplatz: Eine sichere, faire Plattform zum Austausch strukturierter Daten.

Für mehr Details siehe unsere vollständige Missionserklärung.