How to Generate Website Screenshots for an Indian Ecommerce Product Catalog with Screenshotlayer

To generate website screenshots for an Indian ecommerce product catalog with Screenshotlayer, send a capture request for each product page URL using your account access key. Choose the viewport, full-page or thumbnail output, image format, and any documented request headers such as Accept-Language. Build the request list from your store’s authoritative product URL inventory, record the settings and capture time with every image, and budget for each URL, viewport or locale variant, refresh, and retry.

Screenshotlayer captures rendered pages as images. Its documented sources do not describe it as a product-data extraction or catalog-validation API, and they do not establish that a particular request will make a storefront display Indian language, currency, availability, or layout. Those depend on how the target storefront serves the page.

1. Define the catalog capture set

Begin with the exact pages you need to review or display. Product detail pages, category pages, and campaign landing pages are different capture targets; do not infer product URLs from names or IDs when you can use the store’s maintained URL inventory.

1. Export or query an authoritative list of product page URLs.
2. Remove duplicates and decide how to handle discontinued, redirected, or unpublished products.
3. Choose which page types to include, such as product detail pages or category pages.
4. Decide which viewport and locale variants are actually needed for each URL.
5. Set a capture cadence based on how the images will be used, and define a recapture policy for changed pages or failed requests.

A screenshot is a visual record of what a page rendered at capture time. It does not verify current inventory or price, and it does not replace structured catalog data from a product feed or store database.

2. Get access and make a first request

Screenshotlayer’s documented request model uses a target URL and an account access key. Its FAQ gives this HTTP API pattern: http://api.screenshotlayer.com/api/capture?access_key=YOUR_ACCESS_KEY. Use the endpoint and syntax shown in your current account documentation; the official homepage example URL contains an apparent hostname typo, so do not copy that printed hostname. Prefer HTTPS where your account’s current documentation supports it.

Keep the access key on a server or in a protected job runner. Do not put it in browser-side code, source control, or public logs. The terms make the subscriber responsible for credential secrecy, usage limits, and handling returned API errors.

The examples below show the documented request pattern. Check your account’s current endpoint, plan, and accepted parameter syntax before putting a large batch into production.

cURL

curl --get 'https://api.screenshotlayer.com/api/capture' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --data-urlencode 'url=https://shop.example.in/products/item-123' \
  --data-urlencode 'viewport=1440x1000' \
  --data-urlencode 'fullpage=1' \
  --data-urlencode 'format=png' \
  --output item-123-desktop.png

Python

import os
from pathlib import Path

import requests

endpoint = "https://api.screenshotlayer.com/api/capture"
params = {
    "access_key": os.environ["SCREENSHOTLAYER_ACCESS_KEY"],
    "url": "https://shop.example.in/products/item-123",
    "viewport": "1440x1000",
    "fullpage": 1,
    "format": "png",
}

response = requests.get(endpoint, params=params, timeout=90)
response.raise_for_status()

Path("item-123-desktop.png").write_bytes(response.content)

Node.js

const endpoint = new URL('https://api.screenshotlayer.com/api/capture');
endpoint.search = new URLSearchParams({
  access_key: process.env.SCREENSHOTLAYER_ACCESS_KEY,
  url: 'https://shop.example.in/products/item-123',
  viewport: '1440x1000',
  fullpage: '1',
  format: 'png',
});

const response = await fetch(endpoint);
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${response.statusText}`);
}

const bytes = Buffer.from(await response.arrayBuffer());
await import('node:fs/promises').then(({ writeFile }) =>
  writeFile('item-123-desktop.png', bytes)
);

For production, also check that the response is an image before saving it. An HTTP success response alone may not establish that the body is the expected image for your workflow; follow the error handling and response guidance in your current account documentation.

3. Choose capture dimensions and output

Screenshotlayer documents viewport selection, full-page capture, custom thumbnail width, and PNG, JPEG, or GIF output. PNG is the documented default. Select settings based on how the image will be reviewed, stored, or displayed.

Need	Setting to consider	Tradeoff
Review the complete detail page	Full-page capture	Captures more vertical content; check resulting dimensions and downstream storage and display limits.
Compact catalog preview	Custom thumbnail width	Useful for compact previews; verify that text and product details remain legible at the chosen width.
Compare desktop layouts	A consistent desktop viewport	Keeping dimensions stable makes visual comparisons easier.
Review mobile layout	A consistent mobile viewport, with a matching user-agent if needed	Viewport and user-agent can affect responsive behavior; validate against the actual storefront.
Keep image files smaller	JPEG, where acceptable	Compare visual quality against PNG for your content and use case.
Preserve crisp text and edges	PNG	Can produce larger files than a lossy format; check storage and delivery needs.
Animated output	GIF, if your workflow requires it	Confirm the result suits the intended use; the FAQ lists GIF as a supported output format.

Use the exact parameter values accepted by your current Screenshotlayer account documentation. Do not assume that capture dimensions correspond to the final stored image dimensions in every mode; inspect representative outputs before scaling up.

4. Set language and India-specific rendering carefully

Screenshotlayer documents custom HTTP headers, including Accept-Language, and a custom user-agent. These are inputs to the page request, not a guarantee that the storefront will serve a particular Indian language, currency, tax display, or regional catalog.

curl --get 'https://api.screenshotlayer.com/api/capture' \
  --data-urlencode 'access_key=YOUR_ACCESS_KEY' \
  --data-urlencode 'url=https://shop.example.in/products/item-123' \
  --data-urlencode 'viewport=390x844' \
  --data-urlencode 'fullpage=1' \
  --data-urlencode 'format=png' \
  --data-urlencode 'headers[Accept-Language]=en-IN' \
  --data-urlencode 'headers[User-Agent]=YOUR_MOBILE_USER_AGENT' \
  --output item-123-mobile-en-in.png

Header serialization is provider-specific. Confirm the precise syntax for custom headers in the current Screenshotlayer account documentation before using it in a batch. For localization checks:

• Test a few representative URLs directly with the storefront’s documented locale or region behavior.
• Use Accept-Language only when the site responds to that header as expected.
• Set viewport dimensions for the layout you want to inspect; add a matching user-agent only if the site depends on it.
• Record locale-related request settings with the saved image so reviewers can reproduce the capture.
• Review the result for actual language, currency, and regional content rather than assuming the request header changed them.

5. Handle delayed content, caching, and refreshes

The Screenshotlayer FAQ documents a delay parameter for waiting before capture, including when effects or animations need time, and a configurable cache TTL. It states a default cache period of 2,592,000 seconds (30 days) and says a custom ttl can be lower than that default.

Use a delay only when the page needs extra time for visible content to render. A fixed delay adds waiting to each uncached capture and cannot guarantee that a slow or failed page has become complete. Confirm the current parameter syntax and allowed values in the account documentation.

Choose cache behavior based on the intended freshness of the images. Product prices, promotions, stock indicators, recommendations, and consent banners can change. A 30-day default may be unsuitable for frequently changing visual reviews; use a shorter supported TTL or an explicit refresh policy where appropriate. A cached screenshot remains a visual record, not proof of current product data.

6. Capture a catalog in batches

Screenshotlayer’s documented request model is URL-based. A catalog pipeline can therefore create one capture job per product URL and per required settings variant. Keep the work bounded, track each job, and handle errors as your application’s responsibility.

1. Prepare the manifest. Store a stable product identifier, source URL, and the requested viewport, locale headers, output format, and full-page or thumbnail choice.
2. Estimate demand. Count URLs, required variants, scheduled refreshes, and expected retries before selecting a plan.
3. Run a small representative batch. Include different page lengths, product types, and storefront behaviors before processing the complete catalog.
4. Save with metadata. Record the source URL, capture time, settings, and outcome alongside each image. Screenshotlayer documents export options to AWS S3 and FTP; check current plan eligibility and setup in its documentation.
5. Review exceptions. Inspect failures, redirects, consent overlays, blocked pages, and lazy-loaded sections. The reviewed sources do not claim Screenshotlayer automatically resolves these page behaviors.
6. Schedule recaptures. Match refresh cadence to the purpose of the images and the storefront’s rate of change.

A practical volume estimate is:

monthly captures = product URLs × viewport/locale variants × refreshes per month
                   + separate category/campaign captures
                   + retries

For example, 2,000 product URLs with one desktop and one mobile capture, refreshed twice in a month, imply 8,000 planned captures before category pages or retries. This is arithmetic planning guidance, not a vendor benchmark.

7. Plan quota, cost, and usage

The Screenshotlayer pricing page observed for this research lists Free at 100 snapshots per month and labels it non-commercial; Basic at USD 19.99 per month for 10,000 snapshots; Professional at USD 59.99 for 30,000; and Enterprise at USD 149.99 for 75,000. The same page lists commercial use on paid plans, dedicated workers on paid tiers, and FTP/S3 export on Professional and Enterprise. Its FAQ says annual billing can reduce the total by up to 15%. These are vendor-published details observed during research and can change, so verify the live pricing page and account dashboard before budgeting.

The overages documentation lists per-call overage charges in its displayed table: Basic at USD 0.007996, Professional at USD 0.0079986667, and Enterprise at USD 0.0079994667. Check the live overages page and your account terms before relying on these figures. The pricing and overage amounts do not by themselves determine the best plan: include commercial-use requirements, quota, concurrency needs, output requirements, export needs, and overage behavior.

Screenshotlayer’s terms say the subscriber is responsible for detecting and handling returned errors. Add application-level outcome tracking and a review path for failed or unexpected captures. Avoid assuming retries are free or excluded from quota unless current account terms say so.

8. Troubleshoot common capture problems

Symptom	Possible cause	What to do
Authentication error	Missing, invalid, or incorrectly encoded access key	Check the key in the account dashboard, keep it server-side, and verify query parameter encoding.
Request fails or returns an API error	Invalid URL or parameter, quota limit, or another returned API error	Log the status and safe error details, inspect the request settings, and check account usage and current documentation. Never log the access key.
Saved file is not a usable image	The request may have returned an error payload or unexpected response	Check status, content type, and response body handling before writing the file; route failures to a retry or manual review queue.
Page appears incomplete	Content may render late, load lazily, or depend on page scripts	Test a suitable documented delay, inspect a representative page, and verify whether the required content is visible in the rendered result.
Wrong language or currency	The storefront may ignore the header or require its own locale selection or URL	Test the store’s actual locale behavior and use its supported locale URL or settings. Do not infer localization from the request alone.
Mobile image shows desktop layout	Viewport or user-agent settings may not match the storefront’s responsive rules	Confirm viewport dimensions and, if required by the site, provide a matching documented user-agent. Review the rendered output.
Old content appears	The default cache period is 30 days or the selected TTL is longer than desired	Review the current cache settings and select a shorter supported TTL where appropriate.
Over quota or unexpected bill	URL variants, refreshes, or retries increased request volume	Recalculate the URL × variant × refresh estimate, review dashboard usage and overage terms, and limit unnecessary variants.
Consent overlay or popup covers product details	The target page displayed an overlay during capture	Review the capture and investigate the storefront’s consent behavior; the reviewed Screenshotlayer sources do not document automatic overlay removal.

9. Performance and reliability practices

• Keep the capture set purposeful. Each extra viewport, locale, refresh, and retry increases request volume.
• Use delay selectively. Extra wait time can help pages that render late, but applying it to every page can slow a large catalog run.
• Separate transient failures from bad inputs. Record error outcomes and retry only according to an application policy; do not retry indefinitely.
• Make jobs traceable. Associate each output with its source URL and settings so unexpected images can be reproduced and investigated.
• Protect credentials. Use server-side secrets and redact keys from logs and job metadata.
• Validate the image pipeline. Check representative image dimensions, format, and file handling before running a full catalog.
• Check permitted use. The Screenshotlayer terms page reviewed here says it was last modified on 17 February 2018 and includes restrictions on redistribution and transferring API data outside an application. Review the current agreement for your storage, publication, and reuse plans.

10. Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. It offers clean captures by accepting cookie and consent banners and removing 60+ known consent platforms, newsletter popups, and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing, and response headers report the page verdict and billing status. Its MCP server provides take_screenshot, get_page_info, and capture_pdf for Claude, Cursor, and other MCP clients. One thousand screenshots per month are free with no card; paid plans start at $5 for 3,000.

For a product page, make a single GET request. See the ScreenshotNeo API documentation for the request options.

cURL

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://shop.example.in/products/item-123 -o item-123.webp

Python

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://shop.example.in/products/item-123"}, timeout=90)
open("item-123.webp", "wb").write(r.content)

Node.js

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://shop.example.in/products/item-123' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo also supports full-page captures with lazy images loaded, CSS-selector element capture, 12 device presets and custom viewports, retina scale, dark mode, custom CSS and JavaScript, click and hide selectors, wait conditions, request and resource blocking, custom headers and cookies, user-agent, authorization, timezone, geolocation, transparent backgrounds, image resizing, caching with a chosen TTL, signed links for public image tags, asynchronous jobs with signed webhooks, bulk capture of up to 100 URLs per call, a usage API, and an OpenAPI specification. Its parameter names also work with those used by other screenshot APIs to make migration easier.

Plans are Free for 1,000 shots per month, Starter $5 for 3,000, Growth $15 for 15,000, Pro $39 for 60,000, Scale $99 for 250,000, and Business $249 for 1,000,000. Yearly billing gives two months free, and every feature is on every plan. Sign up for 1,000 free screenshots a month with no card.

11. Frequently asked questions

How do I take screenshots of product pages in bulk?

Create jobs from your authoritative product URL list, apply a consistent settings profile, track each outcome, and estimate usage from the URL count, variants, refreshes, and retries. Screenshotlayer’s reviewed sources describe the capture API, not a built-in product catalog validator.

Can I capture a full ecommerce product page?

Screenshotlayer documents full-page capture. Confirm the output dimensions and inspect representative long pages to ensure the image works for your storage and review surface.

How do I get mobile and desktop screenshots?

Make separate requests with consistent desktop and mobile viewport settings. Add a matching user-agent if the storefront’s behavior requires one, then verify the actual rendered layouts.

Can I set the language for a screenshot?

The documentation supports a custom Accept-Language header. Whether that changes language, currency, or regional content depends on the target storefront.

How many screenshots do I need for my catalog?

Multiply product URLs by required viewport and locale variants and refreshes per period, then add separate category or campaign pages and retries. Compare that estimate with the current plan quota and overage terms.

Sources

• Screenshotlayer official homepage — request model and documented capture examples.
• Screenshotlayer FAQ — access key, output formats, cache, delay, and API notes.
• Screenshotlayer pricing — vendor-listed plans and features; verify current terms.
• Screenshotlayer terms — responsibilities and use restrictions; check the current agreement.
• Screenshotlayer overages documentation — displayed overage rates; verify current account terms.