Capture Website Screenshots with a REST API

Need to capture a screenshot of any website from your backend, CI pipeline, or automation script? The Apixies Screenshot API lets you render a URL and receive a pixel-perfect PNG or JPEG image in a single HTTP request -- no headless browser infrastructure to maintain.

How the Screenshot API Works

The endpoint accepts a GET request with the target URL as a query parameter. Behind the scenes, a real Chromium browser loads the page, waits for rendering to complete, and streams back a binary image.

GET https://apixies.io/api/v1/screenshot?url=https://example.com

The response is the raw image bytes with the appropriate Content-Type header (image/png or image/jpeg). There is no JSON wrapper -- you save the response body directly to a file or pass it downstream.

Authentication

Pass your API key in the X-API-Key header. You can start testing immediately: anonymous requests are allowed at 20 requests per day, and a free registered account unlocks 75 requests/day -- more than enough for development and light production workloads.

curl -H "X-API-Key: YOUR_API_KEY" \
  "https://apixies.io/api/v1/screenshot?url=https://example.com" \
  -o screenshot.png

Get a free API key to raise your daily limit and unlock additional features.

Available Parameters

The endpoint exposes five parameters that cover the most common screenshot scenarios:

See the full Screenshot API reference for details on rate limits, error codes, and response headers.

Step-by-Step: Your First Screenshot

1. Capture a Simple Screenshot

The quickest way to test is with cURL. This command saves a 1280x800 viewport screenshot of example.com as a PNG file:

curl -H "X-API-Key: YOUR_API_KEY" \
  "https://apixies.io/api/v1/screenshot?url=https://example.com" \
  -o example.png

2. Change the Viewport Size

If you need a mobile-width screenshot or a wide desktop capture, set width and height:

curl -H "X-API-Key: YOUR_API_KEY" \
  "https://apixies.io/api/v1/screenshot?url=https://example.com&width=375&height=812" \
  -o mobile-screenshot.png

A 375x812 viewport simulates an iPhone-sized screen -- useful for verifying responsive layouts or generating mobile-specific thumbnails.

3. Request JPEG Instead of PNG

JPEG files are significantly smaller, which matters when you are storing thousands of thumbnails or serving them over a bandwidth-constrained connection:

curl -H "X-API-Key: YOUR_API_KEY" \
  "https://apixies.io/api/v1/screenshot?url=https://example.com&format=jpeg" \
  -o example.jpg

PNG is lossless and better for text-heavy pages or design accuracy checks. JPEG is ideal when file size matters more than pixel-perfect fidelity.

4. Capture the Full Page

By default, the API returns only the visible viewport. Pass full_page=true to render the entire scrollable document as a single tall image:

curl -H "X-API-Key: YOUR_API_KEY" \
  "https://apixies.io/api/v1/screenshot?url=https://example.com&full_page=true" \
  -o full-page.png

Full-page mode is covered in depth in the full-page screenshot guide.

Code Examples

JavaScript (Node.js)

const fs = require("fs");

async function captureScreenshot(url) {
  const endpoint = "https://apixies.io/api/v1/screenshot";
  const params = new URLSearchParams({ url, width: "1280", format: "png" });

  const response = await fetch(`${endpoint}?${params}`, {
    headers: { "X-API-Key": process.env.APIXIES_KEY },
  });

  if (!response.ok) {
    throw new Error(`Screenshot failed: ${response.status}`);
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  fs.writeFileSync("screenshot.png", buffer);
  console.log("Saved screenshot.png");
}

captureScreenshot("https://example.com");

Python

import requests
import os

api_key = os.environ["APIXIES_KEY"]

response = requests.get(
    "https://apixies.io/api/v1/screenshot",
    params={"url": "https://example.com", "format": "png", "width": 1280},
    headers={"X-API-Key": api_key},
)
response.raise_for_status()

with open("screenshot.png", "wb") as f:
    f.write(response.content)

print("Saved screenshot.png")

PHP

$apiKey = getenv('APIXIES_KEY');

$query = http_build_query([
    'url'    => 'https://example.com',
    'format' => 'png',
    'width'  => 1280,
]);

$ch = curl_init("https://apixies.io/api/v1/screenshot?{$query}");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["X-API-Key: {$apiKey}"]);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$image = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

if ($status === 200) {
    file_put_contents('screenshot.png', $image);
    echo "Saved screenshot.png\n";
}

Viewport vs. Full-Page Screenshots

Understanding the difference between these two modes is important for choosing the right approach:

• Viewport screenshot (full_page=false, the default) -- renders only the area visible inside the browser window at the given width and height. This is the equivalent of what a user sees without scrolling. Ideal for thumbnails, link previews, and OG images.
• Full-page screenshot (full_page=true) -- renders the entire document from top to bottom regardless of viewport height. The resulting image can be very tall for long pages, making it well-suited for archival, QA testing, and design review.

If you are generating link preview images, check out the dedicated link preview guide for tips on sizing and caching.

Common Use Cases

• Link previews and OG images -- generate a thumbnail for every URL your users submit.
• Automated QA and visual regression -- screenshot staging pages in CI and compare against baselines.
• Archival and compliance -- save a visual record of a page at a specific point in time.
• Monitoring dashboards -- display a live preview of external sites without embedding iframes.
• PDF alternatives -- when you need a quick visual snapshot instead of a full PDF conversion.

Tips for Reliable Screenshots

1. URL-encode the url parameter -- special characters in query strings can break the request. In most languages, use the built-in URL encoding function (encodeURIComponent in JavaScript, urllib.parse.quote in Python, urlencode in PHP).
2. Use JPEG for thumbnails -- if you are serving small preview images, JPEG keeps file sizes low without visible quality loss at thumbnail scale.
3. Set realistic viewport dimensions -- a 1280x800 default works for most desktop pages; use 375x812 for mobile.
4. Handle errors gracefully -- if the target site is slow or unreachable, the API returns an appropriate HTTP error code. Retry with exponential backoff for transient failures.
5. Cache aggressively -- if the target page does not change often, store the screenshot locally and refresh on a schedule rather than re-requesting every time.

Next Steps

The free tier gives you 75 requests/day with a free account, which is enough to integrate screenshots into a side project, internal tool, or staging environment. When you are ready for higher volume, paid plans are available.

• Screenshot API documentation -- full parameter reference and error codes.
• Build link previews -- generate social sharing thumbnails automatically.
• Full-page screenshots -- capture long scrollable pages in one image.
• All guides -- browse every tutorial and use case.

Get your free API key and start capturing screenshots in minutes.