Screenshot APIs for E-Commerce: Price Monitoring and Competitor Tracking

2026-05-12 | Tags: [ecommerce, price-monitoring, screenshot-api, competitor-tracking, automation]

Screenshot APIs for E-Commerce: Price Monitoring and Competitor Tracking

E-commerce is a game of margins and positioning. Your competitor drops their price on a product you both carry. A seasonal promotion changes their homepage layout. A new product line appears that you weren't tracking. Manual monitoring doesn't scale — you can't watch hundreds of product pages across dozens of competitors every day.

Screenshot APIs give e-commerce teams a way to automate this. Not web scraping (which breaks when HTML changes), but visual capture — a record of how the page actually looked at a point in time.

The Core Use Case: Price Change Detection

The basic pattern: screenshot a competitor's product page daily, compare it to yesterday's screenshot, and flag if anything significant changed.

import requests
import json
from datetime import date

SCREENSHOT_API = "https://hermesforge.dev/api/screenshot"
API_KEY = "YOUR_KEY"

def capture_product_page(url, product_id):
    """Capture a product page screenshot and save with date stamp."""
    today = date.today().isoformat()

    response = requests.get(SCREENSHOT_API, params={
        "url": url,
        "width": 1280,
        "height": 900,
        "delay": 1500,  # wait for dynamic pricing to render
        "format": "png"
    }, headers={"X-API-Key": API_KEY})

    filename = f"captures/{product_id}/{today}.png"
    with open(filename, "wb") as f:
        f.write(response.content)
    return filename

# Run daily for your competitor watchlist
watchlist = [
    {"id": "competitor-a-product-123", "url": "https://competitor.com/product/123"},
    {"id": "competitor-b-product-456", "url": "https://other-competitor.com/item/456"},
]

for product in watchlist:
    capture_product_page(product["url"], product["id"])

Once you have daily captures, a pixel diff against yesterday's screenshot tells you when something changed. The change might be a price update, a "sold out" overlay, a promotional badge, or a layout change. All of these are worth knowing about.

Capturing Homepage Promotions

Seasonal promotions, flash sales, and clearance events often appear on competitor homepages first. A daily homepage capture gives you an ongoing record:

HOMEPAGE_WATCHLIST = [
    "https://competitor-a.com",
    "https://competitor-b.com",
    "https://marketplace.com/category/your-niche",
]

for url in HOMEPAGE_WATCHLIST:
    domain = url.split("//")[1].split("/")[0].replace(".", "-")
    capture_product_page(url, f"homepage-{domain}")

When you review these captures weekly, patterns emerge: who runs promotions when, how deep their discounts go, which product categories they're pushing. This is market intelligence that would otherwise require manual browsing.

Price Text Extraction

Screenshots capture how the page looks, but you often want the actual number. Combine screenshot capture with the page's visible text to extract prices:

def capture_with_price_extraction(url):
    """Capture screenshot and extract price from rendered page."""
    # Get the screenshot
    screenshot_resp = requests.get(SCREENSHOT_API, params={
        "url": url,
        "width": 1280,
        "height": 800,
        "delay": 1000,
        "format": "webp"
    }, headers={"X-API-Key": API_KEY})

    # Also get the page text for price extraction
    # (Use your preferred HTML parsing approach here)
    import re
    from bs4 import BeautifulSoup
    import httpx

    page_resp = httpx.get(url, headers={"User-Agent": "Mozilla/5.0"})
    soup = BeautifulSoup(page_resp.text, "html.parser")

    # Find price elements (common patterns)
    price_candidates = soup.select("[class*='price'], [itemprop='price'], [data-price]")
    prices = []
    for el in price_candidates:
        text = el.get_text(strip=True)
        # Extract numeric price
        match = re.search(r'[\$\€\£]?\s*(\d+[\.,]\d{2})', text)
        if match:
            prices.append(match.group(0))

    return {
        "screenshot": screenshot_resp.content,
        "prices_found": prices,
        "captured_at": date.today().isoformat()
    }

Visual Evidence for Internal Reports

Beyond automation, screenshots serve as visual evidence. When you're presenting competitive analysis to your team or management, screenshots of competitor pages are more compelling than spreadsheets. They show context: not just "their price is $49.99" but "their product page with $49.99 price, free shipping badge, and 4.7 stars displayed above the fold."

A simple weekly digest:

def generate_weekly_digest(watchlist, captures_dir):
    """Generate HTML report with this week's competitor captures."""
    html_sections = []

    for product in watchlist:
        captures = sorted(glob.glob(f"{captures_dir}/{product['id']}/*.png"))[-7:]
        section = f"""
        <h2>{product['name']}</h2>
        <div class="captures-row">
            {''.join(f'<img src="{c}" style="width:200px">' for c in captures)}
        </div>
        """
        html_sections.append(section)

    with open("weekly_digest.html", "w") as f:
        f.write(f"<html><body>{''.join(html_sections)}</body></html>")

What This Doesn't Replace

Screenshot monitoring is not a substitute for structured price data. If you need millisecond-accurate pricing or deep product catalog coverage across thousands of SKUs, you need a dedicated price intelligence service. Screenshot APIs are best for:

The economics work for monitoring hundreds of pages daily. At thousands of pages, purpose-built scraping infrastructure is more cost-effective.

The screenshot API handles the capture layer. Rate limits are generous for monitoring use cases — most competitive watchlists fit within the free tier.