DEV Community: bertrand

How to take website screenshots with Python

bertrand — Thu, 03 Jul 2025 08:06:14 +0000

Learn how to take website screenshots with Python. Explore Selenium, Playwright, Pyppeteer, and Screenshot API as a Service with Python SDK.

Capturing website screenshots is a fundamental task for testing, monitoring, and content automation. In this guide, we explore four methods, including Selenium, Playwright, Pyppeteer, and Screenshot API, comparing their strengths, and weaknesses, and providing full Python examples. Whether you need precision control or a hassle-free SaaS integration, this article helps you choose the right approach.

Selenium for Python

Selenium is one of the oldest and most trusted browser automation tools in Python. With roots in the early 2000s, Selenium was created to automate web applications for testing purposes. Powered by real web browsers (Chrome, Firefox, Safari, Edge), it simulates entire user sessions, ensuring high fidelity.

Installation & basic usage

    pip install selenium webdriver-manager

    from selenium import webdriver
    from selenium.webdriver.chrome.service import Service
    from webdriver_manager.chrome import ChromeDriverManager

    driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
    driver.get('https://example.com')
    driver.save_screenshot('selenium_screenshot.png')
    driver.quit()
    print("Selenium: Screenshot saved")

Pros & cons

Selenium excels at faithfully emulating real user interactions using full browser engines, ideal for complex UI and dynamic content. However, its reliance on external browser drivers and the need to manage browser instances can make it heavier and slower than headless solutions.

Playwright for Python

Developed by Microsoft and released in 2020, Playwright is a relative newcomer optimized for end-to-end testing. It supports Chromium, Firefox, and WebKit with consistent APIs and excels at handling modern web apps with built-in network and script control.

Installation & basic usage

    pip install playwright
    playwright install

    from playwright.sync_api import sync_playwright

    with sync_playwright() as p:
      browser = p.chromium.launch()
      page = browser.new_page()
      page.goto('https://example.com')
      page.screenshot(path='playwright_screenshot.png', full_page=True)
      browser.close()
    print("Playwright: Screenshot saved")

Pros & cons

Playwright delivers fast, reliable automation with broader browser support and powerful features like intercepting network traffic and built-in wait mechanisms. Yet, the necessity to install browser binaries and its larger package size may be overkill for simple tasks.

Pyppeteer (Python port of Puppeteer)

Pyppeteer is the Python port of Puppeteer,a tool built by the Chromium team for controlling headless Chrome or Chromium. Emerging around 2018, it brings Puppeteer’s ease-of-use and high-speed operations to Python developers.

Installation & basic Usage

    pip install pyppeteer

    import asyncio
    from pyppeteer import launch

    async def capture():
      browser = await launch()
      page = await browser.newPage()
      await page.goto('https://example.com')
      await page.screenshot({'path': 'pyppeteer_screenshot.png', 'fullPage': True})
      await browser.close()
      print("Pyppeteer: Screenshot saved")

    asyncio.get_event_loop().run_until_complete(capture())

Pros & cons

Pyppeteer offers a lean headless Chromium experience with high-speed execution and easy scripting. On the downside, maintenance lag and dependency on a specific Chromium version can pose compatibility issues, especially as web technologies evolve.

Screenshot API as a service with Python

ScreenshotMAX is a lightweight Screenshot as a Service (SaaS) API designed to simplify and scale screenshot capture. Launched to eliminate local browser setup complexities, this service offers a stable endpoint where you send a URL and receive an image in return. With an accompanying Python SDK, ScreenshotMAX integrates effortlessly into your workflow.

Installation & basic usage

    pip install ScreenshotMAX

    from ScreenshotMAX import SDK
    from screenshotmax.enum import ImageFormat
    from screenshotmax.options import ScreenshotOptions

    # Initialize SDK
    sdk = SDK('YOUR_ACCESS_KEY', 'YOUR_SECRET_KEY')

    # Set up options
    opts = ScreenshotOptions(url="https://example.com", format=ImageFormat.PNG)
    # fetch screenshot
    result, headers = sdk.screenshot.set_options(opts).fetch()

    # save screenshot to file
    with open("screenshot.png", "wb") as f:
      f.write(result)

Pros & cons

ScreenshotMAX abstracts away browser management, offering fast, scalable screenshots with zero local dependencies. It’s ideal for bulk capture, monitoring, and cloud environments. However, it introduces network latency, billing considerations, and potential limits compared to free, entirely local options.

Comparison Overview

Method	Setup Complexity	Speed	Browser Fidelity	Scalability
Selenium	High	Slowest	Very High	Low–Medium
Playwright	Medium	Fast	High	Medium
Pyppeteer	Medium	Fastest	High	Medium
Screenshot API	Very Low	Fast–Medium	Medium	Very High

Selenium requires managing browser drivers, making it less ideal for mass automation.
Playwright offers excellent speed and multimedia handling but includes heavier dependencies.
Pyppeteer trades some maintenance reliability for a minimalistic, direct Chromium approach.
ScreenshotMAX API eliminates local complexity, trading off raw control and introducing API limits and costs.

Which should you choose?

Use Selenium if you need full browser interactions, real user simulations, or testing in real-world environments. Choose Playwright for fast and robust automated testing across multiple browser engines. Opt for Pyppeteer if you want a lightweight, headless Chromium script without larger frameworks. And pick ScreenshotMAX API when you’re dealing with cloud pipelines, scalable capture needs, or want to skip installing and maintaining browsers.

If you need to automate complex browser interactions or generate screenshots in tightly controlled environments, Selenium or Playwright offers fine-grained control. It’s ideal for one-off screenshots, local development, or workflows where you need to manipulate the DOM or wait for dynamic content.

However, if your goal is to capture hundreds or thousands of screenshots reliably, especially in a production setting, a screenshot API like ScreenshotMAX is a better choice. It handles the infrastructure, parallel processing, and scaling for you, so you don’t have to worry about memory limits, browser crashes, or queueing jobs manually. You just call the API and get your result back quickly, with consistent rendering and high availability. It’s purpose-built for bulk screenshot tasks and large workloads.

No matter your needs, this guide empowers you to take high-quality website screenshots using Python, whether open-source or SaaS-powered.

Originally published at: https://screenshotmax.com/blog/how-to-take-website-screenshots-with-python

How to take website screenshots with Javascript/Typescript (Node.js)

bertrand — Wed, 25 Jun 2025 19:18:10 +0000

Learn how to take website screenshots with Javascript/Typescript (Node.js) using Selenium, Puppeteer, or Screenshot API as a Service: compare tools and find the best fit for your workflow.

Why Screenshots in code matter

Capturing website screenshots programmatically is essential for visual audits, regression tests, previews, and more. But doing it reliably,handling lazy loading, pop‑ups, consent banners, mobile layouts,can quickly become a time sink. Let’s contrast self‑hosted tooling with a turnkey API, so you can choose what frees you up to build.

Using Puppeteer

Using Puppeteer lets you wield complete control over headless Chrome (or Chromium), making it ideal for tasks like SPAs, form submissions, and custom workflows,all without incurring any tool-specific costs beyond your hosting environment . However, this power comes with trade-offs: you’ll need to maintain the entire browser infrastructure yourself,binaries, worker processes, scaling logic, retries,and manually handle overlays such as ads or cookie banners . Additionally, because Puppeteer is limited to Chrome/Chromium (with experimental Firefox support), you risk drifting away from true real‑world rendering that users experience on other browsers.

Example using Puppeteer:

    const puppeteer = require('puppeteer');

    (async () => {
      const browser = await puppeteer.launch();
      const page = await browser.newPage();

      await page.setViewport({ width: 1_280, height: 800 });
      await page.goto('https://example.com', { waitUntil: 'networkidle' });

      // Optional: await page.click('.cookie-accept');
      await page.screenshot({ path: 'puppeteer.png', fullPage: true });
      await browser.close();
    })();

This works great locally, but scaling it to hundreds or thousands? Now it’s your cloud to manage.

Using Playwright

Using Playwright gives you a unified API to automate Chromium, Firefox, and WebKit, making it especially powerful for cross‑browser visual testing and reliable execution. It even supports mobile device emulation out of the box, so you can test how your app renders on mobile without extra tooling. However, these benefits come with the same overhead you’d face using Puppeteer: you must manage infrastructure, deal with cookie and ad banners, and navigate headless browser quirks yourself. Ultimately, you’re still responsible for orchestrating the entire process.

Example using Playwright:

    const { chromium } = require('playwright');

    (async () => {
      const browser = await chromium.launch();
      const page = await browser.newPage();

      await page.goto('https://example.com', { waitUntil: 'networkidle' });
      await page.screenshot({ path: 'playwright.png', fullPage: true });
      await browser.close();
    })();

Playwright makes cross‑browser testing elegant, but you still own the stack.

Screenshot API as a service

Enter ScreenshotMAX: the screenshot service you don’t have to build or manage. We handle browser orchestration, scaling, banners, retries, infrastructure... so you can ship screen‑driven features fast.

Why ScreenshotMAX?

You don’t need to worry about managing browser versions or orchestrating clusters,ScreenshotMAX handles all that infrastructure for you. It intelligently detects and hides cookie banners, ads, and chat overlays so your snapshots are clean and professional. Whether you send a single request or millions, it scales instantly to meet your needs. Customize your screenshots with full‑page captures, viewport selection, device emulation, and even dark mode support. On top of that, you benefit from strong service-level agreements, built‑in monitoring, automated retries, and caching,everything needed for enterprise-grade reliability.

Standard HTTP example

    curl https://api.screenshotmax.com/v1/screenshot \
    -G --data-urlencode "url=https://example.com" \
    -d format=webp \
    -d access_key=YOUR_ACCESS_KEY \
    -d full_page=true \
    -d block_annoyance=cookies_banner \
    -d device_scale_factor=2 \
    -d viewport_width=1280 -d viewport_height=800 \
    -o ScreenshotMAX.png

That’s it, one command, no infrastructure.

Javascript SDK example

Here’s how you can use the ScreenshotMAX SDK in a Node.js application:

    import fs from "node:fs";
    import { SDK } from "@screenshotmax/sdk";

    (async () => {
      const client = new SDK("YOUR_ACCESS_KEY", "YOUR_SECRET_KEY");

      const result = await client
        .setOptions({
          url: 'https://example.com',
          full_page: true,
          format: 'webp',
          block_annoyance: 'cookies_banner',
          viewport_width: 1_280,
          viewport_height: 800,
          device_scale_factor: 2,
        })
        .fetch();

      console.log("Screenshot saved:", result.headers.get("Content-Type"));
      fs.writeFileSync("screenshot.png", Buffer.from(result.data, "binary"));
    })();

SDKs also available in Python and PHP.

Comparison at a glance

Allow You To…	Puppeteer	Playwright	Screenshot API
Full Browser Control	✅	✅	❌ (but sufficient)
Cross‑Browser (FF/WebKit)	Partial	✅	✅
Manage Infrastructure & Scale	🚧	🚧	✅
Handle Cookie Banners/Ads	Manual	Manual	✅
Easy to Use API & SDKs	❌	❌	✅
Predictable Pricing & Support	❌	❌	✅

Conclusion

Puppeteer and Playwright are powerful, but maintaining infrastructure, dealing with pop‑ups, and scaling can take more time than building features. If you’d rather focus on your app than managing browser farms, ScreenshotMAX abstracts the pain away.

If you need to automate complex browser interactions or generate screenshots in tightly controlled environments, Puppeteer or Playwright offers fine-grained control. It’s ideal for one-off screenshots, local development, or workflows where you need to manipulate the DOM or wait for dynamic content.

Quickstart

Getting started with ScreenshotMAX is easy:

Sign up for a free account at ScreenshotMAX.
Get your API key from the dashboard.
Use one of the examples above to take your first screenshot.

If you’re ready to offload the complexity and speed past the screenshot busywork, let’s help you ship sooner.

Originally published at: https://screenshotmax.com/blog/how-to-take-website-screenshots-with-javascript-typescript-nodejs

How to generate PDFs with Puppeteer

bertrand — Mon, 23 Jun 2025 13:43:41 +0000

Learn how to use Puppeteer to generate PDFs from web pages efficiently.

Puppeteer is a Node.js library that provides a high-level API to control Google Chrome or Chromium browsers. Developers use Puppeteer to automate browser tasks like navigating pages, clicking elements, taking screenshots, and even generating PDFs.

Because it runs a real headless browser, Puppeteer can render web pages exactly as in a browser, including full CSS, images, and webfonts, making it ideal for converting HTML pages into PDFs (for reports, receipts, invoices, etc.). In practice, you can script Puppeteer to open a URL or HTML content and call page.pdf() to save a PDF file of the rendered page.

Generating PDFs with Puppeteer

First, install Puppeteer via npm install puppeteer. Then you can write a script like this to create a PDF:

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();

  const page = await browser.newPage();

  // Navigate to the page or set HTML content
  await page.goto('https://example.com', { waitUntil: 'networkidle0' });

  // Generate PDF.
  // Options include format (A4, letter), margins, landscape, etc.
  await page.pdf({ path: 'example.pdf', format: 'A4' });

  await browser.close();
})();

This example uses await page.pdf({path: 'example.pdf', format: 'A4'}) to save the page as a PDF. Under the hood, Puppeteer waits for the page to load (including fonts and images) and then prints it to PDF. You can customize page size, margins, headers/footers, and more by passing options to page.pdf().

Challenges of a DIY Puppeteer solution

Using Puppeteer directly gives you fine-grained control over how pages render, but it comes with challenges. You must manage headless Chrome instances yourself, installing or updating Chrome/Chromium, handling memory leaks or crashes, and orchestrating multiple processes.

In fact, one developer notes that “managing headless browsers is a huge pain. The browsers might have memory leaks and sudden restarts”, and that running many concurrent PDFs can become “a computation-heavy task for servers”.

In short, you get precise results, but you also inherit complex operational burdens. Scaling this setup (for example, generating dozens of PDFs per second) requires your own infrastructure, load balancing, and monitoring.

Pros: Complete control over rendering. You can wait for specific elements or animations, then print to PDF.
Cons: Requires heavy lifting (browser updates, memory management).
Scalability Issues: Running multiple headless Chrome instances is CPU/memory intensive, making it hard to scale horizontally.
Quality Issues: Some dynamic content or print-specific CSS may not work perfectly without tweaking.

Because of these hassles, many teams look for a hosted service. That’s where another solution comes in.

Simplifying PDF generation

ScreenshotMAX HTML to PDF API automatically filters out distracting elements like cookie banners and ads, producing clean PDF outputs without any extra effort. Instead of writing and maintaining your own Puppeteer code, you can use ScreenshotMAX’s hosted API. It wraps headless Chrome in a cloud service so you can focus on your application logic. ScreenshotMAX offers an all-in-one API: it supports screenshots, animated videos, HTML to PDF, and web scraping through one unified service. It is a free HTML to PDF API for up to 100 requests.

Key benefits include:

All-in-one API: Screenshots, PDFs, videos, and scraping, no need for multiple libraries or services.
Clean by default: Automatically blocks cookie pop-ups, ads, and other unwanted elements.
Fast & Scalable: Runs on Google Cloud with a global CDN (Cloudflare) for reliable, high-speed rendering.
Developer-Friendly: Well-documented endpoints, official SDKs, and simple API-key authentication.

In short, ScreenshotMAX is “built specifically for developers” who want high-quality PDFs without managing browser servers. You don’t have to deal with Puppeteer upgrades, OS dependencies, or runtime errors. For example, to convert a webpage to PDF with ScreenshotMAX you make one HTTP request instead of writing code.

    GET https://api.screenshotmax.com/v1/pdf
    ?access_key=YOUR_ACCESS_KEY
    &url=https://example.com/report

This single call returns the rendered PDF of the given page (or HTML). The underlying engine still uses headless Chrome, but all that complexity is hidden from you. You can configure page size, delay, and other options via query parameters or JSON payload. And because the service is managed, you get better uptime and throughput without lifting a finger.

Real-world example: generating invoice PDFs

In practice, ScreenshotMAX can handle tasks like generating PDF invoices from HTML templates. For instance, suppose your order system has an invoice URL like https://shop.example.com/order/123/invoice. You could let Puppeteer load that page and print it, but with ScreenshotMAX it’s much simpler:

    curl --location 'https://api.screenshotmax.com/v1/pdf?access_key=YOUR_ACCESS_KEY&url=https://shop.example.com/order/123/invoice'
    --output invoice-123.pdf

The response is a binary PDF file for invoice #123. This offloads the rendering work to ScreenshotMAX’s servers.

In fact, Puppeteer guides note that generating PDFs is perfect for things like reports or invoices. By using ScreenshotMAX, you achieve the same result “with ease”, without writing or maintaining any Puppeteer code yourself. The clean-up of cookie banners and dynamic content is done automatically, ensuring the PDF is polished and ready for your customer or records.

Originally published at: https://screenshotmax.com/blog/how-to-generate-pdf-with-puppeteer

Screenshot API vs Headless Browser: Which Is Best for Your Use Case

bertrand — Sun, 08 Jun 2025 17:31:28 +0000

Introduction

Developers building front-end automations, data scraping pipelines, or site monitoring tools often need screenshots of web pages. Two main approaches can help you here: headless browsers and website screenshot APIs.

While both allow you to generate screenshots, they differ in setup, flexibility, scalability, and use cases. This article explores each, comparing real-world scenarios to help you choose the best solution for your needs.

What is a headless browser?

A headless browser is a real browser running without a graphical user interface (GUI). Instead of clicking around manually, you control the browser with code. Popular tools include Puppeteer, Playwright, and Selenium.

These tools let you load web pages, interact with the DOM, wait for elements to appear, click buttons, fill forms, and finally take a screenshot, all without displaying a window.

Advantages:

Full control: Script every interaction down to the pixel.
Ideal for JavaScript-heavy websites: Wait for async content to render.
Works well for testing: Simulate user behavior in CI/CD pipelines.
Great for scraping: Extract data and then screenshot the result.

Drawbacks:

Setup overhead: Requires installation of Chrome/Firefox, dependencies, and libraries.
Resource-hungry: Running multiple browsers in parallel uses a lot of CPU and RAM.
Not cloud-native by default: Scaling headless browsers needs orchestration.
Anti-bot detection: Some websites detect and block headless browsers.

What is a screenshot API?

A screenshot API provides screenshots as a service. You send an HTTP request with a URL and optional parameters (viewport, full-page, delay, etc.), and get back an image (PNG, JPG) or a PDF.

Most screenshot APIs run headless browsers in the cloud under the hood, but you don’t need to worry about that part.

Advantages:

No setup: No need to install or maintain any browser.
Instant scalability: Handle hundreds or thousands of screenshots in parallel.
Simple integration: Works with any language or platform via HTTP.
Extra features: Full-page rendering, ad and cookie banner blocking, geolocation, PDF output.
Resilient to bot detection: APIs often come with stealth features and proxy rotation.

Drawbacks:

Less flexible: Can’t easily perform complex interactions like logins or popups.
External dependency: Requires an internet connection and trust in the service uptime.
Costs: Most APIs are paid with request quotas or rate limits.
No DOM access: You can’t extract structured data from the page unless the API offers that feature.

Side-by-side comparison

Feature	Headless Browser	Screenshot API
Setup Complexity	High	Low
Control over interactions	Full	Limited
Dynamic content rendering	Excellent	Very good (with wait options)
Scalability	Manual scaling required	Built-in auto-scaling
Data extraction	Yes (DOM access)	No (unless additional API support)
Integration time	Longer	Quick (HTTP request)
Cost	Your infra + dev time	Pay-per-use or subscription
Stability	May require retries, reboots	Generally more stable at scale
Anti-bot capabilities	Manual configuration required	Often included out-of-the-box

Use cases

1. Capturing Dynamic Pages

If you need to wait for JavaScript-heavy content (like charts, lazy-loaded content, or modal popups):

Use a headless browser if you need to simulate user behavior (e.g., clicking tabs before screenshot).
Use a screenshot API if you only need to wait for an element or delay before capture.

2. Web Scraping

Need to extract structured data and generate a screenshot of the result?

Use a headless browser: Navigate, extract, and snapshot all in one flow.
Screenshot APIs don’t give you access to HTML/DOM by default, some may offer it, but it’s not standard.

3. CI/CD Visual Testing

Want to validate frontend appearance in your pipeline?

Use a headless browser with your testing framework (e.g., Jest, Cypress, Playwright).
Use a screenshot API for capturing snapshots of production or staging sites post-deploy.

4. Generating Thumbnails or Previews

Need to generate small previews or marketing thumbnails?

Use a screenshot API. Fast, reliable, and easy to trigger from a serverless function.

Performance and scalability

Headless browsers are flexible but can be hard to scale. Launching multiple browser instances eats CPU and memory. You may need to implement your own queuing system, error retries, and watchdogs to handle browser crashes.

For small-scale or one-off use, that’s manageable, but for production workloads, it’s work.

Screenshot APIs abstract that pain. They can handle 10 or 10,000 screenshots with the same code. You don't need to worry about concurrency, crash recovery, or hardware.

Cost considerations

Running headless browsers yourself is "free" in terms of licensing but not in engineering time. You’re responsible for hosting, updates, and resilience. If you only need a few screenshots, it may not be worth building your own service.

Screenshot APIs typically use a pay-as-you-go model or subscriptions. Some have free tiers. If you're processing thousands of screenshots a month, do the math: the API may still be cheaper than maintaining your own browser farm.

Developer experience

Headless browsers offer full control, but you’ll write and maintain more code.
Screenshot APIs offer speed. With a single HTTP call, you get a reliable screenshot.

If you're prototyping or on a tight deadline, APIs let you ship faster.

When to use both

Some workflows benefit from both tools:

Use a headless browser to scrape data and prepare the page.
Then send the page URL to a screenshot API for rendering and storage.

Hybrid solutions are common in modern automation stacks.

Why ScreenshotMAX?

If you're looking for a reliable, developer-friendly website screenshot API, ScreenshotMAX has you covered.

Full-page screenshots
Ad, cookie, and tracker blocking
Support for dynamic content
HTML to PDF conversion
Geo-targeted rendering
Easy SDKs for TypeScript, Python, and more

Start with our free tier, then scale with your needs. Whether you're building a SaaS feature, monitoring tool, or scraping bot, ScreenshotMAX lets you focus on your logic, not browser quirks.

Conclusion

Use a headless browser if you need control, interaction, or direct data extraction.
Use a screenshot API if you want fast, scalable, and reliable screenshots without managing browsers.

Each approach has trade-offs. For complex automations, a headless browser is unbeatable. For speed and scale, nothing beats a mature API.

ScreenshotMAX gives you the best of both worlds: developer control with API-level simplicity. Try it today and simplify your screenshot workflow.