Tech-Stack-Erkennung

GET /v1/tech

Abfrageparameter

Parameter	Typ	Beschreibung
url optional	string	Vollständige öffentliche HTTP(S)-URL zur Analyse. Wenn sowohl URL als auch domain angegeben sind, hat URL Vorrang.
domain optional	string	Öffentliche Domain oder HTTP(S)-URL zur Analyse. Geben Sie entweder URL oder domain an.
mode optional	string Zulässige Werte `fastrendereddeep` Standard `fast`	Scanmodus: fast kostet 3 Credits, rendered kostet 6 Credits und deep kostet 9 Credits.
max_pages optional	integer Standard `3`	Maximale Anzahl von Seiten desselben Ursprungs, die im Modus deep analysiert werden, von 1 bis 5. Der Standardwert ist 3.
skip_cache optional	string Zulässige Werte `1`	Setzen Sie auf 1, um den Cache zu umgehen und eine neue Prüfung zu erzwingen. Dies gilt nur für den schnellen Modus, da rendered und deep Ergebnisse nie zwischengespeichert werden.

Technologie-Kategorien

Kategorie	Beispiele
`cdn`	Cloudflare, Fastly, Akamai, CloudFront
`cms`	WordPress, Drupal, Shopify, Squarespace
`analytics`	Google Analytics, Mixpanel, Segment
`framework`	React, Vue.js, Angular, Next.js
`server`	nginx, Apache, IIS, LiteSpeed
`hosting`	AWS, Google Cloud, Azure, Vercel
`platform`	GitHub, Medium, Substack, GitBook

Beispielanfrage

curl -H "X-API-Key: your-api-key" "https://domscan.net/v1/tech?url=https%3A%2F%2Fwordpress.example%2F"   -H "x-api-key: YOUR_API_KEY"

const domscanFetch = (url, options = {}) =>
  fetch(url, {
    ...options,
    headers: { ...options.headers, "X-API-Key": "your-api-key" },
  });

const response = await domscanFetch(
  "https://domscan.net/v1/tech?url=https%3A%2F%2Fwordpress.example%2F",
  { headers: { "x-api-key": "YOUR_API_KEY" } }
);
const data = await response.json();

for (const tech of data.technologies) {
  console.log(`${tech.id}: ${tech.confidence_score}/100`);
}

import requests

domscan = requests.Session()
domscan.headers.update({"X-API-Key": "your-api-key"})

response = domscan.get(
    "https://domscan.net/v1/tech",
    params={"url": "https://wordpress.example/"},
    headers={"x-api-key": "YOUR_API_KEY"}
)
data = response.json()

for tech in data['technologies']:
    print(f"{tech['id']}: {tech['confidence_score']}/100")

Beispielantwort

{
  "url": "https://wordpress.example/",
  "technologies": [
    {
      "id": "wordpress",
      "name": "WordPress",
      "category": "cms",
      "version": "6.8.2",
      "version_kind": "product",
      "confidence": "high",
      "confidence_score": 98,
      "evidence": "Meta: generator",
      "evidence_details": [
        {
          "source": "meta",
          "key": "generator",
          "matched": "WordPress 6.8.2"
        }
      ],
      "source_count": 1,
      "caveats": [
        "generator_can_be_removed_or_spoofed",
        "asset_paths_can_be_rewritten"
      ],
      "reference": {
        "website": "https://wordpress.org/",
        "source_url": "https://developer.wordpress.org/reference/functions/get_the_generator/",
        "source_owner": "WordPress.org",
        "source_kind": "official_docs",
        "access": "public",
        "access_method": "target_response_inspection",
        "cost": "none",
        "terms_status": "public_source_reviewed_factual_signature",
        "expected_freshness": "reverify_on_source_or_signature_change",
        "maintenance_risk": "medium",
        "runtime_rate_limits": "not_applicable_no_source_request",
        "fallback_behavior": "unmatched_or_unavailable_signal_is_not_detected",
        "last_verified": "2026-07-15"
      }
    }
  ],
  "detection_summary": {
    "detected_count": 1,
    "category_count": 1,
    "categories": [
      "cms"
    ],
    "high_confidence_count": 1,
    "medium_confidence_count": 0,
    "low_confidence_count": 0,
    "versioned_count": 1,
    "evidence_sources": {
      "header": 0,
      "html": 0,
      "asset_url": 0,
      "network_url": 0,
      "javascript": 0,
      "meta": 1,
      "cookie": 0,
      "url": 0
    },
    "catalog_size": 522,
    "catalog_category_count": 87,
    "summary_field_count": 1
  },
  "summary": {
    "cms": "WordPress"
  },
  "meta": {
    "title": "Example WordPress site",
    "description": "A reserved example response for the technology detection contract.",
    "canonical_url": "https://wordpress.example/",
    "language": "en",
    "favicon": "https://wordpress.example/favicon.ico",
    "open_graph": {
      "title": null,
      "description": null,
      "image": null,
      "url": null,
      "type": null,
      "site_name": null,
      "locale": null
    },
    "twitter_card": {
      "card": null,
      "site": null,
      "creator": null,
      "title": null,
      "description": null,
      "image": null
    },
    "author": null,
    "generator": "WordPress 6.8.2",
    "theme_color": null,
    "manifest_url": null,
    "robots": "index, follow"
  },
  "headers": {
    "content-type": "text/html; charset=UTF-8"
  },
  "ssl": {
    "enabled": true
  },
  "analysis": {
    "status": "complete",
    "requested_url": "https://wordpress.example/",
    "final_url": "https://wordpress.example/",
    "response_status": 200,
    "redirect_count": 0,
    "relay_used": false,
    "signals_checked": [
      "url",
      "header",
      "cookie",
      "html",
      "asset_url",
      "meta"
    ],
    "signals_unavailable": [],
    "html_characters_analyzed": 412,
    "html_bytes_analyzed": 412,
    "html_byte_limit": 1000000,
    "html_truncated": false,
    "response_body_truncated": false,
    "mode": "fast",
    "rendered": false,
    "javascript_executed": false,
    "pages_requested": 1,
    "pages_analyzed": 1,
    "page_limit": 1,
    "network_requests_observed": 0,
    "page_limit_reached": false,
    "resource_limit_reached": false,
    "redirected_to_different_host": false,
    "no_detection_reason": null,
    "recommended_mode": null,
    "pages": [
      {
        "url": "https://wordpress.example/",
        "status": 200,
        "html_truncated": false,
        "network_requests_observed": 0
      }
    ]
  },
  "total_time_ms": 128,
  "checked_at": "2026-07-15T10:30:00Z",
  "_meta": {
    "served_by": "pop=MAD country=ES",
    "analysis_status": "ok",
    "response_status": 200,
    "cache_status": "miss",
    "stale": false
  }
}

Antwortfelder

Feld	Typ
`cache_age_s`	integer
`url`	string
`technologies[]`	object[]
`technologies[]`	object
`technologies[].id`	string
`technologies[].name`	string
`technologies[].category`	string
`technologies[].version`	string
`technologies[].version_kind`	string
`technologies[].confidence`	string
`technologies[].confidence_score`	integer
`technologies[].evidence`	string
`technologies[].evidence_details[]`	object[]
`technologies[].evidence_details[]`	object
`technologies[].evidence_details[].source`	string
`technologies[].evidence_details[].key`	string
`technologies[].evidence_details[].matched`	string
`technologies[].evidence_details[].page_url`	string
`technologies[].source_count`	integer
`technologies[].caveats[]`	string[]
`technologies[].reference`	object
`technologies[].reference.website`	string
`technologies[].reference.source_url`	string
`technologies[].reference.source_owner`	string
`technologies[].reference.source_kind`	string
`technologies[].reference.access`	string
`technologies[].reference.access_method`	string
`technologies[].reference.cost`	string
`technologies[].reference.terms_status`	string
`technologies[].reference.expected_freshness`	string
`technologies[].reference.maintenance_risk`	string
`technologies[].reference.runtime_rate_limits`	string
`technologies[].reference.fallback_behavior`	string
`technologies[].reference.last_verified`	string
`detection_summary`	object
`detection_summary.detected_count`	integer
`detection_summary.category_count`	integer
`detection_summary.categories[]`	string[]
`detection_summary.high_confidence_count`	integer
`detection_summary.medium_confidence_count`	integer
`detection_summary.low_confidence_count`	integer
`detection_summary.versioned_count`	integer
`detection_summary.evidence_sources`	object
`detection_summary.evidence_sources.header`	integer
`detection_summary.evidence_sources.html`	integer
`detection_summary.evidence_sources.asset_url`	integer
`detection_summary.evidence_sources.network_url`	integer
`detection_summary.evidence_sources.javascript`	integer
`detection_summary.evidence_sources.meta`	integer
`detection_summary.evidence_sources.cookie`	integer
`detection_summary.evidence_sources.url`	integer
`detection_summary.catalog_size`	integer
`detection_summary.catalog_category_count`	integer
`detection_summary.summary_field_count`	integer
`summary`	object
`summary.cdn`	string
`summary.server`	string
`summary.framework`	string
`summary.cms`	string
`summary.hosting`	string
`summary.platform`	string
`summary.analytics[]`	string[]
`headers`	object
`meta`	object
`ssl`	object
`ssl.enabled`	boolean
`analysis`	object
`analysis.status`	string
`analysis.requested_url`	string
`analysis.final_url`	string
`analysis.response_status`	integer
`analysis.redirect_count`	integer
`analysis.relay_used`	boolean
`analysis.signals_checked[]`	string[]
`analysis.signals_unavailable[]`	string[]
`analysis.html_characters_analyzed`	integer
`analysis.html_bytes_analyzed`	integer
`analysis.html_byte_limit`	integer
`analysis.html_truncated`	boolean
`analysis.response_body_truncated`	boolean
`analysis.mode`	string
`analysis.rendered`	boolean
`analysis.javascript_executed`	boolean
`analysis.pages_requested`	integer
`analysis.pages_analyzed`	integer
`analysis.page_limit`	integer
`analysis.network_requests_observed`	integer
`analysis.page_limit_reached`	boolean
`analysis.resource_limit_reached`	boolean
`analysis.redirected_to_different_host`	boolean
`analysis.no_detection_reason`	string \| null
`analysis.recommended_mode`	string \| null
`analysis.pages[]`	object[]
`analysis.pages[]`	object
`analysis.pages[].url`	string
`analysis.pages[].status`	integer
`analysis.pages[].html_truncated`	boolean
`analysis.pages[].network_requests_observed`	integer
`total_time_ms`	integer
`checked_at`	string
`_meta`	object
`_meta.served_by`	string
`_meta.analysis_status`	string
`_meta.response_status`	integer
`_meta.cache_status`	string
`_meta.stale`	boolean
`_meta.cached_at`	string

GET /v1/hosting Credits: 3

Abfrageparameter

Parameter	Typ	erforderlich
domain	string	erforderlich

Antwortfelder

Feld	Typ
`domain`	string
`hosting`	object
`hosting.provider`	string
`hosting.provider_id`	string
`hosting.confidence`	number
`hosting.region`	string
`hosting.detection_method`	string
`cdn`	object
`cdn.detected`	boolean
`cdn.provider`	string
`cdn.provider_id`	string
`cdn.confidence`	number
`cdn.detection_method`	string
`cdn.features[]`	string[]
`waf`	object
`waf.detected`	boolean
`waf.provider`	string
`waf.provider_id`	string
`waf.confidence`	number
`waf.detection_method`	string
`dns_provider`	object
`dns_provider.provider`	string
`dns_provider.provider_id`	string
`dns_provider.nameservers[]`	string[]
`dns_provider.confidence`	number
`dns_providers[]`	object[]
`dns_providers[]`	object
`dns_providers[].provider_id`	string
`dns_providers[].provider`	string
`email_provider`	object
`email_provider.provider`	string
`email_provider.provider_id`	string
`email_provider.mx_records[]`	string[]
`email_provider.confidence`	number
`ssh`	object
`ssh.host`	string
`ssh.port`	integer
`ssh.reachable`	boolean
`ssh.banner`	string \| null
`ssh.algorithms[]`	string[]
`ssh.weak_algorithms[]`	string[]
`ssh.keys[]`	object[]
`ssh.keys[]`	object
`ssh.keys[].host`	string
`ssh.keys[].algorithm`	string
`ssh.keys[].key_size`	integer \| null
`ssh.keys[].fingerprint_sha256`	string \| null
`ssh.keys[].weak`	boolean
`ssh.keys[].weak_reasons[]`	string[]
`ssh.error`	string \| null
`ssh.checked_at`	string
`provider_summary`	object
`provider_summary.cache_status`	string
`provider_summary.provider_count`	integer
`provider_summary.detected_surfaces[]`	string[]
`provider_summary.confidence`	string
`provider_summary.confidence_score`	integer
`provider_summary.hosting_provider`	string \| null
`provider_summary.cdn_provider`	string \| null
`provider_summary.waf_provider`	string \| null
`provider_summary.dns_provider_count`	integer
`provider_summary.email_provider`	string \| null
`provider_summary.ssh_exposed`	boolean \| null
`provider_summary.evidence[]`	object[]
`provider_summary.evidence[]`	object
`provider_summary.evidence[].surface`	string
`provider_summary.evidence[].provider`	string
`provider_summary.evidence[].confidence`	number \| null
`provider_summary.evidence[].method`	string \| null
`ip_info`	object
`ip_info.ipv4[]`	string[]
`ip_info.ipv6[]`	string[]
`checked_at`	string
`check_duration_ms`	integer
`meta`	object
`meta.cached`	boolean

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/hosting?domain=example.com"

const response = await fetch("https://domscan.net/v1/hosting?domain=example.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/hosting?domain=example.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/hosting?domain=example.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/hosting?domain=example.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "domain": "github.com",
  "hosting": {
    "provider": "Microsoft Azure",
    "provider_id": "azure",
    "confidence": 0.86,
    "detection_method": "ip_range"
  },
  "cdn": {
    "detected": true,
    "provider": "Fastly",
    "provider_id": "fastly",
    "confidence": 0.94,
    "detection_method": "headers"
  },
  "waf": {
    "detected": false,
    "confidence": 0.2,
    "detection_method": "headers"
  },
  "dns_provider": {
    "provider": "AWS Route 53",
    "provider_id": "route53",
    "nameservers": [
      "ns-1283.awsdns-32.org",
      "ns-1707.awsdns-21.co.uk"
    ],
    "confidence": 0.9
  },
  "email_provider": {
    "provider": "Google Workspace",
    "provider_id": "google_workspace",
    "mx_records": [
      "aspmx.l.google.com"
    ],
    "confidence": 0.95
  },
  "ssh": {
    "host": "github.com",
    "port": 22,
    "reachable": true,
    "banner": "SSH-2.0-babeld",
    "algorithms": [
      "ssh-ed25519",
      "ecdsa-sha2-nistp256"
    ],
    "weak_algorithms": [],
    "keys": [
      {
        "host": "github.com",
        "algorithm": "ssh-ed25519",
        "key_size": 256,
        "fingerprint_sha256": "SHA256:+DiY3wvvV6TuJJhbpZisF/Ym7N3QKXNoZk6sJ2x2d2s",
        "weak": false,
        "weak_reasons": []
      }
    ],
    "error": null,
    "checked_at": "2026-04-18T21:00:00Z"
  },
  "provider_summary": {
    "cache_status": "miss",
    "provider_count": 4,
    "detected_surfaces": [
      "hosting",
      "cdn",
      "dns",
      "email",
      "ssh"
    ],
    "confidence": "high",
    "confidence_score": 92,
    "hosting_provider": "Microsoft Azure",
    "cdn_provider": "Fastly",
    "waf_provider": null,
    "dns_provider_count": 1,
    "email_provider": "Google Workspace",
    "ssh_exposed": true,
    "evidence": [
      {
        "surface": "hosting",
        "provider": "Microsoft Azure",
        "confidence": 0.86,
        "method": "ip_range"
      },
      {
        "surface": "cdn",
        "provider": "Fastly",
        "confidence": 0.94,
        "method": "headers"
      },
      {
        "surface": "dns",
        "provider": "AWS Route 53",
        "confidence": 0.9,
        "method": "ns"
      },
      {
        "surface": "email",
        "provider": "Google Workspace",
        "confidence": 0.95,
        "method": "mx"
      },
      {
        "surface": "ssh",
        "provider": "public-ssh",
        "confidence": 90,
        "method": "edge-relay"
      }
    ]
  },
  "ip_info": {
    "ipv4": [
      "140.82.121.4"
    ],
    "ipv6": []
  },
  "checked_at": "2026-04-18T21:00:00Z",
  "check_duration_ms": 156
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

POST /v1/hosting/bulk Credits: 3/item

Abfrageparameter

Parameter	Typ	erforderlich
dry_run	string Zulässige Werte `true`	optional

Body-Parameter

Parameter	Typ	erforderlich
domains	string[]	erforderlich

Antwortfelder

Feld	Typ
`results[]`	unknown[]
`meta`	object
`meta.total`	integer
`meta.succeeded`	integer
`meta.failed`	integer
`meta.max_items`	integer
`meta.credits_per_item`	integer
`meta.duration_ms`	integer

Beispielanfrage

curl -X POST "https://domscan.net/v1/hosting/bulk" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domains": [
    "example.com",
    "cloudflare.com"
  ]
}'

const response = await fetch("https://domscan.net/v1/hosting/bulk", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "domains": [
      "example.com",
      "cloudflare.com"
    ]
  }),
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.post(
    "https://domscan.net/v1/hosting/bulk",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "domains": [
            "example.com",
            "cloudflare.com",
        ],
    },
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "domains": [
	    "example.com",
	    "cloudflare.com"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/hosting/bulk", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/hosting/bulk")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "domains" => [
    "example.com",
    "cloudflare.com"
  ]
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "results": [
    {
      "input": "example",
      "data": {}
    }
  ],
  "meta": {
    "total": 1,
    "succeeded": 1,
    "failed": 1,
    "max_items": 10,
    "credits_per_item": 1,
    "duration_ms": 1
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
409 HTTP 409
422 HTTP 422
429 Zu viele Anfragen

GET /v1/parking Credits: 2

Abfrageparameter

Parameter	Typ	erforderlich
domain	string	erforderlich

Antwortfelder

Feld	Typ
`domain`	string
`classification`	object
`classification.status`	string
`classification.reason`	string
`classification.evidence`	object
`classification.evidence.source`	string
`classification.evidence.method`	string
`classification.evidence.observed_at`	string
`classification.evidence.detail`	string
`classification.checked_at`	string
`is_parked`	boolean \| null
`is_for_sale`	boolean \| null
`parking_provider`	string \| null
`aftermarket_listings[]`	object[]
`aftermarket_listings[]`	object
`aftermarket_listings[].platform`	string
`aftermarket_listings[].detected_via`	string
`signals[]`	object[]
`signals[]`	object
`signals[].type`	string
`signals[].detail`	string
`signals[].provider`	string
`confidence`	number
`checked_at`	string
`check_duration_ms`	integer

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/parking?domain=example.com"

const response = await fetch("https://domscan.net/v1/parking?domain=example.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/parking?domain=example.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/parking?domain=example.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/parking?domain=example.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "domain": "parked-example.com",
  "is_parked": true,
  "is_for_sale": false,
  "parking_provider": "Sedo",
  "aftermarket_listings": [
    {
      "platform": "Sedo",
      "detected_via": "dns"
    }
  ],
  "signals": [
    {
      "type": "nameserver",
      "detail": "NS record: ns1.sedoparking.com",
      "provider": "Sedo"
    },
    {
      "type": "nameserver",
      "detail": "NS record: ns2.sedoparking.com",
      "provider": "Sedo"
    }
  ],
  "confidence": 0.85,
  "checked_at": "2026-10-09T10:15:30.000Z",
  "check_duration_ms": 842
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/agent-readiness Credits: 3

Abfrageparameter

Parameter	Typ	erforderlich
url	string	optional
domain	string	optional
skip_cache	string Zulässige Werte `1`	optional

Antwortfelder

Feld	Typ
`cache_age_s`	integer
`requested_url`	string
`final_url`	string
`checked_at`	string
`outcome`	string
`fetch_state`	string
`http_status`	integer \| null
`summary`	object
`summary.coverage`	string
`summary.detected_signals`	integer
`summary.total_signals`	integer
`summary.score`	integer \| null
`summary.rating`	string
`summary.confidence`	integer
`summary.passed_checks`	integer
`summary.warning_checks`	integer
`summary.failed_checks`	integer
`summary.unknown_checks`	integer
`summary.not_applicable_checks`	integer
`signals`	object
`signals.webmcp`	object
`signals.webmcp.status`	string
`signals.webmcp.validation`	string
`signals.webmcp.method`	string
`signals.webmcp.checked_url`	string \| null
`signals.webmcp.http_status`	integer \| null
`signals.webmcp.evidence[]`	string[]
`signals.webmcp.caveats[]`	string[]
`signals.remote_mcp`	object
`signals.remote_mcp.status`	string
`signals.remote_mcp.validation`	string
`signals.remote_mcp.method`	string
`signals.remote_mcp.checked_url`	string \| null
`signals.remote_mcp.http_status`	integer \| null
`signals.remote_mcp.evidence[]`	string[]
`signals.remote_mcp.caveats[]`	string[]
`signals.openapi`	object
`signals.openapi.status`	string
`signals.openapi.validation`	string
`signals.openapi.method`	string
`signals.openapi.checked_url`	string \| null
`signals.openapi.http_status`	integer \| null
`signals.openapi.evidence[]`	string[]
`signals.openapi.caveats[]`	string[]
`signals.llms_txt`	object
`signals.llms_txt.status`	string
`signals.llms_txt.validation`	string
`signals.llms_txt.method`	string
`signals.llms_txt.checked_url`	string \| null
`signals.llms_txt.http_status`	integer \| null
`signals.llms_txt.evidence[]`	string[]
`signals.llms_txt.caveats[]`	string[]
`signals.api_catalog`	object
`signals.api_catalog.status`	string
`signals.api_catalog.validation`	string
`signals.api_catalog.method`	string
`signals.api_catalog.checked_url`	string \| null
`signals.api_catalog.http_status`	integer \| null
`signals.api_catalog.evidence[]`	string[]
`signals.api_catalog.caveats[]`	string[]
`signals.mcp_server_card`	object
`signals.mcp_server_card.status`	string
`signals.mcp_server_card.validation`	string
`signals.mcp_server_card.method`	string
`signals.mcp_server_card.checked_url`	string \| null
`signals.mcp_server_card.http_status`	integer \| null
`signals.mcp_server_card.evidence[]`	string[]
`signals.mcp_server_card.caveats[]`	string[]
`signals.agent_skills`	object
`signals.agent_skills.status`	string
`signals.agent_skills.validation`	string
`signals.agent_skills.method`	string
`signals.agent_skills.checked_url`	string \| null
`signals.agent_skills.http_status`	integer \| null
`signals.agent_skills.evidence[]`	string[]
`signals.agent_skills.caveats[]`	string[]
`signals.oauth`	object
`signals.oauth.status`	string
`signals.oauth.validation`	string
`signals.oauth.method`	string
`signals.oauth.checked_url`	string \| null
`signals.oauth.http_status`	integer \| null
`signals.oauth.evidence[]`	string[]
`signals.oauth.caveats[]`	string[]
`signals.markdown`	object
`signals.markdown.status`	string
`signals.markdown.validation`	string
`signals.markdown.method`	string
`signals.markdown.checked_url`	string \| null
`signals.markdown.http_status`	integer \| null
`signals.markdown.evidence[]`	string[]
`signals.markdown.caveats[]`	string[]
`signals.web_bot_auth`	object
`signals.web_bot_auth.status`	string
`signals.web_bot_auth.validation`	string
`signals.web_bot_auth.method`	string
`signals.web_bot_auth.checked_url`	string \| null
`signals.web_bot_auth.http_status`	integer \| null
`signals.web_bot_auth.evidence[]`	string[]
`signals.web_bot_auth.caveats[]`	string[]
`signals.sitemap_markdown`	object
`signals.sitemap_markdown.status`	string
`signals.sitemap_markdown.validation`	string
`signals.sitemap_markdown.method`	string
`signals.sitemap_markdown.checked_url`	string \| null
`signals.sitemap_markdown.http_status`	integer \| null
`signals.sitemap_markdown.evidence[]`	string[]
`signals.sitemap_markdown.caveats[]`	string[]
`signals.agent_guide`	object
`signals.agent_guide.status`	string
`signals.agent_guide.validation`	string
`signals.agent_guide.method`	string
`signals.agent_guide.checked_url`	string \| null
`signals.agent_guide.http_status`	integer \| null
`signals.agent_guide.evidence[]`	string[]
`signals.agent_guide.caveats[]`	string[]
`foundations`	object
`dimensions`	object
`dimensions.discoverability`	object
`dimensions.discoverability.score`	integer \| null
`dimensions.discoverability.confidence`	integer
`dimensions.discoverability.passed`	integer
`dimensions.discoverability.warned`	integer
`dimensions.discoverability.failed`	integer
`dimensions.discoverability.unknown`	integer
`dimensions.discoverability.not_applicable`	integer
`dimensions.discoverability.checks[]`	string[]
`dimensions.content`	object
`dimensions.content.score`	integer \| null
`dimensions.content.confidence`	integer
`dimensions.content.passed`	integer
`dimensions.content.warned`	integer
`dimensions.content.failed`	integer
`dimensions.content.unknown`	integer
`dimensions.content.not_applicable`	integer
`dimensions.content.checks[]`	string[]
`dimensions.access_policy`	object
`dimensions.access_policy.score`	integer \| null
`dimensions.access_policy.confidence`	integer
`dimensions.access_policy.passed`	integer
`dimensions.access_policy.warned`	integer
`dimensions.access_policy.failed`	integer
`dimensions.access_policy.unknown`	integer
`dimensions.access_policy.not_applicable`	integer
`dimensions.access_policy.checks[]`	string[]
`dimensions.capabilities`	object
`dimensions.capabilities.score`	integer \| null
`dimensions.capabilities.confidence`	integer
`dimensions.capabilities.passed`	integer
`dimensions.capabilities.warned`	integer
`dimensions.capabilities.failed`	integer
`dimensions.capabilities.unknown`	integer
`dimensions.capabilities.not_applicable`	integer
`dimensions.capabilities.checks[]`	string[]
`checks`	object
`recommendations[]`	object[]
`recommendations[]`	object
`recommendations[].code`	string
`recommendations[].severity`	string
`meta`	object
`meta.cached`	boolean
`meta.fetch_path`	string
`meta.duration_ms`	integer
`meta.probe_count`	integer
`meta.body_truncated`	boolean
`meta.source_version`	string
`meta.last_verified`	string
`meta.rubric_version`	string
`meta.max_probes`	integer

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/agent-readiness?url=https%3A%2F%2Fexample.com&domain=example.com&skip_cache=1"

const response = await fetch("https://domscan.net/v1/agent-readiness?url=https%3A%2F%2Fexample.com&domain=example.com&skip_cache=1", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/agent-readiness?url=https%3A%2F%2Fexample.com&domain=example.com&skip_cache=1",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/agent-readiness?url=https%3A%2F%2Fexample.com&domain=example.com&skip_cache=1", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/agent-readiness?url=https%3A%2F%2Fexample.com&domain=example.com&skip_cache=1")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "requested_url": "https://www.example.com/",
  "final_url": "https://www.example.com/",
  "checked_at": "2026-10-09T10:15:30.000Z",
  "outcome": "partial",
  "fetch_state": "ok",
  "http_status": 200,
  "summary": {
    "coverage": "multi_channel",
    "detected_signals": 3,
    "total_signals": 12,
    "score": 78,
    "rating": "good",
    "confidence": 95,
    "passed_checks": 18,
    "warning_checks": 12,
    "failed_checks": 2,
    "unknown_checks": 2,
    "not_applicable_checks": 8
  },
  "signals": {
    "webmcp": {
      "status": "unknown",
      "validation": "runtime_required",
      "method": "static_html",
      "checked_url": "https://www.example.com/",
      "http_status": 200,
      "evidence": [],
      "caveats": [
        "runtime_observation_required"
      ]
    },
    "remote_mcp": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "oauth_protected_resource_metadata",
      "checked_url": "https://www.example.com/.well-known/oauth-protected-resource/mcp",
      "http_status": 404,
      "evidence": [
        "exact_missing_response"
      ],
      "caveats": [
        "custom_or_unauthenticated_endpoints_not_checked"
      ]
    },
    "openapi": {
      "status": "detected",
      "validation": "confirmed",
      "method": "service_description",
      "checked_url": "https://www.example.com/openapi.json",
      "http_status": 200,
      "evidence": [
        "openapi_document_validated"
      ],
      "caveats": []
    },
    "llms_txt": {
      "status": "detected",
      "validation": "confirmed",
      "method": "well_known_path",
      "checked_url": "https://www.example.com/llms.txt",
      "http_status": 200,
      "evidence": [
        "markdown_h1",
        "markdown_links_1"
      ],
      "caveats": []
    },
    "api_catalog": {
      "status": "detected",
      "validation": "confirmed",
      "method": "rfc9727_api_catalog",
      "checked_url": "https://www.example.com/.well-known/api-catalog",
      "http_status": 200,
      "evidence": [
        "service_descriptions_1",
        "api_catalog_link_header"
      ],
      "caveats": []
    },
    "mcp_server_card": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "mcp_server_card",
      "checked_url": null,
      "http_status": null,
      "evidence": [
        "bounded_candidates_missing"
      ],
      "caveats": []
    },
    "agent_skills": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "agent_skills_index",
      "checked_url": "https://www.example.com/.well-known/agent-skills/index.json",
      "http_status": 404,
      "evidence": [
        "exact_missing_response"
      ],
      "caveats": []
    },
    "oauth": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "oauth_server_metadata",
      "checked_url": null,
      "http_status": null,
      "evidence": [
        "bounded_candidates_missing"
      ],
      "caveats": []
    },
    "markdown": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "accept_content_negotiation",
      "checked_url": "https://www.example.com/",
      "http_status": 200,
      "evidence": [
        "html_returned_for_markdown_accept"
      ],
      "caveats": []
    },
    "web_bot_auth": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "web_bot_auth_directory",
      "checked_url": "https://www.example.com/.well-known/http-message-signatures-directory",
      "http_status": 404,
      "evidence": [
        "exact_missing_response"
      ],
      "caveats": []
    },
    "sitemap_markdown": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "markdown_sitemap",
      "checked_url": null,
      "http_status": null,
      "evidence": [
        "bounded_candidates_missing"
      ],
      "caveats": []
    },
    "agent_guide": {
      "status": "not_detected",
      "validation": "not_applicable",
      "method": "public_agent_guide",
      "checked_url": null,
      "http_status": null,
      "evidence": [
        "bounded_candidates_missing"
      ],
      "caveats": []
    }
  },
  "foundations": {
    "https": {
      "state": "pass",
      "evidence": [
        "https"
      ]
    },
    "indexable": {
      "state": "pass",
      "evidence": [
        "no_noindex_directive"
      ]
    },
    "robots": {
      "state": "pass",
      "evidence": [
        "robots_allows_crawl"
      ]
    },
    "title": {
      "state": "pass",
      "evidence": [
        "title_present"
      ]
    },
    "meta_description": {
      "state": "pass",
      "evidence": [
        "meta_description_present"
      ]
    },
    "canonical": {
      "state": "warn",
      "evidence": [
        "canonical_missing"
      ]
    },
    "language": {
      "state": "pass",
      "evidence": [
        "html_lang_present"
      ]
    },
    "structured_data": {
      "state": "warn",
      "evidence": [
        "json_ld_not_detected"
      ]
    },
    "labeled_forms": {
      "state": "pass",
      "evidence": [
        "no_form_controls"
      ]
    },
    "origin_isolation": {
      "state": "unknown",
      "evidence": [
        "origin_agent_cluster_not_declared"
      ]
    },
    "webmcp_permission": {
      "state": "pass",
      "evidence": [
        "tools_permission_default_self"
      ]
    }
  },
  "dimensions": {
    "discoverability": {
      "score": 84,
      "confidence": 100,
      "passed": 8,
      "warned": 1,
      "failed": 2,
      "unknown": 0,
      "not_applicable": 1,
      "checks": [
        "https",
        "http_response",
        "redirect_chain",
        "html_content_type",
        "indexable",
        "robots_access",
        "sitemap_xml",
        "sitemap_lastmod",
        "target_discoverable",
        "llms_txt",
        "sitemap_markdown",
        "api_catalog_link"
      ]
    },
    "content": {
      "score": 67,
      "confidence": 100,
      "passed": 5,
      "warned": 8,
      "failed": 0,
      "unknown": 0,
      "not_applicable": 2,
      "checks": [
        "title",
        "meta_description",
        "open_graph",
        "canonical",
        "language",
        "structured_data",
        "heading_structure",
        "content_density",
        "form_controls",
        "markdown_negotiation",
        "markdown_alternate",
        "code_languages",
        "api_schema_link",
        "glossary_context",
        "public_agent_guide"
      ]
    },
    "access_policy": {
      "score": 88,
      "confidence": 100,
      "passed": 2,
      "warned": 1,
      "failed": 0,
      "unknown": 0,
      "not_applicable": 2,
      "checks": [
        "ai_bot_access",
        "explicit_ai_policy",
        "content_signals",
        "agent_content_directives",
        "web_bot_auth"
      ]
    },
    "capabilities": {
      "score": 83,
      "confidence": 75,
      "passed": 3,
      "warned": 2,
      "failed": 0,
      "unknown": 2,
      "not_applicable": 3,
      "checks": [
        "webmcp",
        "remote_mcp",
        "openapi",
        "api_catalog",
        "mcp_server_card",
        "agent_skills",
        "oauth_discovery",
        "service_description_link",
        "origin_isolation",
        "webmcp_permission"
      ]
    }
  },
  "checks": {
    "https": {
      "id": "https",
      "dimension": "discoverability",
      "state": "pass",
      "weight": 3,
      "method": "document_analysis",
      "checked_url": "https://www.example.com/",
      "http_status": 200,
      "evidence": [
        "https"
      ],
      "caveats": [],
      "reference": "HTTPS",
      "maturity": "standard"
    },
    "http_response": {
      "id": "http_response",
      "dimension": "discoverability",
      "state": "pass",
      "weight": 3,
      "method": "document_analysis",
      "checked_url": "https://www.example.com/",
      "http_status": 200,
      "evidence": [
        "http_status_200"
      ],
      "caveats": [],
      "reference": "HTTP semantics",
      "maturity": "standard"
    },
    "llms_txt": {
      "id": "llms_txt",
      "dimension": "discoverability",
      "state": "pass",
      "weight": 2,
      "method": "well_known_path",
      "checked_url": "https://www.example.com/llms.txt",
      "http_status": 200,
      "evidence": [
        "markdown_h1",
        "markdown_links_1"
      ],
      "caveats": [],
      "reference": "llms.txt proposal",
      "maturity": "proposal"
    }
  },
  "recommendations": [
    {
      "code": "ADD_CANONICAL",
      "severity": "medium"
    },
    {
      "code": "ADD_STRUCTURED_DATA",
      "severity": "low"
    },
    {
      "code": "PUBLISH_MCP_METADATA",
      "severity": "medium"
    }
  ],
  "meta": {
    "cached": false,
    "fetch_path": "primary",
    "duration_ms": 1840,
    "probe_count": 22,
    "body_truncated": false,
    "source_version": "2026-08-28",
    "last_verified": "2026-08-28",
    "rubric_version": "2026-08-28.3",
    "max_probes": 32
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen
502 Fehlerhaftes Gateway

GET /v1/robots Credits: 1

Abfrageparameter

Parameter	Typ	erforderlich
url	string	optional
domain	string	optional
user_agent	string Standard `*`	optional
path	string	optional
skip_cache	string Zulässige Werte `1`	optional

Antwortfelder

Feld	Typ
`cache_age_s`	integer
`classification`	object
`classification.status`	string
`classification.reason`	string
`classification.evidence`	object
`classification.evidence.source`	string
`classification.evidence.method`	string
`classification.evidence.observed_at`	string
`classification.evidence.detail`	string
`classification.checked_at`	string
`domain`	string
`url`	string
`robots_url`	string
`status`	string
`checked_at`	string
`fetch`	object
`fetch.checked_url`	string
`fetch.http_status`	integer \| null
`fetch.final_url`	string \| null
`fetch.via_proxy`	boolean \| null
`fetch.redirect_count`	integer \| null
`fetch.content_type`	string \| null
`fetch.bytes`	integer \| null
`fetch.truncated`	boolean
`fetch.error`	string \| null
`sitemaps[]`	string[]
`groups[]`	object[]
`groups[]`	object
`groups[].user_agents[]`	string[]
`groups[].rules[]`	object[]
`groups[].rules[]`	object
`groups[].rules[].type`	string
`groups[].rules[].path`	string
`groups[].rules[].line`	integer
`groups[].crawl_delay`	number \| null
`other_directives[]`	object[]
`other_directives[]`	object
`other_directives[].name`	string
`other_directives[].count`	integer
`other_directives[].standard`	boolean
`test`	object
`test.user_agent`	string
`test.path`	string
`test.allowed`	boolean \| null
`test.matched_rule`	object
`test.matched_rule.type`	string
`test.matched_rule.path`	string
`test.matched_rule.line`	integer
`test.matched_group`	string \| null
`test.matched_user_agents[]`	string[]
`test.reason`	string
`ai_crawlers[]`	object[]
`ai_crawlers[]`	object
`ai_crawlers[].user_agent`	string
`ai_crawlers[].owner`	string
`ai_crawlers[].purpose`	string
`ai_crawlers[].root_access`	string
`ai_crawlers[].group`	string \| null
`issues[]`	object[]
`issues[]`	object
`issues[].code`	string
`issues[].count`	integer
`issues[].lines[]`	integer[]
`caveats[]`	string[]
`summary`	object
`summary.groups`	integer
`summary.rules`	integer
`summary.allow_rules`	integer
`summary.disallow_rules`	integer
`summary.sitemaps`	integer
`summary.issues`	integer
`summary.lines`	integer
`summary.ai_crawlers_allowed`	integer
`summary.ai_crawlers_disallowed`	integer
`summary.ai_crawlers_partial`	integer
`summary.ai_crawlers_unknown`	integer
`summary.ai_crawlers_with_specific_group`	integer
`meta`	object
`meta.cached`	boolean
`meta.duration_ms`	integer
`meta.source_version`	string

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/robots?url=https%3A%2F%2Fexample.com&domain=example.com&user_agent=GPTBot&path=%2Fadmin%2Fsettings&skip_cache=1"

const response = await fetch("https://domscan.net/v1/robots?url=https%3A%2F%2Fexample.com&domain=example.com&user_agent=GPTBot&path=%2Fadmin%2Fsettings&skip_cache=1", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/robots?url=https%3A%2F%2Fexample.com&domain=example.com&user_agent=GPTBot&path=%2Fadmin%2Fsettings&skip_cache=1",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/robots?url=https%3A%2F%2Fexample.com&domain=example.com&user_agent=GPTBot&path=%2Fadmin%2Fsettings&skip_cache=1", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/robots?url=https%3A%2F%2Fexample.com&domain=example.com&user_agent=GPTBot&path=%2Fadmin%2Fsettings&skip_cache=1")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "domain": "example.com",
  "url": "https://example.com/",
  "robots_url": "https://example.com/robots.txt",
  "status": "found",
  "checked_at": "2026-10-09T10:15:30.000Z",
  "fetch": {
    "checked_url": "https://example.com/robots.txt",
    "http_status": 200,
    "final_url": "https://example.com/robots.txt",
    "via_proxy": true,
    "redirect_count": 0,
    "content_type": "text/plain; charset=utf-8",
    "bytes": 180,
    "truncated": false,
    "error": null
  },
  "sitemaps": [
    "https://example.com/sitemap.xml"
  ],
  "groups": [
    {
      "user_agents": [
        "GPTBot",
        "CCBot"
      ],
      "rules": [
        {
          "type": "disallow",
          "path": "/",
          "line": 3
        }
      ],
      "crawl_delay": null
    },
    {
      "user_agents": [
        "*"
      ],
      "rules": [
        {
          "type": "disallow",
          "path": "/admin/",
          "line": 6
        },
        {
          "type": "allow",
          "path": "/admin/public$",
          "line": 7
        }
      ],
      "crawl_delay": 10
    }
  ],
  "other_directives": [
    {
      "name": "host",
      "count": 1,
      "standard": false
    }
  ],
  "test": {
    "user_agent": "GPTBot",
    "path": "/admin/settings",
    "allowed": false,
    "matched_rule": {
      "type": "disallow",
      "path": "/",
      "line": 3
    },
    "matched_group": "specific",
    "matched_user_agents": [
      "GPTBot"
    ],
    "reason": "matched_disallow"
  },
  "ai_crawlers": [
    {
      "user_agent": "GPTBot",
      "owner": "openai",
      "purpose": "training",
      "root_access": "disallowed",
      "group": "specific"
    },
    {
      "user_agent": "OAI-SearchBot",
      "owner": "openai",
      "purpose": "search",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "ChatGPT-User",
      "owner": "openai",
      "purpose": "user_fetch",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "ClaudeBot",
      "owner": "anthropic",
      "purpose": "training",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Claude-SearchBot",
      "owner": "anthropic",
      "purpose": "search",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Claude-User",
      "owner": "anthropic",
      "purpose": "user_fetch",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Google-Extended",
      "owner": "google",
      "purpose": "training_control",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "PerplexityBot",
      "owner": "perplexity",
      "purpose": "search",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Perplexity-User",
      "owner": "perplexity",
      "purpose": "user_fetch",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "CCBot",
      "owner": "common_crawl",
      "purpose": "training",
      "root_access": "disallowed",
      "group": "specific"
    },
    {
      "user_agent": "Bytespider",
      "owner": "bytedance",
      "purpose": "training",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Applebot-Extended",
      "owner": "apple",
      "purpose": "training_control",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "meta-externalagent",
      "owner": "meta",
      "purpose": "training",
      "root_access": "partial",
      "group": "wildcard"
    },
    {
      "user_agent": "Amazonbot",
      "owner": "amazon",
      "purpose": "search",
      "root_access": "partial",
      "group": "wildcard"
    }
  ],
  "issues": [
    {
      "code": "crawl_delay_nonstandard",
      "count": 1,
      "lines": [
        8
      ]
    },
    {
      "code": "nonstandard_directive",
      "count": 1,
      "lines": [
        10
      ]
    }
  ],
  "caveats": [],
  "summary": {
    "groups": 2,
    "rules": 3,
    "allow_rules": 1,
    "disallow_rules": 2,
    "sitemaps": 1,
    "issues": 2,
    "lines": 12,
    "ai_crawlers_allowed": 0,
    "ai_crawlers_disallowed": 2,
    "ai_crawlers_partial": 12,
    "ai_crawlers_unknown": 0,
    "ai_crawlers_with_specific_group": 2
  },
  "meta": {
    "cached": false,
    "duration_ms": 184,
    "source_version": "2026-10-09"
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen
502 Fehlerhaftes Gateway

POST /v1/robots/test Credits: 1

Body-Parameter

Parameter	Typ	erforderlich
robots_txt	string	optional
url	string	optional
urls	string[]	erforderlich
user_agents	string[]	optional

Antwortfelder

Feld	Typ
`source`	string
`url`	string \| null
`robots_url`	string \| null
`status`	string
`checked_at`	string
`summary`	object
`summary.tests`	integer
`summary.allowed`	integer
`summary.disallowed`	integer
`summary.unknown`	integer
`summary.groups`	integer
`summary.rules`	integer
`summary.issues`	integer
`user_agents[]`	object[]
`user_agents[]`	object
`user_agents[].user_agent`	string
`user_agents[].allowed`	integer
`user_agents[].disallowed`	integer
`user_agents[].unknown`	integer
`results[]`	object[]
`results[]`	object
`results[].url`	string
`results[].path`	string
`results[].user_agent`	string
`results[].token`	string
`results[].allowed`	boolean \| null
`results[].reason`	string
`results[].matched_rule`	object
`results[].matched_rule.type`	string
`results[].matched_rule.path`	string
`results[].matched_rule.line`	integer
`results[].matched_group`	string \| null
`results[].matched_user_agents[]`	string[]
`results[].vendor`	object
`results[].vendor.allowed`	boolean \| null
`results[].vendor.reason`	string
`results[].vendor.matched_rule`	object
`results[].vendor.matched_rule.type`	string
`results[].vendor.matched_rule.path`	string
`results[].vendor.matched_rule.line`	integer
`results[].vendor.matched_group`	string
`sitemaps[]`	string[]
`issues[]`	object[]
`issues[]`	object
`issues[].code`	string
`issues[].count`	integer
`issues[].lines[]`	integer[]
`caveats[]`	string[]
`fetch`	object
`fetch.checked_url`	string
`fetch.http_status`	integer \| null
`fetch.final_url`	string \| null
`fetch.via_proxy`	boolean \| null
`fetch.redirect_count`	integer \| null
`fetch.content_type`	string \| null
`fetch.bytes`	integer \| null
`fetch.truncated`	boolean
`fetch.error`	string \| null
`meta`	object
`meta.cached`	boolean
`meta.duration_ms`	integer

Beispielanfrage

curl -X POST "https://domscan.net/v1/robots/test" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "robots_txt": "User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow: /admin/\nAllow: /admin/public",
  "urls": [
    "/blog/post-1",
    "/admin/public"
  ],
  "user_agents": [
    "Googlebot",
    "GPTBot"
  ]
}'

const response = await fetch("https://domscan.net/v1/robots/test", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "robots_txt": "User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow: /admin/\nAllow: /admin/public",
    "urls": [
      "/blog/post-1",
      "/admin/public"
    ],
    "user_agents": [
      "Googlebot",
      "GPTBot"
    ]
  }),
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.post(
    "https://domscan.net/v1/robots/test",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "robots_txt": "User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow: /admin/\nAllow: /admin/public",
        "urls": [
            "/blog/post-1",
            "/admin/public",
        ],
        "user_agents": [
            "Googlebot",
            "GPTBot",
        ],
    },
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "robots_txt": "User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow: /admin/\nAllow: /admin/public",
	  "urls": [
	    "/blog/post-1",
	    "/admin/public"
	  ],
	  "user_agents": [
	    "Googlebot",
	    "GPTBot"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/robots/test", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/robots/test")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "robots_txt" => "User-agent: GPTBot\nDisallow: /\n\nUser-agent: *\nDisallow: /admin/\nAllow: /admin/public",
  "urls" => [
    "/blog/post-1",
    "/admin/public"
  ],
  "user_agents" => [
    "Googlebot",
    "GPTBot"
  ]
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "source": "provided",
  "url": null,
  "robots_url": null,
  "status": "found",
  "checked_at": "2026-10-13T10:00:00.000Z",
  "summary": {
    "tests": 4,
    "allowed": 2,
    "disallowed": 2,
    "unknown": 0,
    "groups": 2,
    "rules": 3,
    "issues": 0
  },
  "user_agents": [
    {
      "user_agent": "Googlebot",
      "allowed": 2,
      "disallowed": 0,
      "unknown": 0
    },
    {
      "user_agent": "GPTBot",
      "allowed": 0,
      "disallowed": 2,
      "unknown": 0
    }
  ],
  "results": [
    {
      "url": "/blog/post-1",
      "path": "/blog/post-1",
      "user_agent": "Googlebot",
      "token": "Googlebot",
      "allowed": true,
      "reason": "no_matching_rule",
      "matched_rule": null,
      "matched_group": "wildcard",
      "matched_user_agents": [
        "*"
      ],
      "vendor": null
    },
    {
      "url": "/admin/public",
      "path": "/admin/public",
      "user_agent": "Googlebot",
      "token": "Googlebot",
      "allowed": true,
      "reason": "matched_allow",
      "matched_rule": {
        "type": "allow",
        "path": "/admin/public",
        "line": 6
      },
      "matched_group": "wildcard",
      "matched_user_agents": [
        "*"
      ],
      "vendor": null
    },
    {
      "url": "/blog/post-1",
      "path": "/blog/post-1",
      "user_agent": "GPTBot",
      "token": "GPTBot",
      "allowed": false,
      "reason": "matched_disallow",
      "matched_rule": {
        "type": "disallow",
        "path": "/",
        "line": 2
      },
      "matched_group": "specific",
      "matched_user_agents": [
        "GPTBot"
      ],
      "vendor": null
    },
    {
      "url": "/admin/public",
      "path": "/admin/public",
      "user_agent": "GPTBot",
      "token": "GPTBot",
      "allowed": false,
      "reason": "matched_disallow",
      "matched_rule": {
        "type": "disallow",
        "path": "/",
        "line": 2
      },
      "matched_group": "specific",
      "matched_user_agents": [
        "GPTBot"
      ],
      "vendor": null
    }
  ],
  "sitemaps": [],
  "issues": [],
  "caveats": [],
  "fetch": null,
  "meta": {
    "cached": false,
    "duration_ms": 2
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
409 HTTP 409
422 HTTP 422
429 Zu viele Anfragen

GET /v1/sitemaps Credits: 2

Abfrageparameter

Parameter	Typ	erforderlich
url	string	optional
domain	string	optional
sitemap	string	optional
max_sitemaps	integer Standard `5`	optional

Antwortfelder

Feld	Typ
`classification`	object
`classification.status`	string
`classification.reason`	string
`classification.evidence`	object
`classification.evidence.source`	string
`classification.evidence.method`	string
`classification.evidence.observed_at`	string
`classification.evidence.detail`	string
`classification.checked_at`	string
`url`	string
`domain`	string
`origin`	string
`status`	string
`checked_at`	string
`fetch`	object
`fetch.checked_url`	string
`fetch.http_status`	integer \| null
`fetch.final_url`	string \| null
`fetch.via_proxy`	boolean \| null
`robots_txt`	object
`robots_txt.status`	string
`robots_txt.url`	string
`robots_txt.http_status`	integer \| null
`robots_txt.declared_sitemaps[]`	object[]
`robots_txt.declared_sitemaps[]`	object
`robots_txt.declared_sitemaps[].url`	string
`robots_txt.declared_sitemaps[].same_site`	boolean
`sitemaps[]`	object[]
`sitemaps[]`	object
`sitemaps[].url`	string
`sitemaps[].source`	string
`sitemaps[].parent`	string \| null
`sitemaps[].status`	string
`sitemaps[].http_status`	integer \| null
`sitemaps[].final_url`	string \| null
`sitemaps[].via_proxy`	boolean \| null
`sitemaps[].content_type`	string \| null
`sitemaps[].bytes`	integer \| null
`sitemaps[].type`	string \| null
`sitemaps[].url_count`	integer
`sitemaps[].child_sitemap_count`	integer
`sitemaps[].lastmod`	object
`sitemaps[].lastmod.newest`	string \| null
`sitemaps[].lastmod.oldest`	string \| null
`sitemaps[].lastmod.with_lastmod_ratio`	number \| null
`sitemaps[].extensions`	object
`sitemaps[].extensions.images`	boolean
`sitemaps[].extensions.videos`	boolean
`sitemaps[].extensions.news`	boolean
`sitemaps[].extensions.hreflang`	boolean
`sitemaps[].counts`	object
`sitemaps[].counts.invalid_loc`	integer
`sitemaps[].counts.missing_loc`	integer
`sitemaps[].counts.loc_too_long`	integer
`sitemaps[].counts.cross_host_urls`	integer
`sitemaps[].counts.protocol_mismatch_urls`	integer
`sitemaps[].counts.duplicate_urls`	integer
`sitemaps[].counts.invalid_lastmod`	integer
`sitemaps[].counts.future_lastmod`	integer
`sitemaps[].counts.cross_site_child_sitemaps`	integer
`sitemaps[].issues[]`	string[]
`sitemaps[].sample_urls[]`	string[]
`totals`	object
`totals.sitemaps_checked`	integer
`totals.sitemaps_discovered`	integer
`totals.urls_counted`	integer
`totals.budget_exhausted`	boolean
`freshness`	object
`freshness.newest_lastmod`	string \| null
`freshness.days_since_newest`	integer \| null
`issues[]`	string[]
`caveats[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/sitemaps?url=https%3A%2F%2Fexample.com&domain=example.com&sitemap=https%3A%2F%2Fexample.com%2Fsitemap_index.xml&max_sitemaps=5"

const response = await fetch("https://domscan.net/v1/sitemaps?url=https%3A%2F%2Fexample.com&domain=example.com&sitemap=https%3A%2F%2Fexample.com%2Fsitemap_index.xml&max_sitemaps=5", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/sitemaps?url=https%3A%2F%2Fexample.com&domain=example.com&sitemap=https%3A%2F%2Fexample.com%2Fsitemap_index.xml&max_sitemaps=5",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/sitemaps?url=https%3A%2F%2Fexample.com&domain=example.com&sitemap=https%3A%2F%2Fexample.com%2Fsitemap_index.xml&max_sitemaps=5", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/sitemaps?url=https%3A%2F%2Fexample.com&domain=example.com&sitemap=https%3A%2F%2Fexample.com%2Fsitemap_index.xml&max_sitemaps=5")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "domain": "example.com",
  "origin": "https://example.com",
  "status": "found",
  "checked_at": "2026-10-09T12:00:00.000Z",
  "fetch": {
    "checked_url": "https://example.com/robots.txt",
    "http_status": 200,
    "final_url": "https://example.com/robots.txt",
    "via_proxy": true
  },
  "robots_txt": {
    "status": "found",
    "url": "https://example.com/robots.txt",
    "http_status": 200,
    "declared_sitemaps": [
      {
        "url": "https://example.com/sitemap_index.xml",
        "same_site": true
      },
      {
        "url": "https://sitemaps.example.net/example.xml",
        "same_site": false
      }
    ]
  },
  "sitemaps": [
    {
      "url": "https://example.com/sitemap_index.xml",
      "source": "robots",
      "parent": null,
      "status": "ok",
      "http_status": 200,
      "final_url": "https://example.com/sitemap_index.xml",
      "via_proxy": true,
      "content_type": "application/xml; charset=utf-8",
      "bytes": 412,
      "type": "sitemapindex",
      "url_count": 0,
      "child_sitemap_count": 2,
      "lastmod": {
        "newest": "2026-10-01T00:00:00.000Z",
        "oldest": "2026-10-01T00:00:00.000Z",
        "with_lastmod_ratio": 1
      },
      "extensions": {
        "images": false,
        "videos": false,
        "news": false,
        "hreflang": false
      },
      "counts": {
        "invalid_loc": 0,
        "missing_loc": 0,
        "loc_too_long": 0,
        "cross_host_urls": 0,
        "protocol_mismatch_urls": 0,
        "duplicate_urls": 0,
        "invalid_lastmod": 0,
        "future_lastmod": 0,
        "cross_site_child_sitemaps": 0
      },
      "issues": [],
      "sample_urls": [
        "https://example.com/posts.xml",
        "https://example.com/pages.xml"
      ]
    },
    {
      "url": "https://example.com/posts.xml",
      "source": "index_child",
      "parent": "https://example.com/sitemap_index.xml",
      "status": "ok",
      "http_status": 200,
      "final_url": "https://example.com/posts.xml",
      "via_proxy": true,
      "content_type": "application/xml",
      "bytes": 18234,
      "type": "urlset",
      "url_count": 120,
      "child_sitemap_count": 0,
      "lastmod": {
        "newest": "2026-10-05T00:00:00.000Z",
        "oldest": "2024-03-11T00:00:00.000Z",
        "with_lastmod_ratio": 0.975
      },
      "extensions": {
        "images": true,
        "videos": false,
        "news": false,
        "hreflang": true
      },
      "counts": {
        "invalid_loc": 0,
        "missing_loc": 0,
        "loc_too_long": 0,
        "cross_host_urls": 0,
        "protocol_mismatch_urls": 2,
        "duplicate_urls": 1,
        "invalid_lastmod": 3,
        "future_lastmod": 0,
        "cross_site_child_sitemaps": 0
      },
      "issues": [
        "protocol_mismatch",
        "duplicate_urls",
        "invalid_lastmod"
      ],
      "sample_urls": [
        "https://example.com/blog/a",
        "https://example.com/blog/b",
        "https://example.com/blog/c",
        "http://example.com/blog/d",
        "https://example.com/blog/e"
      ]
    },
    {
      "url": "https://example.com/pages.xml",
      "source": "index_child",
      "parent": "https://example.com/sitemap_index.xml",
      "status": "unknown",
      "http_status": 429,
      "final_url": "https://example.com/pages.xml",
      "via_proxy": true,
      "content_type": "text/html",
      "bytes": 162,
      "type": null,
      "url_count": 0,
      "child_sitemap_count": 0,
      "lastmod": {
        "newest": null,
        "oldest": null,
        "with_lastmod_ratio": null
      },
      "extensions": {
        "images": false,
        "videos": false,
        "news": false,
        "hreflang": false
      },
      "counts": {
        "invalid_loc": 0,
        "missing_loc": 0,
        "loc_too_long": 0,
        "cross_host_urls": 0,
        "protocol_mismatch_urls": 0,
        "duplicate_urls": 0,
        "invalid_lastmod": 0,
        "future_lastmod": 0,
        "cross_site_child_sitemaps": 0
      },
      "issues": [
        "rate_limited"
      ],
      "sample_urls": []
    }
  ],
  "totals": {
    "sitemaps_checked": 3,
    "sitemaps_discovered": 4,
    "urls_counted": 120,
    "budget_exhausted": false
  },
  "freshness": {
    "newest_lastmod": "2026-10-05T00:00:00.000Z",
    "days_since_newest": 4
  },
  "issues": [
    "cross_site_sitemap_declared",
    "protocol_mismatch",
    "duplicate_urls",
    "invalid_lastmod",
    "rate_limited"
  ],
  "caveats": [
    "counts_cover_fetched_files_only",
    "cross_site_sitemaps_not_fetched"
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen
502 Fehlerhaftes Gateway

GET /v1/onpage Credits: 2-6

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
render	boolean	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string
`fetch.content_type`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`fetch.redirect_count`	integer
`fetch.duration_ms`	integer
`fetch.rendered`	boolean
`score`	integer \| null
`meta`	object
`meta.title`	string \| null
`meta.title_length`	integer
`meta.description`	string \| null
`meta.description_length`	integer
`meta.canonical`	string \| null
`meta.canonical_self_referencing`	boolean \| null
`meta.canonical_header`	string \| null
`meta.robots`	string \| null
`meta.googlebot`	string \| null
`meta.x_robots_tag`	string \| null
`meta.indexable`	boolean
`meta.googlebot_noindex`	boolean
`meta.nofollow`	boolean
`meta.meta_refresh`	string \| null
`meta.duplicate_meta_tags[]`	string[]
`meta.lang`	string \| null
`meta.viewport`	string \| null
`meta.favicon`	string \| null
`meta.open_graph`	object
`meta.open_graph.title`	string \| null
`meta.open_graph.description`	string \| null
`meta.open_graph.image`	string \| null
`meta.open_graph.url`	string \| null
`meta.open_graph.type`	string \| null
`meta.twitter`	object
`meta.twitter.card`	string \| null
`meta.twitter.title`	string \| null
`meta.twitter.description`	string \| null
`meta.twitter.image`	string \| null
`headings`	object
`headings.h1[]`	string[]
`headings.counts`	object
`headings.counts.h1`	integer
`headings.counts.h2`	integer
`headings.counts.h3`	integer
`headings.counts.h4`	integer
`headings.counts.h5`	integer
`headings.counts.h6`	integer
`headings.outline[]`	object[]
`headings.outline[]`	object
`headings.outline[].level`	integer
`headings.outline[].text`	string
`content`	object
`content.word_count`	integer
`content.text_bytes`	integer
`content.html_bytes`	integer
`content.text_to_html_ratio`	number
`links`	object
`links.total`	integer
`links.internal`	integer
`links.external`	integer
`links.nofollow`	integer
`links.empty_anchor`	integer
`links.unresolvable`	integer
`images`	object
`images.total`	integer
`images.missing_alt`	integer
`images.empty_alt`	integer
`images.missing_dimensions`	integer
`images.lazy_loaded`	integer
`resources`	object
`resources.scripts`	integer
`resources.inline_scripts`	integer
`resources.stylesheets`	integer
`resources.iframes`	integer
`resources.mixed_content`	integer
`resources.render_blocking_scripts`	integer \| null
`resources.render_blocking_stylesheets`	integer \| null
`structured_data`	object
`structured_data.json_ld`	integer
`structured_data.microdata`	integer
`structured_data.rdfa`	integer
`structured_data.types[]`	string[]
`hreflang`	object
`hreflang.count`	integer
`checks[]`	object[]
`checks[]`	object
`checks[].id`	string
`checks[].status`	string
`checks[].severity`	string
`checks[].value`	unknown
`issues[]`	string[]
`caveats[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/onpage?url=https%3A%2F%2Fexample.com&render=false"

const response = await fetch("https://domscan.net/v1/onpage?url=https%3A%2F%2Fexample.com&render=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/onpage?url=https%3A%2F%2Fexample.com&render=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/onpage?url=https%3A%2F%2Fexample.com&render=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/onpage?url=https%3A%2F%2Fexample.com&render=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/shoes/trail-runner",
    "content_type": "text/html",
    "bytes": 3535,
    "truncated": false,
    "redirect_count": 0,
    "duration_ms": 412,
    "rendered": false
  },
  "score": 87,
  "meta": {
    "title": "Trail Running Shoes for Rocky Terrain | Example Outdoor",
    "title_length": 55,
    "description": "Lightweight trail running shoes with a grippy outsole, rock plate and breathable mesh. Free returns within 30 days on every pair.",
    "description_length": 129,
    "canonical": "https://example.com/shoes/trail-runner",
    "canonical_self_referencing": true,
    "canonical_header": null,
    "robots": "index, follow",
    "googlebot": null,
    "x_robots_tag": null,
    "indexable": true,
    "googlebot_noindex": false,
    "nofollow": false,
    "meta_refresh": null,
    "duplicate_meta_tags": [],
    "lang": "en",
    "viewport": "width=device-width, initial-scale=1",
    "favicon": "/favicon.ico",
    "open_graph": {
      "title": "Trail Running Shoes for Rocky Terrain",
      "description": null,
      "image": "https://example.com/images/trail-runner.jpg",
      "url": null,
      "type": null
    },
    "twitter": {
      "card": "summary_large_image",
      "title": null,
      "description": null,
      "image": null
    }
  },
  "headings": {
    "h1": [
      "Trail Running Shoes for Rocky Terrain"
    ],
    "counts": {
      "h1": 1,
      "h2": 1,
      "h3": 0,
      "h4": 1,
      "h5": 0,
      "h6": 0
    },
    "outline": [
      {
        "level": 1,
        "text": "Trail Running Shoes for Rocky Terrain"
      },
      {
        "level": 2,
        "text": "Why runners choose these trail running shoes"
      },
      {
        "level": 4,
        "text": "Sizing"
      }
    ]
  },
  "content": {
    "word_count": 122,
    "text_bytes": 780,
    "html_bytes": 3535,
    "text_to_html_ratio": 0.221
  },
  "links": {
    "total": 7,
    "internal": 5,
    "external": 2,
    "nofollow": 1,
    "empty_anchor": 1,
    "unresolvable": 0
  },
  "images": {
    "total": 3,
    "missing_alt": 1,
    "empty_alt": 0,
    "missing_dimensions": 2,
    "lazy_loaded": 0
  },
  "resources": {
    "scripts": 1,
    "inline_scripts": 0,
    "stylesheets": 1,
    "iframes": 0,
    "mixed_content": 1,
    "render_blocking_scripts": 0,
    "render_blocking_stylesheets": 1
  },
  "structured_data": {
    "json_ld": 2,
    "microdata": 1,
    "rdfa": 0,
    "types": [
      "AggregateRating",
      "Brand",
      "BreadcrumbList",
      "ListItem",
      "Offer",
      "Product",
      "Rating",
      "Review"
    ]
  },
  "hreflang": {
    "count": 3
  },
  "checks": [
    {
      "id": "mixed_content",
      "status": "fail",
      "severity": "high",
      "value": 1
    },
    {
      "id": "heading_hierarchy",
      "status": "warn",
      "severity": "low",
      "value": 1
    },
    {
      "id": "word_count",
      "status": "warn",
      "severity": "medium",
      "value": 122
    },
    {
      "id": "images_alt",
      "status": "warn",
      "severity": "medium",
      "value": 1
    },
    {
      "id": "title_present",
      "status": "pass",
      "severity": "high"
    },
    {
      "id": "h1_present",
      "status": "pass",
      "severity": "high",
      "value": 1
    },
    {
      "id": "render_blocking_resources",
      "status": "warn",
      "severity": "low",
      "value": 1
    }
  ],
  "issues": [
    "mixed_content",
    "heading_hierarchy",
    "word_count",
    "images_alt",
    "images_dimensions",
    "empty_anchor_text",
    "render_blocking_resources"
  ],
  "caveats": []
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/onpage/render-diff Credits: 7

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`raw`	object
`raw.fetch`	object
`raw.fetch.http_status`	integer \| null
`raw.fetch.final_url`	string
`raw.fetch.content_type`	string \| null
`raw.fetch.bytes`	integer
`raw.fetch.truncated`	boolean
`raw.fetch.redirect_count`	integer
`raw.fetch.duration_ms`	integer
`raw.fetch.rendered`	boolean
`raw.signals`	object
`raw.signals.title`	string \| null
`raw.signals.meta_description`	string \| null
`raw.signals.canonical`	string \| null
`raw.signals.robots`	string \| null
`raw.signals.noindex`	boolean
`raw.signals.h1[]`	string[]
`raw.signals.word_count`	integer
`raw.signals.internal_links`	integer
`raw.signals.external_links`	integer
`raw.signals.structured_data_types[]`	string[]
`raw.signals.hreflang_count`	integer
`raw.signals.lang`	string \| null
`rendered`	object
`rendered.fetch`	object
`rendered.fetch.http_status`	integer \| null
`rendered.fetch.final_url`	string
`rendered.fetch.content_type`	string \| null
`rendered.fetch.bytes`	integer
`rendered.fetch.truncated`	boolean
`rendered.fetch.redirect_count`	integer
`rendered.fetch.duration_ms`	integer
`rendered.fetch.rendered`	boolean
`rendered.signals`	object
`rendered.signals.title`	string \| null
`rendered.signals.meta_description`	string \| null
`rendered.signals.canonical`	string \| null
`rendered.signals.robots`	string \| null
`rendered.signals.noindex`	boolean
`rendered.signals.h1[]`	string[]
`rendered.signals.word_count`	integer
`rendered.signals.internal_links`	integer
`rendered.signals.external_links`	integer
`rendered.signals.structured_data_types[]`	string[]
`rendered.signals.hreflang_count`	integer
`rendered.signals.lang`	string \| null
`js_dependence`	string \| null
`rendered_word_share`	number \| null
`differences[]`	object[]
`differences[]`	object
`differences[].field`	string
`differences[].change`	string
`differences[].impact`	string
`differences[].raw`	unknown
`differences[].rendered`	unknown
`issues[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/onpage/render-diff?url=https%3A%2F%2Fexample.com"

const response = await fetch("https://domscan.net/v1/onpage/render-diff?url=https%3A%2F%2Fexample.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/onpage/render-diff?url=https%3A%2F%2Fexample.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/onpage/render-diff?url=https%3A%2F%2Fexample.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/onpage/render-diff?url=https%3A%2F%2Fexample.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "raw": {
    "fetch": {
      "http_status": 200,
      "final_url": "https://example.com/shoes/trail-runner",
      "content_type": "text/html",
      "bytes": 183,
      "truncated": false,
      "redirect_count": 0,
      "duration_ms": 380,
      "rendered": false
    },
    "signals": {
      "title": "Example Outdoor",
      "meta_description": null,
      "canonical": null,
      "robots": "noindex",
      "noindex": true,
      "h1": [],
      "word_count": 0,
      "internal_links": 0,
      "external_links": 0,
      "structured_data_types": [],
      "hreflang_count": 0,
      "lang": "en"
    }
  },
  "rendered": {
    "fetch": {
      "http_status": 200,
      "final_url": "https://example.com/shoes/trail-runner",
      "content_type": "text/html",
      "bytes": 3535,
      "truncated": false,
      "redirect_count": 0,
      "duration_ms": 4210,
      "rendered": true
    },
    "signals": {
      "title": "Trail Running Shoes for Rocky Terrain | Example Outdoor",
      "meta_description": "Lightweight trail running shoes with a grippy outsole, rock plate and breathable mesh. Free returns within 30 days on every pair.",
      "canonical": "https://example.com/shoes/trail-runner",
      "robots": "index, follow",
      "noindex": false,
      "h1": [
        "Trail Running Shoes for Rocky Terrain"
      ],
      "word_count": 122,
      "internal_links": 5,
      "external_links": 2,
      "structured_data_types": [
        "AggregateRating",
        "Brand",
        "BreadcrumbList",
        "ListItem",
        "Offer",
        "Product",
        "Rating",
        "Review"
      ],
      "hreflang_count": 3,
      "lang": "en"
    }
  },
  "js_dependence": "high",
  "rendered_word_share": 1,
  "differences": [
    {
      "field": "title",
      "change": "changed_by_js",
      "impact": "high",
      "raw": "Example Outdoor",
      "rendered": "Trail Running Shoes for Rocky Terrain | Example Outdoor"
    },
    {
      "field": "meta_description",
      "change": "added_by_js",
      "impact": "medium",
      "raw": null,
      "rendered": "Lightweight trail running shoes with a grippy outsole, rock plate and breathable mesh. Free returns within 30 days on every pair."
    },
    {
      "field": "canonical",
      "change": "added_by_js",
      "impact": "high",
      "raw": null,
      "rendered": "https://example.com/shoes/trail-runner"
    },
    {
      "field": "robots",
      "change": "changed_by_js",
      "impact": "high",
      "raw": "noindex",
      "rendered": "index, follow"
    },
    {
      "field": "noindex",
      "change": "removed_by_js",
      "impact": "high",
      "raw": true,
      "rendered": false
    }
  ],
  "issues": [
    "robots_changed_by_js",
    "canonical_changed_by_js",
    "h1_requires_js",
    "content_requires_js",
    "links_require_js",
    "structured_data_changed_by_js"
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/structured-data Credits: 2-6

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
render	boolean	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string
`fetch.content_type`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`fetch.redirect_count`	integer
`fetch.duration_ms`	integer
`fetch.rendered`	boolean
`summary`	object
`summary.json_ld`	integer
`summary.microdata`	integer
`summary.rdfa`	integer
`summary.total_items`	integer
`summary.valid_items`	integer
`summary.errors`	integer
`summary.warnings`	integer
`types[]`	string[]
`block_errors[]`	string[]
`items[]`	object[]
`items[]`	object
`items[].format`	string
`items[].types[]`	string[]
`items[].properties[]`	string[]
`items[].values`	object
`items[].children[]`	object[]
`items[].children[]`	object
`items[].children[].format`	string
`items[].children[].types[]`	string[]
`items[].children[].properties[]`	string[]
`items[].children[].values`	object
`items[].children[].children[]`	object[]
`items[].children[].children[]`	object
`items[].children[].path`	string
`items[].children[].status`	string
`items[].children[].errors[]`	object[]
`items[].children[].errors[]`	object
`items[].children[].errors[].code`	string
`items[].children[].errors[].property`	string
`items[].children[].warnings[]`	object[]
`items[].children[].warnings[]`	object
`items[].children[].warnings[].code`	string
`items[].children[].warnings[].property`	string
`items[].path`	string
`items[].status`	string
`items[].errors[]`	object[]
`items[].errors[]`	object
`items[].errors[].code`	string
`items[].errors[].property`	string
`items[].warnings[]`	object[]
`items[].warnings[]`	object
`items[].warnings[].code`	string
`items[].warnings[].property`	string

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/structured-data?url=https%3A%2F%2Fexample.com&render=false"

const response = await fetch("https://domscan.net/v1/structured-data?url=https%3A%2F%2Fexample.com&render=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/structured-data?url=https%3A%2F%2Fexample.com&render=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/structured-data?url=https%3A%2F%2Fexample.com&render=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/structured-data?url=https%3A%2F%2Fexample.com&render=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/shoes/trail-runner",
    "content_type": "text/html",
    "bytes": 3535,
    "truncated": false,
    "redirect_count": 0,
    "duration_ms": 412,
    "rendered": false
  },
  "summary": {
    "json_ld": 2,
    "microdata": 1,
    "rdfa": 0,
    "total_items": 9,
    "valid_items": 3,
    "errors": 1,
    "warnings": 5
  },
  "types": [
    "AggregateRating",
    "Brand",
    "BreadcrumbList",
    "ListItem",
    "Offer",
    "Product",
    "Rating",
    "Review"
  ],
  "block_errors": [],
  "items": [
    {
      "format": "json-ld",
      "types": [
        "Product"
      ],
      "properties": [
        "name",
        "image",
        "sku",
        "brand",
        "offers",
        "aggregateRating"
      ],
      "values": {
        "name": "Trail Runner 2",
        "image": "https://example.com/images/trail-runner.jpg",
        "sku": "TR-2"
      },
      "children": [
        {
          "format": "json-ld",
          "types": [
            "Brand"
          ],
          "properties": [
            "name"
          ],
          "values": {
            "name": "Example Outdoor"
          },
          "children": [],
          "path": "json_ld[0].children[0]",
          "status": "unchecked",
          "errors": [],
          "warnings": []
        },
        {
          "format": "json-ld",
          "types": [
            "Offer"
          ],
          "properties": [
            "price",
            "priceCurrency",
            "availability"
          ],
          "values": {
            "price": "129.00",
            "priceCurrency": "EUR",
            "availability": "https://schema.org/InStock"
          },
          "children": [],
          "path": "json_ld[0].children[1]",
          "status": "warnings",
          "errors": [],
          "warnings": [
            {
              "code": "missing_recommended",
              "property": "url"
            }
          ]
        },
        {
          "format": "json-ld",
          "types": [
            "AggregateRating"
          ],
          "properties": [
            "ratingValue",
            "reviewCount"
          ],
          "values": {
            "ratingValue": "4.6",
            "reviewCount": "87"
          },
          "children": [],
          "path": "json_ld[0].children[2]",
          "status": "warnings",
          "errors": [],
          "warnings": [
            {
              "code": "missing_recommended",
              "property": "bestRating"
            }
          ]
        }
      ],
      "path": "json_ld[0]",
      "status": "warnings",
      "errors": [],
      "warnings": [
        {
          "code": "missing_recommended",
          "property": "description"
        }
      ]
    },
    {
      "format": "json-ld",
      "types": [
        "BreadcrumbList"
      ],
      "properties": [
        "itemListElement"
      ],
      "values": {},
      "children": [
        {
          "format": "json-ld",
          "types": [
            "ListItem"
          ],
          "properties": [
            "position",
            "name",
            "item"
          ],
          "values": {
            "position": "1",
            "name": "Shoes",
            "item": "https://example.com/shoes"
          },
          "children": [],
          "path": "json_ld[1].children[0]",
          "status": "valid",
          "errors": [],
          "warnings": []
        },
        {
          "format": "json-ld",
          "types": [
            "ListItem"
          ],
          "properties": [
            "name"
          ],
          "values": {
            "name": "Trail Runner 2"
          },
          "children": [],
          "path": "json_ld[1].children[1]",
          "status": "errors",
          "errors": [
            {
              "code": "missing_required",
              "property": "position"
            }
          ],
          "warnings": [
            {
              "code": "missing_recommended",
              "property": "item"
            }
          ]
        }
      ],
      "path": "json_ld[1]",
      "status": "valid",
      "errors": [],
      "warnings": []
    }
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/keyword-density Credits: 2-6

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
render	boolean	optional
keywords	string	optional
top	integer Standard `20`	optional
include_stopwords	boolean	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string
`fetch.content_type`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`fetch.redirect_count`	integer
`fetch.duration_ms`	integer
`fetch.rendered`	boolean
`language`	string \| null
`total_words`	integer
`unique_words`	integer
`stopwords_removed`	boolean
`keywords`	object
`keywords.one_word[]`	object[]
`keywords.one_word[]`	object
`keywords.one_word[].keyword`	string
`keywords.one_word[].count`	integer
`keywords.one_word[].density`	number
`keywords.two_words[]`	object[]
`keywords.two_words[]`	object
`keywords.two_words[].keyword`	string
`keywords.two_words[].count`	integer
`keywords.two_words[].density`	number
`keywords.three_words[]`	object[]
`keywords.three_words[]`	object
`keywords.three_words[].keyword`	string
`keywords.three_words[].count`	integer
`keywords.three_words[].density`	number
`targets[]`	object[]
`targets[]`	object
`targets[].keyword`	string
`targets[].count`	integer
`targets[].density`	number
`targets[].in_title`	boolean
`targets[].in_meta_description`	boolean
`targets[].in_h1`	boolean
`targets[].in_headings`	boolean
`targets[].in_url`	boolean
`targets[].in_first_100_words`	boolean
`caveats[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/keyword-density?url=https%3A%2F%2Fexample.com&render=false&keywords=launch%2Cgrid&top=20&include_stopwords=false"

const response = await fetch("https://domscan.net/v1/keyword-density?url=https%3A%2F%2Fexample.com&render=false&keywords=launch%2Cgrid&top=20&include_stopwords=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/keyword-density?url=https%3A%2F%2Fexample.com&render=false&keywords=launch%2Cgrid&top=20&include_stopwords=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/keyword-density?url=https%3A%2F%2Fexample.com&render=false&keywords=launch%2Cgrid&top=20&include_stopwords=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/keyword-density?url=https%3A%2F%2Fexample.com&render=false&keywords=launch%2Cgrid&top=20&include_stopwords=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/shoes/trail-runner",
    "content_type": "text/html",
    "bytes": 3535,
    "truncated": false,
    "redirect_count": 0,
    "duration_ms": 412,
    "rendered": false
  },
  "language": "en",
  "total_words": 122,
  "unique_words": 86,
  "stopwords_removed": true,
  "keywords": {
    "one_word": [
      {
        "keyword": "shoes",
        "count": 5,
        "density": 4.1
      },
      {
        "keyword": "trail",
        "count": 5,
        "density": 4.1
      },
      {
        "keyword": "running",
        "count": 5,
        "density": 4.1
      }
    ],
    "two_words": [
      {
        "keyword": "trail running",
        "count": 5,
        "density": 4.1
      },
      {
        "keyword": "running shoes",
        "count": 4,
        "density": 3.28
      },
      {
        "keyword": "rocky terrain",
        "count": 3,
        "density": 2.46
      }
    ],
    "three_words": [
      {
        "keyword": "trail running shoes",
        "count": 4,
        "density": 3.28
      }
    ]
  },
  "targets": [
    {
      "keyword": "trail running shoes",
      "count": 4,
      "density": 3.28,
      "in_title": true,
      "in_meta_description": true,
      "in_h1": true,
      "in_headings": true,
      "in_url": false,
      "in_first_100_words": true
    }
  ],
  "caveats": []
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/links Credits: 2-6

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
render	boolean	optional
check	boolean	optional
type	string Zulässige Werte `allinternalexternal` Standard `all`	optional
limit	integer Standard `200`	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string
`fetch.content_type`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`fetch.redirect_count`	integer
`fetch.duration_ms`	integer
`fetch.rendered`	boolean
`summary`	object
`summary.total`	integer
`summary.internal`	integer
`summary.external`	integer
`summary.nofollow`	integer
`summary.empty_anchor`	integer
`summary.unique_urls`	integer
`summary.external_domains`	integer
`links[]`	object[]
`links[]`	object
`links[].url`	string
`links[].text`	string
`links[].type`	string
`links[].rel[]`	string[]
`links[].nofollow`	boolean
`links[].image_alt`	string \| null
`has_more`	boolean
`check`	object
`check.unique_targets`	integer
`check.checked`	integer
`check.not_checked`	integer
`check.ok`	integer
`check.redirect`	integer
`check.broken`	integer
`check.unknown`	integer
`check.unchecked`	integer
`check.skipped`	integer
`check.results[]`	object[]
`check.results[]`	object
`check.results[].url`	string
`check.results[].state`	string
`check.results[].http_status`	integer \| null
`check.results[].final_url`	string \| null
`check.results[].redirect_count`	integer
`check.results[].reason`	string \| null

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/links?url=https%3A%2F%2Fexample.com&render=false&check=false&type=all&limit=25"

const response = await fetch("https://domscan.net/v1/links?url=https%3A%2F%2Fexample.com&render=false&check=false&type=all&limit=25", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/links?url=https%3A%2F%2Fexample.com&render=false&check=false&type=all&limit=25",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/links?url=https%3A%2F%2Fexample.com&render=false&check=false&type=all&limit=25", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/links?url=https%3A%2F%2Fexample.com&render=false&check=false&type=all&limit=25")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/shoes/trail-runner",
    "content_type": "text/html",
    "bytes": 3535,
    "truncated": false,
    "redirect_count": 0,
    "duration_ms": 412,
    "rendered": false
  },
  "summary": {
    "total": 7,
    "internal": 5,
    "external": 2,
    "nofollow": 1,
    "empty_anchor": 1,
    "unique_urls": 7,
    "external_domains": 2
  },
  "links": [
    {
      "url": "https://example.com/",
      "text": "Home",
      "type": "internal",
      "rel": [],
      "nofollow": false,
      "image_alt": null
    },
    {
      "url": "https://example.com/shoes",
      "text": "Shoes",
      "type": "internal",
      "rel": [],
      "nofollow": false,
      "image_alt": null
    },
    {
      "url": "https://example.com/missing-page",
      "text": "Old sale",
      "type": "internal",
      "rel": [],
      "nofollow": false,
      "image_alt": null
    }
  ],
  "has_more": true,
  "check": {
    "unique_targets": 7,
    "checked": 7,
    "not_checked": 0,
    "ok": 4,
    "redirect": 1,
    "broken": 1,
    "unknown": 1,
    "unchecked": 0,
    "skipped": 0,
    "results": [
      {
        "url": "https://example.com/",
        "http_status": 200,
        "final_url": "https://example.com/",
        "redirect_count": 0,
        "state": "ok",
        "reason": null
      },
      {
        "url": "https://example.com/shoes",
        "http_status": 200,
        "final_url": "https://example.com/shoes",
        "redirect_count": 1,
        "state": "redirect",
        "reason": null
      },
      {
        "url": "https://example.com/missing-page",
        "http_status": 404,
        "final_url": "https://example.com/missing-page",
        "redirect_count": 0,
        "state": "broken",
        "reason": "http_404"
      },
      {
        "url": "https://partner.example.org/fit-guide",
        "http_status": 403,
        "final_url": "https://partner.example.org/fit-guide",
        "redirect_count": 0,
        "state": "unknown",
        "reason": "blocked"
      }
    ]
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/hreflang Credits: 3

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
max_alternates	integer Standard `10`	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string
`fetch.content_type`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`fetch.redirect_count`	integer
`fetch.duration_ms`	integer
`fetch.rendered`	boolean
`lang`	string \| null
`entries[]`	object[]
`entries[]`	object
`entries[].hreflang`	string
`entries[].href`	string
`entries[].url`	string \| null
`entries[].source`	string
`entries[].valid_code`	boolean
`entries[].issues[]`	string[]
`self_reference`	boolean
`x_default`	boolean
`issues[]`	string[]
`return_links`	object
`return_links.alternates`	integer
`return_links.checked`	integer
`return_links.not_checked`	integer
`return_links.confirmed`	integer
`return_links.missing`	integer
`return_links.code_mismatch`	integer
`return_links.not_found`	integer
`return_links.unknown`	integer
`return_links.results[]`	object[]
`return_links.results[]`	object
`return_links.results[].url`	string
`return_links.results[].hreflang[]`	string[]
`return_links.results[].state`	string
`return_links.results[].http_status`	integer \| null
`return_links.results[].final_url`	string \| null
`return_links.results[].canonical`	string \| null
`return_links.results[].lang`	string \| null
`return_links.results[].issues[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/hreflang?url=https%3A%2F%2Fexample.com&max_alternates=10"

const response = await fetch("https://domscan.net/v1/hreflang?url=https%3A%2F%2Fexample.com&max_alternates=10", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/hreflang?url=https%3A%2F%2Fexample.com&max_alternates=10",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/hreflang?url=https%3A%2F%2Fexample.com&max_alternates=10", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/hreflang?url=https%3A%2F%2Fexample.com&max_alternates=10")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/shoes/trail-runner",
  "final_url": "https://example.com/shoes/trail-runner",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/shoes/trail-runner",
    "content_type": "text/html",
    "bytes": 3535,
    "truncated": false,
    "redirect_count": 0,
    "duration_ms": 412,
    "rendered": false
  },
  "lang": "en",
  "entries": [
    {
      "hreflang": "en",
      "href": "https://example.com/shoes/trail-runner",
      "url": "https://example.com/shoes/trail-runner",
      "source": "html",
      "valid_code": true,
      "issues": []
    },
    {
      "hreflang": "es-ES",
      "href": "https://example.com/es/zapatillas/trail-runner",
      "url": "https://example.com/es/zapatillas/trail-runner",
      "source": "html",
      "valid_code": true,
      "issues": []
    },
    {
      "hreflang": "x-default",
      "href": "https://example.com/shoes/trail-runner",
      "url": "https://example.com/shoes/trail-runner",
      "source": "html",
      "valid_code": true,
      "issues": []
    }
  ],
  "self_reference": true,
  "x_default": true,
  "issues": [],
  "return_links": {
    "alternates": 1,
    "checked": 1,
    "not_checked": 0,
    "confirmed": 1,
    "missing": 0,
    "not_found": 0,
    "unknown": 0,
    "results": [
      {
        "url": "https://example.com/es/zapatillas/trail-runner",
        "hreflang": [
          "es-ES"
        ],
        "http_status": 200,
        "final_url": "https://example.com/es/zapatillas/trail-runner",
        "canonical": "https://example.com/es/zapatillas/trail-runner",
        "lang": "es",
        "issues": [],
        "state": "confirmed"
      }
    ]
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/ads-txt Credits: 2-5

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
file	string Zulässige Werte `ads.txtapp-ads.txt` Standard `ads.txt`	optional
verify_sellers	boolean	optional

Antwortfelder

Feld	Typ
`domain`	string
`file`	string
`url`	string
`checked_at`	string
`status`	string
`reason`	string \| null
`fetch`	object
`fetch.http_status`	integer \| null
`fetch.final_url`	string \| null
`fetch.bytes`	integer
`fetch.truncated`	boolean
`summary`	object
`summary.records`	integer
`summary.direct`	integer
`summary.reseller`	integer
`summary.ad_systems`	integer
`summary.records_truncated`	boolean
`summary.no_authorized_sellers`	boolean
`variables`	object
`records[]`	object[]
`records[]`	object
`records[].line`	integer
`records[].ad_system`	string
`records[].account_id`	string
`records[].relationship`	string
`records[].certification_authority_id`	string \| null
`issues[]`	object[]
`issues[]`	object
`issues[].code`	string
`issues[].count`	integer
`issues[].lines[]`	integer[]
`sellers`	object
`sellers.systems_total`	integer
`sellers.systems_checked`	integer
`sellers.confirmed`	integer
`sellers.confidential`	integer
`sellers.type_mismatch`	integer
`sellers.seller_not_found`	integer
`sellers.unknown`	integer
`sellers.systems[]`	object[]
`sellers.systems[]`	object
`sellers.systems[].ad_system`	string
`sellers.systems[].sellers_json`	string
`sellers.systems[].reason`	string \| null
`sellers.systems[].records_checked`	integer
`sellers.results[]`	object[]
`sellers.results[]`	object
`sellers.results[].ad_system`	string
`sellers.results[].account_id`	string
`sellers.results[].relationship`	string
`sellers.results[].state`	string
`sellers.results[].seller_type`	string \| null
`sellers.results[].seller_name`	string \| null
`sellers.results[].seller_domain`	string \| null
`sellers.results[].match`	string \| null

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/ads-txt?url=https%3A%2F%2Fexample.com&file=ads.txt&verify_sellers=false"

const response = await fetch("https://domscan.net/v1/ads-txt?url=https%3A%2F%2Fexample.com&file=ads.txt&verify_sellers=false", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/ads-txt?url=https%3A%2F%2Fexample.com&file=ads.txt&verify_sellers=false",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/ads-txt?url=https%3A%2F%2Fexample.com&file=ads.txt&verify_sellers=false", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/ads-txt?url=https%3A%2F%2Fexample.com&file=ads.txt&verify_sellers=false")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "domain": "example.com",
  "file": "ads.txt",
  "url": "https://example.com/ads.txt",
  "checked_at": "2026-10-13T12:00:00.000Z",
  "status": "found",
  "reason": null,
  "fetch": {
    "http_status": 200,
    "final_url": "https://example.com/ads.txt",
    "bytes": 20603,
    "truncated": false
  },
  "summary": {
    "records": 2,
    "direct": 1,
    "reseller": 1,
    "ad_systems": 2,
    "records_truncated": false,
    "no_authorized_sellers": false
  },
  "variables": {
    "ownerdomain": [
      "example.com"
    ]
  },
  "records": [
    {
      "line": 3,
      "ad_system": "google.com",
      "account_id": "pub-1234567890",
      "relationship": "DIRECT",
      "certification_authority_id": "f08c47fec0942fa0"
    },
    {
      "line": 4,
      "ad_system": "openx.com",
      "account_id": "537120563",
      "relationship": "RESELLER",
      "certification_authority_id": null
    }
  ],
  "issues": [
    {
      "code": "duplicate_record",
      "count": 1,
      "lines": [
        9
      ]
    }
  ],
  "sellers": {
    "systems_total": 2,
    "systems_checked": 2,
    "confirmed": 1,
    "confidential": 0,
    "type_mismatch": 0,
    "seller_not_found": 0,
    "unknown": 1,
    "systems": [
      {
        "ad_system": "google.com",
        "sellers_json": "unknown",
        "reason": "too_large",
        "records_checked": 1
      },
      {
        "ad_system": "openx.com",
        "sellers_json": "ok",
        "reason": null,
        "records_checked": 1
      }
    ],
    "results": [
      {
        "ad_system": "google.com",
        "account_id": "pub-1234567890",
        "relationship": "DIRECT",
        "state": "unknown",
        "seller_type": null,
        "seller_name": null,
        "seller_domain": null,
        "match": null
      },
      {
        "ad_system": "openx.com",
        "account_id": "537120563",
        "relationship": "RESELLER",
        "state": "confirmed",
        "seller_type": "INTERMEDIARY",
        "seller_name": "Example Exchange",
        "seller_domain": "exchange.example",
        "match": "exact"
      }
    ]
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/duplicate-content Credits: 5

Abfrageparameter

Parameter	Typ	erforderlich
urls	string	erforderlich

Antwortfelder

Feld	Typ
`status`	string
`checked_at`	string
`threshold`	number
`pages[]`	object[]
`pages[]`	object
`pages[].url`	string
`pages[].final_url`	string
`pages[].status`	string
`pages[].reason`	string \| null
`pages[].http_status`	integer \| null
`pages[].title`	string \| null
`pages[].meta_description`	string \| null
`pages[].h1`	string \| null
`pages[].canonical`	string \| null
`pages[].word_count`	integer
`pages[].comparable`	boolean
`pages[].comparison_reason`	string \| null
`pairs[]`	object[]
`pairs[]`	object
`pairs[].a`	string
`pairs[].b`	string
`pairs[].similarity`	number \| null
`pairs[].containment`	number \| null
`pairs[].near_duplicate`	boolean \| null
`pairs[].comparable`	boolean
`pairs[].canonicalized`	boolean
`pairs[].same_final_url`	boolean
`pairs[].reason`	string \| null
`clusters[]`	string[][]
`clusters[][]`	string[]
`duplicates`	object
`duplicates.titles[]`	object[]
`duplicates.titles[]`	object
`duplicates.titles[].value`	string
`duplicates.titles[].urls[]`	string[]
`duplicates.meta_descriptions[]`	object[]
`duplicates.meta_descriptions[]`	object
`duplicates.meta_descriptions[].value`	string
`duplicates.meta_descriptions[].urls[]`	string[]
`duplicates.h1[]`	object[]
`duplicates.h1[]`	object
`duplicates.h1[].value`	string
`duplicates.h1[].urls[]`	string[]
`summary`	object
`summary.pages`	integer
`summary.readable`	integer
`summary.unknown`	integer
`summary.comparable_pairs`	integer
`summary.unknown_pairs`	integer
`summary.same_final_url_pairs`	integer
`summary.near_duplicate_pairs`	integer
`summary.uncanonicalized_near_duplicates`	integer

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/duplicate-content?urls=https%3A%2F%2Fexample.com"

const response = await fetch("https://domscan.net/v1/duplicate-content?urls=https%3A%2F%2Fexample.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/duplicate-content?urls=https%3A%2F%2Fexample.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/duplicate-content?urls=https%3A%2F%2Fexample.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/duplicate-content?urls=https%3A%2F%2Fexample.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "status": "ok",
  "checked_at": "2026-10-13T12:00:00.000Z",
  "threshold": 0.8,
  "pages": [
    {
      "url": "https://example.com/a",
      "final_url": "https://example.com/a",
      "status": "ok",
      "reason": null,
      "http_status": 200,
      "title": "Trail shoes",
      "meta_description": "Shop trail shoes",
      "h1": "Trail shoes",
      "canonical": null,
      "word_count": 640,
      "comparable": true,
      "comparison_reason": null
    },
    {
      "url": "https://example.com/b",
      "final_url": "https://example.com/b",
      "status": "ok",
      "reason": null,
      "http_status": 200,
      "title": "Trail shoes",
      "meta_description": "Shop trail shoes",
      "h1": "Trail running shoes",
      "canonical": null,
      "word_count": 655,
      "comparable": true,
      "comparison_reason": null
    }
  ],
  "pairs": [
    {
      "a": "https://example.com/a",
      "b": "https://example.com/b",
      "similarity": 0.91,
      "containment": 0.96,
      "near_duplicate": true,
      "comparable": true,
      "canonicalized": false,
      "same_final_url": false,
      "reason": null
    }
  ],
  "clusters": [
    [
      "https://example.com/a",
      "https://example.com/b"
    ]
  ],
  "duplicates": {
    "titles": [
      {
        "value": "trail shoes",
        "urls": [
          "https://example.com/a",
          "https://example.com/b"
        ]
      }
    ],
    "meta_descriptions": [
      {
        "value": "shop trail shoes",
        "urls": [
          "https://example.com/a",
          "https://example.com/b"
        ]
      }
    ],
    "h1": []
  },
  "summary": {
    "pages": 2,
    "readable": 2,
    "unknown": 0,
    "comparable_pairs": 1,
    "unknown_pairs": 0,
    "same_final_url_pairs": 0,
    "near_duplicate_pairs": 1,
    "uncanonicalized_near_duplicates": 1
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/site-audit Credits: 10-35

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
max_pages	integer Zulässige Werte `102550` Standard `10`	optional

Antwortfelder

Feld	Typ
`url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`robots_txt`	string
`max_pages`	integer
`summary`	object
`summary.pages_crawled`	integer
`summary.pages_ok`	integer
`summary.pages_not_found`	integer
`summary.pages_unknown`	integer
`summary.pages_not_html`	integer
`summary.pages_redirect_only`	integer
`summary.discovered_not_crawled`	integer
`summary.blocked_by_robots`	integer
`summary.near_duplicate_unknown_pairs`	integer
`summary.average_score`	integer \| null
`summary.crawl_complete`	boolean
`summary.duration_ms`	integer
`issues`	object
`issues.broken_internal_links[]`	object[]
`issues.broken_internal_links[]`	object
`issues.broken_internal_links[].url`	string
`issues.broken_internal_links[].http_status`	integer \| null
`issues.broken_internal_links[].linked_from[]`	string[]
`issues.internal_redirects[]`	object[]
`issues.internal_redirects[]`	object
`issues.internal_redirects[].url`	string
`issues.internal_redirects[].final_url`	string
`issues.internal_redirects[].linked_from[]`	string[]
`issues.duplicate_titles[]`	object[]
`issues.duplicate_titles[]`	object
`issues.duplicate_titles[].value`	string
`issues.duplicate_titles[].urls[]`	string[]
`issues.duplicate_meta_descriptions[]`	object[]
`issues.duplicate_meta_descriptions[]`	object
`issues.duplicate_meta_descriptions[].value`	string
`issues.duplicate_meta_descriptions[].urls[]`	string[]
`issues.duplicate_h1[]`	object[]
`issues.duplicate_h1[]`	object
`issues.duplicate_h1[].value`	string
`issues.duplicate_h1[].urls[]`	string[]
`issues.near_duplicate_content[]`	object[]
`issues.near_duplicate_content[]`	object
`issues.near_duplicate_content[].a`	string
`issues.near_duplicate_content[].b`	string
`issues.near_duplicate_content[].similarity`	number
`issues.noindex_pages[]`	string[]
`issues.canonicalized_pages[]`	object[]
`issues.canonicalized_pages[]`	object
`issues.canonicalized_pages[].url`	string
`issues.canonicalized_pages[].canonical`	string \| null
`issues.thin_pages[]`	object[]
`issues.thin_pages[]`	object
`issues.thin_pages[].url`	string
`issues.thin_pages[].word_count`	integer \| null
`issues.onpage_checks[]`	object[]
`issues.onpage_checks[]`	object
`issues.onpage_checks[].check`	string
`issues.onpage_checks[].pages`	integer
`pages[]`	object[]
`pages[]`	object
`pages[].url`	string
`pages[].final_url`	string
`pages[].depth`	integer
`pages[].status`	string
`pages[].reason`	string \| null
`pages[].http_status`	integer \| null
`pages[].redirect_count`	integer
`pages[].title`	string \| null
`pages[].word_count`	integer \| null
`pages[].score`	integer \| null
`pages[].indexable`	boolean \| null
`pages[].canonical`	string \| null
`pages[].internal_links`	integer
`pages[].inlinks`	integer
`pages[].issues[]`	string[]
`pages[].redirect_only`	boolean
`caveats[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/site-audit?url=https%3A%2F%2Fexample.com&max_pages=10"

const response = await fetch("https://domscan.net/v1/site-audit?url=https%3A%2F%2Fexample.com&max_pages=10", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/site-audit?url=https%3A%2F%2Fexample.com&max_pages=10",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/site-audit?url=https%3A%2F%2Fexample.com&max_pages=10", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/site-audit?url=https%3A%2F%2Fexample.com&max_pages=10")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "robots_txt": "rules",
  "max_pages": 10,
  "summary": {
    "pages_crawled": 10,
    "pages_ok": 9,
    "pages_not_found": 1,
    "pages_unknown": 0,
    "pages_not_html": 0,
    "pages_redirect_only": 0,
    "discovered_not_crawled": 34,
    "blocked_by_robots": 2,
    "near_duplicate_unknown_pairs": 3,
    "average_score": 88,
    "crawl_complete": false,
    "duration_ms": 14200
  },
  "issues": {
    "broken_internal_links": [
      {
        "url": "https://example.com/old-sale",
        "http_status": 404,
        "linked_from": [
          "https://example.com/"
        ]
      }
    ],
    "internal_redirects": [
      {
        "url": "https://example.com/shoes",
        "final_url": "https://example.com/shoes/",
        "linked_from": [
          "https://example.com/"
        ]
      }
    ],
    "duplicate_titles": [],
    "duplicate_meta_descriptions": [
      {
        "value": "shop trail shoes",
        "urls": [
          "https://example.com/a",
          "https://example.com/b"
        ]
      }
    ],
    "duplicate_h1": [],
    "near_duplicate_content": [
      {
        "a": "https://example.com/a",
        "b": "https://example.com/b",
        "similarity": 0.91
      }
    ],
    "noindex_pages": [],
    "canonicalized_pages": [],
    "thin_pages": [
      {
        "url": "https://example.com/contact",
        "word_count": 74
      }
    ],
    "onpage_checks": [
      {
        "check": "images_alt",
        "pages": 6
      }
    ]
  },
  "pages": [
    {
      "url": "https://example.com/",
      "final_url": "https://example.com/",
      "depth": 0,
      "status": "ok",
      "reason": null,
      "http_status": 200,
      "redirect_count": 0,
      "title": "Example Outdoor",
      "word_count": 820,
      "score": 91,
      "indexable": true,
      "canonical": "https://example.com/",
      "internal_links": 42,
      "inlinks": 0,
      "issues": [
        "images_alt"
      ],
      "redirect_only": false
    }
  ],
  "caveats": []
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/screenshot Credits: 10

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
device	string Zulässige Werte `desktopmobile` Standard `desktop`	optional
full_page	boolean	optional
format	string Zulässige Werte `pngjpegwebppdf` Standard `png`	optional
output	string Zulässige Werte `jsonbinary` Standard `json`	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`http_status`	integer \| null
`redirect_count`	integer
`duration_ms`	integer
`resource_limit_reached`	boolean
`capture`	object
`capture.format`	string
`capture.mime_type`	string
`capture.device`	string
`capture.full_page`	boolean
`capture.width`	integer \| null
`capture.height`	integer \| null
`capture.bytes`	integer
`capture.format_fallback`	string \| null
`capture.data_base64`	string

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/screenshot?url=https%3A%2F%2Fexample.com&device=desktop&full_page=false&format=png&output=json"

const response = await fetch("https://domscan.net/v1/screenshot?url=https%3A%2F%2Fexample.com&device=desktop&full_page=false&format=png&output=json", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/screenshot?url=https%3A%2F%2Fexample.com&device=desktop&full_page=false&format=png&output=json",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/screenshot?url=https%3A%2F%2Fexample.com&device=desktop&full_page=false&format=png&output=json", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/screenshot?url=https%3A%2F%2Fexample.com&device=desktop&full_page=false&format=png&output=json")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "final_url": "https://example.com/",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "http_status": 200,
  "redirect_count": 0,
  "duration_ms": 4210,
  "resource_limit_reached": false,
  "capture": {
    "format": "png",
    "mime_type": "image/png",
    "device": "desktop",
    "full_page": false,
    "width": 1366,
    "height": 768,
    "bytes": 182340,
    "data_base64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/accessibility Credits: 8

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich
standard	string Zulässige Werte `wcag2awcag2aawcag21aawcag22aa`	optional

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`http_status`	integer \| null
`redirect_count`	integer
`duration_ms`	integer
`resource_limit_reached`	boolean
`standard`	string \| null
`score`	integer \| null
`engine`	object
`engine.name`	string
`engine.version`	string \| null
`summary`	object
`summary.violations`	integer
`summary.affected_elements`	integer
`summary.by_impact`	object
`summary.by_impact.critical`	integer
`summary.by_impact.serious`	integer
`summary.by_impact.moderate`	integer
`summary.by_impact.minor`	integer
`summary.passes`	integer
`summary.incomplete`	integer
`summary.inapplicable`	integer
`violations[]`	object[]
`violations[]`	object
`violations[].id`	string
`violations[].impact`	string
`violations[].help`	string
`violations[].help_url`	string \| null
`violations[].wcag_level`	string \| null
`violations[].tags[]`	string[]
`violations[].node_count`	integer
`violations[].nodes[]`	object[]
`violations[].nodes[]`	object
`violations[].nodes[].target`	string
`violations[].nodes[].html`	string
`violations[].nodes[].failure_summary`	string
`violations_truncated`	boolean
`incomplete[]`	object[]
`incomplete[]`	object
`incomplete[].id`	string
`incomplete[].impact`	string \| null
`incomplete[].help`	string
`incomplete[].node_count`	integer

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/accessibility?url=https%3A%2F%2Fexample.com&standard=wcag2a"

const response = await fetch("https://domscan.net/v1/accessibility?url=https%3A%2F%2Fexample.com&standard=wcag2a", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/accessibility?url=https%3A%2F%2Fexample.com&standard=wcag2a",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/accessibility?url=https%3A%2F%2Fexample.com&standard=wcag2a", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/accessibility?url=https%3A%2F%2Fexample.com&standard=wcag2a")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "final_url": "https://example.com/",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "http_status": 200,
  "redirect_count": 0,
  "duration_ms": 4210,
  "resource_limit_reached": false,
  "score": 84,
  "engine": {
    "name": "axe-core",
    "version": "4.10.3"
  },
  "summary": {
    "violations": 2,
    "affected_elements": 8,
    "by_impact": {
      "critical": 1,
      "serious": 1,
      "moderate": 0,
      "minor": 0
    },
    "passes": 38,
    "incomplete": 1,
    "inapplicable": 41
  },
  "violations": [
    {
      "id": "image-alt",
      "impact": "critical",
      "help": "Images must have alternative text",
      "help_url": "https://dequeuniversity.com/rules/axe/4.10/image-alt",
      "wcag_level": "A",
      "tags": [
        "wcag2a",
        "wcag111"
      ],
      "node_count": 2,
      "nodes": [
        {
          "target": "main > img.hero",
          "html": "<img src=\"/hero.jpg\">",
          "failure_summary": "Element does not have an alt attribute"
        }
      ]
    }
  ],
  "incomplete": [
    {
      "id": "color-contrast",
      "impact": "serious",
      "help": "Elements must meet minimum color contrast ratio thresholds",
      "node_count": 3
    }
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/cookie-scan Credits: 8

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`http_status`	integer \| null
`redirect_count`	integer
`duration_ms`	integer
`resource_limit_reached`	boolean
`summary`	object
`summary.cookies`	integer
`summary.first_party_cookies`	integer
`summary.third_party_cookies`	integer
`summary.session_cookies`	integer
`summary.persistent_cookies`	integer
`summary.trackers`	integer
`summary.third_party_domains`	integer
`consent`	object
`consent.cmp`	string \| null
`consent.tcf_api`	boolean
`cookies[]`	object[]
`cookies[]`	object
`cookies[].name`	string
`cookies[].domain`	string
`cookies[].path`	string
`cookies[].party`	string
`cookies[].session`	boolean
`cookies[].lifetime_days`	integer \| null
`cookies[].secure`	boolean
`cookies[].http_only`	boolean
`cookies[].same_site`	string \| null
`cookies[].size`	integer
`cookies[].tracker`	object
`cookies[].tracker.name`	string
`cookies[].tracker.category`	string
`trackers[]`	object[]
`trackers[]`	object
`trackers[].name`	string
`trackers[].category`	string
`trackers[].requests`	integer
`trackers[].cookies`	integer
`third_party_domains[]`	object[]
`third_party_domains[]`	object
`third_party_domains[].domain`	string
`third_party_domains[].requests`	integer
`storage`	object
`storage.local_storage_keys`	integer
`storage.session_storage_keys`	integer
`findings[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/cookie-scan?url=https%3A%2F%2Fexample.com"

const response = await fetch("https://domscan.net/v1/cookie-scan?url=https%3A%2F%2Fexample.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/cookie-scan?url=https%3A%2F%2Fexample.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/cookie-scan?url=https%3A%2F%2Fexample.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/cookie-scan?url=https%3A%2F%2Fexample.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "final_url": "https://example.com/",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "http_status": 200,
  "redirect_count": 0,
  "duration_ms": 4210,
  "resource_limit_reached": false,
  "summary": {
    "cookies": 2,
    "first_party_cookies": 1,
    "third_party_cookies": 1,
    "session_cookies": 1,
    "persistent_cookies": 1,
    "trackers": 1,
    "third_party_domains": 3
  },
  "consent": {
    "cmp": "onetrust",
    "tcf_api": true
  },
  "cookies": [
    {
      "name": "_ga",
      "domain": ".example.com",
      "path": "/",
      "party": "first",
      "session": false,
      "lifetime_days": 400,
      "secure": false,
      "http_only": false,
      "same_site": "Lax",
      "size": 30,
      "tracker": null
    },
    {
      "name": "IDE",
      "domain": ".doubleclick.net",
      "path": "/",
      "party": "third",
      "session": true,
      "lifetime_days": null,
      "secure": true,
      "http_only": true,
      "same_site": "None",
      "size": 60,
      "tracker": {
        "name": "Google Ads",
        "category": "advertising"
      }
    }
  ],
  "trackers": [
    {
      "name": "Google Analytics",
      "category": "analytics",
      "requests": 3
    }
  ],
  "third_party_domains": [
    {
      "domain": "google-analytics.com",
      "requests": 3
    }
  ],
  "storage": {
    "local_storage_keys": 4,
    "session_storage_keys": 1
  },
  "findings": [
    "trackers_load_before_consent",
    "third_party_cookies",
    "cookie_lifetime_over_13_months",
    "cookies_without_secure_flag"
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

GET /v1/page-weight Credits: 6

Abfrageparameter

Parameter	Typ	erforderlich
url	string	erforderlich

Antwortfelder

Feld	Typ
`url`	string
`final_url`	string
`status`	string
`reason`	string \| null
`checked_at`	string
`http_status`	integer \| null
`redirect_count`	integer
`duration_ms`	integer
`resource_limit_reached`	boolean
`summary`	object
`summary.requests`	integer
`summary.blocked_requests`	integer
`summary.total_bytes`	integer
`summary.third_party_requests`	integer
`summary.third_party_bytes`	integer
`summary.transfer_bytes`	integer
`by_type[]`	object[]
`by_type[]`	object
`by_type[].type`	string
`by_type[].requests`	integer
`by_type[].bytes`	integer
`largest[]`	object[]
`largest[]`	object
`largest[].url`	string
`largest[].type`	string
`largest[].bytes`	integer
`largest[].mime_type`	string \| null
`third_parties[]`	object[]
`third_parties[]`	object
`third_parties[].domain`	string
`third_parties[].requests`	integer
`third_parties[].bytes`	integer
`render_blocking[]`	object[]
`render_blocking[]`	object
`render_blocking[].url`	string
`render_blocking[].type`	string
`timing`	object
`timing.ttfb_ms`	number \| null
`timing.first_contentful_paint_ms`	number \| null
`timing.dom_content_loaded_ms`	number \| null
`timing.load_ms`	number \| null
`findings[]`	string[]

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/page-weight?url=https%3A%2F%2Fexample.com"

const response = await fetch("https://domscan.net/v1/page-weight?url=https%3A%2F%2Fexample.com", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/page-weight?url=https%3A%2F%2Fexample.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/page-weight?url=https%3A%2F%2Fexample.com", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/page-weight?url=https%3A%2F%2Fexample.com")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "url": "https://example.com/",
  "final_url": "https://example.com/",
  "status": "ok",
  "reason": null,
  "checked_at": "2026-10-13T12:00:00.000Z",
  "http_status": 200,
  "redirect_count": 0,
  "duration_ms": 4210,
  "resource_limit_reached": false,
  "summary": {
    "requests": 86,
    "blocked_requests": 4,
    "total_bytes": 3412887,
    "third_party_requests": 22,
    "third_party_bytes": 1210554,
    "transfer_bytes": 3425100
  },
  "by_type": [
    {
      "type": "image",
      "requests": 31,
      "bytes": 1840221
    },
    {
      "type": "script",
      "requests": 28,
      "bytes": 1120334
    }
  ],
  "largest": [
    {
      "url": "https://example.com/hero.jpg",
      "type": "image",
      "bytes": 612004,
      "mime_type": "image/jpeg"
    }
  ],
  "third_parties": [
    {
      "domain": "googletagmanager.com",
      "requests": 3,
      "bytes": 310442
    }
  ],
  "render_blocking": [
    {
      "url": "https://example.com/styles.css",
      "type": "stylesheet"
    }
  ],
  "timing": {
    "ttfb_ms": 180,
    "first_contentful_paint_ms": 1240,
    "dom_content_loaded_ms": 1610,
    "load_ms": 3890
  },
  "findings": [
    "page_weight_over_3mb",
    "images_over_200kb",
    "render_blocking_resources"
  ]
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
429 Zu viele Anfragen

POST /v1/scrape Credits: 1-20/item

Body-Parameter

Parameter	Typ	erforderlich
url	string	erforderlich
mode	string Zulässige Werte `standardresilientrenderedrendered_resilient` Standard `standard`	optional
output	string Zulässige Werte `htmltextmarkdown` Standard `html`	optional

Antwortfelder

Feld	Typ
`data`	object
`data.url`	string
`data.final_url`	string
`data.status`	integer \| null
`data.outcome`	string
`data.content_type`	string \| null
`data.content`	string
`data.bytes`	integer
`data.truncated`	boolean
`data.redirect_count`	integer
`data.attempt_count`	integer
`data.duration_ms`	integer
`data.fetched_at`	string
`data.headers`	object
`data.rendered`	boolean
`billing`	object
`billing.credits_charged`	integer
`billing.credits_refunded`	integer
`billing.credits_per_item`	integer
`billing.credits_net`	integer
`billing.policy`	string

Beispielanfrage

curl -X POST "https://domscan.net/v1/scrape" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "url": "https://example.com/",
  "mode": "standard",
  "output": "markdown"
}'

const response = await fetch("https://domscan.net/v1/scrape", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "url": "https://example.com/",
    "mode": "standard",
    "output": "markdown"
  }),
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.post(
    "https://domscan.net/v1/scrape",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "url": "https://example.com/",
        "mode": "standard",
        "output": "markdown",
    },
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "url": "https://example.com/",
	  "mode": "standard",
	  "output": "markdown"
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/scrape", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/scrape")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "url" => "https://example.com/",
  "mode" => "standard",
  "output" => "markdown"
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "data": {
    "url": "https://example.com",
    "final_url": "https://example.com",
    "status": 1,
    "outcome": "success",
    "content_type": "domain",
    "content": "example",
    "bytes": 1,
    "truncated": false,
    "redirect_count": 1,
    "attempt_count": 1,
    "duration_ms": 1,
    "fetched_at": "2026-08-27T12:00:00Z",
    "headers": {},
    "rendered": false
  },
  "billing": {
    "credits_charged": 1,
    "credits_refunded": 1,
    "credits_per_item": 1,
    "credits_net": 1,
    "policy": "effort_based"
  }
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
403 Verboten
409 HTTP 409
422 HTTP 422
429 Zu viele Anfragen
503 Dienst nicht verfügbar

POST /v1/scrape/jobs Credits: 1-20/item

Body-Parameter

Parameter	Typ	erforderlich
notify_webhook	unknown	optional
mode	string Zulässige Werte `standardresilientrenderedrendered_resilient` Standard `standard`	optional
output	string Zulässige Werte `htmltextmarkdown` Standard `html`	optional
urls	unknown[]	erforderlich

Antwortfelder

Feld	Typ
`job`	object
`job.id`	string
`job.status`	string
`job.mode`	string
`job.output`	string
`job.total`	integer
`job.counts`	object
`job.counts.pending`	integer
`job.counts.processing`	integer
`job.counts.succeeded`	integer
`job.counts.failed`	integer
`job.billing`	object
`job.billing.credits_charged`	integer
`job.billing.credits_refunded`	integer
`job.billing.credits_per_item`	integer
`job.billing.credits_net`	integer
`job.billing.policy`	string
`job.status_url`	string
`job.results_url`	string
`job.poll_after_ms`	integer \| null
`job.created_at`	string
`job.started_at`	string \| null
`job.completed_at`	string \| null
`job.updated_at`	string
`job.processing_deadline_at`	string
`job.results_expires_at`	string
`idempotent_replay`	boolean

Beispielanfrage

curl -X POST "https://domscan.net/v1/scrape/jobs" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "mode": "resilient",
  "output": "text",
  "urls": [
    "https://example.com/",
    {
      "url": "https://example.org/",
      "reference": "page-2"
    }
  ]
}'

const response = await fetch("https://domscan.net/v1/scrape/jobs", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "mode": "resilient",
    "output": "text",
    "urls": [
      "https://example.com/",
      {
        "url": "https://example.org/",
        "reference": "page-2"
      }
    ]
  }),
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.post(
    "https://domscan.net/v1/scrape/jobs",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "mode": "resilient",
        "output": "text",
        "urls": [
            "https://example.com/",
            {
                "url": "https://example.org/",
                "reference": "page-2",
            },
        ],
    },
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
)

func main() {
	body := strings.NewReader(`{
	  "mode": "resilient",
	  "output": "text",
	  "urls": [
	    "https://example.com/",
	    {
	      "url": "https://example.org/",
	      "reference": "page-2"
	    }
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/scrape/jobs", body)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/scrape/jobs")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "mode" => "resilient",
  "output" => "text",
  "urls" => [
    "https://example.com/",
    {
      "url" => "https://example.org/",
      "reference" => "page-2"
    }
  ]
})

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "job": {
    "id": "example-id",
    "status": "queued",
    "mode": "standard",
    "output": "html",
    "total": 1,
    "counts": {
      "pending": 1,
      "processing": 1,
      "succeeded": 1,
      "failed": 1
    },
    "billing": {
      "credits_charged": 1,
      "credits_refunded": 1,
      "credits_per_item": 1,
      "credits_net": 1,
      "policy": "effort_based"
    },
    "status_url": "https://example.com",
    "results_url": "https://example.com",
    "poll_after_ms": 1,
    "created_at": "2026-08-27T12:00:00Z",
    "started_at": "2026-08-27T12:00:00Z",
    "completed_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z",
    "processing_deadline_at": "2026-08-27T12:00:00Z",
    "results_expires_at": "2026-08-27T12:00:00Z"
  },
  "idempotent_replay": false
}

HTTP-Statuscodes

202 Akzeptiert
400 Ungültige Anfrage
401 Nicht autorisiert
402 Zahlung erforderlich
403 Verboten
409 HTTP 409
429 Zu viele Anfragen
503 Dienst nicht verfügbar

GET /v1/scrape/jobs/:job_id Credits: 0

Abfrageparameter

Parameter	Typ	erforderlich
job_id	string	erforderlich

Antwortfelder

Feld	Typ
`job`	object
`job.id`	string
`job.status`	string
`job.mode`	string
`job.output`	string
`job.total`	integer
`job.counts`	object
`job.counts.pending`	integer
`job.counts.processing`	integer
`job.counts.succeeded`	integer
`job.counts.failed`	integer
`job.billing`	object
`job.billing.credits_charged`	integer
`job.billing.credits_refunded`	integer
`job.billing.credits_per_item`	integer
`job.billing.credits_net`	integer
`job.billing.policy`	string
`job.status_url`	string
`job.results_url`	string
`job.poll_after_ms`	integer \| null
`job.created_at`	string
`job.started_at`	string \| null
`job.completed_at`	string \| null
`job.updated_at`	string
`job.processing_deadline_at`	string
`job.results_expires_at`	string

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/scrape/jobs/example"

const response = await fetch("https://domscan.net/v1/scrape/jobs/example", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/scrape/jobs/example",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/scrape/jobs/example", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/scrape/jobs/example")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "job": {
    "id": "example-id",
    "status": "queued",
    "mode": "standard",
    "output": "html",
    "total": 1,
    "counts": {
      "pending": 1,
      "processing": 1,
      "succeeded": 1,
      "failed": 1
    },
    "billing": {
      "credits_charged": 1,
      "credits_refunded": 1,
      "credits_per_item": 1,
      "credits_net": 1,
      "policy": "effort_based"
    },
    "status_url": "https://example.com",
    "results_url": "https://example.com",
    "poll_after_ms": 1,
    "created_at": "2026-08-27T12:00:00Z",
    "started_at": "2026-08-27T12:00:00Z",
    "completed_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z",
    "processing_deadline_at": "2026-08-27T12:00:00Z",
    "results_expires_at": "2026-08-27T12:00:00Z"
  }
}

HTTP-Statuscodes

200 OK
401 Nicht autorisiert
404 Nicht gefunden
429 Zu viele Anfragen

GET /v1/scrape/jobs/:job_id/results Credits: 0

Abfrageparameter

Parameter	Typ	erforderlich
job_id	string	erforderlich
limit	integer Standard `20`	optional
offset	integer Standard `0`	optional

Antwortfelder

Feld	Typ
`job`	object
`job.id`	string
`job.status`	string
`job.mode`	string
`job.output`	string
`job.total`	integer
`job.counts`	object
`job.counts.pending`	integer
`job.counts.processing`	integer
`job.counts.succeeded`	integer
`job.counts.failed`	integer
`job.billing`	object
`job.billing.credits_charged`	integer
`job.billing.credits_refunded`	integer
`job.billing.credits_per_item`	integer
`job.billing.credits_net`	integer
`job.billing.policy`	string
`job.status_url`	string
`job.results_url`	string
`job.poll_after_ms`	integer \| null
`job.created_at`	string
`job.started_at`	string \| null
`job.completed_at`	string \| null
`job.updated_at`	string
`job.processing_deadline_at`	string
`job.results_expires_at`	string
`results[]`	object[]
`results[]`	object
`results[].index`	integer
`results[].url`	string
`results[].reference`	string
`results[].status`	string
`results[].data`	object
`results[].data.url`	string
`results[].data.final_url`	string
`results[].data.status`	integer \| null
`results[].data.outcome`	string
`results[].data.content_type`	string \| null
`results[].data.content`	string
`results[].data.bytes`	integer
`results[].data.truncated`	boolean
`results[].data.redirect_count`	integer
`results[].data.attempt_count`	integer
`results[].data.duration_ms`	integer
`results[].data.fetched_at`	string
`results[].data.headers`	object
`results[].data.rendered`	boolean
`results[].billing`	object
`results[].billing.credits_charged`	integer
`results[].billing.credits_refunded`	integer
`results[].billing.credits_per_item`	integer
`results[].billing.credits_net`	integer
`results[].billing.policy`	string
`pagination`	object

Beispielanfrage

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/scrape/jobs/example/results?limit=25&offset=0"

const response = await fetch("https://domscan.net/v1/scrape/jobs/example/results?limit=25&offset=0", {
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY },
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.get(
    "https://domscan.net/v1/scrape/jobs/example/results?limit=25&offset=0",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
)
print(response.json())

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
)

func main() {
	req, err := http.NewRequest(http.MethodGet, "https://domscan.net/v1/scrape/jobs/example/results?limit=25&offset=0", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("X-API-Key", os.Getenv("DOMSCAN_API_KEY"))

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

	data, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(resp.Status, string(data))
}

require "json"
require "net/http"

uri = URI("https://domscan.net/v1/scrape/jobs/example/results?limit=25&offset=0")
request = Net::HTTP::Get.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
puts JSON.pretty_generate(JSON.parse(response.body))

Beispielantwort

{
  "job": {
    "id": "example-id",
    "status": "queued",
    "mode": "standard",
    "output": "html",
    "total": 1,
    "counts": {
      "pending": 1,
      "processing": 1,
      "succeeded": 1,
      "failed": 1
    },
    "billing": {
      "credits_charged": 1,
      "credits_refunded": 1,
      "credits_per_item": 1,
      "credits_net": 1,
      "policy": "effort_based"
    },
    "status_url": "https://example.com",
    "results_url": "https://example.com",
    "poll_after_ms": 1,
    "created_at": "2026-08-27T12:00:00Z",
    "started_at": "2026-08-27T12:00:00Z",
    "completed_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z",
    "processing_deadline_at": "2026-08-27T12:00:00Z",
    "results_expires_at": "2026-08-27T12:00:00Z"
  },
  "results": [
    {
      "index": 1,
      "url": "https://example.com",
      "reference": "example",
      "status": "pending",
      "data": {
        "url": "https://example.com",
        "final_url": "https://example.com",
        "status": 1,
        "outcome": "success",
        "content_type": "domain",
        "content": "example",
        "bytes": 1,
        "truncated": false,
        "redirect_count": 1,
        "attempt_count": 1,
        "duration_ms": 1,
        "fetched_at": "2026-08-27T12:00:00Z",
        "headers": {},
        "rendered": false
      },
      "billing": {
        "credits_charged": 1,
        "credits_refunded": 1,
        "credits_per_item": 1,
        "credits_net": 1,
        "policy": "effort_based"
      }
    }
  ],
  "pagination": {}
}

HTTP-Statuscodes

200 OK
400 Ungültige Anfrage
401 Nicht autorisiert
404 Nicht gefunden
410 HTTP 410
429 Zu viele Anfragen