Crawl4AI Cloud is live: the README with the two ways to use it and the launch banner, the docs home, the cloud notice as a daily yellow banner while the offer runs

Author: unclecode

README-first.md

@@ -1,18 +1,24 @@
-"""The Crawl4AI Cloud notice: short lines that tell a user the hosted version exists.
+"""The Crawl4AI Cloud notice: a short yellow banner that tells a user the hosted version exists.
 
 It prints in four places:
 
 - at the end of ``crawl4ai-setup``, every time (``show_at_install``);
-- once per minor release per machine, when the first ``AsyncWebCrawler`` starts or the ``crwl`` CLI runs
-  (``show_once``; a marker file in the crawl4ai home folder holds the last minor version shown);
+- when the first ``AsyncWebCrawler`` starts or the ``crwl`` CLI runs (``show_once``): once a day per
+  machine while the launch offer runs (before ``DAILY_UNTIL``), then once per version per machine, a
+  patch release included. A marker file in the crawl4ai home folder holds the day, or the version, last shown;
 - when a crawl is blocked by anti-bot protection, at most once a day (``show_blocked``);
 - when ``crawl4ai-setup`` could not install the browser (``show_setup_failed``).
 
+The banner goes to the logger's console (stderr by default), never to stdout, so a piped ``crwl`` output
+or an MCP stdio transport stays clean. Rich drops the color when the output is not a terminal and honours
+``NO_COLOR``. Only ASCII characters, so every console can print it.
+
 Each link carries its own ``ref`` so the cloud can tell which moment brought a user.
 ``CRAWL4AI_NO_CLOUD_NOTICE=1`` turns every line off, for operators who run the library in production logs.
 """
 
 import os
+import sys
 import time
 from pathlib import Path
 
@@ -23,19 +29,25 @@
 _MARKER = ".cloud-notice-shown"
 _BLOCKED_MARKER = ".cloud-notice-blocked"
 
+# The first day the banner stops returning daily: the launch offer ends on 31 December 2026.
+DAILY_UNTIL = "2027-01-01"
+_RULE = "=" * 72
+
 LINES = (
-    "Crawl4AI Cloud is live: the same crawler, hosted. Your first $10 pack is on us until 31 Dec 2026 (then $5 to start). No card.",
-    f"Get a key in 10 seconds: {CLOUD_URL}   (the library stays open source, forever)",
-    f"Hide this notice: {_ENV_OFF}=1",
+    "Crawl4AI Cloud is live: the same crawler, hosted.",
+    "Your first $10 pack is on us until 31 Dec 2026 (then $5 to start). No card.",
+    f"Get a key in 10 seconds:  {CLOUD_URL}",
+    f"The library stays open source, forever.   Hide this banner: {_ENV_OFF}=1",
 )
 
 BLOCKED_LINES = (
-    f"Blocked? Crawl4AI Cloud gets through the hard sites, free credit to start: {BLOCKED_URL}",
-    f"Hide this notice: {_ENV_OFF}=1",
+    "Blocked? Crawl4AI Cloud gets through the hard sites, free credit to start.",
+    f"{BLOCKED_URL}   Hide this banner: {_ENV_OFF}=1",
 )
 
 SETUP_LINES = (
-    f"Browser setup failed? Skip it: the same crawler, hosted, nothing to install, free credit to start: {SETUP_URL}",
+    "Browser setup failed? Skip it: the same crawler, hosted, nothing to install, free credit to start.",
+    SETUP_URL,
 )
 
 
@@ -48,32 +60,43 @@ def _home() -> Path:
         return Path.home() / ".crawl4ai"
 
 
-def _minor_version() -> str:
-    """This release's minor version, "0.9" for 0.9.3: the notice returns once per minor release."""
+def _version() -> str:
+    """This release's full version, "0.9.4": after the offer the banner returns once per version."""
     try:
         from .__version__ import __version__
 
-        return ".".join(__version__.split(".")[:2])
+        return __version__
     except Exception:
         return ""
 
 
+def _today() -> str:
+    """Today's date in UTC, "2026-09-25": the daily markers compare this string."""
+    return time.strftime("%Y-%m-%d", time.gmtime())
+
+
 def is_off() -> bool:
     """True when the operator turned the notice off with the environment variable."""
     return os.environ.get(_ENV_OFF, "").strip().lower() in ("1", "true", "yes")
 
 
-def text() -> str:
-    """The notice as one block of text."""
-    return "\n".join(LINES)
+def text(lines=LINES) -> str:
+    """The banner as plain text: a rule, the lines indented by two spaces, a rule."""
+    return "\n".join([_RULE, *(f"  {line}" for line in lines), _RULE])
 
 
 def _print(lines, logger=None) -> None:
-    if logger is not None:
-        for line in lines:
-            logger.info(line, tag="CLOUD")
-    else:
-        print("\n".join(lines))
+    """Print the banner in yellow, the first line bold, through the logger's console; without a logger,
+    through a console on stderr. Rich keeps the text plain when the output is not a terminal."""
+    from rich.console import Console
+    from rich.text import Text
+
+    console = getattr(logger, "console", None) or Console(stderr=True, width=200)
+    banner = Text(_RULE + "\n", style="yellow")
+    for i, line in enumerate(lines):
+        banner.append(f"  {line}\n", style="bold yellow" if i == 0 else "yellow")
+    banner.append(_RULE, style="yellow")
+    console.print(banner, highlight=False, soft_wrap=True)
 
 
 def _claim(name: str, value: str) -> bool:
@@ -91,32 +114,36 @@ def _claim(name: str, value: str) -> bool:
 
 
 def show_at_install(logger=None) -> None:
-    """Print the notice at the end of ``crawl4ai-setup``. Every run; nothing is remembered."""
+    """Print the banner at the end of ``crawl4ai-setup``. Every run; nothing is remembered."""
     if is_off():
         return
     _print(LINES, logger)
 
 
 def show_once(logger=None) -> bool:
-    """Print the notice the first time the library or the CLI runs on this machine after a new minor
-    release. Returns True when it printed."""
-    if is_off() or not _claim(_MARKER, _minor_version() or "shown"):
+    """Print the banner when the library or the CLI runs: once a day per machine while the offer runs,
+    then once per version per machine. Returns True when it printed."""
+    if is_off():
+        return False
+    today = _today()
+    value = today if today < DAILY_UNTIL else (_version() or "shown")
+    if not _claim(_MARKER, value):
         return False
     _print(LINES, logger)
     return True
 
 
 def show_blocked(logger=None) -> bool:
-    """Print the blocked line when a crawl hit anti-bot protection: the moment the cloud helps most.
+    """Print the blocked banner when a crawl hit anti-bot protection: the moment the cloud helps most.
     At most once a day per machine. Returns True when it printed."""
-    if is_off() or not _claim(_BLOCKED_MARKER, time.strftime("%Y-%m-%d", time.gmtime())):
+    if is_off() or not _claim(_BLOCKED_MARKER, _today()):
         return False
     _print(BLOCKED_LINES, logger)
     return True
 
 
 def show_setup_failed(logger=None) -> None:
-    """Print the setup line when ``crawl4ai-setup`` could not install the browser."""
+    """Print the setup banner when ``crawl4ai-setup`` could not install the browser."""
     if is_off():
         return
     _print(SETUP_LINES, logger)

README.md

@@ -126,4 +126,14 @@ Some older docs mention running Crawl4AI as a local server. This approach has be
 5. **Docker** is **experimental**—use at your own risk until the stable version is released.
 6. **Local server** references in older docs are largely deprecated; a new solution is in progress.
 
-**Got questions?** Check [GitHub issues](https://github.com/unclecode/crawl4ai/issues) for updates or ask the community!
+**Got questions?** Check [GitHub issues](https://github.com/unclecode/crawl4ai/issues) for updates or ask the community!
+
+## Version numbering
+
+Crawl4AI follows PEP 440: `MAJOR.MINOR.PATCH`, for example `0.9.4`. A pre-release carries a suffix: `dev` (unstable), `a` (alpha), `b` (beta), `rc` (release candidate).
+
+- The stable version: `pip install -U crawl4ai`
+- The latest pre-release: `pip install crawl4ai --pre`
+- One exact version: `pip install crawl4ai==0.9.4`
+
+Use the stable version in production. Pre-releases exist to test new features with real users before the final release.

crawl4ai/cloud_notice.py

@@ -1,4 +1,4 @@
-# 🚀🤖 Crawl4AI: Open-Source LLM-Friendly Web Crawler & Scraper
+# 🚀🤖 Crawl4AI: the open-source web crawler for LLMs and AI agents
 
 <div class = "badges" align="center">
 
@@ -55,19 +55,60 @@
 
 </div>
 
----
-#### 🚀 Crawl4AI Cloud API — Closed Beta (Launching Soon)
-Reliable, large-scale web extraction, now built to be _**drastically more cost-effective**_ than any of the existing solutions.
+Crawl4AI turns any website into clean, LLM-ready Markdown for RAG, AI agents and data pipelines. Run the open-source web crawler and scraper yourself, free forever, or use it hosted with one key: scrape, search and extract through one API, with MCP for your agent.
 
-👉 **Apply [here](https://forms.gle/E9MyPaNXACnAMaqG7) for early access**  
-_We’ll be onboarding in phases and working closely with early users.
-Limited slots._
+## Two ways to use Crawl4AI
 
----
+### 🐍 Run it yourself: open source, forever
+
+```bash
+pip install -U crawl4ai
+crawl4ai-setup        # installs the browser, once
+```
+
+```python
+import asyncio
+from crawl4ai import AsyncWebCrawler
+
+async def main():
+    async with AsyncWebCrawler() as crawler:
+        result = await crawler.arun(url="https://news.ycombinator.com")
+        print(result.markdown)
+
+asyncio.run(main())
+```
+
+Docker server, CLI and every option: [Installation](core/installation.md) · [Self-hosting](core/self-hosting.md)
+
+### ☁️ Or use the cloud: no browsers, no proxies
+
+1. [![Get a key in 10 seconds](https://img.shields.io/badge/Get_a_key_in_10_seconds-%241_pass%2C_no_signup-f5a300?style=for-the-badge&labelColor=0d0d10)](https://crawl4ai.com/?ref=docs)  
+   Verify your email and your first $10 pack is on us (until 31 December 2026, then $5 to start). No card.
+2. Get any page as Markdown:
+
+   ```bash
+   curl -s https://api.crawl4ai.com/scrape \
+     -H "Authorization: Bearer $CRAWL4AI_KEY" \
+     -H "Content-Type: application/json" \
+     -d '{"url": "https://news.ycombinator.com"}' | jq -r .markdown
+   ```
 
-Crawl4AI is the #1 trending GitHub repository, actively maintained by a vibrant community. It delivers blazing-fast, AI-ready web crawling tailored for large language models, AI agents, and data pipelines. Fully open source, flexible, and built for real-time performance, **Crawl4AI** empowers developers with unmatched speed, precision, and deployment ease.
+   The same key works for `/search`, `/answer`, `/extract` and many URLs at once (`/scrape/batch`, `/scrape/jobs`). Pay as you go: [live prices](https://crawl4ai.com/docs?ref=docs#pricing).
+3. Give it to your AI agent. Claude Code shown; [Codex, Cursor and OpenCode →](https://crawl4ai.com/docs?ref=docs#mcp)
 
-> Enjoy using Crawl4AI? Consider **[becoming a sponsor](https://github.com/sponsors/unclecode)** to support ongoing development and community growth!
+   ```bash
+   claude mcp add --transport http crawl4ai https://api.crawl4ai.com/mcp \
+     --header "Authorization: Bearer $CRAWL4AI_KEY"
+   ```
+
+### Which one?
+
+| | 🐍 Library | 🐳 Your own server | ☁️ Crawl4AI Cloud |
+|---|---|---|---|
+| **Runs the browsers** | you, in your Python process | you, in Docker on your machine | we do |
+| **JS-heavy pages and bot walls** | your settings, your proxies | your settings, your proxies | handled for you, automatically |
+| **Web search** | – | – | `/search` and `/answer` |
+| **Price** | free, forever | free (your hosting) | pay as you go; your first $10 is on us |
 
 ## 🆕 AI Assistant Skill Now Available!
 
@@ -97,29 +138,6 @@ Crawl4AI now features intelligent adaptive crawling that knows when to stop! Usi
 [Learn more about Adaptive Crawling →](core/adaptive-crawling.md)
 
 
-## Quick Start
-
-Here's a quick example to show you how easy it is to use Crawl4AI with its asynchronous capabilities:
-
-```python
-import asyncio
-from crawl4ai import AsyncWebCrawler
-
-async def main():
-    # Create an instance of AsyncWebCrawler
-    async with AsyncWebCrawler() as crawler:
-        # Run the crawler on a URL
-        result = await crawler.arun(url="https://crawl4ai.com")
-
-        # Print the extracted content
-        print(result.markdown)
-
-# Run the async main function
-asyncio.run(main())
-```
-
----
-
 ## Video Tutorial
 
 <div align="center">

docs/assets/cloud-launch-banner-dark.svg

@@ -0,0 +1,70 @@
+"""The cloud notice: when it prints, and what it prints."""
+
+import io
+
+import pytest
+from rich.console import Console
+
+from crawl4ai import cloud_notice
+
+
+@pytest.fixture
+def home(tmp_path, monkeypatch):
+    """The marker files go to a temporary home folder; the notice is on."""
+    monkeypatch.setattr(cloud_notice, "_home", lambda: tmp_path)
+    monkeypatch.delenv(cloud_notice._ENV_OFF, raising=False)
+    return tmp_path
+
+
+def _render(lines) -> str:
+    """The banner as a terminal without colour would show it."""
+    out = io.StringIO()
+    console = Console(file=out, width=200, force_terminal=False, color_system=None)
+    cloud_notice._print(lines, logger=type("L", (), {"console": console})())
+    return out.getvalue()
+
+
+def test_the_environment_variable_turns_every_banner_off(home, monkeypatch):
+    monkeypatch.setenv(cloud_notice._ENV_OFF, "1")
+    assert cloud_notice.show_once() is False
+    assert cloud_notice.show_blocked() is False
+    assert not (home / cloud_notice._MARKER).exists()
+
+
+def test_daily_while_the_offer_runs_then_once_per_version(home, monkeypatch):
+    printed = []
+    monkeypatch.setattr(cloud_notice, "_print", lambda lines, logger=None: printed.append(lines))
+    monkeypatch.setattr(cloud_notice, "_version", lambda: "0.9.4")
+
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2026-10-01")
+    assert cloud_notice.show_once() is True
+    assert cloud_notice.show_once() is False, "the same day prints once"
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2026-10-02")
+    assert cloud_notice.show_once() is True, "the next day prints again"
+
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2027-01-01")
+    assert cloud_notice.show_once() is True, "the first run after the offer prints once per version"
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2027-01-02")
+    assert cloud_notice.show_once() is False, "the next day, same version: quiet"
+    monkeypatch.setattr(cloud_notice, "_version", lambda: "0.9.5")
+    assert cloud_notice.show_once() is True, "a new version, a patch included, prints again"
+    assert len(printed) == 4
+
+
+def test_the_blocked_banner_prints_once_a_day(home, monkeypatch):
+    monkeypatch.setattr(cloud_notice, "_print", lambda lines, logger=None: None)
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2026-10-01")
+    assert cloud_notice.show_blocked() is True
+    assert cloud_notice.show_blocked() is False
+    monkeypatch.setattr(cloud_notice, "_today", lambda: "2026-10-02")
+    assert cloud_notice.show_blocked() is True
+
+
+def test_the_banner_is_ascii_with_the_link_and_the_off_switch():
+    for lines in (cloud_notice.LINES, cloud_notice.BLOCKED_LINES, cloud_notice.SETUP_LINES):
+        shown = _render(lines)
+        assert shown.isascii(), "every console can print it"
+        assert shown.startswith(cloud_notice._RULE) and shown.rstrip().endswith(cloud_notice._RULE)
+        assert "https://crawl4ai.com/?ref=" in shown
+    assert cloud_notice._ENV_OFF in _render(cloud_notice.LINES)
+    assert cloud_notice.text() == _render(cloud_notice.LINES).rstrip("\n")