Screenshot APIs for Web Scraping — Capture Web Pages at Scale

Web scraping isn't just about extracting text and structured data. Sometimes you need visual data — screenshots of pages for archiving, compliance monitoring, visual testing, or building datasets for computer vision models. Screenshot APIs handle the browser rendering, viewport management, and image capture so you don't have to maintain headless browser infrastructure. This guide covers the best screenshot APIs for web scraping at scale.

Key Takeaways

• SearchHive ScrapeForge captures full-page and viewport screenshots as part of its unified scraping API — one credit system for text, data, and images
• ScrapingBee includes screenshot capture on all paid plans with PDF and PNG output options
• Screenshotapi.net is a dedicated screenshot service with advanced features (wait-for selectors, click actions, authentication)
• ApiFlash offers Google Lighthouse integration alongside screenshots
• Puppeteer/Playwright give you free, self-hosted screenshot capture with full control
• Screenshot APIs save 10-50 hours/month compared to maintaining your own headless browser fleet

---

Why Screenshot APIs Matter for Scraping

Text extraction misses a lot:

• Visual verification: Confirm that scraped data matches what users actually see
• Compliance monitoring: Archive pages for regulatory records (financial services, pharma)
• Competitive intelligence: Track competitor website changes visually over time
• Machine learning: Build image datasets from web pages for computer vision training
• Social media previews: Generate OG images and preview thumbnails
• Quality assurance: Automated visual regression testing for web applications

---

1. SearchHive ScrapeForge

ScrapeForge handles screenshots as part of its web scraping API. You get text extraction, structured data, and visual capture from a single endpoint and a single credit pool.

Pricing: Free tier with 500 credits. Builder at $49/mo (100K credits). Screenshots cost the same as regular scrapes — 1 credit per page capture.

Features:

• Full-page and viewport screenshots
• PNG and JPEG output
• Custom viewport dimensions (mobile, tablet, desktop)
• JS rendering before capture
• Proxy rotation included

import requests
import base64

API_KEY = "sh_live_your_key"

# Capture a full-page screenshot
response = requests.post(
    "https://api.searchhive.dev/v1/scrape",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "url": "https://example.com/landing-page",
        "render_js": True,
        "screenshot": {
            "full_page": True,
            "format": "png",
            "viewport": {
                "width": 1920,
                "height": 1080
            }
        }
    }
)

result = response.json()

# Save screenshot to file
if "screenshot" in result:
    image_data = base64.b64decode(result["screenshot"]["data"])
    with open("screenshot.png", "wb") as f:
        f.write(image_data)
    print(f"Screenshot saved: {len(image_data)} bytes")

# You also get the page content in the same response
print(f"Page title: {result.get('content', {}).get('title', 'N/A')}")

Batch screenshot capture for monitoring:

import requests
import base64
from datetime import datetime

API_KEY = "sh_live_your_key"

urls_to_monitor = [
    "https://competitor-a.com/pricing",
    "https://competitor-b.com/pricing",
    "https://competitor-c.com/features",
]

timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")

for url in urls_to_monitor:
    response = requests.post(
        "https://api.searchhive.dev/v1/scrape",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "url": url,
            "render_js": True,
            "screenshot": {"full_page": True, "format": "png"},
            "format": "markdown"
        }
    )
    
    result = response.json()
    
    if "screenshot" in result:
        image_data = base64.b64decode(result["screenshot"]["data"])
        safe_name = url.replace("https://", "").replace("/", "_").replace(".", "_")
        filename = f"screenshots/{safe_name}_{timestamp}.png"
        with open(filename, "wb") as f:
            f.write(image_data)
        print(f"Captured: {filename}")

Best for: Teams that want screenshots and text extraction from one API without managing separate tools.

/compare/scrapingbee

---

2. ScrapingBee

ScrapingBee includes screenshot capture on all paid plans (Freelance and above). It captures both PNG screenshots and PDF renders.

Pricing: Screenshot requests cost 1 credit each (same as regular scraping). Freelance at $49/mo (250K credits) gives 250K screenshots.

import requests

SCRAPINGBEE_KEY = "your_key"

response = requests.get(
    "https://app.scrapingbee.com/api/v1/",
    params={
        "api_key": SCRAPINGBEE_KEY,
        "url": "https://example.com",
        "screenshot": "true",
        "screenshot_full_page": "true",
        "render_js": "true",
        "window_width": "1920",
        "window_height": "1080",
    }
)

with open("scrapingbee_screenshot.png", "wb") as f:
    f.write(response.content)

Strengths: Simple API, PDF generation included, no separate tool needed.

Weaknesses: No advanced features like wait-for-selector or click-before-capture. JPEG quality options are limited.

---

3. Screenshotapi.net

A dedicated screenshot service with more advanced browser interaction features.

Pricing: Free tier with 100 screenshots/mo. Pro at $29/mo (5K), Business at $99/mo (25K), Premium at $249/mo (100K).

import requests

response = requests.get(
    "https://api.screenshotapi.net/screenshot",
    params={
        "url": "https://example.com",
        "token": "your_key",
        "output": "image",
        "width": 1920,
        "height": 1080,
        "fullPage": "true",
        "waitFor": 2000,  # Wait 2 seconds after load
    }
)

with open("screenshot.png", "wb") as f:
    f.write(response.content)

Strengths: Wait-for-selector support, click actions, JavaScript execution before capture, authentication support.

Weaknesses: Screenshot-only — no text extraction or data scraping. Pricing is per-screenshot rather than credit-based.

---

4. ApiFlash

ApiFlash (formerly screenshotlayer) is built on top of Chrome and offers screenshot capture with Google Lighthouse integration.

Pricing: Free tier with 100 screenshots/mo. Micro at $12/mo (500), Startup at $39/mo (2,500), Business at $99/mo (10,000).

import requests

response = requests.get(
    "https://api.apiflash.com/v1/urltoimage",
    params={
        "access_key": "your_key",
        "url": "https://example.com",
        "format": "png",
        "width": 1920,
        "height": 1080,
        "full_page": "true",
        "lighthouse": "true",  # Include Lighthouse score
    }
)

with open("apiflash_screenshot.png", "wb") as f:
    f.write(response.content)

Strengths: Lighthouse integration (performance, accessibility, SEO scores alongside screenshots), Google Fonts rendering, retina display support.

Weaknesses: Expensive per screenshot ($3.96/100 screenshots on Business), no text extraction.

---

5. Self-Hosted with Playwright

For complete control and zero per-screenshot costs, run Playwright yourself:

import asyncio
from playwright.async_api import async_playwright

async def capture_screenshots(urls, output_dir="screenshots"):
    os.makedirs(output_dir, exist_ok=True)
    
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        
        for url in urls:
            page = await browser.new_page(viewport={"width": 1920, "height": 1080})
            await page.goto(url, wait_until="networkidle")
            
            # Optional: wait for specific element
            # await page.wait_for_selector(".main-content")
            
            safe_name = url.replace("https://", "").replace("/", "_")
            await page.screenshot(path=f"{output_dir}/{safe_name}.png", full_page=True)
            print(f"Captured: {url}")
            await page.close()
        
        await browser.close()

asyncio.run(capture_screenshots([
    "https://example.com/page1",
    "https://example.com/page2",
]))

Cost: Server with Chrome ($20-40/mo). Unlimited screenshots within hardware constraints.

Trade-off: You manage browser versions, handle crashes, deal with memory leaks, and scale infrastructure yourself.

---

Comparison Table

---

Best Practices for Screenshot Scraping

1. Standardize viewport sizes. Use consistent dimensions (1920x1080, 1366x768, 375x812) to make screenshots comparable across captures.

2. Wait for dynamic content. Many pages load content after initial paint. Use wait_until: networkidle or explicit wait-for-selector to ensure complete renders.

3. Handle cookie banners. Either accept/reject them before capturing, or accept that they'll appear in screenshots.

4. Compress for storage. PNG screenshots of full pages can be 5-20MB. Consider JPEG compression or WebP for archival use.

5. Implement deduplication. Compare new screenshots against previous captures to detect actual changes (perceptual hashing works well here).

6. Set up monitoring. Failed screenshot captures often indicate the target site has changed or blocked your requests.

---

Our Recommendation

SearchHive ScrapeForge is the best choice when you need both screenshots and text extraction from the same pages. One API call returns both the visual capture and the structured data, and the unified credit system means you're not paying two separate providers.

For screenshot-only workflows with advanced browser interaction (click, scroll, wait-for), Screenshotapi.net is the specialist pick. For teams that need Lighthouse performance metrics alongside screenshots, ApiFlash is worth the premium.

For teams with engineering capacity and genuinely high volume, self-hosted Playwright is the most cost-effective path — zero per-capture costs after infrastructure setup.

---

Get Started with SearchHive

500 free credits. Capture screenshots, extract data, and search the web from one API.

pip install searchhive

from searchhive import ScrapeForge
sf = ScrapeForge('sh_live_your_key')
result = sf.scrape(
    'https://example.com',
    screenshot={'full_page': True, 'format': 'png'},
    render_js=True
)
with open('capture.png', 'wb') as f:
    import base64
    f.write(base64.b64decode(result['screenshot']['data']))

Read the docs or sign up for free.