Screenshot API for developers Capture any web page with one API call.

cURL

curl -G "https://api.urlshot.io/v1/screenshot" \
  -H "Authorization: Bearer $URLSHOT_API_KEY" \
  --data-urlencode "url=https://example.com" \
  --data-urlencode "full_page=true" \
  --output screenshot.png

Node.js

const params = new URLSearchParams({
  url: 'https://example.com',
  format: 'webp',
  full_page: 'true',
});

const response = await fetch(`https://api.urlshot.io/v1/screenshot?${params.toString()}`, {
  headers: { Authorization: `Bearer ${process.env.URLSHOT_API_KEY}` },
});

if (!response.ok) {
  // Every non-2xx response is the JSON envelope, never image bytes.
  const { error } = await response.json();
  throw new Error(`${error.code}: ${error.message} (request ${error.requestId})`);
}

const image = Buffer.from(await response.arrayBuffer());

Python

import os, requests

response = requests.get(
    "https://api.urlshot.io/v1/screenshot",
    headers={"Authorization": f"Bearer {os.environ['URLSHOT_API_KEY']}"},
    params={"url": "https://example.com", "format": "jpeg", "quality": 90},
    timeout=60,
)

if response.status_code != 200:
    error = response.json()["error"]
    raise RuntimeError(f"{error['code']}: {error['message']} ({error['requestId']})")

open("screenshot.jpg", "wb").write(response.content)

PHP

<?php
// Requires the PHP cURL extension.
$params = http_build_query([
    'url' => 'https://example.com',
    'viewport_width' => 1280,
    'full_page' => 'true',
]);

$request = curl_init('https://api.urlshot.io/v1/screenshot?' . $params);
curl_setopt_array($request, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . getenv('URLSHOT_API_KEY')],
    CURLOPT_TIMEOUT => 60,
]);

$body = curl_exec($request);
if ($body === false) {
    throw new RuntimeException('Screenshot request failed: ' . curl_error($request));
}

if (curl_getinfo($request, CURLINFO_RESPONSE_CODE) !== 200) {
    $error = json_decode($body, true, 512, JSON_THROW_ON_ERROR)['error'];
    throw new RuntimeException(
        $error['code'] . ': ' . $error['message'] . ' (request ' . $error['requestId'] . ')'
    );
}

if (file_put_contents('screenshot.png', $body) === false) {
    throw new RuntimeException('Could not write screenshot.png');
}

Ruby

require "json"
require "net/http"

uri = URI("https://api.urlshot.io/v1/screenshot")
uri.query = URI.encode_www_form(
  url: "https://example.com",
  viewport_width: 1280,
  full_page: true,
)

request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch("URLSHOT_API_KEY")}"

response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", read_timeout: 60) do |http|
  http.request(request)
end

unless response.is_a?(Net::HTTPSuccess)
  # Every non-2xx response is the JSON envelope, never image bytes.
  error = JSON.parse(response.body).fetch("error")
  raise "#{error["code"]}: #{error["message"]} (request #{error["requestId"]})"
end

File.binwrite("screenshot.png", response.body)

Java

// Java 11 or later. No dependencies.
import java.net.URI;
import java.net.URLEncoder;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;

public class Screenshot {
    public static void main(String[] args) throws Exception {
        Map<String, String> params = new LinkedHashMap<>();
        params.put("url", "https://example.com");
        params.put("viewport_width", "1280");
        params.put("full_page", "true");

        String query = params.entrySet().stream()
            .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "="
                + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
            .collect(Collectors.joining("&"));

        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.urlshot.io/v1/screenshot?" + query))
            .header("Authorization", "Bearer " + System.getenv("URLSHOT_API_KEY"))
            .timeout(Duration.ofSeconds(60))
            .build();

        HttpResponse<byte[]> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofByteArray());

        if (response.statusCode() != 200) {
            // Every non-2xx response is the JSON envelope, never image bytes. Java has no JSON
            // parser built in, so this reports it whole: code, message and requestId are all in it.
            throw new IllegalStateException(new String(response.body(), StandardCharsets.UTF_8));
        }

        Files.write(Path.of("screenshot.png"), response.body());
    }
}

C# / .NET

// .NET 6 or later: a `dotnet new console` project. No packages.
using System.Net.Http.Headers;
using System.Text.Json;

var query = await new FormUrlEncodedContent(new Dictionary<string, string>
{
    ["url"] = "https://example.com",
    ["viewport_width"] = "1280",
    ["full_page"] = "true",
}).ReadAsStringAsync();

using var client = new HttpClient { Timeout = TimeSpan.FromSeconds(60) };
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(
    "Bearer", Environment.GetEnvironmentVariable("URLSHOT_API_KEY"));

using var response = await client.GetAsync($"https://api.urlshot.io/v1/screenshot?{query}");

if (!response.IsSuccessStatusCode)
{
    // Every non-2xx response is the JSON envelope, never image bytes.
    using var body = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    var error = body.RootElement.GetProperty("error");
    throw new InvalidOperationException(
        $"{error.GetProperty("code")}: {error.GetProperty("message")} (request {error.GetProperty("requestId")})");
}

await File.WriteAllBytesAsync("screenshot.png", await response.Content.ReadAsByteArrayAsync());

Go

package main

import (
	"encoding/json"
	"io"
	"log"
	"net/http"
	"net/url"
	"os"
	"time"
)

func main() {
	query := url.Values{}
	query.Set("url", "https://example.com")
	query.Set("viewport_width", "1280")
	query.Set("full_page", "true")

	request, err := http.NewRequest(http.MethodGet, "https://api.urlshot.io/v1/screenshot?"+query.Encode(), nil)
	if err != nil {
		log.Fatal(err)
	}
	request.Header.Set("Authorization", "Bearer "+os.Getenv("URLSHOT_API_KEY"))

	client := &http.Client{Timeout: 60 * time.Second}
	response, err := client.Do(request)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()

	body, err := io.ReadAll(response.Body)
	if err != nil {
		log.Fatal(err)
	}

	if response.StatusCode != http.StatusOK {
		// Every non-2xx response is the JSON envelope, never image bytes.
		var envelope struct {
			Error struct {
				Code      string `json:"code"`
				Message   string `json:"message"`
				RequestID string `json:"requestId"`
			} `json:"error"`
		}
		if err := json.Unmarshal(body, &envelope); err != nil {
			log.Fatal(err)
		}
		log.Fatalf("%s: %s (request %s)", envelope.Error.Code, envelope.Error.Message, envelope.Error.RequestID)
	}

	if err := os.WriteFile("screenshot.png", body, 0o644); err != nil {
		log.Fatal(err)
	}
}