API-referentie

Domeinwatchlist API-referentie

Beheer uw domeinwatchlist. Ontvang meldingen wanneer domeinen beschikbaar worden of van status veranderen. Gebruik deze referentie om het juiste endpoint te kiezen en precies te zien wat het teruggeeft.

Bewerkingen

GET /v1/watchlist API-referentie bekijken
POST /v1/watchlist API-referentie bekijken
PATCH /v1/watchlist/:domain API-referentie bekijken
DELETE /v1/watchlist API-referentie bekijken
GET /v1/watchlist/expiring API-referentie bekijken
GET /v1/watchlist/available API-referentie bekijken
PATCH /v1/webhooks/:webhook_id API-referentie bekijkenLees de gids
DELETE /v1/webhooks/:webhook_id API-referentie bekijkenLees de gids
POST /v1/webhooks/:webhook_id/test API-referentie bekijkenLees de gids
POST /v1/webhooks/:webhook_id/rotate-secret API-referentie bekijkenLees de gids
GET /v1/webhooks/:webhook_id/deliveries API-referentie bekijkenLees de gids
GET /v1/watchlist/alerts API-referentie bekijkenLees de gids
POST /v1/watchlist/alerts API-referentie bekijkenLees de gids
GET /v1/watchlist/alerts/:subscription_id API-referentie bekijkenLees de gids
PATCH /v1/watchlist/alerts/:subscription_id API-referentie bekijkenLees de gids
DELETE /v1/watchlist/alerts/:subscription_id API-referentie bekijkenLees de gids

GET /v1/watchlist

Bewerking: getWatchlist Credits en authenticatie: 1 Authenticatie vereist
GET /v1/watchlist Tegoeden: 1

Queryparameters

Parameter Type vereist
limit integer optioneel
cursor string optioneel

Antwoordvelden

Veld Type
has_more boolean
next_cursor string | null
watchlist[] object[]
watchlist[] object
watchlist[].domain string
watchlist[].added_at string
watchlist[].status string
watchlist[].last_checked string
watchlist[].expiry_date string
watchlist[].days_until_expiry integer
watchlist[].notify_email string
watchlist[].check_count integer
total integer
max_domains integer
limit_basis string
updated_at string

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/watchlist"
const response = await fetch("https://domscan.net/v1/watchlist", {
  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/watchlist",
    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/watchlist", 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/watchlist")
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))

Voorbeeldantwoord

{
  "watchlist": [
    {
      "domain": "example.com",
      "added_at": "2024-01-01T00:00:00Z",
      "status": "registered",
      "last_checked": "2024-01-15T12:00:00Z"
    }
  ],
  "total": 1,
  "max_domains": 333,
  "limit_basis": "monthly_credits",
  "updated_at": "2024-01-15T12:00:00Z"
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 402 Betaling vereist
  • 429 Te veel verzoeken

POST /v1/watchlist

Bewerking: addToWatchlist Credits en authenticatie: 1 Authenticatie vereist
POST /v1/watchlist Tegoeden: 1

Body-parameters

Parameter Type vereist
domain string vereist
notify_email string optioneel

Antwoordvelden

Veld Type
success boolean
message string
watchlist[] object[]
watchlist[] object
watchlist[].domain string
watchlist[].added_at string
watchlist[].status string
watchlist[].last_checked string
watchlist[].expiry_date string
watchlist[].days_until_expiry integer
watchlist[].notify_email string
watchlist[].check_count integer
total integer
max_domains integer
limit_basis string

Voorbeeldverzoek

curl -X POST "https://domscan.net/v1/watchlist" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "domain": "example.org",
  "notify_email": "[email protected]"
}'
const response = await fetch("https://domscan.net/v1/watchlist", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "domain": "example.org",
    "notify_email": "[email protected]"
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.post(
    "https://domscan.net/v1/watchlist",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "domain": "example.org",
        "notify_email": "[email protected]",
    },
)
print(response.json())
package main

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

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

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))

Voorbeeldantwoord

{
  "success": true,
  "message": "Added example.org to watchlist",
  "watchlist": [
    {
      "domain": "example.com",
      "added_at": "2026-06-02T09:12:00.000Z",
      "last_checked": "2026-10-09T03:00:12.000Z",
      "status": "expiring_soon",
      "expiry_date": "2026-12-18T14:22:08Z",
      "days_until_expiry": 70,
      "notify_email": "[email protected]"
    },
    {
      "domain": "example.org",
      "added_at": "2026-10-09T10:15:30.000Z",
      "status": "unknown",
      "notify_email": "[email protected]"
    }
  ],
  "total": 2,
  "max_domains": 333,
  "limit_basis": "monthly_credits"
}

HTTP-statuscodes

  • 201 Aangemaakt
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 402 Betaling vereist
  • 409 HTTP 409
  • 422 HTTP 422
  • 429 Te veel verzoeken

PATCH /v1/watchlist/:domain

Bewerking: updateWatchlistDomain Credits en authenticatie: Gratis Authenticatie vereist
PATCH /v1/watchlist/:domain Tegoeden: 0

Queryparameters

Parameter Type vereist
domain string vereist

Body-parameters

Parameter Type vereist
notify_email string | null vereist

Antwoordvelden

Veld Type
success boolean
message string
domain object
domain.domain string
domain.added_at string
domain.status string
domain.last_checked string
domain.expiry_date string
domain.days_until_expiry integer
domain.notify_email string
domain.check_count integer

Voorbeeldverzoek

curl -X PATCH "https://domscan.net/v1/watchlist/example.com" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "notify_email": "[email protected]"
}'
const response = await fetch("https://domscan.net/v1/watchlist/example.com", {
  method: "PATCH",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "notify_email": "[email protected]"
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.patch(
    "https://domscan.net/v1/watchlist/example.com",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "notify_email": "[email protected]",
    },
)
print(response.json())
package main

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

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

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))

Voorbeeldantwoord

{
  "success": true,
  "message": "Updated example.com in your watchlist",
  "domain": {
    "domain": "example.com",
    "added_at": "2026-06-02T09:12:00.000Z",
    "status": "registered",
    "notify_email": "[email protected]",
    "check_count": 12
  }
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

DELETE /v1/watchlist

Bewerking: removeFromWatchlist Credits en authenticatie: Gratis Authenticatie vereist
DELETE /v1/watchlist Tegoeden: 0

Queryparameters

Parameter Type vereist
domain string vereist

Antwoordvelden

Veld Type
success boolean
message string
domain string
watchlist[] object[]
watchlist[] object
watchlist[].domain string
watchlist[].added_at string
watchlist[].status string
watchlist[].last_checked string
watchlist[].expiry_date string
watchlist[].days_until_expiry integer
watchlist[].notify_email string
watchlist[].check_count integer
total integer

Voorbeeldverzoek

curl -X DELETE "https://domscan.net/v1/watchlist?domain=example.com" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'
const response = await fetch("https://domscan.net/v1/watchlist?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/watchlist?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/watchlist?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/watchlist?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))

Voorbeeldantwoord

{
  "success": true,
  "message": "Request completed",
  "domain": "example.com",
  "watchlist": [
    {
      "domain": "example.com",
      "added_at": "2026-08-27T12:00:00Z",
      "status": "registered",
      "last_checked": "2026-08-27T12:00:00Z",
      "expiry_date": "2026-08-27T12:00:00Z",
      "days_until_expiry": 1,
      "notify_email": "[email protected]",
      "check_count": 1
    }
  ],
  "total": 1
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 402 Betaling vereist
  • 429 Te veel verzoeken

GET /v1/watchlist/expiring

Bewerking: getExpiringWatchlist Credits en authenticatie: 1 Authenticatie vereist
GET /v1/watchlist/expiring Tegoeden: 1

Queryparameters

Parameter Type vereist
days integer
Standaard 90
optioneel
limit integer optioneel
cursor string optioneel

Antwoordvelden

Veld Type
has_more boolean
next_cursor string | null
expiring_domains[] object[]
expiring_domains[] object
expiring_domains[].domain string
expiring_domains[].added_at string
expiring_domains[].status string
expiring_domains[].last_checked string
expiring_domains[].expiry_date string
expiring_domains[].days_until_expiry integer
expiring_domains[].notify_email string
expiring_domains[].check_count integer
total integer
threshold_days integer

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/watchlist/expiring?days=90"
const response = await fetch("https://domscan.net/v1/watchlist/expiring?days=90", {
  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/watchlist/expiring?days=90",
    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/watchlist/expiring?days=90", 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/watchlist/expiring?days=90")
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))

Voorbeeldantwoord

{
  "expiring_domains": [
    {
      "domain": "example.com",
      "added_at": "2026-06-02T09:12:00.000Z",
      "last_checked": "2026-10-09T03:00:12.000Z",
      "status": "expiring_soon",
      "expiry_date": "2026-12-18T14:22:08Z",
      "days_until_expiry": 70,
      "notify_email": "[email protected]"
    }
  ],
  "total": 1,
  "threshold_days": 90
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 402 Betaling vereist
  • 429 Te veel verzoeken

GET /v1/watchlist/available

Bewerking: getAvailableWatchlist Credits en authenticatie: 1 Authenticatie vereist
GET /v1/watchlist/available Tegoeden: 1

Queryparameters

Parameter Type vereist
limit integer optioneel
cursor string optioneel

Antwoordvelden

Veld Type
has_more boolean
next_cursor string | null
available_domains[] object[]
available_domains[] object
available_domains[].domain string
available_domains[].added_at string
available_domains[].status string
available_domains[].last_checked string
available_domains[].expiry_date string
available_domains[].days_until_expiry integer
available_domains[].notify_email string
available_domains[].check_count integer
total integer
message string

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/watchlist/available"
const response = await fetch("https://domscan.net/v1/watchlist/available", {
  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/watchlist/available",
    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/watchlist/available", 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/watchlist/available")
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))

Voorbeeldantwoord

{
  "has_more": false,
  "next_cursor": "example",
  "available_domains": [
    {
      "domain": "example.com",
      "added_at": "2026-08-27T12:00:00Z",
      "status": "registered",
      "last_checked": "2026-08-27T12:00:00Z",
      "expiry_date": "2026-08-27T12:00:00Z",
      "days_until_expiry": 1,
      "notify_email": "[email protected]",
      "check_count": 1
    }
  ],
  "total": 1,
  "message": "Request completed"
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 402 Betaling vereist
  • 429 Te veel verzoeken

GET /v1/webhooks

Bewerking: listAlertWebhooks Credits en authenticatie: Gratis Authenticatie vereist
GET /v1/webhooks Tegoeden: 0

Antwoordvelden

Veld Type
endpoints[] object[]
endpoints[] object
endpoints[].id string
endpoints[].url string
endpoints[].description string | null
endpoints[].events[] string[]
endpoints[].status string
endpoints[].disabled_reason string | null
endpoints[].consecutive_failures integer
endpoints[].secret_hint string
endpoints[].previous_secret_expires_at string | null
endpoints[].secret_rotated_at string | null
endpoints[].last_success_at string | null
endpoints[].last_failure_at string | null
endpoints[].last_error string | null
endpoints[].created_at string
endpoints[].updated_at string
endpoints[].disabled_at string | null
available_events[] string[]
all_events string
test_event string
policy object
policy.secret_rotation_grace_seconds integer
policy.secret_rotation_credits integer
policy.credits_per_delivered_alert integer
policy.test_event_credits integer
policy.job_event_credits integer
policy.failed_deliveries_charged boolean
policy.max_endpoints integer
policy.max_attempts integer
policy.disable_after_consecutive_failures integer
policy.signature_tolerance_seconds integer

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/webhooks"
const response = await fetch("https://domscan.net/v1/webhooks", {
  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/webhooks",
    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/webhooks", 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/webhooks")
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))

Voorbeeldantwoord

{
  "endpoints": [
    {
      "id": "example-id",
      "url": "https://example.com",
      "events": [
        "example"
      ],
      "status": "active",
      "secret_hint": "example",
      "created_at": "2026-08-27T12:00:00Z",
      "description": "example",
      "disabled_reason": "customer",
      "consecutive_failures": 1,
      "previous_secret_expires_at": "2026-08-27T12:00:00Z",
      "secret_rotated_at": "2026-08-27T12:00:00Z",
      "last_success_at": "2026-08-27T12:00:00Z",
      "last_failure_at": "2026-08-27T12:00:00Z",
      "last_error": "example",
      "updated_at": "2026-08-27T12:00:00Z",
      "disabled_at": "2026-08-27T12:00:00Z"
    }
  ],
  "available_events": [
    "domain.available"
  ],
  "policy": {
    "credits_per_delivered_alert": 2,
    "test_event_credits": 0,
    "failed_deliveries_charged": false,
    "max_endpoints": 1,
    "max_attempts": 1,
    "disable_after_consecutive_failures": 1,
    "signature_tolerance_seconds": 1,
    "secret_rotation_grace_seconds": 86400,
    "secret_rotation_credits": 0,
    "job_event_credits": 0
  },
  "all_events": "*",
  "test_event": "webhook.test"
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 429 Te veel verzoeken

POST /v1/webhooks

Bewerking: createAlertWebhook Credits en authenticatie: Gratis Authenticatie vereist
POST /v1/webhooks Tegoeden: 0

Body-parameters

Parameter Type vereist
url string vereist
description string | null optioneel
events unknown[] optioneel

Antwoordvelden

Veld Type
endpoint object
endpoint.id string
endpoint.url string
endpoint.description string | null
endpoint.events[] string[]
endpoint.status string
endpoint.disabled_reason string | null
endpoint.consecutive_failures integer
endpoint.secret_hint string
endpoint.previous_secret_expires_at string | null
endpoint.secret_rotated_at string | null
endpoint.last_success_at string | null
endpoint.last_failure_at string | null
endpoint.last_error string | null
endpoint.created_at string
endpoint.updated_at string
endpoint.disabled_at string | null
secret string

Voorbeeldverzoek

curl -X POST "https://domscan.net/v1/webhooks" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "url": "https://hooks.example.com/domscan",
  "description": "Production alerts",
  "events": [
    "domain.expiring_30",
    "domain.available",
    "domain.dns_changed"
  ]
}'
const response = await fetch("https://domscan.net/v1/webhooks", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "url": "https://hooks.example.com/domscan",
    "description": "Production alerts",
    "events": [
      "domain.expiring_30",
      "domain.available",
      "domain.dns_changed"
    ]
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.post(
    "https://domscan.net/v1/webhooks",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "url": "https://hooks.example.com/domscan",
        "description": "Production alerts",
        "events": [
            "domain.expiring_30",
            "domain.available",
            "domain.dns_changed",
        ],
    },
)
print(response.json())
package main

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

func main() {
	body := strings.NewReader(`{
	  "url": "https://hooks.example.com/domscan",
	  "description": "Production alerts",
	  "events": [
	    "domain.expiring_30",
	    "domain.available",
	    "domain.dns_changed"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/webhooks", 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/webhooks")
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://hooks.example.com/domscan",
  "description" => "Production alerts",
  "events" => [
    "domain.expiring_30",
    "domain.available",
    "domain.dns_changed"
  ]
})

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))

Voorbeeldantwoord

{
  "endpoint": {
    "id": "example-id",
    "url": "https://example.com",
    "events": [
      "example"
    ],
    "status": "active",
    "secret_hint": "example",
    "created_at": "2026-08-27T12:00:00Z",
    "description": "example",
    "disabled_reason": "customer",
    "consecutive_failures": 1,
    "previous_secret_expires_at": "2026-08-27T12:00:00Z",
    "secret_rotated_at": "2026-08-27T12:00:00Z",
    "last_success_at": "2026-08-27T12:00:00Z",
    "last_failure_at": "2026-08-27T12:00:00Z",
    "last_error": "example",
    "updated_at": "2026-08-27T12:00:00Z",
    "disabled_at": "2026-08-27T12:00:00Z"
  },
  "secret": "example"
}

HTTP-statuscodes

  • 201 Aangemaakt
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 409 HTTP 409
  • 429 Te veel verzoeken

PATCH /v1/webhooks/:webhook_id

Bewerking: updateAlertWebhook Credits en authenticatie: Gratis Authenticatie vereist
PATCH /v1/webhooks/:webhook_id Tegoeden: 0

Queryparameters

Parameter Type vereist
webhook_id string vereist

Body-parameters

Parameter Type vereist
enabled boolean optioneel
description string | null optioneel
events unknown[] optioneel

Antwoordvelden

Veld Type
endpoint object
endpoint.id string
endpoint.url string
endpoint.description string | null
endpoint.events[] string[]
endpoint.status string
endpoint.disabled_reason string | null
endpoint.consecutive_failures integer
endpoint.secret_hint string
endpoint.previous_secret_expires_at string | null
endpoint.secret_rotated_at string | null
endpoint.last_success_at string | null
endpoint.last_failure_at string | null
endpoint.last_error string | null
endpoint.created_at string
endpoint.updated_at string
endpoint.disabled_at string | null

Voorbeeldverzoek

curl -X PATCH "https://domscan.net/v1/webhooks/string" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "enabled": true,
  "events": [
    "*"
  ]
}'
const response = await fetch("https://domscan.net/v1/webhooks/string", {
  method: "PATCH",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "enabled": true,
    "events": [
      "*"
    ]
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.patch(
    "https://domscan.net/v1/webhooks/string",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "enabled": True,
        "events": [
            "*",
        ],
    },
)
print(response.json())
package main

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

func main() {
	body := strings.NewReader(`{
	  "enabled": true,
	  "events": [
	    "*"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPatch, "https://domscan.net/v1/webhooks/string", 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/webhooks/string")
request = Net::HTTP::Patch.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "enabled" => true,
  "events" => [
    "*"
  ]
})

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))

Voorbeeldantwoord

{
  "endpoint": {
    "id": "example-id",
    "url": "https://example.com",
    "events": [
      "example"
    ],
    "status": "active",
    "secret_hint": "example",
    "created_at": "2026-08-27T12:00:00Z",
    "description": "example",
    "disabled_reason": "customer",
    "consecutive_failures": 1,
    "previous_secret_expires_at": "2026-08-27T12:00:00Z",
    "secret_rotated_at": "2026-08-27T12:00:00Z",
    "last_success_at": "2026-08-27T12:00:00Z",
    "last_failure_at": "2026-08-27T12:00:00Z",
    "last_error": "example",
    "updated_at": "2026-08-27T12:00:00Z",
    "disabled_at": "2026-08-27T12:00:00Z"
  }
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

DELETE /v1/webhooks/:webhook_id

Bewerking: deleteAlertWebhook Credits en authenticatie: Gratis Authenticatie vereist
DELETE /v1/webhooks/:webhook_id Tegoeden: 0

Queryparameters

Parameter Type vereist
webhook_id string vereist

Antwoordvelden

Veld Type
id string
deleted boolean

Voorbeeldverzoek

curl -X DELETE "https://domscan.net/v1/webhooks/string" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'
const response = await fetch("https://domscan.net/v1/webhooks/string", {
  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/webhooks/string",
    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/webhooks/string", 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/webhooks/string")
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))

Voorbeeldantwoord

{
  "id": "example-id",
  "deleted": true
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

POST /v1/webhooks/:webhook_id/test

Bewerking: testAlertWebhook Credits en authenticatie: Gratis Authenticatie vereist
POST /v1/webhooks/:webhook_id/test Tegoeden: 0

Queryparameters

Parameter Type vereist
webhook_id string vereist

Antwoordvelden

Veld Type
delivery object
delivery.id string
delivery.endpoint_id string
delivery.event_id string
delivery.event_type string
delivery.status string
delivery.attempts integer
delivery.next_attempt_at string | null
delivery.last_attempt_at string | null
delivery.response_status integer | null
delivery.last_error string | null
delivery.credits_charged integer
delivery.refunded boolean
delivery.created_at string
delivery.delivered_at string | null
delivered boolean

Voorbeeldverzoek

curl -X POST "https://domscan.net/v1/webhooks/string/test" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'
const response = await fetch("https://domscan.net/v1/webhooks/string/test", {
  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/webhooks/string/test",
    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/webhooks/string/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/webhooks/string/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({})

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))

Voorbeeldantwoord

{
  "delivery": {
    "id": "example-id",
    "endpoint_id": "example",
    "event_id": "example",
    "event_type": "domain",
    "status": "pending",
    "attempts": 1,
    "next_attempt_at": "2026-08-27T12:00:00Z",
    "last_attempt_at": "2026-08-27T12:00:00Z",
    "response_status": 1,
    "last_error": "example",
    "credits_charged": 1,
    "refunded": false,
    "created_at": "2026-08-27T12:00:00Z",
    "delivered_at": "2026-08-27T12:00:00Z"
  },
  "delivered": false
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 409 HTTP 409
  • 429 Te veel verzoeken

POST /v1/webhooks/:webhook_id/rotate-secret

Bewerking: rotateAlertWebhookSecret Credits en authenticatie: Gratis Authenticatie vereist
POST /v1/webhooks/:webhook_id/rotate-secret Tegoeden: 0

Queryparameters

Parameter Type vereist
webhook_id string vereist

Antwoordvelden

Veld Type
endpoint object
endpoint.id string
endpoint.url string
endpoint.description string | null
endpoint.events[] string[]
endpoint.status string
endpoint.disabled_reason string | null
endpoint.consecutive_failures integer
endpoint.secret_hint string
endpoint.previous_secret_expires_at string | null
endpoint.secret_rotated_at string | null
endpoint.last_success_at string | null
endpoint.last_failure_at string | null
endpoint.last_error string | null
endpoint.created_at string
endpoint.updated_at string
endpoint.disabled_at string | null
secret string
previous_secret_expires_at string
grace_period_seconds integer

Voorbeeldverzoek

curl -X POST "https://domscan.net/v1/webhooks/string/rotate-secret" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'
const response = await fetch("https://domscan.net/v1/webhooks/string/rotate-secret", {
  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/webhooks/string/rotate-secret",
    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/webhooks/string/rotate-secret", 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/webhooks/string/rotate-secret")
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))

Voorbeeldantwoord

{
  "endpoint": {
    "id": "whe_3f1c0a9b8e7d6c5b4a39281706f5e4d3",
    "url": "https://hooks.example.com/domscan",
    "events": [
      "*"
    ],
    "status": "active",
    "secret_hint": "4b7a",
    "previous_secret_expires_at": "2026-10-11T12:00:00.000Z",
    "secret_rotated_at": "2026-10-10T12:00:00.000Z",
    "created_at": "2026-10-01T09:30:00.000Z"
  },
  "secret": "whsec_...",
  "previous_secret_expires_at": "2026-10-11T12:00:00.000Z",
  "grace_period_seconds": 86400
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

GET /v1/webhooks/:webhook_id/deliveries

Bewerking: listAlertWebhookDeliveries Credits en authenticatie: Gratis Authenticatie vereist
GET /v1/webhooks/:webhook_id/deliveries Tegoeden: 0

Queryparameters

Parameter Type vereist
webhook_id string vereist
limit integer
Standaard 50
optioneel

Antwoordvelden

Veld Type
endpoint_id string
deliveries[] object[]
deliveries[] object
deliveries[].id string
deliveries[].endpoint_id string
deliveries[].event_id string
deliveries[].event_type string
deliveries[].status string
deliveries[].attempts integer
deliveries[].next_attempt_at string | null
deliveries[].last_attempt_at string | null
deliveries[].response_status integer | null
deliveries[].last_error string | null
deliveries[].credits_charged integer
deliveries[].refunded boolean
deliveries[].created_at string
deliveries[].delivered_at string | null

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/webhooks/string/deliveries?limit=25"
const response = await fetch("https://domscan.net/v1/webhooks/string/deliveries?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/webhooks/string/deliveries?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/webhooks/string/deliveries?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/webhooks/string/deliveries?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))

Voorbeeldantwoord

{
  "endpoint_id": "example",
  "deliveries": [
    {
      "id": "example-id",
      "endpoint_id": "example",
      "event_id": "example",
      "event_type": "domain",
      "status": "pending",
      "attempts": 1,
      "next_attempt_at": "2026-08-27T12:00:00Z",
      "last_attempt_at": "2026-08-27T12:00:00Z",
      "response_status": 1,
      "last_error": "example",
      "credits_charged": 1,
      "refunded": false,
      "created_at": "2026-08-27T12:00:00Z",
      "delivered_at": "2026-08-27T12:00:00Z"
    }
  ]
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

GET /v1/watchlist/alerts

Bewerking: listWatchlistAlerts Credits en authenticatie: Gratis Authenticatie vereist
GET /v1/watchlist/alerts Tegoeden: 0

Antwoordvelden

Veld Type
subscriptions[] object[]
subscriptions[] object
subscriptions[].id string
subscriptions[].type string
subscriptions[].target string
subscriptions[].registrar string | null
subscriptions[].events[] string[]
subscriptions[].status string
subscriptions[].ssl_expiring_days integer | null
subscriptions[].price_type string | null
subscriptions[].drop_percent number | null
subscriptions[].target_price number | null
subscriptions[].currency string | null
subscriptions[].record_types[] string[]
subscriptions[].attributes[] string[]
subscriptions[].notify_email string | null
subscriptions[].observed object | null
subscriptions[].last_check_at string | null
subscriptions[].last_check_status string | null
subscriptions[].last_error string | null
subscriptions[].next_check_at string | null
subscriptions[].created_at string
subscriptions[].updated_at string
total integer
available_types object
available_types.ssl[] string[]
available_types.price[] string[]
available_types.dns[] string[]
available_types.typosquat[] string[]
available_types.brand[] string[]
policy object
policy.credits_per_delivered_alert integer
policy.check_credits integer
policy.unknown_checks_charged boolean
policy.max_subscriptions integer
policy.max_typosquat_subscriptions integer
policy.max_brand_subscriptions integer
policy.brand_attributes[] string[]
policy.ssl_expiring_days[] integer[]
policy.default_ssl_expiring_days integer
policy.record_types[] string[]
policy.price_types[] string[]
policy.check_interval_minutes object
policy.confirmation_checks object

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/watchlist/alerts"
const response = await fetch("https://domscan.net/v1/watchlist/alerts", {
  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/watchlist/alerts",
    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/watchlist/alerts", 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/watchlist/alerts")
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))

Voorbeeldantwoord

{
  "subscriptions": [
    {
      "id": "example-id",
      "type": "ssl",
      "target": "example",
      "registrar": "example",
      "events": [
        "ssl.expiring"
      ],
      "status": "active",
      "ssl_expiring_days": 30,
      "price_type": "registration",
      "drop_percent": 0.5,
      "target_price": 0.5,
      "currency": "USD",
      "record_types": [
        "A"
      ],
      "attributes": [
        "logo"
      ],
      "notify_email": "[email protected]",
      "observed": {},
      "last_check_at": "2026-08-27T12:00:00Z",
      "last_check_status": "baseline",
      "last_error": "example",
      "next_check_at": "2026-08-27T12:00:00Z",
      "created_at": "2026-08-27T12:00:00Z",
      "updated_at": "2026-08-27T12:00:00Z"
    }
  ],
  "total": 1,
  "available_types": {
    "ssl": [
      "ssl.expiring"
    ],
    "price": [
      "price.dropped"
    ],
    "dns": [
      "dns.changed"
    ],
    "typosquat": [
      "typosquat.detected"
    ],
    "brand": [
      "brand.updated"
    ]
  },
  "policy": {
    "credits_per_delivered_alert": 2,
    "check_credits": 0,
    "unknown_checks_charged": false,
    "max_subscriptions": 1,
    "check_interval_minutes": {},
    "max_typosquat_subscriptions": 1,
    "max_brand_subscriptions": 1,
    "brand_attributes": [
      "logo"
    ],
    "ssl_expiring_days": [
      1
    ],
    "default_ssl_expiring_days": 1,
    "record_types": [
      "A"
    ],
    "price_types": [
      "registration"
    ],
    "confirmation_checks": {}
  }
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 429 Te veel verzoeken

POST /v1/watchlist/alerts

Bewerking: createWatchlistAlert Credits en authenticatie: Gratis Authenticatie vereist
POST /v1/watchlist/alerts Tegoeden: 0

Body-parameters

Parameter Type vereist
type string
Toegestane waarden sslpricednstyposquatbrand
vereist
domain string optioneel
tld string optioneel
registrar string | null optioneel
events string[]
Toegestane waarden ssl.expiringssl.expiredssl.changedprice.droppeddns.changedtyposquat.detectedbrand.updated
optioneel
ssl_expiring_days integer
Toegestane waarden 301471
Standaard 14
optioneel
price_type string
Toegestane waarden registrationrenewal
Standaard registration
optioneel
drop_percent number | null optioneel
target_price number | null optioneel
record_types string[]
Toegestane waarden AAAAAMXNSTXTCNAME
optioneel
attributes string[]
Toegestane waarden logowide_logocolorsnamesocials
optioneel
notify_email string | null optioneel

Antwoordvelden

Veld Type
subscription object
subscription.id string
subscription.type string
subscription.target string
subscription.registrar string | null
subscription.events[] string[]
subscription.status string
subscription.ssl_expiring_days integer | null
subscription.price_type string | null
subscription.drop_percent number | null
subscription.target_price number | null
subscription.currency string | null
subscription.record_types[] string[]
subscription.attributes[] string[]
subscription.notify_email string | null
subscription.observed object | null
subscription.last_check_at string | null
subscription.last_check_status string | null
subscription.last_error string | null
subscription.next_check_at string | null
subscription.created_at string
subscription.updated_at string

Voorbeeldverzoek

curl -X POST "https://domscan.net/v1/watchlist/alerts" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "type": "ssl",
  "domain": "shop.example.com",
  "events": [
    "ssl.expiring",
    "ssl.changed"
  ],
  "ssl_expiring_days": 14
}'
const response = await fetch("https://domscan.net/v1/watchlist/alerts", {
  method: "POST",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "type": "ssl",
    "domain": "shop.example.com",
    "events": [
      "ssl.expiring",
      "ssl.changed"
    ],
    "ssl_expiring_days": 14
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.post(
    "https://domscan.net/v1/watchlist/alerts",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "type": "ssl",
        "domain": "shop.example.com",
        "events": [
            "ssl.expiring",
            "ssl.changed",
        ],
        "ssl_expiring_days": 14,
    },
)
print(response.json())
package main

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

func main() {
	body := strings.NewReader(`{
	  "type": "ssl",
	  "domain": "shop.example.com",
	  "events": [
	    "ssl.expiring",
	    "ssl.changed"
	  ],
	  "ssl_expiring_days": 14
	}`)
	req, err := http.NewRequest(http.MethodPost, "https://domscan.net/v1/watchlist/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/watchlist/alerts")
request = Net::HTTP::Post.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "type" => "ssl",
  "domain" => "shop.example.com",
  "events" => [
    "ssl.expiring",
    "ssl.changed"
  ],
  "ssl_expiring_days" => 14
})

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))

Voorbeeldantwoord

{
  "subscription": {
    "id": "example-id",
    "type": "ssl",
    "target": "example",
    "registrar": "example",
    "events": [
      "ssl.expiring"
    ],
    "status": "active",
    "ssl_expiring_days": 30,
    "price_type": "registration",
    "drop_percent": 0.5,
    "target_price": 0.5,
    "currency": "USD",
    "record_types": [
      "A"
    ],
    "attributes": [
      "logo"
    ],
    "notify_email": "[email protected]",
    "observed": {},
    "last_check_at": "2026-08-27T12:00:00Z",
    "last_check_status": "baseline",
    "last_error": "example",
    "next_check_at": "2026-08-27T12:00:00Z",
    "created_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z"
  }
}

HTTP-statuscodes

  • 201 Aangemaakt
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 409 HTTP 409
  • 429 Te veel verzoeken

GET /v1/watchlist/alerts/:subscription_id

Bewerking: getWatchlistAlert Credits en authenticatie: Gratis Authenticatie vereist
GET /v1/watchlist/alerts/:subscription_id Tegoeden: 0

Queryparameters

Parameter Type vereist
subscription_id string vereist

Antwoordvelden

Veld Type
subscription object
subscription.id string
subscription.type string
subscription.target string
subscription.registrar string | null
subscription.events[] string[]
subscription.status string
subscription.ssl_expiring_days integer | null
subscription.price_type string | null
subscription.drop_percent number | null
subscription.target_price number | null
subscription.currency string | null
subscription.record_types[] string[]
subscription.attributes[] string[]
subscription.notify_email string | null
subscription.observed object | null
subscription.last_check_at string | null
subscription.last_check_status string | null
subscription.last_error string | null
subscription.next_check_at string | null
subscription.created_at string
subscription.updated_at string
events[] object[]
events[] object
events[].id string
events[].event_type string
events[].detected_at string
events[].published_at string | null
events[].data object

Voorbeeldverzoek

curl -H "X-API-Key: $DOMSCAN_API_KEY" "https://domscan.net/v1/watchlist/alerts/string"
const response = await fetch("https://domscan.net/v1/watchlist/alerts/string", {
  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/watchlist/alerts/string",
    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/watchlist/alerts/string", 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/watchlist/alerts/string")
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))

Voorbeeldantwoord

{
  "subscription": {
    "id": "example-id",
    "type": "ssl",
    "target": "example",
    "registrar": "example",
    "events": [
      "ssl.expiring"
    ],
    "status": "active",
    "ssl_expiring_days": 30,
    "price_type": "registration",
    "drop_percent": 0.5,
    "target_price": 0.5,
    "currency": "USD",
    "record_types": [
      "A"
    ],
    "attributes": [
      "logo"
    ],
    "notify_email": "[email protected]",
    "observed": {},
    "last_check_at": "2026-08-27T12:00:00Z",
    "last_check_status": "baseline",
    "last_error": "example",
    "next_check_at": "2026-08-27T12:00:00Z",
    "created_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z"
  },
  "events": [
    {
      "id": "example-id",
      "event_type": "ssl.expiring",
      "detected_at": "2026-08-27T12:00:00Z",
      "published_at": "2026-08-27T12:00:00Z",
      "data": {}
    }
  ]
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

PATCH /v1/watchlist/alerts/:subscription_id

Bewerking: updateWatchlistAlert Credits en authenticatie: Gratis Authenticatie vereist
PATCH /v1/watchlist/alerts/:subscription_id Tegoeden: 0

Queryparameters

Parameter Type vereist
subscription_id string vereist

Body-parameters

Parameter Type vereist
enabled boolean optioneel
events string[]
Toegestane waarden ssl.expiringssl.expiredssl.changedprice.droppeddns.changedtyposquat.detectedbrand.updated
optioneel
ssl_expiring_days integer
Toegestane waarden 301471
optioneel
drop_percent number | null optioneel
target_price number | null optioneel
record_types string[]
Toegestane waarden AAAAAMXNSTXTCNAME
optioneel
attributes string[]
Toegestane waarden logowide_logocolorsnamesocials
optioneel
notify_email string | null optioneel

Antwoordvelden

Veld Type
subscription object
subscription.id string
subscription.type string
subscription.target string
subscription.registrar string | null
subscription.events[] string[]
subscription.status string
subscription.ssl_expiring_days integer | null
subscription.price_type string | null
subscription.drop_percent number | null
subscription.target_price number | null
subscription.currency string | null
subscription.record_types[] string[]
subscription.attributes[] string[]
subscription.notify_email string | null
subscription.observed object | null
subscription.last_check_at string | null
subscription.last_check_status string | null
subscription.last_error string | null
subscription.next_check_at string | null
subscription.created_at string
subscription.updated_at string

Voorbeeldverzoek

curl -X PATCH "https://domscan.net/v1/watchlist/alerts/string" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{
  "enabled": true,
  "events": [
    "ssl.expiring",
    "ssl.expired",
    "ssl.changed"
  ]
}'
const response = await fetch("https://domscan.net/v1/watchlist/alerts/string", {
  method: "PATCH",
  headers: { "X-API-Key": process.env.DOMSCAN_API_KEY, "Content-Type": "application/json" },
  body: JSON.stringify({
    "enabled": true,
    "events": [
      "ssl.expiring",
      "ssl.expired",
      "ssl.changed"
    ]
  }),
});
const data = await response.json();
console.log(data);
import os
import requests

response = requests.patch(
    "https://domscan.net/v1/watchlist/alerts/string",
    headers={"X-API-Key": os.environ["DOMSCAN_API_KEY"]},
    json={
        "enabled": True,
        "events": [
            "ssl.expiring",
            "ssl.expired",
            "ssl.changed",
        ],
    },
)
print(response.json())
package main

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

func main() {
	body := strings.NewReader(`{
	  "enabled": true,
	  "events": [
	    "ssl.expiring",
	    "ssl.expired",
	    "ssl.changed"
	  ]
	}`)
	req, err := http.NewRequest(http.MethodPatch, "https://domscan.net/v1/watchlist/alerts/string", 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/watchlist/alerts/string")
request = Net::HTTP::Patch.new(uri)
request["X-API-Key"] = ENV.fetch("DOMSCAN_API_KEY")
request["Content-Type"] = "application/json"
request.body = JSON.generate({
  "enabled" => true,
  "events" => [
    "ssl.expiring",
    "ssl.expired",
    "ssl.changed"
  ]
})

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))

Voorbeeldantwoord

{
  "subscription": {
    "id": "example-id",
    "type": "ssl",
    "target": "example",
    "registrar": "example",
    "events": [
      "ssl.expiring"
    ],
    "status": "active",
    "ssl_expiring_days": 30,
    "price_type": "registration",
    "drop_percent": 0.5,
    "target_price": 0.5,
    "currency": "USD",
    "record_types": [
      "A"
    ],
    "attributes": [
      "logo"
    ],
    "notify_email": "[email protected]",
    "observed": {},
    "last_check_at": "2026-08-27T12:00:00Z",
    "last_check_status": "baseline",
    "last_error": "example",
    "next_check_at": "2026-08-27T12:00:00Z",
    "created_at": "2026-08-27T12:00:00Z",
    "updated_at": "2026-08-27T12:00:00Z"
  }
}

HTTP-statuscodes

  • 200 OK
  • 400 Ongeldig verzoek
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

DELETE /v1/watchlist/alerts/:subscription_id

Bewerking: deleteWatchlistAlert Credits en authenticatie: Gratis Authenticatie vereist
DELETE /v1/watchlist/alerts/:subscription_id Tegoeden: 0

Queryparameters

Parameter Type vereist
subscription_id string vereist

Antwoordvelden

Veld Type
id string
deleted boolean

Voorbeeldverzoek

curl -X DELETE "https://domscan.net/v1/watchlist/alerts/string" \
  -H "Content-Type: application/json" \
  -H "X-API-Key: $DOMSCAN_API_KEY" \
  -d '{}'
const response = await fetch("https://domscan.net/v1/watchlist/alerts/string", {
  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/watchlist/alerts/string",
    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/watchlist/alerts/string", 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/watchlist/alerts/string")
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))

Voorbeeldantwoord

{
  "id": "example-id",
  "deleted": true
}

HTTP-statuscodes

  • 200 OK
  • 401 Niet geautoriseerd
  • 404 Niet gevonden
  • 429 Te veel verzoeken

Referentiebronnen