Screenshot API with Node.js and Express: Web Capture Guide

Node.js and Express power millions of web application backends. When your Express app needs to generate screenshots, SnapAPI provides a REST API that integrates naturally with Node's async patterns, Express middleware, and popular ecosystem tools like Axios, node-fetch, and got.

Installing and Configuring the SnapAPI Client

No special SDK is required. Use any HTTP client that supports binary responses. Install Axios if it is not already in your project:

npm install axios

Create lib/snapapi.js as a reusable module:

const axios = require("axios");

const SNAP_API = "https://snapapi.pics/screenshot";
const API_KEY  = process.env.SNAPAPI_KEY;

async function capture(url, options = {}) {
  const { data } = await axios.get(SNAP_API, {
    params: {
      access_key:     API_KEY,
      url,
      viewport_width: options.width    || 1280,
      full_page:      options.fullPage || false,
      format:         options.format   || "png",
    },
    responseType: "arraybuffer",
    timeout: 30000,
  });
  return Buffer.from(data);
}

module.exports = { capture };

Add SNAPAPI_KEY=your_key to your .env file and load it with dotenv. Never hardcode API keys in source files.

Express Route for On-Demand Screenshots

const express = require("express");
const snap    = require("./lib/snapapi");
const router  = express.Router();

router.post("/screenshot", async (req, res) => {
  const { url, width } = req.body;
  if (!url) return res.status(400).json({ error: "url required" });
  try {
    const img = await snap.capture(url, { width });
    res.set("Content-Type", "image/png");
    res.send(img);
  } catch (err) {
    res.status(502).json({ error: "capture failed", detail: err.message });
  }
});

module.exports = router;

Async Queue with Bull for Background Captures

For production apps, process screenshot jobs in the background using Bull and Redis:

const Queue = require("bull");
const snap  = require("./lib/snapapi");
const db    = require("./db");

const screenshotQueue = new Queue("screenshots", process.env.REDIS_URL);

screenshotQueue.process(async (job) => {
  const { recordId, url } = job.data;
  const img = await snap.capture(url);
  const key = `screenshots/${recordId}.png`;
  await uploadToS3(key, img);
  await db.records.update({ id: recordId }, { screenshotKey: key });
});

// Enqueue from your route:
// screenshotQueue.add({ recordId: record.id, url: record.url });

Use attempts: 3 and backoff: { type: "exponential", delay: 5000 } in the job options for automatic retry with backoff on failures.

Caching Screenshots with Node-Cache or Redis

const NodeCache = require("node-cache");
const cache = new NodeCache({ stdTTL: 86400 });

async function cachedCapture(url, options) {
  const key = require("crypto").createHash("md5").update(url).digest("hex");
  const hit = cache.get(key);
  if (hit) return hit;
  const img = await snap.capture(url, options);
  cache.set(key, img);
  return img;
}

For multi-instance deployments, replace node-cache with Redis-based caching using ioredis to share the cache across all Express instances.

Getting Started

Create a free account at snapapi.pics/dashboard. 200 screenshots per month, no credit card required. Full parameter reference at snapapi.pics/docs.

Production Node.js Screenshot Patterns

Node.js screenshot services that handle production traffic need more than a basic HTTP wrapper. Implement circuit breaker logic using opossum to prevent SnapAPI failures from cascading into your main application. When the circuit is open, return a placeholder image from CDN storage rather than letting errors propagate to users. Use p-queue to limit concurrent SnapAPI requests from your application, preventing burst traffic from exceeding rate limits. Add request-level timeouts using AbortController to cancel slow screenshot captures that would otherwise delay your response pipeline. These production patterns ensure your screenshot functionality degrades gracefully under load rather than failing catastrophically.

TypeScript Integration for Node.js SnapAPI Clients

TypeScript projects benefit from typed SnapAPI client interfaces. Define a CaptureOptions interface with typed parameters for all supported options. Use discriminated unions for the format parameter to enforce valid values at compile time. Return a typed CaptureResult object that includes the image buffer, response headers, and timing metadata alongside the raw binary. A well-typed SnapAPI client catches integration errors at development time and provides autocomplete support that accelerates onboarding for new team members. The additional type safety is particularly valuable in large codebases where the screenshot client is used across many different modules and services.

Next.js API Routes and Screenshot Generation

Next.js applications can expose screenshot functionality as API routes that frontend components call directly. Create pages/api/screenshot.js in your Next.js app:

import snap from "../../lib/snapapi"; export default async function handler(req, res) { const { url } = req.query; if (!url) return res.status(400).json({ error: "url required" }); const img = await snap.capture(url); res.setHeader("Content-Type", "image/png"); res.setHeader("Cache-Control", "public, max-age=86400"); res.send(img); }

The API route proxies SnapAPI on the server side, keeping your API key secure while allowing React components to request screenshots via a simple fetch call. Add authentication middleware to restrict who can trigger screenshot captures.

Node.js Screenshot Microservice Architecture

Large Node.js platforms benefit from extracting screenshot functionality into a dedicated microservice rather than embedding it in multiple application services. A screenshot microservice built on Express or Fastify provides a single internal API endpoint that all other services in your architecture call for screenshot needs. The microservice handles API key management, caching, retry logic, and CDN upload in one place. Other services call it with a simple HTTP POST and receive a screenshot URL in response. Centralizing screenshot logic reduces code duplication, makes quota monitoring easier, and allows independent scaling of screenshot capacity without affecting other services.

Webhook-Based Async Screenshot Delivery

SnapAPI supports webhook callbacks that notify your Node.js service when a screenshot is ready rather than waiting for a synchronous response. Configure a webhook URL in your SnapAPI request and SnapAPI posts the result to your endpoint when the capture completes. Your Express route receives the screenshot binary via the webhook, stores it to CDN, and updates the relevant database record. This pattern is ideal for mobile API backends where long-polling would drain battery and for serverless architectures where synchronous long requests are expensive. Node.js' event-driven architecture handles incoming webhooks efficiently without blocking other request processing.

Screenshot API in Node.js Monorepos

Node.js monorepos using Nx, Turborepo, or Yarn Workspaces benefit from a shared SnapAPI package in the packages/ directory that all workspace apps can import. Define the client, types, and caching utilities in the shared package. Each app in the monorepo imports the package and uses screenshot functionality without duplicating the integration code. When SnapAPI releases new features or you update your integration patterns, a single change to the shared package propagates to all apps. Create a free account at snapapi.pics/dashboard to get started and review the complete API documentation at snapapi.pics/docs.

SnapAPI Technical Specifications and SLA

SnapAPI runs on a distributed fleet of headless Chromium browsers with automatic failover. Each screenshot request is processed in an isolated browser context with no shared state between requests. The rendering fleet scales horizontally to absorb traffic spikes without degrading response times. Average response time for screenshots of standard web pages is 1.5 to 2.5 seconds. JavaScript-heavy single-page applications typically render in 2 to 4 seconds. Full-page captures of long-form content pages take 3 to 5 seconds depending on page height. PDF generation averages 3 to 6 seconds for standard document-length pages.

SnapAPI supports the following output parameters for all capture requests: PNG and JPEG output formats with configurable JPEG quality from 1 to 100, viewport width from 320 pixels to 2560 pixels, device scale factor from 1 to 3 for retina simulation, custom HTTP request headers for authentication and user-agent overrides, CSS injection for hiding overlays and adjusting page layout before capture, element selector for cropping to a specific DOM node, delay in milliseconds to wait before capturing after page load, block ads flag to remove advertising content from captures, proxy configuration for routing capture requests through specific IP addresses, and webhook URL for asynchronous result delivery. PDF captures additionally support page size, orientation, and margin configuration. All parameters are documented with examples at snapapi.pics/docs. Get started free with 200 screenshots per month at snapapi.pics/dashboard with no credit card required and no time limit on the free plan.