How to take website screenshots with Crawl4AI

Crawl4AI is useful when you need to crawl a website, extract content, and attach an image of the page to the result. You can enable screenshot capture in the same Python workflow.

If your application only needs screenshots, ScreenshotOne gives you a focused HTTP API without operating a crawler. It is also worth trying when you need cleaner output and dedicated controls for banners, lazy-loaded content, or image delivery.

Let’s start with a working local script, then look at full-page capture, dynamic content, and the API alternative.

Install Crawl4AI and its browser dependencies

Create a virtual environment and install the core package:

1
python3 -m venv .venv
2
source .venv/bin/activate
3
python -m pip install crawl4ai
4
crawl4ai-setup
5
crawl4ai-doctor

The activation command above is for macOS and Linux. On Windows, activate the virtual environment with .venv\Scripts\Activate.ps1 in PowerShell.

The setup command prepares the required browser dependencies. The doctor command checks the installation. Follow the Crawl4AI installation guide for your operating system if either reports a missing dependency.

You do not need the optional LLM or machine-learning packages for a screenshot. The examples below use the BrowserConfig and CrawlerRunConfig API documented in the current Crawl4AI documentation.

Take a website screenshot and save the PNG

Save this script as screenshot.py:

1
import asyncio
2
import base64
3
from pathlib import Path
4

5
from crawl4ai import AsyncWebCrawler, BrowserConfig, CacheMode, CrawlerRunConfig
6

7

8
async def main():
9
    browser_config = BrowserConfig(
10
        headless=True,
11
        viewport_width=1280,
12
        viewport_height=800,
13
        text_mode=False,
14
    )
15
    run_config = CrawlerRunConfig(
16
        screenshot=True,
17
        force_viewport_screenshot=True,
18
        wait_until="load",
19
        page_timeout=60_000,
20
        cache_mode=CacheMode.BYPASS,
21
    )
22

23
    async with AsyncWebCrawler(config=browser_config) as crawler:
24
        result = await crawler.arun(
25
            url="https://example.com",
26
            config=run_config,
27
        )
28

29
        if not result.success:
30
            raise RuntimeError(result.error_message or "The crawl failed")
31
        if not result.screenshot:
32
            raise RuntimeError("The crawl returned no screenshot")
33

34
        image = base64.b64decode(result.screenshot, validate=True)
35
        Path("screenshot.png").write_bytes(image)
36
        print("Saved screenshot.png")
37

38

39
if __name__ == "__main__":
40
    asyncio.run(main())

Run it with:

1
python screenshot.py

This requests a viewport screenshot at 1280 by 800 CSS pixels. The browser configuration keeps image loading enabled, and the run configuration bypasses the crawl cache to request a fresh result.

The important detail is the output type: result.screenshot is a base64-encoded PNG string. Writing that string directly to a .png file will not create a valid image. Decode it to bytes first.

The script also checks both crawl success and screenshot presence. A crawl can return useful content without the image your application requested, so check the output you actually need.

Capture a full page, including lazy-loaded content

To capture the whole page, replace the run configuration with:

1
run_config = CrawlerRunConfig(
2
    screenshot=True,
3
    force_viewport_screenshot=False,
4
    scan_full_page=True,
5
    scroll_delay=0.3,
6
    max_scroll_steps=30,
7
    wait_until="load",
8
    page_timeout=60_000,
9
    cache_mode=CacheMode.BYPASS,
10
)

force_viewport_screenshot=False permits full-page capture. scan_full_page=True scrolls the page, which can trigger content that only loads after entering the viewport. scroll_delay controls the delay between scrolling steps, and max_scroll_steps caps the scan. Increase the cap for a longer finite page after inspecting the result.

These options are described in the Crawl4AI parameter reference.

Full-page capture and complete content are separate concerns. A tall image can still contain placeholders if the site did not finish loading the images or sections you expected.

Try a representative long page and inspect its bottom sections. Infinite feeds, virtualized lists, sticky headers, and continuously changing content may need a site-specific capture strategy. Scrolling an infinite feed also needs a defined stopping point rather than an expectation of capturing everything.

Wait for a JavaScript application before capture

A page’s load event can fire before an application has populated its report, table, or chart. Use a readiness signal that describes the content you want.

For a page you control, you might add data-ready="true" to its report after rendering. Then configure:

1
run_config = CrawlerRunConfig(
2
    screenshot=True,
3
    force_viewport_screenshot=True,
4
    wait_until="domcontentloaded",
5
    wait_for='css:.report[data-ready="true"]',
6
    page_timeout=60_000,
7
    cache_mode=CacheMode.BYPASS,
8
)

Replace the selector with one from your application. Waiting for a ready attribute is more useful than waiting for an empty container that exists before the data arrives.

Crawl4AI also supports a JavaScript condition through wait_for. For example, this checks for a ready report and loaded fonts:

1
run_config = CrawlerRunConfig(
2
    screenshot=True,
3
    wait_for="""js:() => {
4
        const report = document.querySelector('.report[data-ready="true"]');
5
        return Boolean(report) && document.fonts.status === "loaded";
6
    }""",
7
    cache_mode=CacheMode.BYPASS,
8
)

See the page interaction guide for CSS and JavaScript waits.

You can add screenshot_wait_for=1.0 when a page needs an extra second before capture. Treat that as a measured fallback: a fixed delay is less useful than a condition that identifies completed content.

The same readiness problem appears when using Playwright directly. The guide on waiting for page load in Playwright explains the difference between navigation events and application state.

Take screenshots of multiple URLs

Reuse the crawler for a small batch instead of opening a new browser for every URL:

1
import asyncio
2
import base64
3
from pathlib import Path
4

5
from crawl4ai import AsyncWebCrawler, BrowserConfig, CacheMode, CrawlerRunConfig
6

7

8
async def main():
9
    urls = ["https://example.com", "https://screenshotone.com"]
10
    output = Path("screenshots")
11
    output.mkdir(exist_ok=True)
12

13
    browser_config = BrowserConfig(
14
        headless=True,
15
        viewport_width=1280,
16
        viewport_height=800,
17
        text_mode=False,
18
    )
19
    run_config = CrawlerRunConfig(
20
        screenshot=True,
21
        force_viewport_screenshot=False,
22
        scan_full_page=True,
23
        max_scroll_steps=30,
24
        wait_until="load",
25
        cache_mode=CacheMode.BYPASS,
26
    )
27

28
    async with AsyncWebCrawler(config=browser_config) as crawler:
29
        for index, url in enumerate(urls, start=1):
30
            try:
31
                result = await crawler.arun(url=url, config=run_config)
32
                if not result.success or not result.screenshot:
33
                    raise RuntimeError(result.error_message or "No screenshot returned")
34

35
                destination = output / f"page-{index}.png"
36
                destination.write_bytes(
37
                    base64.b64decode(result.screenshot, validate=True)
38
                )
39
                print(f"Saved {destination}")
40
            except Exception as error:
41
                print(f"Failed {url}: {error}")
42

43

44
if __name__ == "__main__":
45
    asyncio.run(main())

This processes URLs sequentially and reports failures per page. For larger jobs, Crawl4AI also has arun_many(). Choose concurrency based on the browser memory available and the target sites’ capacity, and keep per-URL success and screenshot checks.

If you only need images, a screenshot API can move browser operation, rendering, and output delivery out of this batch script.

Common screenshot problems

There is no universal delay that fixes every page. Start with the missing visual element and identify what must happen before it can render.

Crawl4AI also has remove_overlay_elements and remove_consent_popups controls in its parameter reference. Test them when overlays cover your content. A managed screenshot API is useful when you want the browser operation and those rendering adjustments handled by a service.

Use ScreenshotOne when you need only screenshots or cleaner output

Crawl4AI is a useful choice when crawling and content extraction are part of the same job. For a website preview, screenshot archive, report image, or AI vision workflow that only needs images, ScreenshotOne is a focused alternative.

You can request a full-page screenshot with banner and ad blocking through its HTTP API:

1
import os
2
from pathlib import Path
3
from urllib.parse import urlencode
4
from urllib.request import urlopen
5

6
options = {
7
    "access_key": os.environ["SCREENSHOTONE_ACCESS_KEY"],
8
    "url": "https://example.com",
9
    "full_page": "true",
10
    "viewport_width": "1280",
11
    "viewport_height": "800",
12
    "block_cookie_banners": "true",
13
    "block_chats": "true",
14
    "block_ads": "true",
15
    "reduce_motion": "true",
16
    "format": "png",
17
}
18

19
request_url = "https://api.screenshotone.com/take?" + urlencode(options)
20
with urlopen(request_url, timeout=90) as response:
21
    image = response.read()
22

23
Path("screenshot.png").write_bytes(image)

Set SCREENSHOTONE_ACCESS_KEY in your environment before running the script. This example uses Python’s standard library, so it does not require a browser or a separate HTTP package in your application.

ScreenshotOne handles the browser rendering and returns PNG bytes directly. It does not return Crawl4AI’s base64 screenshot string, so the example saves the response without decoding it.

For better control of screenshot quality, ScreenshotOne provides:

• Cookie-banner removal and chat-widget removal to uncover the page content.
• Full-page scrolling to trigger lazy-loaded content before capture.
• Motion reduction to reduce changes from supported animations and media.
• Viewport and image options for consistent dimensions and output formats.
• Caching and S3-compatible storage for delivering the rendered images.

Use the blockers when you want a clean preview, and leave them off when an overlay or ad belongs in the record you are capturing. Motion reduction is best-effort; changing page content can still make repeated captures differ.

If your Crawl4AI screenshots already meet your needs, keep using them. If output quality takes repeated custom fixes, test ScreenshotOne on the same URLs and compare the completeness, overlays, fonts, and layout. You can start with 100 free screenshots.

For another managed option, see the screenshot-focused comparison of ScreenshotOne and ScrapingBee.

Frequently Asked Questions

If you read the article, but still have questions. Please, check the most frequently asked. And if you still have questions, feel free reach out at support@screenshotone.com.

Can Crawl4AI take website screenshots?

Yes. Set screenshot=True in CrawlerRunConfig. Crawl4AI returns the image as a base64-encoded PNG string in result.screenshot. Decode it before writing an image file.

How do I take a full-page screenshot with Crawl4AI?

Enable screenshot=True and leave force_viewport_screenshot=False. For pages with lazy-loaded content, scan_full_page=True can scroll the page before capture. Check the output on long or animated pages.

Do I need an LLM to take screenshots with Crawl4AI?

No. Local screenshot capture uses browser rendering and does not require an LLM or an extraction API key.

When should I use ScreenshotOne instead of Crawl4AI?

Use ScreenshotOne when you need only screenshots, want managed browser infrastructure, or need dedicated controls for cleaner output, such as cookie-banner removal, full-page scrolling, image formats, and motion reduction.