For teams building agents

Give a model the page, not the page's source code

Render the page an agent needs and hand it Markdown that reads like the page looks, from your code or as MCP tools.

Get your free API key Try the playground

The problem

Your agent needs to read a supplier's product page, a competitor's pricing table, a customer's help centre. You fetch the URL and get back a document that is mostly framework: hydration payloads, inline styles, cookie banners, three navigation menus. The model spends its context window reading markup, and it still gets the price wrong, because the price arrived after the JavaScript ran and the fetch never ran any.

How domscout handles it

One POST renders the page in a real headless Chromium, lets its scripts run until the network goes quiet (up to five seconds, or longer with waitForSelector), and hands back Markdown that reads like the page looks. Headings, tables, lists, links and images with their alt text survive. Scripts, styles and hydration data do not. The same capture is available as MCP tools, so an assistant in Claude, Cursor or VS Code can open a page itself instead of being handed a scrape.

Where it shows up

Ingestion for a RAG index that stays close to what a human reader would have seen.
A research agent that can open a link its user pasted, rather than guessing from the URL.
A product-catalogue sync that reads the live page instead of a stale feed.

The request

POST /screenshot. Markdown extraction is on every plan, including the free Hobby plan. Semantic snapshots and the rest of the DOM intelligence start 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/pricing", "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/pricing", 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/pricing", "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/pricing",
		"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/pricing', '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/pricing", 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/pricing",
                "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/pricing", extractMarkdown = true });
var result = await response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(result.GetProperty("markdown"));

Go further

Semantic snapshots

MCP server

Try URL to Markdown

Guide: web pages to Markdown for an LLM

Other use cases: Website change monitoring · Web archiving and evidence · 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