DEV Community: alekseykazandaev

How to Take a Website Screenshot with PHP

alekseykazandaev — Mon, 06 Apr 2026 18:09:26 +0000

PHP still powers a lot of real-world web applications, so screenshot generation fits naturally into CMS plugins, monitoring tools, and link preview workflows. This Dev.to version keeps the original examples intact while tightening the framing for developers who want a straightforward API-based approach.

Prerequisites

PHP 7.4+ with the cURL extension enabled
A Site-Shot API key (sign up here)

Basic Screenshot Capture

<?php

$params = http_build_query([
    'url'     => 'https://example.com',
    'userkey' => 'YOUR_API_KEY',
    'width'   => 1280,
    'height'  => 1024,
    'format'  => 'png',
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

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

if ($httpCode === 200 && $image) {
    file_put_contents('screenshot.png', $image);
    echo "Screenshot saved.\n";
} else {
    echo "Error: HTTP {$httpCode}\n";
}

The API returns the raw image bytes. Just save them to a file or serve them to the browser.

Full Page Screenshot

To capture the entire scrollable page:

$params = http_build_query([
    'url'        => 'https://example.com',
    'userkey'    => 'YOUR_API_KEY',
    'full_size'  => 1,
    'max_height' => 15000,
    'format'     => 'png',
]);

JSON Response with Base64

If you need the image as base64 along with HTTP metadata:

<?php

$params = http_build_query([
    'url'           => 'https://example.com',
    'userkey'       => 'YOUR_API_KEY',
    'width'         => 1280,
    'height'        => 1024,
    'format'        => 'png',
    'response_type' => 'json',
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);

if (!empty($data['error'])) {
    die("API error: " . $data['error']);
}

$base64 = $data['image'];
if (strpos($base64, ',') !== false) {
    $base64 = explode(',', $base64, 2)[1];
}

file_put_contents('screenshot.png', base64_decode($base64));
echo "Screenshot saved.\n";

Serving Screenshots in a Web Application

Generate and serve a thumbnail screenshot directly to the browser:

<?php

$targetUrl = $_GET['url'] ?? '';
if (empty($targetUrl)) {
    http_response_code(400);
    die('Missing url parameter');
}

$params = http_build_query([
    'url'          => $targetUrl,
    'userkey'      => 'YOUR_API_KEY',
    'width'        => 1280,
    'height'       => 800,
    'format'       => 'jpeg',
    'scaled_width' => 400,
]);

$ch = curl_init("https://api.site-shot.com/?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 70);

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

if ($httpCode === 200 && $image) {
    header('Content-Type: image/jpeg');
    header('Cache-Control: public, max-age=3600');
    echo $image;
} else {
    http_response_code(502);
    die('Screenshot failed');
}

WordPress Integration

You can integrate the screenshot API into a WordPress plugin or theme:

function site_shot_capture($url, $options = []) {
    $defaults = [
        'url'     => $url,
        'userkey' => defined('SITE_SHOT_API_KEY') ? SITE_SHOT_API_KEY : '',
        'width'   => 1280,
        'height'  => 1024,
        'format'  => 'png',
    ];

    $params = http_build_query(array_merge($defaults, $options));

    $response = wp_remote_get(
        "https://api.site-shot.com/?{$params}",
        ['timeout' => 70]
    );

    if (is_wp_error($response)) {
        return false;
    }

    return wp_remote_retrieve_body($response);
}

// Usage:
$image = site_shot_capture('https://example.com', ['full_size' => 1]);
if ($image) {
    file_put_contents('/tmp/screenshot.png', $image);
}

Summary

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`scaled_width`	Resize output	`400`

See the full API documentation for all available parameters.

Try Site-Shot free — no registration needed: https://www.site-shot.com/

How to Take a Website Screenshot with Node.js

alekseykazandaev — Mon, 06 Apr 2026 18:07:11 +0000

If you are building link previews, monitoring dashboards, or visual testing tools in Node.js, a screenshot API gives you a clean HTTP-based workflow without browser orchestration. This version is tuned for the Dev.to audience and keeps the examples focused on the most common production use cases.

Prerequisites

Node.js 18+ (for built-in fetch) or any version with axios
A Site-Shot API key (sign up here)

Using Built-in Fetch (Node.js 18+)

const fs = require('fs');

async function captureScreenshot(url, outputPath = 'screenshot.png') {
  const params = new URLSearchParams({
    url,
    userkey: 'YOUR_API_KEY',
    width: '1280',
    height: '1024',
    format: 'png',
  });

  const response = await fetch(
    `https://api.site-shot.com/?${params.toString()}`
  );

  if (!response.ok) {
    throw new Error(`API returned ${response.status}`);
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  fs.writeFileSync(outputPath, buffer);
  console.log(`Screenshot saved to ${outputPath}`);
}

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

Using Axios

const axios = require('axios');
const fs = require('fs');

async function captureScreenshot(url, outputPath = 'screenshot.png') {
  const response = await axios.get('https://api.site-shot.com/', {
    params: {
      url,
      userkey: 'YOUR_API_KEY',
      width: 1280,
      height: 1024,
      format: 'png',
    },
    responseType: 'arraybuffer',
    timeout: 70000,
  });

  fs.writeFileSync(outputPath, response.data);
  console.log(`Screenshot saved to ${outputPath}`);
}

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

Full Page Scrolling Screenshot

Capture the entire page, not just the viewport:

const params = new URLSearchParams({
  url: 'https://example.com',
  userkey: 'YOUR_API_KEY',
  full_size: '1',
  max_height: '15000',
  format: 'png',
});

const response = await fetch(
  `https://api.site-shot.com/?${params.toString()}`
);

JSON Response with Base64

Get the screenshot as base64-encoded data along with HTTP metadata:

const params = new URLSearchParams({
  url: 'https://example.com',
  userkey: 'YOUR_API_KEY',
  width: '1280',
  height: '1024',
  format: 'png',
  response_type: 'json',
});

const response = await fetch(
  `https://api.site-shot.com/?${params.toString()}`
);
const data = await response.json();

if (data.error) {
  throw new Error(data.error);
}

// Remove data URL prefix if present
let base64 = data.image;
if (base64.includes(',')) {
  base64 = base64.split(',')[1];
}

const buffer = Buffer.from(base64, 'base64');
fs.writeFileSync('screenshot.png', buffer);

Express.js Integration

Serve screenshots dynamically in an Express app:

const express = require('express');
const app = express();

app.get('/preview', async (req, res) => {
  const targetUrl = req.query.url;
  if (!targetUrl) {
    return res.status(400).send('Missing url parameter');
  }

  const params = new URLSearchParams({
    url: targetUrl,
    userkey: 'YOUR_API_KEY',
    width: '1280',
    height: '800',
    format: 'jpeg',
    scaled_width: '400',
  });

  const response = await fetch(
    `https://api.site-shot.com/?${params.toString()}`
  );

  if (!response.ok) {
    return res.status(502).send('Screenshot failed');
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  res.set('Content-Type', 'image/jpeg');
  res.set('Cache-Control', 'public, max-age=3600');
  res.send(buffer);
});

app.listen(3000);

This creates a /preview?url=https://example.com endpoint that returns a thumbnail screenshot — useful for link preview cards.

Capturing Multiple URLs

const urls = [
  'https://example.com',
  'https://wikipedia.org',
  'https://github.com',
];

const results = await Promise.all(
  urls.map(async (url) => {
    const params = new URLSearchParams({
      url,
      userkey: 'YOUR_API_KEY',
      width: '1280',
      height: '1024',
      format: 'png',
    });

    const response = await fetch(
      `https://api.site-shot.com/?${params.toString()}`
    );
    const buffer = Buffer.from(await response.arrayBuffer());
    const filename = url.replace(/https?:\/\//, '').replace(/\//g, '_') + '.png';
    fs.writeFileSync(filename, buffer);
    return filename;
  })
);

console.log('Saved:', results);

The number of concurrent requests depends on your plan's dedicated worker count.

Summary

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`scaled_width`	Resize output image	`400`

See the full API documentation and all code samples for more details.

Try Site-Shot free — no registration needed: https://www.site-shot.com/

How to Take a Website Screenshot with Python

alekseykazandaev — Mon, 06 Apr 2026 18:01:28 +0000

If you are building monitoring dashboards, link previews, or visual QA tooling in Python, a screenshot API is a practical way to avoid browser automation overhead. This post walks through the common capture patterns Dev.to readers usually care about: basic screenshots, full-page capture, JSON output, mobile emulation, geolocation, and batch jobs.

Prerequisites

Python 3.7+
The requests library (pip install requests)
A Site-Shot API key (sign up here)

Basic Screenshot Capture

The simplest approach — send a GET request to the API and save the image:

import requests

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 1280,
    "height": 1024,
    "format": "png",
}, timeout=70)

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

That's it. The API renders the page in a real Chromium browser and returns the screenshot image directly.

Full Page Screenshot

To capture the entire scrollable page, not just the viewport:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "full_size": 1,
    "max_height": 15000,
    "format": "png",
}, timeout=70)

The full_size=1 parameter tells the API to scroll through the entire document. max_height caps the capture at 15,000 pixels (max 20,000).

JSON Response with Base64 Image

If you need the image as base64 along with HTTP response metadata:

import base64
import requests

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 1280,
    "height": 1024,
    "format": "png",
    "response_type": "json",
}, timeout=70)

payload = response.json()
if payload.get("error"):
    raise RuntimeError(payload["error"])

image_b64 = payload["image"]
if "," in image_b64:
    image_b64 = image_b64.split(",", 1)[1]

with open("screenshot.png", "wb") as f:
    f.write(base64.b64decode(image_b64))

The JSON response includes the image field (base64-encoded), HTTP status_code, and response_headers from the target URL.

Mobile Device Screenshot

Emulate a mobile viewport by setting width, height, and user agent:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "width": 375,
    "height": 812,
    "zoom": 100,
    "format": "png",
    "user_agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) "
                  "AppleWebKit/605.1.15 (KHTML, like Gecko) "
                  "Version/16.0 Mobile/15E148 Safari/604.1",
}, timeout=70)

Screenshot from a Specific Country

Route the request through a country-specific proxy:

response = requests.get("https://api.site-shot.com/", params={
    "url": "https://example.com",
    "userkey": "YOUR_API_KEY",
    "country": "Germany",
    "language": "de",
    "format": "png",
}, timeout=70)

The country parameter automatically sets a proxy IP, default language, time zone, and geolocation for that country.

Batch Screenshots

To capture multiple URLs, loop through them:

import requests

API_KEY = "YOUR_API_KEY"
urls = [
    "https://example.com",
    "https://wikipedia.org",
    "https://github.com",
]

for url in urls:
    response = requests.get("https://api.site-shot.com/", params={
        "url": url,
        "userkey": API_KEY,
        "width": 1280,
        "height": 1024,
        "format": "png",
    }, timeout=70)

    filename = url.replace("https://", "").replace("/", "_") + ".png"
    with open(filename, "wb") as f:
        f.write(response.content)
    print(f"Saved {filename}")

For higher throughput, use concurrent.futures.ThreadPoolExecutor to capture multiple URLs in parallel — the API supports concurrent requests based on your plan's dedicated worker count.

Summary

The Site-Shot API makes it straightforward to capture website screenshots with Python. Key parameters:

Parameter	Description	Example
`url`	Target web page	`https://example.com`
`userkey`	Your API key	`abc123`
`width`	Viewport width (100–8000)	`1280`
`height`	Viewport height (100–20000)	`1024`
`full_size`	Capture full page	`1`
`format`	Output format	`png` or `jpeg`
`response_type`	Response format	`image` or `json`
`country`	Proxy country	`Germany`
`delay_time`	Wait before capture (ms)	`2000`

Check the full API documentation for all available parameters.

Try Site-Shot free — no registration needed: https://www.site-shot.com/