Markenüberwachung

GET /v1/brand-monitor

Rufen Sie alle überwachten Marken und ihren aktuellen Bedrohungsstatus ab.

Paginiert: Sende limit (1 bis 100) und gib next_cursor als cursor zurück. Antworten enthalten has_more und next_cursor. Ohne limit wird die gesamte Liste zurückgegeben. Siehe Pagination.

Beispielantwort

{
                "brands": [
                {
                "domain": "mycompany.com",
                "added_at": "2024-03-01T12:00:00Z",
                "last_scan_at": "2024-03-14T08:30:00Z",
                "scan_count": 6,
                "registered_typos": 3,
                "new_threats_since_baseline": 1,
                "has_alerts": true
                }
                ],
                "total": 1,
                "updated_at": "2024-03-14T08:30:00Z"
                }

Antwortfelder

Feld	Typ
`has_more`	boolean
`next_cursor`	string \| null
`brands[]`	object[]
`brands[]`	object
`brands[].domain`	string
`brands[].added_at`	string
`brands[].last_scan_at`	string \| null
`brands[].scan_count`	integer
`brands[].registered_typos`	integer
`brands[].new_threats_since_baseline`	integer
`brands[].has_alerts`	boolean
`brands[].scan_status`	string
`total`	integer
`updated_at`	string

POST /v1/brand-monitor

Erstellen Sie eine neue Markenüberwachung.

Anfragetext

{
                "domain": "mycompany.com",
                "alert_email": "[email protected]"
                }

Antwortfelder

Feld	Typ
`success`	boolean
`message`	string
`brand`	object
`brand.domain`	string
`brand.baseline_threats`	integer
`brand.scan_status`	string
`initial_scan`	object \| null

Beispielantwort

{
  "success": true,
  "message": "Request completed",
  "brand": {
    "domain": "example.com",
    "baseline_threats": 1,
    "scan_status": "pending"
  },
  "initial_scan": {}
}

POST /v1/brand-monitor/scan?domain=mycompany.com

Starten Sie sofort einen Scan für eine überwachte Marke.

Antwortfelder

Feld	Typ
`success`	boolean
`scan`	object \| null
`alert`	object
`alert.level`	string
`alert.message`	string

Beispielantwort

{
  "success": true,
  "scan": {},
  "alert": {
    "level": "medium",
    "message": "Request completed"
  }
}

DELETE /v1/brand-monitor Credits: 1

Abfrageparameter

Parameter	Typ	erforderlich
domain	string	erforderlich

Antwortfelder

Feld	Typ
`success`	boolean
`message`	string

Beispielanfrage

curl -X DELETE "https://domscan.net/v1/brand-monitor?domain=example.com" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'

const response = await fetch("https://domscan.net/v1/brand-monitor?domain=example.com", {
  method: "DELETE",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({}),
});
const data = await response.json();
console.log(data);

import os
import requests

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

package main

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

func main() {
	body := strings.NewReader(`{}`)
	req, err := http.NewRequest(http.MethodDelete, "https://domscan.net/v1/brand-monitor?domain=example.com", 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/brand-monitor?domain=example.com")
request = Net::HTTP::Delete.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({})

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

{
  "success": true,
  "message": "Request completed"
}

HTTP-Statuscodes

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

GET /v1/brand-monitor/status Credits: 1

Abfrageparameter

Parameter	Typ	erforderlich
domain	string	erforderlich

Antwortfelder

Feld	Typ
`brand`	object
`brand.domain`	string
`brand.name`	string
`brand.tld`	string
`brand.added_at`	string
`brand.last_scan_at`	string \| null
`brand.scan_count`	integer
`threats`	object
`threats.baseline_count`	integer
`threats.current_count`	integer
`threats.new_since_baseline`	integer
`threats.new_threat_domains[]`	string[]
`threats.all_registered[]`	string[]
`alerts`	object
`alerts.email`	string \| null
`alerts.webhook`	string \| null

Beispielanfrage

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

const response = await fetch("https://domscan.net/v1/brand-monitor/status?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/brand-monitor/status?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/brand-monitor/status?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/brand-monitor/status?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

{
  "brand": {
    "domain": "example.com",
    "name": "example",
    "tld": "com",
    "added_at": "2026-08-27T12:00:00Z",
    "last_scan_at": "2026-08-27T12:00:00Z",
    "scan_count": 1
  },
  "threats": {
    "baseline_count": 1,
    "current_count": 1,
    "new_since_baseline": 1,
    "new_threat_domains": [
      "example.com"
    ],
    "all_registered": [
      "example"
    ]
  },
  "alerts": {
    "email": "[email protected]",
    "webhook": "example"
  }
}

HTTP-Statuscodes

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

POST /v1/brand-monitor/reset-baseline Credits: 1

Abfrageparameter

Parameter	Typ	erforderlich
domain	string	erforderlich

Antwortfelder

Feld	Typ
`success`	boolean
`message`	string

Beispielanfrage

curl -X POST "https://domscan.net/v1/brand-monitor/reset-baseline?domain=example.com" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'

const response = await fetch("https://domscan.net/v1/brand-monitor/reset-baseline?domain=example.com", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({}),
});
const data = await response.json();
console.log(data);

import os
import requests

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

package main

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

func main() {
	body := strings.NewReader(`{}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/brand-monitor/reset-baseline?domain=example.com", 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/brand-monitor/reset-baseline?domain=example.com")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({})

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

{
  "success": true,
  "message": "Request completed"
}

HTTP-Statuscodes

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

PUT /v1/brand-monitor/alerts Credits: 1

Body-Parameter

Parameter	Typ	erforderlich
domain	string	erforderlich
alert_email	string \| null	optional
alert_webhook	string \| null	optional

Antwortfelder

Feld	Typ
`success`	boolean
`message`	string

Beispielanfrage

curl -X PUT "https://domscan.net/v1/brand-monitor/alerts" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domain": "example.com",
  "alert_email": "[email protected]",
  "alert_webhook": "https://hooks.example.com/domscan"
}'

const response = await fetch("https://domscan.net/v1/brand-monitor/alerts", {
  method: "PUT",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "domain": "example.com",
    "alert_email": "[email protected]",
    "alert_webhook": "https://hooks.example.com/domscan"
  }),
});
const data = await response.json();
console.log(data);

import os
import requests

response = requests.put(
    "https://domscan.net/v1/brand-monitor/alerts",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "domain": "example.com",
        "alert_email": "[email protected]",
        "alert_webhook": "https://hooks.example.com/domscan",
    },
)
print(response.json())

package main

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

func main() {
	body := strings.NewReader(`{
	  "domain": "example.com",
	  "alert_email": "[email protected]",
	  "alert_webhook": "https://hooks.example.com/domscan"
	}`)
	req, err := http.NewRequest(http.MethodPut, "https://domscan.net/v1/brand-monitor/alerts", 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/brand-monitor/alerts")
request = Net::HTTP::Put.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "domain" => "example.com",
  "alert_email" => "[email protected]",
  "alert_webhook" => "https://hooks.example.com/domscan"
})

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

{
  "success": true,
  "message": "Request completed"
}

HTTP-Statuscodes

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

Support