Skip to content

πŸ”₯πŸ•·οΈ Crawl4AI: Open-source LLM Friendly Web Crawler & Scrapper

License

Notifications You must be signed in to change notification settings

unclecode/crawl4ai

Repository files navigation

πŸ”₯πŸ•·οΈ Crawl4AI: LLM Friendly Web Crawler & Scraper

unclecode%2Fcrawl4ai | Trendshift

GitHub Stars PyPI - Downloads GitHub Forks GitHub Issues GitHub Pull Requests License

Crawl4AI simplifies asynchronous web crawling and data extraction, making it accessible for large language models (LLMs) and AI applications. πŸ†“πŸŒ

🌟 Meet the Crawl4AI Assistant: Your Copilot for Crawling

Use the Crawl4AI GPT Assistant as your AI-powered copilot! With this assistant, you can:

  • πŸ§‘β€πŸ’» Generate code for complex crawling and extraction tasks
  • πŸ’‘ Get tailored support and examples
  • πŸ“˜ Learn Crawl4AI faster with step-by-step guidance

New in 0.3.73 ✨

  • 🐳 Docker Ready: Full API server with seamless deployment & scaling
  • 🎯 Browser Takeover: Use your own browser with cookies & history intact (CDP support)
  • πŸ“ Mockdown+: Enhanced tag preservation & content extraction
  • ⚑️ Parallel Power: Supercharged multi-URL crawling performance
  • 🌟 And many more exciting updates...

Try it Now!

✨ Play around with this Open In Colab

✨ Visit our Documentation Website

Features ✨

  • πŸ†“ Completely free and open-source
  • πŸš€ Blazing fast performance, outperforming many paid services
  • πŸ€– LLM-friendly output formats (JSON, cleaned HTML, markdown)
  • 🌐 Multi-browser support (Chromium, Firefox, WebKit)
  • 🌍 Supports crawling multiple URLs simultaneously
  • 🎨 Extracts and returns all media tags (Images, Audio, and Video)
  • πŸ”— Extracts all external and internal links
  • πŸ“š Extracts metadata from the page
  • πŸ”„ Custom hooks for authentication, headers, and page modifications
  • πŸ•΅οΈ User-agent customization
  • πŸ–ΌοΈ Takes screenshots of pages with enhanced error handling
  • πŸ“œ Executes multiple custom JavaScripts before crawling
  • πŸ“Š Generates structured output without LLM using JsonCssExtractionStrategy
  • πŸ“š Various chunking strategies: topic-based, regex, sentence, and more
  • 🧠 Advanced extraction strategies: cosine clustering, LLM, and more
  • 🎯 CSS selector support for precise data extraction
  • πŸ“ Passes instructions/keywords to refine extraction
  • πŸ”’ Proxy support with authentication for enhanced access
  • πŸ”„ Session management for complex multi-page crawling
  • 🌐 Asynchronous architecture for improved performance
  • πŸ–ΌοΈ Improved image processing with lazy-loading detection
  • πŸ•°οΈ Enhanced handling of delayed content loading
  • πŸ”‘ Custom headers support for LLM interactions
  • πŸ–ΌοΈ iframe content extraction for comprehensive analysis
  • ⏱️ Flexible timeout and delayed content retrieval options

Installation πŸ› οΈ

Crawl4AI offers flexible installation options to suit various use cases. You can install it as a Python package or use Docker.

Using pip 🐍

Choose the installation option that best fits your needs:

Basic Installation

For basic web crawling and scraping tasks:

pip install crawl4ai

By default, this will install the asynchronous version of Crawl4AI, using Playwright for web crawling.

πŸ‘‰ Note: When you install Crawl4AI, the setup script should automatically install and set up Playwright. However, if you encounter any Playwright-related errors, you can manually install it using one of these methods:

  1. Through the command line:

    playwright install
  2. If the above doesn't work, try this more specific command:

    python -m playwright install chromium

This second method has proven to be more reliable in some cases.

Installation with Synchronous Version

If you need the synchronous version using Selenium:

pip install crawl4ai[sync]

Development Installation

For contributors who plan to modify the source code:

git clone https://github.com/unclecode/crawl4ai.git
cd crawl4ai
pip install -e .

Using Docker 🐳

Crawl4AI is available as Docker images for easy deployment. You can either pull directly from Docker Hub (recommended) or build from the repository.

Option 1: Docker Hub (Recommended)

# 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

Option 2: Build from Repository

# 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
  .

# Run your local build
docker run -p 11235:11235 crawl4ai:local

Quick test (works for both options):

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}")

For advanced configuration, environment variables, and usage examples, see our Docker Deployment Guide.

Quick Start πŸš€

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())

Advanced Usage πŸ”¬

Executing JavaScript and Using CSS Selectors

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())

Using a Proxy

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())

Extracting Structured Data without LLM

The JsonCssExtractionStrategy allows for precise extraction of structured data from web pages using CSS selectors.

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())

For more advanced usage examples, check out our Examples section in the documentation.

Extracting Structured Data with OpenAI

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())

Session Management and Dynamic Content Crawling

Crawl4AI excels at handling complex scenarios, such as crawling multiple pages with dynamic content loaded via JavaScript. Here's an example of crawling GitHub commits across multiple pages:

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())

This example demonstrates Crawl4AI's ability to handle complex scenarios where content is loaded asynchronously. It crawls multiple pages of GitHub commits, executing JavaScript to load new content and using custom hooks to ensure data is loaded before proceeding.

For more advanced usage examples, check out our Examples section in the documentation.

Speed Comparison πŸš€

Crawl4AI is designed with speed as a primary focus. Our goal is to provide the fastest possible response with high-quality data extraction, minimizing abstractions between the data and the user.

We've conducted a speed comparison between Crawl4AI and Firecrawl, a paid service. The results demonstrate Crawl4AI's superior performance:

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: 89

As you can see, Crawl4AI outperforms Firecrawl significantly:

  • Simple crawl: Crawl4AI is over 4 times faster than Firecrawl.
  • With JavaScript execution: Even when executing JavaScript to load more content (doubling the number of images found), Crawl4AI is still faster than Firecrawl's simple crawl.

You can find the full comparison code in our repository at docs/examples/crawl4ai_vs_firecrawl.py.

Documentation πŸ“š

For detailed documentation, including installation instructions, advanced features, and API reference, visit our Documentation Website.

Crawl4AI Roadmap πŸ—ΊοΈ

For detailed information on our development plans and upcoming features, check out our Roadmap.

Advanced Crawling Systems πŸ”§

  • 0. Graph Crawler: Smart website traversal using graph search algorithms for comprehensive nested page extraction
  • 1. Question-Based Crawler: Natural language driven web discovery and content extraction
  • 2. Knowledge-Optimal Crawler: Smart crawling that maximizes knowledge while minimizing data extraction
  • 3. Agentic Crawler: Autonomous system for complex multi-step crawling operations

Specialized Features πŸ› οΈ

  • 4. Automated Schema Generator: Convert natural language to extraction schemas
  • 5. Domain-Specific Scrapers: Pre-configured extractors for common platforms (academic, e-commerce)
  • 6. Web Embedding Index: Semantic search infrastructure for crawled content

Development Tools πŸ”¨

  • 7. Interactive Playground: Web UI for testing, comparing strategies with AI assistance
  • 8. Performance Monitor: Real-time insights into crawler operations
  • 9. Cloud Integration: One-click deployment solutions across cloud providers

Community & Growth 🌱

  • 10. Sponsorship Program: Structured support system with tiered benefits
  • 11. Educational Content: "How to Crawl" video series and interactive tutorials

Contributing 🀝

We welcome contributions from the open-source community. Check out our contribution guidelines for more information.

License πŸ“„

Crawl4AI is released under the Apache 2.0 License.

Contact πŸ“§

For questions, suggestions, or feedback, feel free to reach out:

Happy Crawling! πŸ•ΈοΈπŸš€

Mission

Our mission is to unlock the untapped potential of personal and enterprise data in the digital age. In today's world, individuals and organizations generate vast amounts of valuable digital footprints, yet this data remains largely uncapitalized as a true asset.

Our open-source solution empowers developers and innovators to build tools for data extraction and structuring, laying the foundation for a new era of data ownership. By transforming personal and enterprise data into structured, tradeable assets, we're creating opportunities for individuals to capitalize on their digital footprints and for organizations to unlock the value of their collective knowledge.

This democratization of data represents the first step toward a shared data economy, where willing participation in data sharing drives AI advancement while ensuring the benefits flow back to data creators. Through this approach, we're building a future where AI development is powered by authentic human knowledge rather than synthetic alternatives.

Mission Diagram

For a detailed exploration of our vision, opportunities, and pathway forward, please see our full mission statement.

Key Opportunities

  • Data Capitalization: Transform digital footprints into valuable assets that can appear on personal and enterprise balance sheets
  • Authentic Data: Unlock the vast reservoir of real human insights and knowledge for AI advancement
  • Shared Economy: Create new value streams where data creators directly benefit from their contributions

Development Pathway

  1. Open-Source Foundation: Building transparent, community-driven data extraction tools
  2. Data Capitalization Platform: Creating tools to structure and value digital assets
  3. Shared Data Marketplace: Establishing an economic platform for ethical data exchange

For a detailed exploration of our vision, challenges, and solutions, please see our full mission statement.

Star History

Star History Chart

About

πŸ”₯πŸ•·οΈ Crawl4AI: Open-source LLM Friendly Web Crawler & Scrapper

Resources

License

Stars

Watchers

Forks

Packages

No packages published