For sites rendered on the server and the client

See the page a visitor gets before the JavaScript takes over

Capture the page when its HTML first arrives and again once its scripts have run, side by side.

Get your free API key Try the playground

The problem

On a slow phone, the first moments of a page are whatever the server sent: the full layout, a spinner, or unstyled text that jumps when the styles and scripts arrive. Developers on fast machines never see that state, so it never gets fixed.

How domscout handles it

captureMode: skeleton takes one image at DOMContentLoaded, when the HTML has been parsed but before the page has settled, and a second after its scripts have run and the network has gone quiet. They come back as skeletonBase64 and hydratedBase64. A large difference between the two is a page that relies on JavaScript for its first impression, and a nearly empty first image is what a slow connection shows first.

Where it shows up

A check that server-rendered pages arrive with their layout in place.
Reviewing loading skeletons and placeholders as visitors see them.
Spotting content that jumps once the scripts run.

The request

POST /screenshot. Available on every plan, including the free Hobby plan. A skeleton capture costs 2 credits, because the page is captured twice.

cURL

curl -X POST https://api.domscout.io/screenshot \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://www.example.com/",
    "captureMode": "skeleton",
    "format": "webp",
    "responseType": "json"
  }'

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://www.example.com/",
    captureMode: "skeleton",
    format: "webp",
    responseType: "json"
  }),
});
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://www.example.com/",
        "captureMode": "skeleton",
        "format": "webp",
        "responseType": "json"
    },
)
print(response.json())

package main

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

func main() {
	body, _ := json.Marshal(map[string]any{
		"url": "https://www.example.com/",
		"captureMode": "skeleton",
		"format": "webp",
		"responseType": "json",
	})
	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://www.example.com/',
        'captureMode' => 'skeleton',
        'format' => 'webp',
        'responseType' => 'json'
    ]),
]);
$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://www.example.com/",
    captureMode: "skeleton",
    format: "webp",
    responseType: "json"
  }.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://www.example.com/",
                "captureMode": "skeleton",
                "format": "webp",
                "responseType": "json"
            }
            """;
        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://www.example.com/",
    captureMode = "skeleton",
    format = "webp",
    responseType = "json"
});
Console.WriteLine(await response.Content.ReadAsStringAsync());

Go further

JavaScript SEO checks

Page weight and load metrics

Screenshot API

More in Testing and QA: Responsive layout checks · Visual regression testing · JavaScript error checks · Signup and checkout flow checks · Hover, focus and dark mode screenshots · Localization screenshots · Unlabelled control checks · A screenshot of every step · Embedded widget checks · Screenshots for support tickets · Ad landing page checks · Selectors for test automation · Print layout checks · All use cases

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