How to capture website screenshots in multiple languages with LambdaTest

LambdaTest’s Automated Screenshot API captures the page rendered at a URL in the browser and operating system configurations you request. To capture multiple languages, prepare a URL or session that already renders each intended locale, then submit a screenshot test for each one. The documented request schema does not show a language or locale switch, so the API does not automatically translate a page or select its language for you.

The API guide is branded TestMu AI (formerly LambdaTest), while its documented endpoints and examples use lambdatest.com. Check the current screenshot API guide and your account dashboard for available browser, operating system, resolution, access, and plan details.

1. Prepare each localized page

First determine how the site selects its language. Common application patterns include a locale-specific route such as https://example.com/fr/, or a site-controlled session or cookie preference. These are ways a website may expose a locale; they are not LambdaTest API parameters documented in the cited request schema.

List the locales you need to capture, such as en, fr, and de.
For each locale, identify a URL or session state that makes the application render that language.
Open the target using the same relevant conditions and confirm the visible language before submitting the capture.
Keep a mapping of locale to target URL or setup instructions so repeated runs capture the same variant.

If a language is selected only after an interactive step, or depends on a session cookie, verify how your application can reproduce that state in the capture environment. Do not assume that adding a language label to your own test record changes the page. If the submitted page still resolves to the default locale, the screenshot will show that default.

2. Choose a consistent browser and viewport matrix

The documented request accepts a configs object for operating system and browser combinations, along with resolution fields for Mac and Windows. Use the same matrix for every locale you want to compare. The exact currently available combinations and accepted values can change; use the live documentation and account dashboard as the authority.

Decide whether you need one representative browser configuration or a broader cross-browser matrix. A controlled matrix helps distinguish translation-related layout changes from browser or viewport differences. Record the locale separately: the cited result example includes browser and operating system metadata, but not a locale field.

3. Submit one screenshot test per locale

The following cURL example follows the official request schema. Replace the example credentials, URL, callback, and configuration values with values accepted by your account and the current API documentation. The example shows a request shape; it does not assert that a particular browser or operating system combination is currently available.

curl --request POST \
  --url 'https://api.lambdatest.com/screenshots/v1' \
  --user 'YOUR_USERNAME:YOUR_ACCESS_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "url": "https://example.com/fr/",
    "defer_time": 5,
    "mac_res": "1920x1080",
    "win_res": "1920x1080",
    "callback_url": "https://example.com/lambdatest-callback",
    "configs": [
      {
        "os": "Windows 10",
        "browser": "chrome",
        "versions": ["latest"]
      }
    ]
  }'

Use the endpoint, authentication method, accepted JSON shape, and configuration values shown in the live Start Screenshot Test API reference if they differ from this illustrative request. The reference documents fields including the target URL, defer_time, mac_res, win_res, optional tunnel settings and identifier, credentials, callback URL, and a configs object.

Repeat the request for each locale-specific URL. Store your own locale label alongside the returned test ID. If your locale depends on a session or cookie, use only a method supported by the live API and your application; do not treat the example as proof that arbitrary locale cookies can be supplied through this endpoint.

Request fields to review

Field or setting	Purpose	Practical guidance
`url`	Page to capture.	Use the locale-specific URL when the site provides one, and verify that it displays the intended language.
`configs`	Browser and operating system combinations.	Use the same combinations for each locale. Confirm supported names and versions in current documentation.
`mac_res`, `win_res`	Resolution settings shown in the request example.	Keep the target viewport consistent across locale runs where a fair visual comparison matters.
`defer_time`	Delay before the capture, as documented in the request schema.	Choose a delay appropriate to the page’s loading behavior. There is no universal value established by the reviewed documentation.
Tunnel settings and identifier	Optional request fields in the official example for tunnel-related setup.	Use them when your account and test target require a tunnel, following current vendor instructions.
`callback_url`	Callback address included in the documented request example.	Use a reachable endpoint if your workflow relies on callbacks; otherwise follow the API’s current rules for omitting it.
Authentication	Required to submit a screenshot test.	Keep credentials in environment variables or a secret store; never commit real credentials to a repository or expose them in browser code.

4. Retrieve and label the results

The start request returns a test ID. Use that ID with the documented fetch-details operation to retrieve the completed screenshot information. The official example response includes operating system, browser, browser version, status, screenshot URL, thumbnail URL, activity ID, and resolution.

curl --request GET \
  --url 'https://api.lambdatest.com/screenshots/v1/YOUR_TEST_ID' \
  --user 'YOUR_USERNAME:YOUR_ACCESS_KEY'

Check the live Fetch specified screenshot details reference for the current retrieval URL, authentication requirements, and response shape. Save the returned screenshot links and metadata with your own locale label, for example fr, because the cited result example does not identify the page language.

5. Compare language variants consistently

Compare results only when browser, operating system, browser version, and viewport match. Then inspect the differences that translation can introduce:

Text wrapping that changes card, navigation, or button dimensions.
Longer translated labels that overflow or push nearby controls out of alignment.
Missing glyphs or fallback fonts for characters used by a locale.
Clipped text, truncated labels, or controls that move below the fold.
Pages that unexpectedly render the default language instead of the requested locale.

These are review checks for your application, not results of a LambdaTest product test. Preserve the test ID, locale label, target URL, and returned browser and resolution metadata together so a later comparison can be reproduced.

6. Handle timing, access, and repeat runs

Dynamic content and capture delay

The request schema documents defer_time, which lets you allow time before capture. Set it based on how the page loads and how the localized content appears. The reviewed documentation does not give one delay that works for every site. A delay that is too short can capture an incomplete page; an unnecessarily long delay makes a batch take longer.

Private or staging targets

The official request example includes optional tunnel-related settings. If the target is not publicly reachable, check the current LambdaTest tunnel documentation and account configuration. Do not assume that a public capture endpoint can access an internal site without the required network setup.

Repeatability

For visual regression work, keep the locale, URL, browser matrix, resolution, and delay consistent between runs. Where the application changes its locale through state, ensure the capture run recreates that state. Record the input configuration with the returned test metadata so changes can be traced to a specific run.

Common errors and fixes

Symptom	Likely cause	What to do
Screenshot shows the default language.	The URL or captured session did not select the intended locale.	Verify the localized URL or application state in the target environment before capture. Track the locale yourself; the documented API request does not show a locale switch.
Request is rejected or cannot authenticate.	Credentials are missing or invalid, or the request does not match current endpoint requirements.	Check the live API reference and account credentials. Keep secrets out of client-side code and source control.
Browser or configuration value is rejected.	The selected OS, browser, version, or resolution is not accepted for the account or current API.	Use the current documented options and dashboard availability; published examples may show older combinations.
Capture is incomplete or content is missing.	The page had not finished rendering when captured, or its dynamic content needs more time.	Adjust `defer_time` and confirm the page’s behavior. No universal delay is documented.
Private target cannot be reached.	The test environment lacks access to the staging or internal host.	Review the vendor’s current tunnel setup and the optional tunnel request fields.
Results are difficult to compare.	Locale runs used different browser, OS, version, or resolution settings, or locale labels were not saved.	Use a fixed matrix and store the locale with each test ID and response metadata.
No useful result appears after submission.	The test may still be processing, the test ID may be wrong, or retrieval details may have changed.	Retain the returned ID and follow the current fetch-details operation and status fields.

Performance, reliability, and cost considerations

A multi-locale run multiplies the number of captures by the number of locale variants and browser configurations. Start with the smallest matrix that answers the review question, then expand when you need broader coverage. Keep delays no longer than the page requires, and use callbacks if they fit your asynchronous workflow and the current API supports your setup.

Authentication is required, and private targets may require tunnel configuration. A screenshot is only useful for the intended locale if the page actually rendered in that language; verify this rather than inferring it from the request label. The reviewed sources do not establish current pricing, limits, account entitlements, or a universal completion time, so check your live account before estimating a run’s cost or capacity.

Or skip the browser setup

ScreenshotNeo is a website screenshot API and MCP server for developers. For a straightforward public-page capture, one GET request returns an image or PDF. Here is the cURL form:

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

See the ScreenshotNeo API documentation for request options. Cookie banners and consent overlays, newsletter popups, and chat widgets are removed 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 lets AI agents use take_screenshot, get_page_info, and capture_pdf. The free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots.

FAQ

Does LambdaTest translate a page when I specify a language?

The reviewed screenshot request schema does not show a language or locale parameter. Prepare a page that already renders the desired language before submitting the capture.

Will the returned screenshot metadata tell me which locale was captured?

The cited response example lists browser and operating system details, status, screenshot links, activity ID, and resolution, but not locale. Keep your own locale label with the test ID.

Can I use this workflow for a private staging page?

The official request example includes optional tunnel settings. Whether you need a tunnel depends on where the target is hosted and your account setup; consult the current vendor instructions.

Where can I check the current browser options and API behavior?

Use the current TestMu AI API guide and your LambdaTest account dashboard, since available combinations and account-specific details may change.