How to Capture a Full-Page Screenshot of a Hindi Website with ScreenshotMachine

To capture a Hindi website at full page height with ScreenshotMachine, send its screenshot API a URL-encoded page URL, set dimension to a width followed by xfull (for example, 1024xfull), and set accept-language to hi or hi-IN. The language header asks the site to serve Hindi; it does not translate a page or guarantee that the site will respond in Hindi.

This guide uses ScreenshotMachine’s documented API settings. The URL and settings below are illustrative; no request or output is claimed to have been tested. See the vendor’s Website screenshot API documentation for the current parameter details.

1. Prepare the page URL and API request

Use the Hindi page’s own URL if the site provides one. Otherwise, ask the site to choose a language with accept-language. ScreenshotMachine requires a customer key and target URL. URL percent-encoding is strongly recommended, especially when the URL contains query parameters, ampersands, or other reserved characters.

The API uses an HTTP GET request. These are the core settings for a full-page Hindi capture:

Parameter	Example	Purpose
key	YOUR_CUSTOMER_KEY	Your ScreenshotMachine account key.
url	https://example.com/hi/page	The page to capture. Encode it as a query parameter.
dimension	1024xfull	Capture at 1024 pixels wide and the full page height. The documented width range is 100–1920 pixels; full is accepted as the height.
accept-language	hi or hi-IN	Set the outgoing Accept-Language header sent to the target site.

ScreenshotMachine documents the language parameter as a way to capture a webpage with a specific language. In practice, the site controls which languages it serves and how it renders them. If it ignores the header, use its Hindi-specific URL or language selector instead.

2. Make a full-page capture from the command line

Install curl, replace the key and URL, then save the response to a file. The URL is encoded by curl’s query parameter handling.

curl -G "https://api.screenshotmachine.com?key=YOUR_CUSTOMER_KEY" \
  --data-urlencode "url=https://example.com/hi/page" \
  --data-urlencode "dimension=1024xfull" \
  --data-urlencode "accept-language=hi" \
  --data-urlencode "device=desktop" \
  --data-urlencode "format=png" \
  --data-urlencode "delay=2000" \
  --output hindi-page.png

The endpoint and parameter names are based on ScreenshotMachine’s official API documentation. Keep the key private: do not commit it to a repository or expose it in public browser-side code. ScreenshotMachine recommends its hash parameter for protecting calls made from public HTML pages when a secret phrase is configured; consult the documentation for the signing details.

3. Capture with Python

This example uses Python’s standard library, so it needs no third-party package. It URL-encodes the parameters, makes the GET request, and writes the returned bytes to a PNG file.

from urllib.parse import urlencode
from urllib.request import urlopen

params = {
    "key": "YOUR_CUSTOMER_KEY",
    "url": "https://example.com/hi/page",
    "dimension": "1024xfull",
    "accept-language": "hi",
    "device": "desktop",
    "format": "png",
    "delay": "2000",
}
request_url = "https://api.screenshotmachine.com?" + urlencode(params)

with urlopen(request_url, timeout=90) as response:
    image_bytes = response.read()

with open("hindi-page.png", "wb") as image_file:
    image_file.write(image_bytes)

For production use, put the key in an environment variable or secret manager and handle HTTP errors explicitly. Check the response status and content before treating the bytes as an image; API errors may not be image data.

4. Capture with Node.js

This runnable Node.js example uses the built-in fetch available in recent Node.js releases. It writes the response body to a file and checks for an unsuccessful HTTP status.

import { writeFile } from "node:fs/promises";

const params = new URLSearchParams({
  key: "YOUR_CUSTOMER_KEY",
  url: "https://example.com/hi/page",
  dimension: "1024xfull",
  "accept-language": "hi",
  device: "desktop",
  format: "png",
  delay: "2000",
});

const response = await fetch(`https://api.screenshotmachine.com?${params}`);
if (!response.ok) {
  throw new Error(`ScreenshotMachine returned HTTP ${response.status}: ${await response.text()}`);
}

const image = Buffer.from(await response.arrayBuffer());
await writeFile("hindi-page.png", image);

Save this as an ES module (for example, capture.mjs) and run it with a current Node.js version that supports global fetch. Keep the customer key out of source control in real applications.

5. Choose width, device, wait time, format, and cache behavior

Choice	When to use it	Tradeoff or detail
Width and device	Choose the layout your reader or evidence needs.	ScreenshotMachine documents desktop, phone, and tablet. Responsive breakpoints can change text wrapping, menus, and page height. The width in dimension determines the capture width.
Full page or viewport	Use 1024xfull (or another allowed width) for the entire page.	A numeric height requests a bounded capture instead of full page height.
Delay	Increase it if images, animations, or other content appears late.	ScreenshotMachine suggests considering delay=2000 milliseconds or more for long pages with images or animations. More delay increases waiting time and does not guarantee that every dynamic element has finished.
Language	Try hi or hi-IN when the site negotiates language from request headers.	The header is a request to the website, not a translation instruction. Some sites choose language from cookies, URL paths, account settings, or client-side controls.
Image format	Pick a supported format suited to the use case.	Documented formats are JPG, PNG, and GIF. The documentation does not establish one as universally best; inspect text edges, file needs, and compatibility for your purpose.
Cache freshness	Choose whether an existing capture can be reused.	The cacheLimit setting accepts values from 0 to 14 days. Use 0 to request a fresh screenshot; a longer allowance may reuse a cached result when the page is changing less often.

ScreenshotMachine’s website screenshot generator also exposes full-page capture and settings for dimensions, device, delay, and format. If you prefer a visual interface, configure those options there and verify that its language setting maps to the desired request header.

6. Verify the output

1. Open the saved image and confirm it contains the top, middle, and bottom of the page.
2. Check that the page is actually in Hindi. The language header may be ignored or overridden by the site’s own language state.
3. Inspect Devanagari text at the selected width for clipping, unexpected wrapping, or missing glyphs.
4. Look for unloaded images, blank sections, animation frames, or content that only appears after scrolling or interaction.
5. If the result is wrong, try the site’s Hindi URL or language selector, select the intended device width, and adjust the delay before capturing again.

A screenshot records what the target site serves and renders at capture time. It cannot make a Hindi translation appear if the site does not provide one, and the API documentation does not promise Hindi font behavior for every target site.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server. Its one-call API accepts a URL and returns PNG, JPEG, WebP, or PDF output. The parameter names other screenshot APIs use also work, which makes switching straightforward. See the ScreenshotNeo API documentation for available settings.

curl -G "https://api.screenshotneo.com/v1/shot" \
  -d access_key=YOUR_API_KEY \
  --data-urlencode url=https://example.com/hi/page \
  -o hindi-page.webp

Cookie and consent banners, newsletter popups, and chat widgets are removed before capture. Bot checks, blank pages, failed loads, timeouts, and cache hits are never billed; response headers say which page verdict applied and whether the request was billed. AI agents can use its MCP server tools take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000 screenshots.

Create a free ScreenshotNeo account to get 1,000 screenshots a month with no card.

Troubleshooting

Symptom	Likely cause	What to try
The page is not in Hindi	The site ignores Accept-Language, uses a stored preference, or has no Hindi version.	Use the site’s Hindi URL or language switcher. If the language choice is stored in a cookie, use a capture configuration that supplies the required state if supported by your workflow.
The URL or request fails	Reserved characters in the page URL or other parameters were not encoded, or the required key is missing or invalid.	Use curl --data-urlencode, Python’s urlencode, or Node’s URLSearchParams. Confirm the key and complete target URL.
The image stops before the bottom	The request used a fixed height, or full-page mode was not set.	Set dimension to a valid width plus xfull, such as 1024xfull.
Images or sections are missing	Content loaded after capture, depends on scrolling, or requires interaction.	Increase the delay, use the site’s own page controls if necessary, and verify the result. A longer wait helps with late content but cannot guarantee completion for every page.
Hindi characters appear clipped or wrong	The page’s font or layout behavior at the selected viewport may be responsible.	Try the Hindi-specific page, a different supported device or width, and inspect whether the issue exists on the page itself. The documentation does not promise font fallback behavior.
The output file is not a readable image	The response may contain an API error rather than image bytes, or the requested format and file extension do not match.	Check HTTP status and response content before writing, confirm the format parameter, and use an extension matching the requested output.
A fresh page change does not appear	A cached capture may be returned under the selected cache policy.	Set cacheLimit=0 when you need a fresh screenshot, within the documented 0–14 day range.

Performance, reliability, and cost

• Performance: Full-page images take longer to produce and can be larger than viewport captures. Wider output and extra delay can increase processing and transfer time. The research sources give no benchmark, so measure with your actual target pages and settings.
• Reliability: A screenshot depends on the target site’s availability, scripts, access controls, and rendering. The API documentation does not guarantee a Hindi response, complete rendering of every dynamic page, or a particular completion time.
• Cost: ScreenshotMachine’s pricing page displays a free allowance and paid tiers, but plan terms can change. Confirm current allowances and rates on its pricing page before deploying a recurring capture job.
• Security: Treat the API key as a secret. Server-side calls or the vendor’s documented hash approach are safer than placing an unrestricted key in public page source.

FAQ

Does accept-language=hi translate an English page?

No. It asks the website to serve a preferred language. Translation must be provided by the site or another translation workflow.

Should I use hi or hi-IN?

Try the language tag the target site recognizes. If neither produces Hindi, use its Hindi page URL or language control.

Can I capture only the visible browser area?

Yes. Use a fixed numeric height in the dimension instead of full; that limits the screenshot to the requested dimensions.

Does full-page mode guarantee every lazy-loaded section appears?

No. The capture height requests the entire page, while loading behavior depends on the target site. Inspect the image and adjust wait time or page state when needed.

Where can I confirm ScreenshotMachine’s current settings and plan terms?

Use its API documentation for request settings and its pricing page for current displayed plans.