Browser & Request Emulation

ScreenshotAPI allows you to simulate different browser environments before capturing a screenshot, helping you see how a webpage appears under various visual and privacy conditions. You can emulate modes such as dark mode, grayscale, and incognito mode to reflect how users experience your site across different browser settings.

In addition to visual settings, you can configure advanced request-level parameters such as User-Agent, Accept-Language, custom headers, and proxy. This enables you to simulate different browsers, devices, locations, and user contexts. It is especially useful for testing localized content, geo-specific responses, authentication flows, and ensuring that the final screenshot accurately represents real-world scenarios.


const axios = require("axios");

let config = {
	method: "get",
	maxBodyLength: Infinity,
	url: "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]",
	headers: { }
};

axios.request(config).then((response) => {
	console.log(JSON.stringify(response.data));
}.catch((error) => {
	console.log(error);
});


<?php
	$client = new http.Client;
	$request = new http.Client.Request;
	$request->setRequestUrl("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]");
	$request->setRequestMethod("GET");
	$request->setOptions(array());

	$client->enqueue($request)->send();
	$response = $client->getResponse();
	echo $response->getBody();
?>


package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {
	url := "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]"
	method := "GET"

	client := &http.Client { }
	req, err := http.NewRequest(method, url, nil)

	if err != nil {
		fmt.Println(err)
		return
	}

	res, err := client.Do(req)
	if err != nil {
		fmt.Println(err)
		return
	}

	defer res.Body.Close()
	body, err := io.ReadAll(res.Body)
	if err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(string(body))
}


OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("text/plain");
RequestBody body = RequestBody.create(mediaType, "");
Request request = new Request.Builder().url("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]"
	.method("GET", body)
	.build();
Response response = client.newCall(request)
	.execute();


import requests

url = "https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]"
payload = {}
headers = {}

response = requests.request("GET", url, headers, data=payload)
print(response.text)


require "uri"
require "net/http"

url = URI("https://shot.screenshotapi.net/v3/screenshot?token=TOKEN&url=https%3A%2F%2Fwww.apple.com%2F&dark_mode=true&grayscale=60&incognito_mode=true&user_agent=USER_AGENT&accept_languages=en-US&headers=CUSTOM_HEADERS&proxy=http://xo:llksoigsgrewvc@157.230.191.197:3128&[OPTIONS]")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = true

request = Net::HTTP::Get.new(url)

response = https.request(request)
puts response.read_body

Proxy

Parameter Name : proxy

This parameter allows you to route your screenshot or render request through a specified proxy server. This enables the request to appear as if it is originating from a different IP address or location, which can be useful for accessing geo-restricted content, testing regional variations, or bypassing certain network restrictions.

By using a proxy, you gain more control over how the target website is accessed during the rendering process.

Format

Provide the proxy in one of the following formats:

Address and port: address:port
With authentication: username:password@address:port

When to use

Use this parameter when you need to simulate requests from different locations, test region-specific content, or access websites that restrict traffic based on IP.
It is also useful for advanced scraping, monitoring, or automation workflows where IP rotation or anonymity is required. Additionally, proxies help reduce the chances of bot detection by masking the original IP and mimicking real user traffic patterns.

Default value:' '.

Headers

Parameter Name : headers

It allows you to define custom HTTP headers that will be sent with the request before the webpage is rendered. These headers are included in the browser request and can be used to modify how the target website responds during the rendering process.

This is useful for simulating different client behaviors, passing authentication tokens, setting language preferences, or customizing request metadata for testing and automation purposes. Multiple headers can be provided in a single request.

Options

Provide headers in a key-value format separated by semicolons, for example:

X-HEADER: value; X-OTHER-HEADER: otherValue;
Authorization: Bearer TOKEN; Accept-Language: en-US;

When to use

Use this parameter when you need to control how the request is interpreted by the target server, such as accessing authenticated pages, testing API-driven rendering, or simulating different user environments.
It is commonly used in advanced scraping, automation, and debugging workflows where custom request behavior is required.

Default value:' '(empty string).

User Agent

Parameter Name : user_agent

This parameter allows you to define a custom User-Agent string for the rendering request. This string is sent in the HTTP headers and identifies the browser, device, or client making the request to the target website.

By modifying the User-Agent, you can simulate different devices such as desktop browsers, mobile phones, or specific browser versions. This is useful for testing responsive layouts, accessing device-specific content, or ensuring consistent rendering across different environments.

Options

Provide a valid User-Agent string, for example:

Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36

When to use

Use this parameter when you need to test how a webpage behaves on different browsers or devices, or when certain content is served conditionally based on the User-Agent.

Default value:' '.

Accept Language

Parameter Name : accept_languages

It sets the Accept-Language HTTP header for the rendering request. This header informs the target website about the preferred language of the client, allowing the server to serve localized content based on the specified language preferences.

This is particularly useful for testing multilingual websites, verifying localized versions of pages, or capturing region-specific content as it would appear to users in different language settings.

Option

Provide a valid language preference string, for example:

en-US,en;q=0.8: (English - United States)
fr-FR,fr;q=0.9: (French - France)
es-ES,es;q=0.8: (Spanish - Spain)

When to use

Use this parameter when you need to test or capture localized versions of a webpage, or when content varies based on the user’s language settings. It is especially useful for international websites, SEO localization testing, and regional content verification.

Default value:en-US,en;q=0.8(English - United States, with fallback to English).

Dark Mode

Parameter Name : dark_mode

This parameter enables dark mode rendering for the target webpage during screenshot or PDF generation. When set to true, the system attempts to render the page in dark mode, provided the website supports a dark theme or has built-in dark mode styles.

This is useful for capturing how a website appears to users who prefer dark mode or when testing UI consistency across different theme settings.

Options

true: Forces or enables dark mode rendering for supported websites, producing a dark-themed version of the page.
false: Renders the page in its default theme (usually light mode), without applying dark mode styles.

When to use

Use true when you want to test or capture the dark theme version of a website, especially for UI/UX reviews or theme consistency checks.
Use false when you need the standard default appearance of the webpage as seen by most users.

Default value:false.

Grayscale

Parameter Name : grayscale

This applies a black-and-white filter to the rendered screenshot or image output by reducing or fully removing color information. It allows you to control the intensity of desaturation applied to the final render.

This is useful when you want a simplified visual representation of a webpage, reduce visual noise, or create consistent monochrome outputs for reporting, documentation, or analysis purposes.

Options

The value ranges from 0 to 100:

0: No grayscale effect; the image remains in full color
1–99: Partial grayscale effect with gradual desaturation
100: Fully grayscale image with all colors removed

When to use

Use lower values when you want subtle color reduction while maintaining visual clarity.
Use higher values when you need a completely desaturated output for clean, distraction-free visuals or formal reporting purposes.

Default value:0.

Incognito Mode

Parameter Name : incognito_mode

It enables private browsing for the rendering session. When activated, the browser runs in an isolated environment where no cookies, cache, session storage, or browsing data is persisted between requests. Each render starts with a clean slate, ensuring complete session isolation.

This is useful for capturing how a website behaves for first-time users or for avoiding interference from previously stored session data such as login states, personalization, or cached content.

Options

true: Launches the browser in incognito mode, ensuring no data is stored or reused between rendering sessions.
false: Runs the browser in standard mode where cookies, cache, and session data may persist depending on configuration.

When to use

Use true when you need a fresh, untracked browsing session for every request, such as testing login flows, personalization behavior, or anonymous user experience.
Use false when session persistence is required for workflows that depend on cookies or authenticated states across multiple requests.

Default value:false.

Note: Some websites may restrict or modify content when they detect incognito mode, which can affect rendering results or access to certain features.