For teams that need a record

Keep proof of what a page said on the day it said it

Save an image or PDF of what the browser saw, with the text alongside, as a side effect of work you already do.

Get your free API key Try the playground

The problem

A dispute, an audit, a takedown, a claim about what your terms used to be. A saved copy of the HTML is not persuasive, and neither is a description. What settles it is an image of the page as a browser rendered it, with the date attached, and the moment you need one is always after the page has changed.

How domscout handles it

Every capture can return an image or a PDF of what the browser saw, alongside the extracted text. With save turned on, the capture is retained on your plan's schedule and can be pulled back from the dashboard or the API, so the record is created as a side effect of the work you were already doing.

Where it shows up

Archival of terms, disclosures and public filings on a schedule.
Evidence capture inside a support or trust-and-safety workflow.
Client-ready PDF reports generated from live pages.

The request

POST /screenshot. Saved captures are kept for up to 7 days on Hobby, 30 on Pro, 90 on Business and 365 on Enterprise. PDF output starts at Pro.

cURL

curl -X POST https://api.domscout.io/screenshot \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/terms",
    "save": true,
    "extractMarkdown": true
  }'

Node.js

const response = await fetch("https://api.domscout.io/screenshot", {
  method: "POST",
  headers: { "Content-Type": "application/json", "x-api-key": "YOUR_API_KEY" },
  body: JSON.stringify({
    url: "https://example.com/terms",
    save: true,
    extractMarkdown: true
  }),
});
console.log(await response.json());

Python

import requests

response = requests.post(
    "https://api.domscout.io/screenshot",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "url": "https://example.com/terms",
        "save": True,
        "extractMarkdown": True
    },
)
print(response.json())

package main

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

func main() {
	body, _ := json.Marshal(map[string]any{
		"url": "https://example.com/terms",
		"save": true,
		"extractMarkdown": true,
	})
	req, _ := http.NewRequest("POST", "https://api.domscout.io/screenshot", bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("x-api-key", "YOUR_API_KEY")

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

	raw, _ := io.ReadAll(res.Body)
	fmt.Println(string(raw))
}

PHP

<?php
$ch = curl_init('https://api.domscout.io/screenshot');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ['Content-Type: application/json', 'x-api-key: YOUR_API_KEY'],
    CURLOPT_POSTFIELDS => json_encode([
        'url' => 'https://example.com/terms',
        'save' => true,
        'extractMarkdown' => true
    ]),
]);
$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
echo $response;

Ruby

require "json"
require "net/http"

response = Net::HTTP.post(
  URI("https://api.domscout.io/screenshot"),
  {
    url: "https://example.com/terms",
    save: true,
    extractMarkdown: true
  }.to_json,
  "Content-Type" => "application/json",
  "x-api-key" => "YOUR_API_KEY"
)
puts response.body

Java

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Capture {
    public static void main(String[] args) throws Exception {
        String body = """
            {
                "url": "https://example.com/terms",
                "save": true,
                "extractMarkdown": true
            }
            """;
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.domscout.io/screenshot"))
            .header("Content-Type", "application/json")
            .header("x-api-key", "YOUR_API_KEY")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();
        HttpResponse<String> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

using System.Net.Http.Json;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var response = await client.PostAsJsonAsync("https://api.domscout.io/screenshot", new {
    url = "https://example.com/terms",
    save = true,
    extractMarkdown = true
});
Console.WriteLine(await response.Content.ReadAsStringAsync());

Go further

Screenshot API

Try a screenshot

Other use cases: Web access for AI agents · Website change monitoring · Crawling a whole site · SEO regression checks · Thumbnails and link previews · PDFs from your own HTML · Structured data from web pages · Link preview checks · Responsive layout checks

Give your product a browser.

Get clean web content and visual proof into your workflow in minutes.

Get your free API key Read the docs