5 Real-World Use Cases for Web Screenshot APIs in 2026

pip install requests pillow schedule

export APIVULT_API_KEY="YOUR_API_KEY"

import os
import requests
 
API_KEY = os.environ["APIVULT_API_KEY"]
BASE_URL = "https://apivult.com/api/v1/webshot"
 
def capture(
    url: str,
    device: str = "desktop",  # desktop, tablet, mobile
    full_page: bool = True,
    wait_for: str = None,  # CSS selector to wait for before capturing
    delay_ms: int = 0,
) -> bytes:
    """Capture a screenshot of the given URL."""
    payload = {
        "url": url,
        "device": device,
        "full_page": full_page,
        "format": "png",
    }
    if wait_for:
        payload["wait_for_selector"] = wait_for
    if delay_ms:
        payload["wait_ms"] = delay_ms
 
    response = requests.post(
        f"{BASE_URL}/capture",
        headers={"X-API-Key": API_KEY},
        json=payload,
    )
    response.raise_for_status()
    return response.content

import hashlib
import json
from datetime import datetime
from pathlib import Path
 
COMPETITORS = {
    "competitor_a": "https://example-competitor-a.com/pricing",
    "competitor_b": "https://example-competitor-b.com/plans",
    "competitor_c": "https://example-competitor-c.com/pricing",
}
 
def monitor_pricing_pages(storage_dir: str = "competitor_snapshots"):
    Path(storage_dir).mkdir(exist_ok=True)
 
    changes = []
    for name, url in COMPETITORS.items():
        print(f"Capturing {name}...")
        screenshot = capture(url, wait_for=".pricing-table, [data-pricing]", delay_ms=500)
        current_hash = hashlib.sha256(screenshot).hexdigest()
 
        # Check against last known state
        hash_file = Path(storage_dir) / f"{name}.hash"
        previous_hash = hash_file.read_text() if hash_file.exists() else None
 
        if previous_hash != current_hash:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            screenshot_path = Path(storage_dir) / f"{name}_{timestamp}.png"
            screenshot_path.write_bytes(screenshot)
 
            changes.append({
                "competitor": name,
                "url": url,
                "screenshot": str(screenshot_path),
                "detected_at": datetime.now().isoformat(),
            })
            print(f"  CHANGE DETECTED for {name}")
        else:
            print(f"  No change for {name}")
 
        hash_file.write_text(current_hash)
 
    if changes:
        notify_team(changes)  # Send Slack/email alert
 
    return changes
 
def notify_team(changes: list[dict]):
    """Send notification about detected pricing changes."""
    message = f"🔔 Competitor pricing changes detected ({len(changes)} pages):\n"
    for change in changes:
        message += f"  • {change['competitor']}: {change['url']}\n"
    print(message)  # Replace with actual notification logic
 
# Schedule to run every 6 hours
import schedule
import time
 
schedule.every(6).hours.do(monitor_pricing_pages)
while True:
    schedule.run_pending()
    time.sleep(60)

def generate_og_image(
    page_url: str,
    output_path: str,
    width: int = 1200,
    height: int = 630,
) -> str:
    """Generate a 1200x630 OG image for social sharing."""
    response = requests.post(
        f"{BASE_URL}/capture",
        headers={"X-API-Key": API_KEY},
        json={
            "url": page_url,
            "viewport": {"width": width, "height": height},
            "full_page": False,  # Just the viewport, not full page
            "device": "desktop",
            "format": "jpeg",
            "quality": 90,
            "clip": {"x": 0, "y": 0, "width": width, "height": height},
        },
    )
    response.raise_for_status()
 
    with open(output_path, "wb") as f:
        f.write(response.content)
    return output_path
 
# Generate OG images for all blog posts
blog_posts = [
    {"slug": "how-to-automate-data-validation", "url": "https://yourblog.com/posts/data-validation"},
    {"slug": "api-security-guide-2026", "url": "https://yourblog.com/posts/api-security"},
]
 
for post in blog_posts:
    output = f"public/og/{post['slug']}.jpg"
    generate_og_image(post["url"], output)
    print(f"Generated OG image: {output}")

from PIL import Image, ImageChops
import io
import numpy as np
 
def compare_screenshots(baseline: bytes, current: bytes, threshold: float = 0.02) -> dict:
    """
    Compare two screenshots and return diff metrics.
    threshold: maximum acceptable pixel difference ratio (0.02 = 2%)
    """
    img1 = Image.open(io.BytesIO(baseline)).convert("RGB")
    img2 = Image.open(io.BytesIO(current)).convert("RGB")
 
    # Ensure same size
    if img1.size != img2.size:
        img2 = img2.resize(img1.size, Image.LANCZOS)
 
    diff = ImageChops.difference(img1, img2)
    diff_array = np.array(diff)
 
    total_pixels = diff_array.shape[0] * diff_array.shape[1]
    changed_pixels = np.sum(diff_array.sum(axis=2) > 30)  # Threshold for significant change
    diff_ratio = changed_pixels / total_pixels
 
    return {
        "passed": diff_ratio <= threshold,
        "diff_ratio": diff_ratio,
        "changed_pixels": int(changed_pixels),
        "total_pixels": total_pixels,
    }
 
def run_visual_regression_tests(
    pages: list[dict],
    baseline_dir: str = "visual-baselines",
):
    """
    Run visual regression tests against stored baselines.
    pages: [{"name": "homepage", "url": "...", "selector": "..."}]
    """
    Path(baseline_dir).mkdir(exist_ok=True)
    failures = []
 
    for page in pages:
        name = page["name"]
        screenshot = capture(page["url"], wait_for=page.get("selector"))
 
        baseline_path = Path(baseline_dir) / f"{name}.png"
 
        if not baseline_path.exists():
            # First run — save as baseline
            baseline_path.write_bytes(screenshot)
            print(f"  Baseline created: {name}")
            continue
 
        baseline = baseline_path.read_bytes()
        result = compare_screenshots(baseline, screenshot)
 
        status = "PASS" if result["passed"] else "FAIL"
        print(f"  [{status}] {name}: {result['diff_ratio']:.2%} pixels changed")
 
        if not result["passed"]:
            # Save the failing screenshot for inspection
            fail_path = Path(baseline_dir) / f"{name}_failed.png"
            fail_path.write_bytes(screenshot)
            failures.append({"page": name, **result})
 
    if failures:
        print(f"\n{len(failures)} visual regression failures detected")
        return False
    return True
 
# Run in CI
pages_to_test = [
    {"name": "homepage", "url": "https://staging.yourdomain.com/"},
    {"name": "pricing", "url": "https://staging.yourdomain.com/pricing"},
    {"name": "dashboard", "url": "https://staging.yourdomain.com/dashboard"},
]
success = run_visual_regression_tests(pages_to_test)
sys.exit(0 if success else 1)

from datetime import datetime, timezone
import hashlib
import json
 
def archive_page(url: str, case_id: str, archive_dir: str = "compliance_archive") -> dict:
    """
    Capture and archive a webpage with cryptographic proof of integrity.
    Returns archive metadata including file hash for chain-of-custody documentation.
    """
    Path(archive_dir).mkdir(exist_ok=True)
 
    captured_at = datetime.now(timezone.utc)
    screenshot = capture(url, full_page=True)
 
    # Generate deterministic filename
    timestamp_str = captured_at.strftime("%Y%m%d_%H%M%S")
    filename = f"{case_id}_{timestamp_str}.png"
    filepath = Path(archive_dir) / filename
 
    filepath.write_bytes(screenshot)
 
    # Compute hash for integrity verification
    file_hash = hashlib.sha256(screenshot).hexdigest()
 
    metadata = {
        "case_id": case_id,
        "url": url,
        "captured_at": captured_at.isoformat(),
        "filename": filename,
        "file_size_bytes": len(screenshot),
        "sha256": file_hash,
        "archive_path": str(filepath),
    }
 
    # Save metadata alongside the screenshot
    meta_path = Path(archive_dir) / f"{case_id}_{timestamp_str}_metadata.json"
    with open(meta_path, "w") as f:
        json.dump(metadata, f, indent=2)
 
    print(f"Archived: {url}")
    print(f"  File: {filepath}")
    print(f"  SHA-256: {file_hash}")
 
    return metadata
 
# Example: Archive pages for a legal dispute
pages_to_preserve = [
    "https://example.com/terms-of-service",
    "https://example.com/privacy-policy",
    "https://example.com/product-description",
]
 
for url in pages_to_preserve:
    archive_page(url, case_id="CASE-2026-0117")

DEVICES = [
    {"name": "desktop_1440", "device": "desktop", "viewport": {"width": 1440, "height": 900}},
    {"name": "desktop_1280", "device": "desktop", "viewport": {"width": 1280, "height": 800}},
    {"name": "tablet_ipad", "device": "tablet", "viewport": {"width": 768, "height": 1024}},
    {"name": "mobile_iphone14", "device": "mobile", "viewport": {"width": 390, "height": 844}},
    {"name": "mobile_small", "device": "mobile", "viewport": {"width": 320, "height": 568}},
]
 
def responsive_audit(url: str, output_dir: str = "responsive_audit"):
    """Capture screenshots at multiple viewport sizes for responsive testing."""
    Path(output_dir).mkdir(exist_ok=True)
 
    captures = []
    for device in DEVICES:
        response = requests.post(
            f"{BASE_URL}/capture",
            headers={"X-API-Key": API_KEY},
            json={
                "url": url,
                "device": device["device"],
                "viewport": device["viewport"],
                "full_page": True,
                "format": "png",
            },
        )
        response.raise_for_status()
 
        filename = f"{device['name']}.png"
        filepath = Path(output_dir) / filename
        filepath.write_bytes(response.content)
        captures.append({"device": device["name"], "path": str(filepath)})
        print(f"  Captured: {device['name']} ({device['viewport']['width']}x{device['viewport']['height']})")
 
    print(f"\nAll captures saved to: {output_dir}/")
    return captures
 
captures = responsive_audit("https://staging.yourdomain.com/pricing")