How to Use a Screenshot API to Create Product Listing Images for an Indian Marketplace

Short answer: Build the listing image as HTML around an accurate product photo, render that page or HTML with a screenshot API, and inspect the resulting file against the destination marketplace’s current rules. An API renders pixels; it does not verify product claims or make an image compliant by itself.

Start by choosing the marketplace, product category, and image role. Amazon.in’s MAIN image has specific composition rules, while additional images can serve other purposes. The reviewed Flipkart API references confirm an image URL field in listing data but do not establish visual acceptance rules. Do not copy Amazon’s specifications to Flipkart.

1. Check the marketplace rules before designing

Amazon.in

Amazon Seller Central India says every product needs at least one compliant main image. The MAIN image appears first on the detail page and in search results. Its guide says the main image should accurately represent the product, show the product at 85% of the image, include the entire product in frame, and show one unit and included accessories. It also prohibits misleading or temporary placeholders.

Amazon’s guidance generally prohibits text and pricing details, review imagery, seller-specific information, and Amazon marks or badges in product images. Image-role and category guidance matters: do not assume that the MAIN-image rules describe every permitted additional image.

Amazon.in image detail	Guidance in the reviewed India help pages
Supported formats	JPEG, TIFF, PNG, and non-animated GIF; JPEG is recommended.
Longest side	At least 500 px and no more than 10,000 px.
Zoom	1,000 px or larger on the longest side enables zoom; the image guide recommends 1,000+ px.
Resolution and color	At least 72 dpi; RGB is preferred.
MAIN composition	Accurate product, full product visible, product occupies 85% of the image, one unit and included accessories.

These are the figures stated by the reviewed [Amazon Seller Central India image guide](https://sellercentral.amazon.in/help/hub/reference/G200270100) and [Amazon Seller India beginner guide](https://sell.amazon.in/learn/image-guidelines). Check the live guidance for the product category and image role before publishing, since marketplace requirements can change.

Flipkart

Flipkart’s [Listing Management API reference](https://seller.flipkart.com/api-docs/) includes a conditional product_image_url field in listing data. Its [Create Listings API documentation](https://seller.flipkart.com/api-docs/) describes JSON requests and notes that listing rules may change. Those reviewed API pages do not establish current image dimensions, formats, or composition requirements. Consult Flipkart Seller Hub and the current instructions for your product vertical.

2. Prepare the source image and verified product facts

Use a real, accurate product photograph or other source image you are authorized to use. Verify the product’s color, quantity, included accessories, dimensions, and every claim before adding them to a layout. A screenshot API can reproduce an inaccurate claim just as faithfully as an accurate one.

• Choose the image role and destination before making a template.
• Keep marketplace-specific overlays and layout rules configurable instead of assuming one design works everywhere.
• For an Amazon MAIN image, avoid adding text or promotional overlays where the rules prohibit them; check the category-specific guidance.
• Use additional images for permitted views or details only after checking the rules for that role.
• Keep the original product photo available so reviewers can compare the rendered image with the actual product.

3. Create a fixed-size HTML layout

A fixed canvas makes output dimensions predictable. The example below uses a 1,200 by 1,200 pixel canvas and a local product photo. Replace the sample path with your own image. This is a rendering example, not a guarantee that the composition qualifies as an Amazon MAIN image or meets another marketplace’s policy.

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    * { box-sizing: border-box; }
    html, body { margin: 0; width: 1200px; height: 1200px; }
    body {
      display: grid;
      place-items: center;
      background: #fff;
      font-family: Arial, sans-serif;
    }
    .canvas {
      width: 1200px;
      height: 1200px;
      display: grid;
      place-items: center;
      overflow: hidden;
      background: #fff;
    }
    .product {
      display: block;
      max-width: 100%;
      max-height: 100%;
      object-fit: contain;
    }
  </style>
</head>
<body>
  <main class="canvas">
    <img class="product" src="file:///absolute/path/to/product.jpg" alt="Product">
  </main>
</body>
</html>

For remote rendering, host the HTML and source photo where the renderer can access them, or submit HTML using the API’s documented input method. Relative paths only work when the rendering environment can resolve them. If the product photo is unavailable to the renderer, the output may contain a broken-image icon or omit the image.

4. Render the page through a screenshot API

Screenshot API implementations differ in endpoint, authentication, accepted input, and output controls. The following vendor-specific example uses ScreenshotOne’s documented /take endpoint and parameter names. Keep credentials on a server or in a secure environment variable; do not expose a secret API key in browser-side code. Use HTTPS.

ScreenshotOne documents URL, HTML, or Markdown input, image output including PNG, JPEG/JPG, and WebP, and selector-based capture controls. For larger HTML or Markdown, its documentation recommends a JSON POST body; the getting-started page states a maximum POST body of 100 MiB. Check the [current ScreenshotOne getting-started guide](https://screenshotone.com/docs/getting-started/) and [options documentation](https://screenshotone.com/docs/options/) for current request details.

cURL: render a hosted HTML page

export SCREENSHOTONE_ACCESS_KEY='YOUR_API_KEY'
curl -G 'https://api.screenshotone.com/take' \
  --data-urlencode "access_key=$SCREENSHOTONE_ACCESS_KEY" \
  --data-urlencode 'url=https://example.com/product-image.html' \
  --data-urlencode 'format=png' \
  --data-urlencode 'width=1200' \
  --data-urlencode 'height=1200' \
  -o listing.png

Use the exact option names and supported combinations in the current vendor documentation. The example demonstrates the documented GET request pattern; it does not assert that every parameter shown is accepted in every API version.

Python: save the response

import os
import requests

access_key = os.environ["SCREENSHOTONE_ACCESS_KEY"]
response = requests.get(
    "https://api.screenshotone.com/take",
    params={
        "access_key": access_key,
        "url": "https://example.com/product-image.html",
        "format": "png",
        "width": 1200,
        "height": 1200,
    },
    timeout=90,
)
response.raise_for_status()
with open("listing.png", "wb") as image_file:
    image_file.write(response.content)

Node.js: save the response

const key = process.env.SCREENSHOTONE_ACCESS_KEY;
if (!key) throw new Error('Set SCREENSHOTONE_ACCESS_KEY');

const params = new URLSearchParams({
  access_key: key,
  url: 'https://example.com/product-image.html',
  format: 'png',
  width: '1200',
  height: '1200',
});
const response = await fetch(`https://api.screenshotone.com/take?${params}`);
if (!response.ok) {
  throw new Error(`Screenshot request failed: ${response.status} ${await response.text()}`);
}
const bytes = new Uint8Array(await response.arrayBuffer());
await import('node:fs/promises').then(fs => fs.writeFile('listing.png', bytes));

5. Inspect the saved image before upload

Rendering success only means an image response was produced. It does not mean the marketplace will accept it. Review the actual saved file at its final dimensions and at a smaller search-result scale.

• Confirm the file opens and its format matches the extension and upload requirements.
• Check pixel width and height, crop, margins, and whether the entire product is visible.
• Look for missing remote images, browser artifacts, unexpected text, and layout overflow.
• Compare the depiction, quantity, color, and included accessories with the real product.
• For Amazon MAIN images, check occupancy and all MAIN-image restrictions; do not add overlays just because the API can render them.
• For Flipkart, check the current Seller Hub guidance for the relevant product vertical.
• Keep a review record of the source photo, template version, rendered file, destination marketplace, and image role.

6. Upload through the current seller workflow

Amazon describes image upload as part of listing creation and Seller Central management. Flipkart’s listing API represents a product image with a conditional product_image_url field. Use the current marketplace seller workflow or API schema for the upload itself; the screenshot endpoint only creates the image file and does not publish a listing.

For bulk catalogs, render to a controlled staging location, validate dimensions and file readability automatically where practical, and route the results for human review before listing updates. Handle listing API errors explicitly, and avoid replacing a known-good listing image until the new asset has passed review.

7. Troubleshoot common problems

Symptom	Likely cause	Fix
Product photo is missing	Renderer cannot access a local file or relative URL.	Use a reachable HTTPS asset URL or the API’s supported HTML submission method; verify access from the rendering service.
Output has the wrong dimensions	Viewport dimensions and captured page dimensions differ, or the page has intrinsic sizing.	Set explicit CSS canvas dimensions and the API’s capture dimensions; inspect the resulting file metadata.
Image is cropped	The source photo exceeds its container or uses a cropping fit mode.	Use object-fit: contain where full visibility is needed; ensure the canvas does not clip the product.
Text or elements are cut off	Font loading, dynamic content, or capture timing changed the layout.	Wait for required assets or a stable selector using the API’s documented controls; use installed or reliably loaded fonts.
Request fails for large HTML	HTML was placed into an unsuitable GET query string or exceeded request limits.	Use the documented JSON POST flow for larger HTML; check the current body limit and response error.
API returns an error instead of an image	Invalid key, unsupported option combination, inaccessible URL, or rate/plan restriction.	Check status and response body, verify credentials and URL access, and compare options with current vendor docs.
Marketplace rejects the image	Successful rendering was mistaken for policy approval, or image-role/category rules were missed.	Review current marketplace guidance for the exact category and role; correct the content or composition and render again.
Flipkart requirements are unclear	The reviewed listing API schema does not specify complete visual rules.	Consult current Flipkart Seller Hub instructions for the product vertical instead of borrowing Amazon’s limits.

8. Performance, reliability, and cost

Rendering time depends on the page, assets, network access, and vendor service. Keep templates lightweight, use appropriately sized source images, and avoid unnecessary third-party scripts. For catalogs, bound concurrency, set a request timeout, record failures, and retry transient errors with a limit and backoff. Do not retry permanent authentication or invalid-parameter errors unchanged.

Check whether the API charges for failed requests, whether image storage or transfer adds cost, and whether caching is available before choosing a vendor or designing a bulk pipeline. The research sources establish ScreenshotOne’s input and output capabilities, but do not provide comparable price, reliability, or benchmark data; no vendor ranking on those grounds is justified here.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server from Yorker Media. Its one-call endpoint can return a screenshot image, but a screenshot still needs to be reviewed against the marketplace rules and the true product details.

See the ScreenshotNeo API documentation for request options. This example renders a hosted product layout; use a URL and output format appropriate to your workflow.

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

ScreenshotNeo removes cookie banners, popups, and chat widgets before the shot. Bot checks, blank pages, and failed loads are never billed. Its MCP server lets AI agents take screenshots. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 shots. These rendering features do not certify marketplace compliance.

Sign up for 1,000 free screenshots a month, with no card.

FAQ

Can a screenshot API make a product photo compliant?

No. It renders the provided page or HTML. You must verify the source image, claims, image role, and current marketplace policy.

Should I use Amazon’s image dimensions for Flipkart?

No. The reviewed Flipkart API references do not establish visual specifications. Check the current guidance for the relevant Flipkart product vertical.

Can I put promotional text on the Amazon main image?

Amazon’s India guidance generally prohibits text and pricing details on product images. Check the current category and image-role rules before adding any overlay.

Does a successful API response mean the listing will be accepted?

No. It means the renderer returned a result. Marketplace review and listing acceptance are separate steps.