E-Commerce Product Listing Screenshot API

E-commerce product pages are among the most dynamic pages on the web. Prices change hourly, images rotate, buy box ownership shifts between sellers, and promotional banners appear and disappear based on inventory levels. The screenshot API captures any product page as a clean image (PNG, WebP, or PDF) through a single GET request. That image proves what a customer actually saw at a specific moment. Price scraping tools and data feeds can't give you that.

A JSON feed tells you the price changed from $49.99 to $39.99. A screenshot shows the strikethrough styling, the "Limited Time" badge, the shipping estimate, the competitor ad in the sidebar, and the four-star rating below the title. For MAP enforcement, compliance audits, and competitive research, that visual context matters more than the raw data.

Capture a product page without triggering bot detection

Amazon, Shopify storefronts, and most major marketplaces run bot detection. A plain headless Chrome request gets you a CAPTCHA page or a degraded layout. The stealth parameter handles this by masking common headless-browser signals so the request looks like a regular desktop visit:

curl -G "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer $SCREENSHOTRUN_KEY" \
  --data-urlencode "url=https://www.amazon.com/dp/B0EXAMPLE" \
  --data-urlencode "format=webp" \
  --data-urlencode "full_page=true" \
  --data-urlencode "stealth=true" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "block_ads=true" \
  --data-urlencode "delay=3000" \
  --data-urlencode "response_type=image" \
  -o product-page.webp

delay=3000 gives lazy-loaded images three seconds to render. Amazon product pages load the main image immediately but defer gallery thumbnails, A+ content below the fold, and "Frequently bought together" sections. Without the delay, you get a page with placeholder gray boxes where those images should be. I tested this across 20 Amazon listings and 3000ms worked reliably (2000ms missed A+ content on about 30% of pages).

block_cookies=true removes the cookie consent overlay that covers half the viewport on EU captures. block_ads=true strips sponsored product placements, which you probably don't want cluttering your screenshots unless you're specifically monitoring ad placement.

MAP enforcement with timestamped evidence

Minimum Advertised Price violations are hard to prove after the fact. The evidence disappears. A reseller drops the price to $29.99 on Friday evening, sells through their inventory, and bumps it back to $49.99 by Monday. Your MAP monitoring tool logged the violation, but the reseller claims it was a "pricing error" and the data must be wrong.

A certified screenshot with a SHA-256 hash and timestamp tells a different story. The image, the hash, and the timestamp form a chain: tamper with the image and the hash won't match. This Python script runs nightly against your authorized reseller list:

import httpx, os, json, datetime

API_KEY = os.environ["SCREENSHOTRUN_KEY"]
BASE = "https://api.screenshotrun.com/v1/screenshots/capture"
today = datetime.date.today().isoformat()

resellers = [
    {"name": "East Coast Electronics", "url": "https://eastcoast-elec.com/product/widget-pro"},
    {"name": "BuyDirect Store", "url": "https://buydirect.store/widget-pro"},
    {"name": "TechMall AU", "url": "https://techmall.com.au/widget-pro"},
]

for seller in resellers:
    resp = httpx.get(BASE, params={
        "url": seller["url"],
        "format": "png",
        "full_page": "true",
        "stealth": "true",
        "block_cookies": "true",
        "certified": "true",
        "extract_metadata": "true",
        "response_type": "json",
    }, headers={"Authorization": f"Bearer {API_KEY}"}, timeout=60)

    data = resp.json()
    folder = f"map-audit/{today}/{seller['name'].lower().replace(' ', '-')}"
    os.makedirs(folder, exist_ok=True)

    # Save certification separately for legal
    with open(f"{folder}/certification.json", "w") as f:
        json.dump(data.get("certification", {}), f, indent=2)

    print(f"{seller['name']}: {data['certification']['hash'][:16]}...")

Each morning you've got a folder per reseller with the screenshot and a JSON certification file. If a violation shows up, you hand the certification to your channel sales team (or legal). TrackStreet and MAPP Trap charge $1,000+ per month for this workflow. The API does the capture part for under $30 a month.

One thing to know: certified=true proves the image hasn't been altered and records when it was captured. It doesn't prove the page was actually live at that URL (someone could theoretically set up a fake page and screenshot it). For court-level evidence, you'd pair this with DNS records or a notarized attestation. For reseller negotiations, the certification alone is usually enough.

Price checks from five countries

Global brands deal with geo-specific pricing that resellers sometimes exploit. A product listed at €49 in Germany might show £39 in the UK and $59 in the US. The geolocation parameter captures the page as seen from each market:

const API_KEY = process.env.SCREENSHOTRUN_KEY;

const markets = [
    { geo: 'us', label: 'United States' },
    { geo: 'gb', label: 'United Kingdom' },
    { geo: 'de', label: 'Germany' },
    { geo: 'jp', label: 'Japan' },
    { geo: 'au', label: 'Australia' },
];

const productUrl = 'https://brand-store.com/products/widget-pro';

for (const market of markets) {
    const params = new URLSearchParams({
        url: productUrl,
        format: 'webp',
        geolocation: market.geo,
        full_page: 'true',
        stealth: 'true',
        block_cookies: 'true',
        delay: '3000',
        response_type: 'image',
    });

    const res = await fetch(
        `https://api.screenshotrun.com/v1/screenshots/capture?${params}`,
        { headers: { Authorization: `Bearer ${API_KEY}` } }
    );

    if (res.ok) {
        const fs = await import('fs');
        const dir = `price-audit/geo`;
        fs.mkdirSync(dir, { recursive: true });
        fs.writeFileSync(`${dir}/${market.geo}-${market.label.toLowerCase().replace(/ /g, '-')}.webp`,
            Buffer.from(await res.arrayBuffer()));
        console.log(`${market.label}: ${Math.round(
            res.headers.get('content-length') / 1024)} KB`);
    }
}

Five captures of the same product URL, each showing local pricing, currency, shipping estimates, and availability. Same page, five different stories. Drop them side by side and you can spot unauthorized discounting in specific markets. Some brands run this weekly; others trigger it on price alert from their data feed and use the screenshot as visual confirmation.

Crop to the buy box

Full-page screenshots are useful for archiving, but when you're tracking the buy box or a specific pricing section, you don't need 15,000 pixels of product reviews and related items. The selector parameter crops to a specific element:

curl -G "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer $SCREENSHOTRUN_KEY" \
  --data-urlencode "url=https://www.amazon.com/dp/B0EXAMPLE" \
  --data-urlencode "selector=#buyBoxInner" \
  --data-urlencode "format=png" \
  --data-urlencode "retina=true" \
  --data-urlencode "stealth=true" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "response_type=image" \
  -o buy-box.png

You get just the buy box: price, seller name, shipping info, Add to Cart button. The file weighs far less than a full-page capture, and the retina=true flag gives you 2x pixel density so the price text is sharp enough to read at any zoom level. (Retina doubles both width and height, so the file ends up about 4x the size of a standard capture. Worth it for price monitoring where you need to OCR or visually verify small text.)

The CSS selector varies by marketplace. Amazon's buy box lives in #buyBoxInner or #desktop_buybox depending on the page variant. Shopify stores typically use .product-form or [data-product-form]. eBay's is trickier because the DOM structure changes between auction and Buy It Now listings. You'll want to test your selectors on a few pages before automating.

Monitoring competitor listings at scale

Price intelligence platforms like Prisync and Competera charge $500-2,000 per month for structured pricing data. That's worth it if you need parsed price fields and historical charts. But if your competitive intelligence is visual (how is the listing presented? what badges do they show? how does their imagery compare to ours?), screenshots tell you more than a CSV of prices ever will.

A weekly capture of 200 competitor product pages costs roughly 800 API calls per month (200 pages x 4 weeks). On the Starter plan ($9/month, 5,000 captures), that's 16% of your allocation. Add mobile captures for the same pages and you're at 32%. Still leaves room for MAP audits, geo checks, and ad hoc investigations.

For recurring captures, set up a cron job or GitHub Action that runs your script on a schedule. Our scheduled screenshots page walks through five different scheduling approaches. The screenshots go into date-stamped folders, and over a few weeks you've built a visual history of how competitor listings evolve (seasonal promotions, badge changes, image updates, copy tweaks).

This is digital shelf monitoring on your own terms. The enterprise platforms (Profitero, Salsify, Syndigo) charge five figures for this and bundle it with content management. If all you need is the visual layer (what does the listing actually look like?), the API gives you that without the platform tax.

Lazy images and dynamic content on product pages

Product pages are among the worst offenders for lazy loading. A typical Amazon listing loads the hero image immediately, defers the gallery, waits for scroll to load A+ content, and triggers "Customers also bought" via an API call after the initial render. Shopify themes with infinite product recommendations keep loading content as you scroll.

full_page=true scrolls the entire page before capture, which triggers most lazy-load implementations (they rely on Intersection Observer, so the scroll fires the observers). But some implementations use a debounce or don't trigger until the element is actually in the viewport for a certain duration. That's where delay comes in: the API scrolls, then waits the specified milliseconds before taking the screenshot.

For most Shopify and WooCommerce pages, delay=2000 is enough. Amazon and eBay listings with A+ content below the fold need delay=3000. Walmart.com is the slowest in my testing (heavy client-side rendering), and sometimes needs delay=4000 plus wait_for_selector targeting a specific below-fold element to get everything loaded.

If a product page uses a sticky "Add to Cart" bar that follows the user on scroll, the full-page capture will include it stitched into the screenshot at every scroll position. Use hide_selectors to remove it:

curl -G "https://api.screenshotrun.com/v1/screenshots/capture" \
  -H "Authorization: Bearer $SCREENSHOTRUN_KEY" \
  --data-urlencode "url=https://store.example.com/products/widget" \
  --data-urlencode "full_page=true" \
  --data-urlencode "stealth=true" \
  --data-urlencode "block_cookies=true" \
  --data-urlencode "delay=2000" \
  --data-urlencode "hide_selectors=.sticky-cart-bar,.announcement-bar" \
  --data-urlencode "response_type=image" \
  -o clean-listing.webp

Full parameter reference in the API docs.

Mobile vs desktop: why you need both

Over 60% of e-commerce traffic is mobile (Statista), but most product page monitoring only captures the desktop layout. Mobile listings look different: smaller images, collapsed description sections, a different buy box layout, and touch-optimized buttons that sometimes hide pricing details behind a "See more" tap.

Run your capture script with device=mobile alongside your desktop captures. The API emulates an iPhone viewport (375x812) with proper touch event support. Some Shopify themes serve entirely different product templates to mobile users, so a desktop-only audit misses what the majority of your customers actually see.

Double the devices, double the API calls. Two hundred products across desktop and mobile is 400 captures per week, 1,600 per month. That's still well within the Starter plan.

What screenshots don't replace

Screenshots capture visual state. They don't parse structured data from the page. If you need product prices in a spreadsheet column, inventory counts, or review scores as numbers, you need a scraping tool or a data feed. Prisync, Keepa, and Jungle Scout do that well. The screenshot shows what the scraper can't: the full visual experience, including how the price is styled, what badges appear, and what the page feels like to a shopper.

Login-gated content (Amazon Seller Central, wholesale pricing pages behind authentication) requires session cookies passed via the cookies parameter. That works, but managing cookie rotation for sites with aggressive session policies adds operational complexity. For public product pages, which is 90% of e-commerce monitoring, no authentication is needed.

Stealth mode handles most marketplace bot detection, but it's not perfect. About 5% of captures on heavily protected sites return degraded content or CAPTCHAs. Amazon in particular rotates their detection methods regularly. If a specific ASIN consistently fails, it might need a different approach (residential proxy via the proxy parameter, or capturing a cached Google version instead).

For product pages behind Cloudflare's managed challenge, stealth mode usually clears the challenge automatically. Walmart.com's PerimeterX protection is tougher. As far as I can tell, the success rate there depends heavily on request timing and IP reputation.

Why ScreenshotRun for e-commerce monitoring

Prisync and Competera give you data. Screenshot APIs give you the picture. ScreenshotRun sits between data feeds (Prisync, Keepa, Competera) and manual browser checks. You get stealth mode that handles marketplace bot detection, certified timestamps for MAP enforcement, geolocation for multi-market price audits, and element cropping for buy-box-only captures. Wire it into your existing pricing tools or monitoring dashboards through the API, Zapier, Make, or n8n.

The free plan includes 200 captures per month with every parameter available. That covers a weekly audit of 50 product pages across desktop. Enough to test whether this fits your workflow before committing to a paid plan. For recurring monitoring, see scheduled screenshots. For bulk one-off audits, the batch capture dashboard handles CSV uploads with zero code.