What is kept and what is removed?

Headings, paragraphs, lists, tables, links, and images with their alt text are kept. Scripts, styles, form controls and framework hydration data are dropped. The page's scripts run first, and the conversion waits until the network has been quiet for half a second, up to five seconds, so content that arrives in that time is included.

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

Convert a web page to Markdown

Paste a URL and get the page back as Markdown an LLM can read: headings, lists, tables and links kept, scripts and styling dropped. The token estimate tells you roughly how much context it will take.

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", "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", extractMarkdown: true }),
});
const result = await response.json();
console.log(result.markdown);

Python

import requests

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

package main

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

func main() {
	body, _ := json.Marshal(map[string]any{"url": "https://example.com", "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()

	var result map[string]any
	json.NewDecoder(res.Body).Decode(&result)
	fmt.Println(result["markdown"])
}

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', 'extractMarkdown' => true]),
]);
$response = curl_exec($ch);
if ($response === false) {
    throw new RuntimeException(curl_error($ch));
}
$result = json_decode($response, true);
print_r($result['markdown']);

Ruby

require "json"
require "net/http"

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

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", "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 System.Text.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", extractMarkdown = true });
var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result.GetProperty("markdown"));

Questions

It is an estimate: the length of the Markdown divided by four, the same figure the API returns as markdownMeta.estimatedTokens. A model's own tokenizer will give a slightly different number.

More free tools

Website screenshot

Capture any public page as PNG, JPEG or WebP, at desktop or phone size.

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