You can run Puppeteer screenshot tests on a Linux VPS in India by installing a supported Node.js version, Puppeteer and its Chrome for Testing browser, then checking that Linux has the libraries Chrome needs. Start with one test and measure your own suite’s memory, CPU and run time before deciding how much concurrency a low-cost server can handle. Published VPS prices alone do not establish capacity.
Choose a VPS by specifications, region and workload
A virtual private server (VPS) gives you rented virtual compute to run Node.js, Puppeteer, Chrome and your test project. DigitalOcean calls its virtual machines Droplets and lists Linux options and datacenter regions, including Bangalore. That makes it one documented India-region example, not evidence that it will be fastest for your target websites. Choose a region based on where your tests need to run and measure latency against your own targets.
As an Amazon Associate I earn from qualifying purchases.
The following are DigitalOcean provider-listed examples surfaced October 3, 2026. These figures describe the plans, not a tested recommendation for screenshot workloads; verify live pricing, availability, taxes and billing terms before ordering.
| Plan example | Listed price | Memory | CPU | SSD | Transfer |
|---|---|---|---|---|---|
| Basic | $4/month | 512 MiB | 1 vCPU | 10 GiB | 500 GiB |
| Basic | $6/month | 1 GiB | 1 vCPU | 25 GiB | 1,000 GiB |
DigitalOcean says per-second Droplet billing with a 60-second or $0.01 minimum became effective January 1, 2026. Confirm its current billing terms and your checkout total. These USD prices should not be treated as fixed INR costs.
#1 Best Overall
Do not infer test capacity from the price
The listed plans do not establish a minimum RAM or CPU requirement for your suite, nor how many simultaneous screenshot jobs they can reliably run. A browser process, pages, application assets and artifacts all consume resources. Begin with low concurrency, watch memory and CPU during representative runs, and increase jobs only if your own measurements support it.
Account for disk and network use
Puppeteer’s installation guide estimates the Linux Chrome for Testing download at about 282 MB. That is the browser download, not total disk required for Node dependencies, project files, caches or retained screenshots. Estimate storage and transfer from your test volume and artifact-retention policy; the provider’s published allowances are not workload forecasts.
Install Node.js, Puppeteer and Chrome for Testing
The Puppeteer system-requirements page surfaced for version 25.12.0 specifies Node.js 22.12 or later and includes Debian/Ubuntu x64 and arm64 among supported platforms. These are version-specific requirements, so check the current requirements for the Puppeteer version you install. Puppeteer runs in headless mode by default.
- Select a supported Linux image. A current Debian or Ubuntu image is a practical starting point when following Puppeteer’s documented Chrome for Testing support. Keep the distribution and architecture in mind when resolving browser libraries.
- Install Node.js 22.12 or later for Puppeteer 25.12.0. Use your project’s established Node installation method and verify with
node --version. Check the requirements again if you use a later Puppeteer release. - Move into the test project and install Puppeteer. For a new project, run
npm init -y, thennpm install puppeteer. In an existing project, use its lockfile and package manager, for examplenpm ciwhen the project uses npm. - Confirm the browser installation. Installing
puppeteernormally downloads a compatible Chrome for Testing browser. If your package manager blocks install scripts and the browser is missing, runnpx puppeteer browsers install.
When to use puppeteer-core instead
puppeteer-core does not download Chrome. Use it when you deliberately manage the browser separately; you must then install and maintain a compatible browser and tell Puppeteer its executable path or channel. That control adds setup and version-management responsibility. For a first VPS setup, puppeteer is the more direct route.
Check Linux libraries if Chrome will not launch
A browser can be installed but fail at launch because the operating system lacks a shared library it needs. Puppeteer’s Linux troubleshooting guidance recommends inspecting the Chrome binary with ldd chrome | grep not to identify missing dependencies. Run the check against the Chrome executable installed for your project, then install the corresponding packages using your distribution’s current package names.
Dependency lists can change with the Linux distribution and browser revision. Consult the current Puppeteer troubleshooting guidance rather than copying a package list from another OS version. Puppeteer documents supported Chrome for Testing configurations on Debian/Ubuntu x64 and arm64; matching a supported base makes diagnosis more straightforward.
Rank #3
- HP MicroServer Gen10 Plus Tower Server for Business with Microsoft Windows Server 2019 OS!
- Intel Xeon E-2224 Quad-Core 3.4GHz 8MB CPU, Up To 4.6GHz Turbo
- 32GB (2 x 16GB) DDR4 PC4-21300 2666MHz Unbuffered Memory
- 16TB (4 x 4TB) 7.2K 6Gb/s SATA 3.5" HDDs in RAID
- Hard drives and memory upgrades included separately NOT installed, installation required.
Do not add --no-sandbox as a routine workaround. Some hosted-environment examples may use it, but disabling Chrome’s sandbox has security implications and is not a universal VPS fix. If your chosen runtime appears to require it, investigate the environment and consult current security guidance before changing the launch configuration.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Write a minimal screenshot test
This ES module illustrates the documented flow: launch the browser, create a page, navigate, save a screenshot and close the browser even if a step fails. Save it as screenshot.mjs in a project with Puppeteer installed:
import puppeteer from 'puppeteer';
const browser = await puppeteer.launch();
try {
const page = await browser.newPage();
await page.goto('https://example.com', { waitUntil: 'networkidle2' });
await page.screenshot({ path: 'artifacts/example.png' });
} finally {
await browser.close();
}Create the output directory before running the script, because the screenshot call writes to a path and does not create parent directories:
Rank #4
mkdir -p artifacts
node screenshot.mjsThe official screenshot example uses networkidle2, but it is not a universal timing guarantee. Pages with long-lived network connections may never meet a network-idle condition, while pages that render content later may need an application-specific readiness signal. Choose a navigation or wait condition that matches what the screenshot must contain. For more complex tests, wait for a specific selector or application state before capturing rather than assuming navigation completion means the page is visually ready.
Puppeteer’s official API workflow is to navigate, call Page.screenshot() with a file path, then close the browser. The finally block is important in a test runner: it closes Chrome after navigation or capture errors instead of leaving browser processes behind.
Recommended Free Tools
Measure before increasing concurrency
No published figure here establishes a reliable jobs-per-hour rate or minimum server size for your suite. Determine capacity with a controlled run of your own pages and settings.
Best Value
- Run a representative set of pages sequentially on the VPS and save artifacts to a known directory.
- Record each test’s result, failure details, browser version, artifact path and elapsed time.
- Observe server memory and CPU during the run, including peaks rather than only idle usage.
- Repeat with the same URLs, viewport, browser version, test count and wait strategy while raising concurrency in small increments.
- Compare completion time, failures and peak resource use. Stop increasing concurrency if failures or resource pressure make results unreliable.
This gives you workload-specific evidence without assuming that a low advertised price means a particular throughput. Revisit the measurements if you change browser versions, target pages, viewport, wait logic, artifact retention or server size.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Troubleshoot common setup failures
puppeteer.launch()reports that Chrome is missing: the package manager may have blocked install scripts. Runnpx puppeteer browsers installfrom the project directory and confirm the browser download completed.- Chrome exits immediately or reports missing shared libraries: inspect the installed Chrome executable with
ldd chrome | grep not, then install the distribution-appropriate packages for the missing libraries. - The screenshot call fails because its path is unavailable: create the parent directory, such as with
mkdir -p artifacts, and confirm the process can write there. - Navigation times out or never reaches network idle: the target may be slow or keep connections open. Use a wait condition appropriate to the page and, when applicable, wait for the particular selector or state needed for the screenshot.
- Screenshot misses content that appears later: navigation completion may precede client-side rendering or lazy content. Wait for the relevant element or application readiness condition before capture.
- Runs become unstable as jobs are added: reduce concurrency and check peak memory, CPU and per-test failures. The provider’s CPU and memory listing cannot predict your browser workload’s safe concurrency.
- A new Puppeteer release stops working with the installed Node version: check the release’s current system requirements and align Node, Puppeteer and its managed Chrome installation.
Or skip the browser setup
If your goal is to get screenshots rather than maintain Chrome on a VPS, ScreenshotNeo is a screenshot API and MCP server. One GET request can return a PNG, JPEG, WebP or PDF. For example, save a WebP response with cURL:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://example.com -o shot.webpSee the ScreenshotNeo API documentation for request options. Cookie/consent banners are accepted like a visitor and removed before capture, along with 60+ known consent platforms, newsletter popups and chat widgets; each step can be turned off. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads and cache hits cost nothing, and response headers say which page verdict applied and whether it was billed. Its MCP server lets AI agents, including Claude and Cursor, use take_screenshot, get_page_info and capture_pdf. The free plan includes 1,000 shots per month with no card; paid plans start at $5 for 3,000 shots.
Sign up for ScreenshotNeo’s free plan to get 1,000 screenshots a month with no card.
Sources and version-sensitive details
Check these primary pages when setting up a new server, since browser requirements, dependencies, pricing and region availability can change:
Quick Recap
- Puppeteer overview and system requirements.
- Puppeteer installation guide, screenshot guide and troubleshooting guide.
- DigitalOcean Droplet pricing for listed plan specifications, billing terms and region choices.
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
