Screenshot API

const response = await fetch('https://app.html2img.com/api/screenshot', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.HTML2IMG_API_KEY,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    url: 'https://en.wikipedia.org/wiki/Screenshot',
    width: 1200,
    height: 750,
  }),
});

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

const { url } = await response.json();
console.log(url); // https://i.html2img.com/image-....png

import os
import requests

response = requests.post(
    'https://app.html2img.com/api/screenshot',
    headers={'X-API-Key': os.environ['HTML2IMG_API_KEY']},
    json={
        'url': 'https://en.wikipedia.org/wiki/Screenshot',
        'width': 1200,
        'height': 750,
    },
    timeout=60,
)
response.raise_for_status()

print(response.json()['url'])  # https://i.html2img.com/image-....png

<?php

$ch = curl_init('https://app.html2img.com/api/screenshot');

curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'X-API-Key: ' . getenv('HTML2IMG_API_KEY'),
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'url'    => 'https://en.wikipedia.org/wiki/Screenshot',
        'width'  => 1200,
        'height' => 750,
    ]),
]);

$response = json_decode(curl_exec($ch), true);
curl_close($ch);

echo $response['url']; // https://i.html2img.com/image-....png

require 'net/http'
require 'json'

uri = URI('https://app.html2img.com/api/screenshot')

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = ENV.fetch('HTML2IMG_API_KEY')
request['Content-Type'] = 'application/json'
request.body = {
  url: 'https://en.wikipedia.org/wiki/Screenshot',
  width: 1200,
  height: 750
}.to_json

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)['url']

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body, err := json.Marshal(map[string]any{
		"url":    "https://en.wikipedia.org/wiki/Screenshot",
		"width":  1200,
		"height": 750,
	})
	if err != nil {
		panic(err)
	}

	req, err := http.NewRequest(http.MethodPost, "https://app.html2img.com/api/screenshot", bytes.NewReader(body))
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("HTML2IMG_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	var result struct {
		URL string `json:"url"`
	}
	if err := json.NewDecoder(res.Body).Decode(&result); err != nil {
		panic(err)
	}

	fmt.Println(result.URL)
}

// Java 17+, no dependencies beyond the JDK.
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Screenshot {
    public static void main(String[] args) throws Exception {
        String payload = """
            {
              "url": "https://en.wikipedia.org/wiki/Screenshot",
              "width": 1200,
              "height": 750
            }
            """;

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://app.html2img.com/api/screenshot"))
            .header("X-API-Key", System.getenv("HTML2IMG_API_KEY"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        // {"success":true,"url":"https://i.html2img.com/image-....png", ...}
        System.out.println(response.body());
    }
}

using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", Environment.GetEnvironmentVariable("HTML2IMG_API_KEY"));

var response = await client.PostAsJsonAsync("https://app.html2img.com/api/screenshot", new
{
    url = "https://en.wikipedia.org/wiki/Screenshot",
    width = 1200,
    height = 750,
});

response.EnsureSuccessStatusCode();

var result = await response.Content.ReadFromJsonAsync<JsonElement>();

Console.WriteLine(result.GetProperty("url").GetString());

// Cargo.toml:
//   reqwest = { version = "0.12", features = ["json"] }
//   serde_json = "1"
//   tokio = { version = "1", features = ["full"] }
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response: Value = reqwest::Client::new()
        .post("https://app.html2img.com/api/screenshot")
        .header("X-API-Key", std::env::var("HTML2IMG_API_KEY")?)
        .json(&json!({
            "url": "https://en.wikipedia.org/wiki/Screenshot",
            "width": 1200,
            "height": 750
        }))
        .send()
        .await?
        .json()
        .await?;

    println!("{}", response["url"].as_str().unwrap_or_default());

    Ok(())
}

// app/api/screenshot/route.ts (App Router handler). Runs on the server
// so the API key never reaches the browser.
import { Html2img } from '@html2img/client';

const client = new Html2img(process.env.HTML2IMG_API_KEY!);

export async function POST(request: Request) {
  const { url } = await request.json();

  const shot = await client.screenshot({
    url,
    width: 1200,
    height: 630,
  });

  return Response.json({ image: shot.url });
}

// server/api/screenshot.post.ts
export default defineEventHandler(async (event) => {
  const { url } = await readBody<{ url: string }>(event);

  const shot = await $fetch<{ url: string }>(
    'https://app.html2img.com/api/screenshot',
    {
      method: 'POST',
      headers: { 'X-API-Key': process.env.HTML2IMG_API_KEY as string },
      body: { url, width: 1200, height: 630 },
    },
  );

  return { image: shot.url };
});

import express from 'express';
import { Html2img } from '@html2img/client';

const app = express();
const client = new Html2img(process.env.HTML2IMG_API_KEY);

// GET /preview?url=https://example.com -> redirects to the rendered PNG
app.get('/preview', async (req, res, next) => {
  try {
    const shot = await client.screenshot({
      url: req.query.url,
      width: 1200,
      height: 630,
    });

    res.redirect(shot.url);
  } catch (err) {
    next(err);
  }
});

app.listen(3000);

<?php
// composer require html2img/html2img-laravel
// HTML2IMG_API_KEY=your-api-key in .env

use Html2img\Laravel\Facades\Html2img;
use Html2img\Request\ScreenshotRequest;

$response = Html2img::screenshot(new ScreenshotRequest(
    url: 'https://en.wikipedia.org/wiki/Screenshot',
    width: 1200,
    height: 750,
));

return $response->url;

# app/services/screenshot_service.rb
require 'net/http'
require 'json'

class ScreenshotService
  ENDPOINT = URI('https://app.html2img.com/api/screenshot').freeze

  def self.capture(page_url, width: 1200, height: 750)
    request = Net::HTTP::Post.new(ENDPOINT)
    request['X-API-Key'] = Rails.application.credentials.html2img_api_key
    request['Content-Type'] = 'application/json'
    request.body = { url: page_url, width: width, height: height }.to_json

    response = Net::HTTP.start(ENDPOINT.hostname, ENDPOINT.port, use_ssl: true) do |http|
      http.request(request)
    end

    JSON.parse(response.body).fetch('url')
  end
end

# ScreenshotService.capture('https://en.wikipedia.org/wiki/Screenshot')

# screenshots/services.py
import requests
from django.conf import settings

ENDPOINT = 'https://app.html2img.com/api/screenshot'


def capture(page_url, width=1200, height=750):
    """Return the CDN URL of a PNG capture of page_url."""
    response = requests.post(
        ENDPOINT,
        headers={'X-API-Key': settings.HTML2IMG_API_KEY},
        json={'url': page_url, 'width': width, 'height': height},
        timeout=60,
    )
    response.raise_for_status()

    return response.json()['url']