Build the service as an HTTP API that validates a capture request, adds a small job to a Redis-backed queue, and returns a job ID. A separate worker uses Puppeteer to open the page in headless Chrome, take the screenshot, and save it; the API then exposes job status and a way to retrieve the result. This keeps variable browser work out of the request path and lets you control worker concurrency, retries, and rate limits independently.
How the service fits together
A screenshot service has two different kinds of work: quick request handling and comparatively slow, resource-intensive browser rendering. Keep them separate. The API authenticates and validates a request, assigns an ID, and enqueues the capture. A worker consumes the job, launches or reuses Chrome, captures the page, persists the file, and records the outcome. Callers poll a status endpoint and fetch the image after completion.
As an Amazon Associate I earn from qualifying purchases.
- Submit: the client sends a URL and bounded capture options.
- Queue: the API stores a compact job payload and returns an ID without waiting for Chrome.
- Capture: a worker navigates to the page, waits for the selected readiness condition, and takes the screenshot.
- Deliver: the worker stores the image and marks the job complete; the client checks status and retrieves the result.
This is an architectural pattern built from Puppeteer’s browser automation and screenshot APIs and BullMQ’s Redis-backed queue and worker model. Neither library dictates your public API, storage, retention, authentication, or billing policy; those are service decisions.
Choose synchronous capture or a queue
| Design | What happens | Trade-off |
|---|---|---|
| Single process, synchronous | The HTTP request remains open while the browser navigates and renders the page. | Simpler to prototype, but a slow page ties up request handling and makes bursts harder to absorb. |
| API plus queue and workers | The API responds with a job ID; workers perform captures separately. | Adds Redis-compatible queue operations, status handling, and result delivery, while allowing capture capacity to scale separately from intake. |
For a small proof of concept, synchronous capture may be enough. Use a queue when requests can be slow or arrive in bursts, or when you need independent control over retries and rendering capacity. There are no universal throughput or latency figures for this design: browser cost depends on the pages, capture settings, deployment, and concurrency you measure.
#1 Best Overall
- Compatible with Nintendo Switch 2’s new GameChat mode
- Auto-Light Balance: RightLight boosts brightness by up to 50%, reducing shadows so you look your best—compared to previous-generation Logitech webcams (1)
- Privacy with a Slide: The integrated webcam cover makes it easy to get total, reliable privacy when you're not on a video call
- Built-In Mic: The built-in microphone lets others hear you clearly during video calls
- Easy Plug-And-Play: The Brio 101 works with most video calling platforms, including Microsoft Teams, Zoom and Google Meet—no hassle; it just works
Define a small, bounded capture API
Start with a narrow JSON request contract. For example, accept url, width, height, format, quality, fullPage, and an optional selector. Treat the exact names, defaults, limits, and response shape as your API choices, not library defaults. Validate types and bounds before enqueueing so malformed or excessive requests do not consume browser time.
- Viewport: set width and height limits appropriate to your deployment. Puppeteer supports setting a page viewport.
- Format: PNG, JPEG, and WebP are available screenshot formats through browser capture APIs. Quality applies to lossy formats; do not assume a PNG quality setting behaves like JPEG quality.
- Full page or viewport: a full-page capture may be much taller and more expensive to process than a viewport capture.
- Element capture: accept a selector only if your service supports it; wait for a match, then use Puppeteer’s element screenshot behavior. The element screenshot method attempts to scroll a hidden matching element into view by default.
- Readiness: choose an explicit wait policy. A page load event, a selector, a short delay, or network-idle behavior can suit different sites; no one condition is reliable for every application.
For duplicate suppression, accept an idempotency key or derive a stable job identifier from a request fingerprint. This is a product policy: decide whether a repeated key reuses a prior result, creates a new capture, or is rejected.
Build a minimal queued Node.js service
The example below uses Express, BullMQ, Redis, Puppeteer, and a local output directory so you can see the whole request-to-result path. It runs as one API process and one worker process. Install Node.js, Chrome-compatible runtime dependencies for Puppeteer, and a running Redis service first. In an empty project, install packages with npm install express bullmq puppeteer. Pin tested versions in your lockfile before deployment.
Rank #2
- Compatible with Nintendo Switch 2’s new GameChat mode
- Crisp HD 720p/30 fps video calls with diagonal 55° field of view and auto light correction. Compatible with popular platforms including Skype and Zoom.
- The built-in noise-reducing mic makes sure your voice comes across clearly up to 1.5 meters away, even if you’re in busy surroundings.
- C270’s RightLight 2 feature adjusts to lighting conditions, producing brighter, contrasted images to help you look good in all your conference calls.
- The adjustable universal clip lets you attach the camera securely to your screen or laptop, or fold the clip and set the webcam on a shelf. You’re always ready for your next video call.
Save this as service.js. The API accepts POST /jobs, reports status from GET /jobs/:id, and serves the completed image from GET /jobs/:id/image. Run ROLE=api node service.js and ROLE=worker node service.js in separate processes with the same Redis and output-directory configuration.
const express = require('express');
const { Queue, Worker } = require('bullmq');
const puppeteer = require('puppeteer');
const fs = require('node:fs/promises');
const path = require('node:path');
const { randomUUID } = require('node:crypto');
const redisUrl = new URL(process.env.REDIS_URL || 'redis://127.0.0.1:6379');
const connection = {
host: redisUrl.hostname,
port: Number(redisUrl.port || 6379),
...(redisUrl.password ? { password: decodeURIComponent(redisUrl.password) } : {}),
...(redisUrl.username ? { username: decodeURIComponent(redisUrl.username) } : {}),
...(redisUrl.protocol === 'rediss:' ? { tls: {} } : {}),
maxRetriesPerRequest: null
};
const queueName = 'page-screenshots';
const queue = new Queue(queueName, { connection });
const outputDir = path.resolve(process.env.OUTPUT_DIR || './screenshots');
const role = process.env.ROLE;
function validate(body) {
if (!body || typeof body.url !== 'string') throw new Error('url must be a string');
let parsed;
try { parsed = new URL(body.url); } catch { throw new Error('url must be a valid absolute URL'); }
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
throw new Error('only http and https URLs are accepted');
}
const width = body.width ?? 1280;
const height = body.height ?? 800;
const format = body.format ?? 'png';
const quality = body.quality;
if (!Number.isInteger(width) || width < 320 || width > 2560) throw new Error('width must be an integer from 320 to 2560');
if (!Number.isInteger(height) || height < 200 || height > 2000) throw new Error('height must be an integer from 200 to 2000');
if (!['png', 'jpeg', 'webp'].includes(format)) throw new Error('format must be png, jpeg, or webp');
if (quality !== undefined && (!Number.isInteger(quality) || quality < 0 || quality > 100)) {
throw new Error('quality must be an integer from 0 to 100');
}
if (quality !== undefined && format === 'png') throw new Error('quality is only supported here for jpeg or webp');
if (body.fullPage !== undefined && typeof body.fullPage !== 'boolean') throw new Error('fullPage must be a boolean');
if (body.selector !== undefined && (typeof body.selector !== 'string' || body.selector.length > 500)) {
throw new Error('selector must be a string of at most 500 characters');
}
return { url: parsed.href, width, height, format, quality, fullPage: body.fullPage ?? false, selector: body.selector };
}
async function runApi() {
const app = express();
app.use(express.json({ limit: '16kb' }));
app.post('/jobs', async (req, res) => {
let data;
try { data = validate(req.body); } catch (error) { return res.status(400).json({ error: error.message }); }
const id = randomUUID();
await queue.add('capture', data, {
jobId: id,
attempts: 2,
backoff: { type: 'exponential', delay: 1000 },
removeOnComplete: false,
removeOnFail: false
});
return res.status(202).json({ id, statusUrl: `/jobs/${id}` });
});
app.get('/jobs/:id', async (req, res) => {
const job = await queue.getJob(req.params.id);
if (!job) return res.status(404).json({ error: 'job not found' });
const state = await job.getState();
const result = { id: job.id, state };
if (state === 'completed') result.imageUrl = `/jobs/${job.id}/image`;
if (state === 'failed') result.error = job.failedReason;
return res.json(result);
});
app.get('/jobs/:id/image', async (req, res) => {
const job = await queue.getJob(req.params.id);
if (!job || await job.getState() !== 'completed') return res.status(404).json({ error: 'completed image not found' });
const file = path.join(outputDir, `${job.id}.${job.data.format}`);
try {
await fs.access(file);
return res.type(job.data.format).sendFile(file);
} catch {
return res.status(404).json({ error: 'image file not found' });
}
});
app.listen(Number(process.env.PORT || 3000), () => console.log('API listening'));
}
async function runWorker() {
await fs.mkdir(outputDir, { recursive: true });
let browser;
const worker = new Worker(queueName, async job => {
if (!browser || !browser.isConnected()) browser = await puppeteer.launch();
const page = await browser.newPage();
try {
await page.setViewport({ width: job.data.width, height: job.data.height });
await page.goto(job.data.url, { waitUntil: 'domcontentloaded', timeout: 30000 });
if (job.data.selector) await page.waitForSelector(job.data.selector, { timeout: 10000 });
const options = {
path: path.join(outputDir, `${job.id}.${job.data.format}`),
type: job.data.format,
fullPage: job.data.fullPage
};
if (job.data.quality !== undefined) options.quality = job.data.quality;
if (job.data.selector) {
const element = await page.$(job.data.selector);
if (!element) throw new Error('selector was not found');
await element.screenshot(options);
} else {
await page.screenshot(options);
}
return { format: job.data.format };
} finally {
await page.close();
}
}, { connection, concurrency: Number(process.env.CONCURRENCY || 1) });
worker.on('failed', (job, error) => console.error('capture failed', job?.id, error.message));
const shutdown = async () => {
await worker.close();
await browser?.close();
await queue.close();
process.exit(0);
};
process.on('SIGTERM', shutdown);
process.on('SIGINT', shutdown);
}
if (role === 'api') runApi().catch(error => { console.error(error); process.exit(1); });
else if (role === 'worker') runWorker().catch(error => { console.error(error); process.exit(1); });
else throw new Error('Set ROLE=api or ROLE=worker');For example, submit a capture with curl -X POST http://localhost:3000/jobs -H 'content-type: application/json' -d '{"url":"https://example.com","width":1280,"height":800,"format":"png"}'. The response contains an ID; poll its statusUrl until the state is completed, then request the returned imageUrl. The implementation is intentionally a starting point: add authentication, durable/shared output storage, retention cleanup, and production error handling before serving real users.
Set readiness and capture behavior deliberately
The worker example navigates with domcontentloaded, then optionally waits for a selector. This avoids treating one network-idle setting as a universal readiness signal. Puppeteer’s screenshot guide also demonstrates waitUntil: 'networkidle2', but pages with persistent connections, delayed assets, or animation can need a different policy. A more complete API can expose a small set of named wait modes or an explicitly bounded selector wait rather than allowing arbitrary scripts or unbounded delays.
Rank #3
- 【Full HD 1080P Webcam】Powered by a 1080p FHD two-MP CMOS, the NexiGo N60 Webcam produces exceptionally sharp and clear videos at resolutions up to 1920 x 1080 with 30fps. The 3.6mm glass lens provides a crisp image at fixed distances and is optimized between 19.6 inches to 13 feet, making it ideal for almost any indoor use.
- 【Wide Compatibility】Works with USB 2.0/3.0, no additional drivers required. Ready to use in approximately one minute or less on any compatible device. Compatible with Mac OS X 10.7 and higher / Windows 7, 8, 10 & 11 / Android 4.0 or higher / Linux 2.6.24 / Chrome OS 29.0.1547 / Ubuntu Version 10.04 or above. Not compatible with XBOX/PS4/PS5.
- 【Built-in Noise-Cancelling Microphone】The built-in noise-canceling microphone reduces ambient noise to enhance the sound quality of your video. Great for Zoom / Facetime / Video Calling / OBS / Twitch / Facebook / YouTube / Conferencing / Gaming / Streaming / Recording / Online School.
- 【USB Webcam with Privacy Protection Cover】The privacy cover blocks the lens when the webcam is not in use. It's perfect to help provide security and peace of mind to anyone, from individuals to large companies. 【Note:】Please contact our support for firmware update if you have noticed any audio delays.
- 【Wide Compatibility】Works with USB 2.0/3.0, no additional drivers required. Ready to use in approximately one minute or less on any compatible device. Compatible with Mac OS X 10.7 and higher / Windows 7, 10 & 11, Pro / Android 4.0 or higher / Linux 2.6.24 / Chrome OS 29.0.1547 / Ubuntu Version 10.04 or above. Not compatible with XBOX/PS4/PS5.
- Use a selector wait when the result depends on a particular component appearing.
- Use a bounded delay only when the page has known delayed rendering; cap it to prevent a caller from holding a worker indefinitely.
- Consider disabling or normalizing animation where reproducible output matters.
- For pages with lazy-loaded images, scrolling or full-page capture behavior may affect what is present in the image; test the actual Puppeteer/browser version and target sites.
Puppeteer provides a high-level JavaScript interface for browser automation and screenshots, and runs headless by default. Chrome DevTools Protocol is a lower-level alternative with a Page.captureScreenshot method and format, quality, and clipping parameters. Prefer Puppeteer for a conventional Node.js service unless direct protocol-level control is an explicit requirement.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Prevent arbitrary-URL access from becoming a security flaw
A public screenshot endpoint is also a browser-navigation endpoint for URLs selected by its callers. Checking that the URL parses and uses HTTP or HTTPS—as the sample does—is not a complete security policy and does not make an open service safe. Before exposing it publicly, have an engineer define and test controls for internal and private IP ranges, DNS resolution and rebinding, redirects, non-HTTP schemes, local services, downloads, request size and duration, and outbound network access. This checklist is not a complete defense specification.
- Isolate browser workers from sensitive networks and credentials; do not give them ambient access to internal services.
- Apply network-level egress restrictions as well as application validation, and account for destination changes during DNS resolution and redirects.
- Limit request body size, navigation duration, page dimensions, and output size.
- Do not permit arbitrary caller-supplied browser arguments, headers, cookies, scripts, or executable content without a reviewed policy.
- Use authentication, quotas, and abuse monitoring before allowing public submissions.
The precise protections depend on your infrastructure and threat model. Queueing work does not mitigate URL-based risks; it only changes how rendering work is scheduled.
Rank #4
- 1080P Webcam with Cover for Video Calls - EMEET computer webcam provides design and Optimization for professional video streaming. Realistic 1920 x 1080p video, 5-layer anti-glare lens, providing smooth video. C960 computer camera delivers 1920x1080 video with fixed focus (11.8–118.1 inches), so as to provide a clearer image. C960 USB webcam has a cover and can be removed automatically to meet your needs for privacy. For optimal image performance, use the webcam in a well-lit environment.
- Built-in 2 Omnidirectional Mics - EMEET webcam with microphone for desktop features 2 built-in omnidirectional microphones, picking up your voice to create clear audio for communication. When installing the webcam, select EMEET C960 as the default microphone input device in your computer and video applications and select C960 as the default device in Zoom/Teams and ensure microphone permissions are enabled for proper use. Please note that C960 does not include built-in speakers.
- Automatic Light Adjustment - Automatic exposure adjustment is applied in EMEET HD webcam 1080p so that the streaming webcam can deliver stable image performance. EMEET C960 camera for computer also features color adjustment and exposure optimization to help you look your best. For optimal video quality, it is recommended to use the webcam in normal or well-lit environments and select suitable video settings in your application. Proper lighting helps achieve a clearer and more balanced image.
- Plug-and-Play & Upgraded USB Connectivity - New C960 webcam features both USB Type-A & A-to-C adapter connections for wider compatibility. For stable performance, connect the webcam directly to the computer's main USB port and ensure the device is recognized correctly. If a hub or docking station is used, please ensure it provides sufficient power and stable data transmission, as limited ports may affect performance. 90° wide-angle lens captures more participants without frequent adjustments.
- High Compatibility & Multi Application - C960 webcam for laptop is compatible with Windows 10/11, macOS 10.14+, and Android TV 7.0+. Not supported: Windows Hello, TVs, tablets, or game consoles. It works with Zoom, Teams, Facetime, Google Meet, YouTube and more. Please select C960 webcam as the default camera and microphone device in your application and ensure camera/microphone permissions are enabled, especially on macOS. (Tips: Incompatible with Windows Hello)
Control retries, concurrency, and reliability
BullMQ documents worker concurrency, retries, rate limiting, and multiple workers. Start with conservative per-worker concurrency and increase it only after observing memory, CPU, browser stability, queue delay, and failure rates on representative pages. A browser capture consumes real resources, and a concurrency setting copied from another kind of job is not a sizing result for this workload.
- Retry transient failures: use bounded retries with backoff for timeouts or temporary browser failures. Do not repeatedly retry invalid input or a selector that is definitively absent.
- Make side effects retry-safe: stable job IDs can help suppress duplicate submissions, but a retry can still repeat capture work. Choose whether a retry overwrites a file or writes a versioned output, and ensure status reflects the final attempt.
- Set queue rate limits: protect your browser pool and any external target sites from sudden bursts; also impose per-caller quotas at the API layer.
- Watch stalled jobs and worker recovery: use BullMQ’s production guidance for the deployed version, and decide how to alert on growing queue age, repeated failures, or workers that stop making progress.
- Keep payloads small: put request options in Redis jobs, not screenshot bytes. Store outputs in a file or object store and keep only the metadata or object reference in the job result.
BullMQ describes its goal as “Exactly once queue semantics,” while qualifying that delivery is at least once in the worst case. Do not interpret that description as a guarantee that external effects such as writing a screenshot can never repeat.
PC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPersist and deliver results with an explicit lifecycle
The sample writes files locally to keep the mechanics concrete. That is suitable only when the API and worker can access the same persistent filesystem and the service accepts its availability limits. In a multi-host deployment, use storage accessible to both the worker and result-delivery path, and store the object reference and metadata rather than binary data in Redis.
Best Value
- Compatible with Nintendo Switch 2’s new GameChat mode
- HD lighting adjustment and autofocus: The Logitech webcam automatically fine-tunes the lighting, producing bright, razor-sharp images even in low-light settings. This makes it a great webcam for streaming and an ideal web camera for laptop use
- Advanced capture software: Easily create and share video content with this Logitech camera that is suitable for use as a desktop computer camera or a monitor webcam
- Stereo audio with dual mics: Capture natural sound during calls and recorded videos with this 1080p webcam, great as a video conference camera or a computer webcam
- Full HD 1080p video calling and recording at 30 fps. You'll make a strong impression with this PC webcam that features crisp, clearly detailed, and vibrantly colored video
- Decide how long screenshots and job records remain available, then implement cleanup for both.
- Protect result retrieval with the same caller identity or a deliberately scoped, expiring link.
- Return a clear state for queued, active, completed, and failed jobs, with a useful error category that does not leak secrets.
- Record capture time, requested format, and relevant options if callers need auditability or support diagnostics.
Storage retention, result access, and billing are not specified by Puppeteer or BullMQ; set them according to your privacy, cost, and product requirements.
Performance and cost: measure the workload you actually serve
There is no defensible universal number for browser memory, captures per second, latency, or cost from the available library documentation. Benchmark representative pages in your intended deployment. Measure queue wait separately from browser execution so you can tell whether a backlog comes from worker capacity, slow targets, or failed navigation.
- Track queue age, time to first worker, navigation duration, capture duration, output bytes, retry rate, and failure category.
- Compare memory and CPU at different worker concurrency settings before raising the limit.
- Test a mix of short and slow pages, full-page captures, selector captures, and pages with delayed resources.
- Set timeouts and result-retention rules based on observed usage rather than leaving browser work or stored files unbounded.
Common failures and practical fixes
| Symptom | Likely cause | What to check or change |
|---|---|---|
| Jobs remain queued | No worker is connected, Redis is unreachable, or the worker process failed at startup. | Check the worker logs, ROLE, Redis URL and connectivity, and that API and worker use the same queue name. |
| Navigation times out | The site is slow, unreachable from the worker, or never reaches the chosen event. | Check worker egress and DNS, classify the failure, and choose a bounded readiness condition suitable for that page. |
| The screenshot is blank or incomplete | The page rendered later than the selected readiness condition, or content depends on lazy loading or animation. | Wait for a relevant selector or use a bounded site-appropriate delay; inspect the target page behavior rather than globally increasing every timeout. |
| Element capture fails | The selector is invalid, the element does not appear in time, or the page changed. | Validate selector input, inspect the failed job reason, and wait for a matching element only when element capture was requested. |
| Worker memory grows or becomes unstable | Concurrency is too high for the target workload, pages are unusually heavy, or browser/page lifecycle cleanup is incomplete. | Lower concurrency, ensure pages close in a finally path, and measure representative jobs before scaling back up. |
| Completed status but image is missing | Output storage is local to another host, the file was removed, or the output directory differs between processes. | Use shared or object storage, configure the same output location, and align file retention with job-record retention. |
| Duplicate files or repeated captures | A client retried after an uncertain response, or the queue retried a failed attempt. | Define idempotency behavior and make output naming/overwrite policy deliberate; do not assume a retry cannot repeat work. |
| Unexpected access to a private destination | Basic URL parsing does not prevent unsafe destinations, DNS changes, or redirects. | Disable public access until a dedicated URL-navigation security policy and network isolation have been reviewed and tested. |
Or skip the browser setup
ScreenshotNeo is a website screenshot API and MCP server for developers. It accepts cookie and consent banners before capture and removes 60+ known consent platforms, newsletter popups, and chat widgets; each of those steps can be turned off. Bot checks/CAPTCHAs, blank pages, timeouts, failed loads, and cache hits are not billed, and responses identify the page verdict and billing status in headers. Its MCP server lets AI agents use take_screenshot, get_page_info, and capture_pdf.
Recommended Free Tools
One GET request can return a screenshot or PDF. For example, this cURL request saves a WebP capture of Stripe; see the ScreenshotNeo API documentation for request options:
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpEquivalent Python call:
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)Equivalent Node.js call:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);The Free plan includes 1,000 screenshots per month with no card; paid plans start at $5 for 3,000 screenshots. Sign up for free and try ScreenshotNeo.
FAQ
Should the API return the screenshot bytes immediately?
For this queue-backed design, return a job ID and let the caller retrieve the result later. Returning bytes immediately would keep the HTTP request tied to browser rendering and change the service back toward synchronous capture.
Should each job launch a new browser?
The example reuses one browser per worker process and creates a fresh page for each job. Browser lifecycle is an operational choice: test stability and resource use with your workload, and plan how the worker replaces a disconnected or unhealthy browser.
Do these 3 things before closing this tab:
1Fix the driver behind crashes, sound loss and screen glitches2Clear out junk files and repair common Windows errors3Scan for outdated or missing drivers - takes under a minuteQuick Recap
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.
