Does it wait for JavaScript?

Yes. The page loads in Chromium, its scripts run, and the capture waits until the network has been quiet for half a second, up to five seconds. Content a single-page app renders in that time is in the image. Through the API, waitForSelector waits for a specific element instead.

It runs on the same capture API you would call with a key, so you can see exactly what a capture returns before you create an account. Every run is a real request: a page load in a real Chromium browser, or, for the JavaScript check and the llms.txt generator, the HTML the server sends.

3 runs an hour from each network, shared with the API playground. Viewports are between 320 and 1600 pixels wide, and full-page capture, PDF, cookies, headers and custom scripts are not available here. All free runs also draw on one shared monthly allowance, so the tool can occasionally be unavailable until it resets. A free account gets 1000 credits a month of its own, and a basic capture costs 1.

Is the page I capture saved?

The capture is not. The tool does not ask the API to save it, so the image and the Markdown come back to your browser in the response and are not kept. The request itself, including the URL you entered, is recorded in the request log like every API call.

Which pages can it not capture?

Anything on a private or local network address is refused. Behind a login or a captcha, you get the login or verification page rather than the content. Captures leave from a single network address with no proxy rotation, so a site that blocks that address cannot be captured.

Free tools · no sign-up

Screenshot any website

Paste a URL and get an image of the page as a browser renders it, after its JavaScript has run. PNG, JPEG or WebP, at desktop or phone size.

The same capture from your code

With an API key it is one POST, in whatever language you already use. Replace YOUR_API_KEY with a key from the dashboard.

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",
    "format": "png",
    "width": 1280,
    "height": 800,
    "deviceScaleFactor": 1,
    "responseType": "binary"
  }' \
  -o page.png

Node.js

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

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",
    format: "png",
    width: 1280,
    height: 800,
    deviceScaleFactor: 1,
    responseType: "binary"
  }),
});
await writeFile("page.png", Buffer.from(await response.arrayBuffer()));

Python

import requests

response = requests.post(
    "https://api.domscout.io/screenshot",
    headers={"x-api-key": "YOUR_API_KEY"},
    json={
        "url": "https://example.com",
        "format": "png",
        "width": 1280,
        "height": 800,
        "deviceScaleFactor": 1,
        "responseType": "binary"
    },
)
with open("page.png", "wb") as f:
    f.write(response.content)

package main

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

func main() {
	body, _ := json.Marshal(map[string]any{
		"url": "https://example.com",
		"format": "png",
		"width": 1280,
		"height": 800,
		"deviceScaleFactor": 1,
		"responseType": "binary",
	})
	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()

	out, _ := os.Create("page.png")
	defer out.Close()
	io.Copy(out, res.Body)
}

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',
        'format' => 'png',
        'width' => 1280,
        'height' => 800,
        'deviceScaleFactor' => 1,
        'responseType' => 'binary'
    ]),
]);
$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
file_put_contents('page.png', $response);

Ruby

require "json"
require "net/http"

response = Net::HTTP.post(
  URI("https://api.domscout.io/screenshot"),
  {
    url: "https://example.com",
    format: "png",
    width: 1280,
    height: 800,
    deviceScaleFactor: 1,
    responseType: "binary"
  }.to_json,
  "Content-Type" => "application/json",
  "x-api-key" => "YOUR_API_KEY"
)
File.binwrite("page.png", response.body)

Java

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

public class Capture {
    public static void main(String[] args) throws Exception {
        String body = """
            {
                "url": "https://example.com",
                "format": "png",
                "width": 1280,
                "height": 800,
                "deviceScaleFactor": 1,
                "responseType": "binary"
            }
            """;
        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<Path> response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofFile(Path.of("page.png")));
        System.out.println("Saved " + 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",
    format = "png",
    width = 1280,
    height = 800,
    deviceScaleFactor = 1,
    responseType = "binary"
});
await File.WriteAllBytesAsync("page.png", await response.Content.ReadAsByteArrayAsync());

Questions

Here, PNG, JPEG or WebP at a desktop viewport of 1280 by 800 or a phone viewport of 390 by 844. Through the API you set the viewport yourself, and Pro and above add PDF and full-page capture.

More free tools

URL to Markdown

Turn a web page into clean Markdown with a token estimate, ready to hand to an LLM.

Meta tag and Open Graph preview

See the title, description, og: tags and canonical URL a page publishes after its JavaScript runs.

JavaScript rendering checker

See whether a page's text is in the HTML the server sends or only appears after JavaScript runs.

llms.txt generator

Draft an llms.txt for a site from its homepage and sitemap, grouped into sections and ready to edit.

Find all pages on a website

List a site's pages from its sitemaps and its links, with where each one was found.

XML sitemap checker

Paste a sitemap and see which entries Google would refuse or ignore, and on which line.

Hreflang checker

Paste a page's HTML and check its hreflang codes, URLs, self-reference and canonical.

robots.txt tester

Paste a robots.txt and see whether a crawler may fetch a URL, and which rule decides it.

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