도메인 감시 목록 API 레퍼런스
도메인 감시 목록을 관리합니다. 도메인이 가능해지거나 상태가 변경될 때 알림을 받습니다. 이 레퍼런스에서 알맞은 엔드포인트를 고르고 반환되는 결과를 정확히 확인하세요.
작업
GET /v1/watchlist
GET
/v1/watchlist
크레딧: 1
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| limit | integer | 선택 사항 |
| cursor | string | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음402결제 필요429요청 과다
POST /v1/watchlist
POST
/v1/watchlist
크레딧: 1
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| domain | string | 필수 |
| notify_email | string | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
201생성됨400잘못된 요청401인증되지 않음402결제 필요409HTTP 409422HTTP 422429요청 과다
PATCH /v1/watchlist/:domain
PATCH
/v1/watchlist/:domain
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| domain | string | 필수 |
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| notify_email | string | null | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음404찾을 수 없음429요청 과다
DELETE /v1/watchlist
DELETE
/v1/watchlist
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| domain | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음402결제 필요429요청 과다
GET /v1/watchlist/expiring
GET
/v1/watchlist/expiring
크레딧: 1
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| days |
integer
기본값
90
|
선택 사항 |
| limit | integer | 선택 사항 |
| cursor | string | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음402결제 필요429요청 과다
GET /v1/watchlist/available
GET
/v1/watchlist/available
크레딧: 1
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| limit | integer | 선택 사항 |
| cursor | string | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음402결제 필요429요청 과다
GET /v1/webhooks
GET
/v1/webhooks
크레딧: 0
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공401인증되지 않음429요청 과다
POST /v1/webhooks
POST
/v1/webhooks
크레딧: 0
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| url | string | 필수 |
| description | string | null | 선택 사항 |
| events | unknown[] | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
201생성됨400잘못된 요청401인증되지 않음409HTTP 409429요청 과다
PATCH /v1/webhooks/:webhook_id
PATCH
/v1/webhooks/:webhook_id
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| webhook_id | string | 필수 |
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| enabled | boolean | 선택 사항 |
| description | string | null | 선택 사항 |
| events | unknown[] | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음404찾을 수 없음429요청 과다
DELETE /v1/webhooks/:webhook_id
DELETE
/v1/webhooks/:webhook_id
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| webhook_id | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
id |
string |
deleted |
boolean |
예제 요청
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))예제 응답
{
"id": "example-id",
"deleted": true
}
HTTP 상태 코드
200성공401인증되지 않음404찾을 수 없음429요청 과다
POST /v1/webhooks/:webhook_id/test
POST
/v1/webhooks/:webhook_id/test
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| webhook_id | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공401인증되지 않음404찾을 수 없음409HTTP 409429요청 과다
POST /v1/webhooks/:webhook_id/rotate-secret
POST
/v1/webhooks/:webhook_id/rotate-secret
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| webhook_id | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공401인증되지 않음404찾을 수 없음429요청 과다
GET /v1/webhooks/:webhook_id/deliveries
GET
/v1/webhooks/:webhook_id/deliveries
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| webhook_id | string | 필수 |
| limit |
integer
기본값
50
|
선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음404찾을 수 없음429요청 과다
GET /v1/watchlist/alerts
GET
/v1/watchlist/alerts
크레딧: 0
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공401인증되지 않음429요청 과다
POST /v1/watchlist/alerts
POST
/v1/watchlist/alerts
크레딧: 0
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| type |
string
허용된 값
sslpricednstyposquatbrand
|
필수 |
| domain | string | 선택 사항 |
| tld | string | 선택 사항 |
| registrar | string | null | 선택 사항 |
| events |
string[]
허용된 값
ssl.expiringssl.expiredssl.changedprice.droppeddns.changedtyposquat.detectedbrand.updated
|
선택 사항 |
| ssl_expiring_days |
integer
허용된 값
301471
기본값
14
|
선택 사항 |
| price_type |
string
허용된 값
registrationrenewal
기본값
registration
|
선택 사항 |
| drop_percent | number | null | 선택 사항 |
| target_price | number | null | 선택 사항 |
| record_types |
string[]
허용된 값
AAAAAMXNSTXTCNAME
|
선택 사항 |
| attributes |
string[]
허용된 값
logowide_logocolorsnamesocials
|
선택 사항 |
| notify_email | string | null | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
201생성됨400잘못된 요청401인증되지 않음409HTTP 409429요청 과다
GET /v1/watchlist/alerts/:subscription_id
GET
/v1/watchlist/alerts/:subscription_id
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| subscription_id | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공401인증되지 않음404찾을 수 없음429요청 과다
PATCH /v1/watchlist/alerts/:subscription_id
PATCH
/v1/watchlist/alerts/:subscription_id
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| subscription_id | string | 필수 |
본문 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| enabled | boolean | 선택 사항 |
| events |
string[]
허용된 값
ssl.expiringssl.expiredssl.changedprice.droppeddns.changedtyposquat.detectedbrand.updated
|
선택 사항 |
| ssl_expiring_days |
integer
허용된 값
301471
|
선택 사항 |
| drop_percent | number | null | 선택 사항 |
| target_price | number | null | 선택 사항 |
| record_types |
string[]
허용된 값
AAAAAMXNSTXTCNAME
|
선택 사항 |
| attributes |
string[]
허용된 값
logowide_logocolorsnamesocials
|
선택 사항 |
| notify_email | string | null | 선택 사항 |
응답 필드
| 필드 | 유형 |
|---|---|
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 |
예제 요청
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))예제 응답
{
"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 상태 코드
200성공400잘못된 요청401인증되지 않음404찾을 수 없음429요청 과다
DELETE /v1/watchlist/alerts/:subscription_id
DELETE
/v1/watchlist/alerts/:subscription_id
크레딧: 0
쿼리 매개변수
| 매개변수 | 유형 | 필수 |
|---|---|---|
| subscription_id | string | 필수 |
응답 필드
| 필드 | 유형 |
|---|---|
id |
string |
deleted |
boolean |
예제 요청
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))예제 응답
{
"id": "example-id",
"deleted": true
}
HTTP 상태 코드
200성공401인증되지 않음404찾을 수 없음429요청 과다