How to Compare Competitor Product Prices with Side-by-Side Screenshots

To compare competitor product prices with side-by-side screenshots, capture the same product or a clearly documented equivalent from each seller under the same market, locale, viewport, and customer conditions. Put the screenshots beside a small table that records the displayed price, currency, variant, pack size, promotion terms, availability, source URL, and capture time. The screenshots preserve the surrounding offer context; the table makes differences easier to scan. Treat the result as evidence of what each page showed at that moment, not proof of a final checkout total or a price that remains available.

1. Define a fair comparison

Before capturing anything, decide exactly what is being compared. A lower number is not necessarily a better price if the products, quantities, sellers, or purchase conditions differ.

Product identity: match the model, variant, size, color, and included accessories. If an exact match is unavailable, label the item as an equivalent and explain the difference.
Quantity and unit: distinguish a single item from a multipack, refill, subscription, or bulk size. Calculate a unit price only when the units are comparable, and show the calculation.
Market and currency: use the same country or region and record the currency. Local storefronts can show different offers.
Customer state: note membership, sign-in, loyalty, coupon, or subscription requirements that affect the displayed offer.
Offer scope: decide whether you are comparing the displayed price, a price after a visible promotion, or a verified checkout total. Do not call a displayed product-page price a checkout total.

Price-comparison tools are commonly described as services that let people compare sellers’ offers and link through to sellers’ websites; that definition does not establish one universal method for normalizing price fields. See the European Commission staff working document.

2. Capture each page consistently

List the exact product-page URLs and the market you intend to represent.
Use the same browser viewport and zoom level for each capture. Keep locale and relevant account or membership state consistent where possible.
Capture pages close together in time. Prices, inventory, and promotions can change while you work.
Save the original screenshot without cropping away price labels, promotion conditions, product identity, or availability. You can create a presentation crop separately.
Record the URL, timestamp, market, and any access conditions with each file.
Revisit the page or proceed to checkout if your conclusion depends on shipping, tax, coupon eligibility, or a final payable amount. Record what you verified and what you did not.

A dated screenshot archive helps another reviewer retrace the comparison. A screenshot is evidence of page appearance at capture time; it does not establish that the offer was enduring or available to every customer. [iTechGuides’ screenshot tracking guide]

3. Build the side-by-side comparison

Place each full screenshot in a column, sized to the same width where practical. Keep enough of the page visible to identify the product and understand the price context. Put a compact table next to or below the images:

Field	What to record
Seller and product	Seller name, product name, model, and variant
Pack or unit	Quantity, size, and unit used for any normalized comparison
Displayed price	Value and currency exactly as shown
Promotion	Sale badge, crossed-out former price, coupon, member price, or conditions
Availability	In stock, limited stock, backorder, unavailable, or not stated
Additional costs	Shipping, tax, or fees if shown; otherwise mark them unverified
Evidence	Page URL, market, capture timestamp, and relevant customer state

Keep structured values with the images. Extracted fields make sorting easier, while the screenshot can reveal sale badges, former prices, member-only messaging, and stock labels that a bare number misses. ScreenshotCenter describes capturing product name, price, availability, and promotion badges alongside screenshots in its ecommerce screenshot workflow.

4. Interpret the evidence carefully

Compare like with like: a different pack size, variant, seller, geography, tax treatment, shipping charge, membership state, or coupon can make displayed amounts incomparable.
Separate observed from verified: label what the page displayed and separately state whether shipping, tax, or promotion eligibility was checked at checkout.
Preserve promotion terms: “20% off” may depend on a code, minimum spend, membership, or selected option. Include the condition visible on the page.
Explain unit-price math: show the numerator, quantity, and unit. Do not silently divide prices for differently sized products and present the result as a direct comparison.
Call out uncertainty: if a price is personalized, a page failed to load completely, or availability is ambiguous, note that alongside the result.

For recurring checks or large product sets, scheduled screenshot services and price-monitoring software may help. ScreenshotCenter and Allscreenshots describe ecommerce page monitoring, and NetPricer describes price and availability collection with product matching and screenshot history. These are vendor-described capabilities; the cited materials do not independently validate service coverage, matching accuracy, or performance. See Allscreenshots’ ecommerce monitoring documentation and NetPricer.

5. Automate captures with a browser

For a small comparison, a manual browser capture is often enough. When you need repeatable captures, a browser automation script can visit each URL, use a fixed viewport, and save a full-page screenshot. The following runnable Playwright example uses Node.js and records the URL and capture time in a JSON manifest.

import { chromium } from 'playwright';
import { writeFile } from 'node:fs/promises';

const pages = [
  { seller: 'Seller A', url: 'https://example.com/product-a' },
  { seller: 'Seller B', url: 'https://example.org/product-a' },
];

const browser = await chromium.launch({ headless: true });
const context = await browser.newContext({
  viewport: { width: 1440, height: 1000 },
  locale: 'en-US',
  timezoneId: 'America/New_York',
});
const results = [];

try {
  for (const [index, item] of pages.entries()) {
    const page = await context.newPage();
    const capturedAt = new Date().toISOString();
    try {
      const response = await page.goto(item.url, {
        waitUntil: 'domcontentloaded',
        timeout: 45000,
      });
      await page.locator('body').waitFor({ state: 'visible', timeout: 15000 });
      await page.screenshot({
        path: `competitor-${index + 1}.png`,
        fullPage: true,
        animations: 'disabled',
      });
      results.push({
        seller: item.seller,
        url: item.url,
        capturedAt,
        httpStatus: response?.status() ?? null,
        screenshot: `competitor-${index + 1}.png`,
      });
    } catch (error) {
      results.push({ seller: item.seller, url: item.url, capturedAt, error: String(error) });
    } finally {
      await page.close();
    }
  }
} finally {
  await browser.close();
}

await writeFile('comparison-manifest.json', JSON.stringify(results, null, 2));

Replace the example URLs with pages you are authorized to access. Install the browser automation dependency with npm install playwright and install its browser with npx playwright install chromium. This script captures page appearance; it does not determine whether products are equivalent, interpret offer terms, or verify checkout prices. Review each result manually and complete the comparison table.

Browser capture options to consider

Viewport: keep width and height fixed across sellers. Responsive pages can show different layouts and content at different sizes.
Full-page versus viewport: full-page captures preserve more context but may be tall; viewport captures are easier to align but can omit details below the fold.
Readiness: choose a wait condition that fits the site. Network-idle waits can be unreliable on pages with persistent requests; a specific product or price selector can be a better signal when stable.
Lazy content: full-page capture behavior varies. If important images or prices load only after scrolling, scroll through the page or wait for the relevant content before saving.
Authentication: use a dedicated, permitted account state when membership pricing is part of the question. Protect cookies and credentials as secrets.
Evidence manifest: keep capture time, URL, market, viewport, and state alongside each screenshot. Do not rely on filenames alone.

cURL, Python, and Node.js with ScreenshotNeo

For a managed website screenshot API, ScreenshotNeo takes a URL and returns an image or PDF. These examples capture one product page; repeat the request for each competitor under the same conditions. See the ScreenshotNeo API documentation for request options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
r.raise_for_status()
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await import('node:fs/promises').then(({ writeFile }) => writeFile('shot.webp', Buffer.from(await res.arrayBuffer())));

Replace the example target with the product page URL. For a comparison, keep the viewport, locale, and other relevant request settings consistent across captures; write the URL and timestamp into your own manifest. ScreenshotNeo supports 63 options, including device and viewport selection, full-page capture, waiting for a selector or delay, custom headers and cookies, and caching with a chosen TTL. Use settings that match the comparison question and consult the docs for parameter names and formats.

Or skip the browser setup

Make one GET request per product page with ScreenshotNeo. For example:

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

ScreenshotNeo accepts cookie and consent banners like a visitor and removes more than 60 known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, and failed loads are not billed, and cache hits cost nothing. Response headers report the page verdict and whether the request was billed. An MCP server gives AI agents tools to take screenshots, get page information, and capture PDFs. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000. Every feature is available on every plan. Sign up for 1,000 free screenshots a month, with no card.

Reliability, performance, and cost

Reliability

Price pages can vary with location, account state, cookies, experiments, and inventory. Keep captures close in time, record conditions, and repeat a capture when a page appears incomplete. Preserve failed attempts in the manifest rather than quietly omitting a seller. Recheck checkout when the conclusion depends on final payable cost.

Performance

For a handful of pages, capture them sequentially to simplify debugging and keep timestamps clear. For larger sets, limited concurrency can reduce elapsed time, but high concurrency may trigger rate limits or bot checks and makes conditions harder to keep aligned. Start with a small batch, use explicit timeouts, and retry transient failures with a delay. Avoid retrying indefinitely.

Cost

Manual browser capture has no per-request screenshot service charge, but takes staff time and needs a consistent process. Automated browser runs consume compute and require maintenance. Monitoring platforms and screenshot APIs may charge by plan or usage; compare the current published terms before committing. ScreenshotNeo’s stated plans are Free: 1,000 shots/month; Starter: $5 for 3,000; Growth: $15 for 15,000; Pro: $39 for 60,000; Scale: $99 for 250,000; Business: $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. A free signup is available without a card.

Troubleshooting

Symptom	Likely cause	What to do
Screenshot is blank or incomplete	Navigation timed out, content loads late, or the page returned a bot check	Inspect the page result, use a suitable readiness condition, and retry once after a delay. Record the failure instead of treating it as a price.
Price differs between repeated captures	Market, cookies, customer state, promotion, stock, or page experiment changed	Capture with documented locale and state, compare timestamps, and state the observed variation.
Sale price is shown without its conditions	Coupon details or membership terms appear elsewhere on the page	Capture enough surrounding content and record the condition. Verify at checkout if the conclusion depends on eligibility.
Pages do not align visually	Different viewport, zoom, full-page behavior, or responsive layout	Use the same viewport and capture mode, then arrange images at matching widths.
Automated capture hangs waiting for network idle	Persistent analytics or streaming requests prevent the network from becoming idle	Wait for DOM content or a stable product/price selector, with a timeout.
Screenshot API returns an error or non-image response	Invalid key, malformed URL, inaccessible page, or failed navigation	Check the request parameters and response status/body before saving it as an image; review the API docs and response headers.
Displayed price is mistaken for total cost	Shipping, taxes, fees, or coupon restrictions were not included	Label the figure as the displayed price and verify checkout separately for a total-cost claim.

FAQ

Should I compare the crossed-out price or the current price?

Record both when visible, label which is the current displayed amount, and preserve any conditions attached to the reduction.

Can screenshots prove that a competitor always offers a price?

No. They preserve a page appearance at a particular time and under particular conditions. Use dated repeated captures to describe observed changes, without implying universal or continuing availability.

How many pages should I capture?

Capture the sellers relevant to your decision, using the same product definition and market. There is no universal useful count; expanding the set is valuable only when the additional offers are comparable and their context can be documented.

Can automated extraction replace reviewing the screenshots?

Use extracted fields to sort and summarize, then inspect the images for context such as badges, former prices, stock labels, and conditions. ScreenshotCenter describes pairing extracted ecommerce fields with the visual capture, but the extracted values still need review.

Sources and scope

The workflow above uses the European Commission’s historical sector-inquiry document for the definition of price-comparison tools and the cited vendor documentation for examples of screenshot monitoring and extracted fields. The Commission document reports that tools listed offerings in relation to an average of eight of nine selected categories in its 2016 inquiry; that is a historical finding, not a current market statistic or a measurement of screenshot monitoring. Vendor capability descriptions are not independent validation.