Web screenshot API for developers and agents

curl -X POST "https://shotkit.net/api/take" \
  -H "X-Access-Key: YOUR_ACCESS_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://github.com","format":"png","full_page":true,"block_cookie_banners":true,"dark_mode":true}' \
  --fail-with-body -o shot.png

import { writeFile } from "node:fs/promises";

const res = await fetch("https://shotkit.net/api/take", {
  method: "POST",
  headers: { "X-Access-Key": "YOUR_ACCESS_KEY", "Content-Type": "application/json" },
  body: JSON.stringify({
    "url": "https://github.com",
    "format": "png",
    "full_page": true,
    "block_cookie_banners": true,
    "dark_mode": true
  }),
});
if (!res.ok) throw new Error((await res.json()).error_message);
await writeFile("shot.png", Buffer.from(await res.arrayBuffer()));

import requests

res = requests.post(
    "https://shotkit.net/api/take",
    headers={"X-Access-Key": "YOUR_ACCESS_KEY"},
    json={
      "url": "https://github.com",
      "format": "png",
      "full_page": True,
      "block_cookie_banners": True,
      "dark_mode": True
    },
    timeout=90,
)
res.raise_for_status()
open("shot.png", "wb").write(res.content)

package main

import (
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := `{
	  "url": "https://github.com",
	  "format": "png",
	  "full_page": true,
	  "block_cookie_banners": true,
	  "dark_mode": true
	}`
	req, _ := http.NewRequest("POST", "https://shotkit.net/api/take", strings.NewReader(body))
	req.Header.Set("X-Access-Key", "YOUR_ACCESS_KEY")
	req.Header.Set("Content-Type", "application/json")
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		msg, _ := io.ReadAll(res.Body)
		panic(string(msg))
	}
	f, _ := os.Create("shot.png")
	defer f.Close()
	io.Copy(f, res.Body)
}

require "net/http"

uri = URI("https://shotkit.net/api/take")
body = <<~'JSON'
  {
    "url": "https://github.com",
    "format": "png",
    "full_page": true,
    "block_cookie_banners": true,
    "dark_mode": true
  }
JSON

res = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", read_timeout: 90) do |http|
  http.post(uri.path, body, "X-Access-Key" => "YOUR_ACCESS_KEY", "Content-Type" => "application/json")
end
raise res.body unless res.is_a?(Net::HTTPSuccess)
File.binwrite("shot.png", res.body)

<?php

$body = <<<'JSON'
{
  "url": "https://github.com",
  "format": "png",
  "full_page": true,
  "block_cookie_banners": true,
  "dark_mode": true
}
JSON;

$ch = curl_init("https://shotkit.net/api/take");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => ["X-Access-Key: YOUR_ACCESS_KEY", "Content-Type: application/json"],
    CURLOPT_POSTFIELDS => $body,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 90,
]);
$res = curl_exec($ch);
if (curl_getinfo($ch, CURLINFO_HTTP_CODE) !== 200) {
    throw new Exception($res);
}
file_put_contents("shot.png", $res);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Path;
import java.time.Duration;

public class Screenshot {
    public static void main(String[] args) throws Exception {
        String body = """
            {
              "url": "https://github.com",
              "format": "png",
              "full_page": true,
              "block_cookie_banners": true,
              "dark_mode": true
            }
            """;
        HttpRequest req = HttpRequest.newBuilder(URI.create("https://shotkit.net/api/take"))
            .header("X-Access-Key", "YOUR_ACCESS_KEY")
            .header("Content-Type", "application/json")
            .timeout(Duration.ofSeconds(90))
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<byte[]> res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofByteArray());
        if (res.statusCode() != 200) throw new RuntimeException(new String(res.body()));
        java.nio.file.Files.write(Path.of("shot.png"), res.body());
    }
}

using System.Text;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(90) };
http.DefaultRequestHeaders.Add("X-Access-Key", "YOUR_ACCESS_KEY");

var body = """
    {
      "url": "https://github.com",
      "format": "png",
      "full_page": true,
      "block_cookie_banners": true,
      "dark_mode": true
    }
    """;
var res = await http.PostAsync("https://shotkit.net/api/take", new StringContent(body, Encoding.UTF8, "application/json"));
if (!res.IsSuccessStatusCode) throw new Exception(await res.Content.ReadAsStringAsync());
await File.WriteAllBytesAsync("shot.png", await res.Content.ReadAsByteArrayAsync());

import java.io.File
import java.net.URI
import java.net.http.HttpClient
import java.net.http.HttpRequest
import java.net.http.HttpResponse
import java.time.Duration

fun main() {
    val body = """
        {
          "url": "https://github.com",
          "format": "png",
          "full_page": true,
          "block_cookie_banners": true,
          "dark_mode": true
        }
    """.trimIndent()
    val req = HttpRequest.newBuilder(URI.create("https://shotkit.net/api/take"))
        .header("X-Access-Key", "YOUR_ACCESS_KEY")
        .header("Content-Type", "application/json")
        .timeout(Duration.ofSeconds(90))
        .POST(HttpRequest.BodyPublishers.ofString(body))
        .build()
    val res = HttpClient.newHttpClient().send(req, HttpResponse.BodyHandlers.ofByteArray())
    check(res.statusCode() == 200) { String(res.body()) }
    File("shot.png").writeBytes(res.body())
}

// Cargo.toml: reqwest = { version = "0.12", features = ["blocking"] }
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let body = r#"{
      "url": "https://github.com",
      "format": "png",
      "full_page": true,
      "block_cookie_banners": true,
      "dark_mode": true
    }"#;
    let res = reqwest::blocking::Client::new()
        .post("https://shotkit.net/api/take")
        .header("X-Access-Key", "YOUR_ACCESS_KEY")
        .header("Content-Type", "application/json")
        .timeout(Duration::from_secs(90))
        .body(body)
        .send()?;
    if !res.status().is_success() {
        return Err(res.text()?.into());
    }
    std::fs::write("shot.png", res.bytes()?)?;
    Ok(())
}

import Foundation

var req = URLRequest(url: URL(string: "https://shotkit.net/api/take")!)
req.httpMethod = "POST"
req.timeoutInterval = 90
req.setValue("YOUR_ACCESS_KEY", forHTTPHeaderField: "X-Access-Key")
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
req.httpBody = #"""
{
  "url": "https://github.com",
  "format": "png",
  "full_page": true,
  "block_cookie_banners": true,
  "dark_mode": true
}
"""#.data(using: .utf8)

let (data, res) = try await URLSession.shared.data(for: req)
guard (res as! HTTPURLResponse).statusCode == 200 else {
    fatalError(String(decoding: data, as: UTF8.self))
}
try data.write(to: URL(fileURLWithPath: "shot.png"))

Mix.install([{:req, "~> 0.5"}])

body = ~S"""
{
  "url": "https://github.com",
  "format": "png",
  "full_page": true,
  "block_cookie_banners": true,
  "dark_mode": true
}
"""

res =
  Req.post!("https://shotkit.net/api/take",
    headers: [{"x-access-key", "YOUR_ACCESS_KEY"}, {"content-type", "application/json"}],
    body: body,
    receive_timeout: 90_000,
    decode_body: false
  )

if res.status != 200, do: raise(res.body)
File.write!("shot.png", res.body)

https://shotkit.net/api/take?access_key=YOUR_ACCESS_KEY&url=https%3A%2F%2Fgithub.com&format=png&full_page=true&block_cookie_banners=true&dark_mode=true