DNS Records API

This uses the requests library (pip install requests):

import os

import requests

params = {"status": "failing", "limit": 200}
while True:
    response = requests.get(
        "https://www.dnscheck.co/api/v2/dns-records",
        headers={"Authorization": f"Bearer {os.environ['DNSCHECK_API_KEY']}"},
        params=params,
        timeout=30,
    )
    if response.headers.get("Content-Type", "").startswith("application/problem+json"):
        problem = response.json()
        print(f"{problem['code']}: {problem['detail']}")
        raise SystemExit(1)
    response.raise_for_status()
    page = response.json()
    for record in page["data"]:
        print(record["name"], record["type"], record["web_url"])
    if not page["has_more"]:
        break
    params["cursor"] = page["next_cursor"]

This needs Node.js 18 or later. Save it in a .mjs file, so top-level await works:

const params = new URLSearchParams({ status: "failing", limit: "200" });
while (true) {
  const response = await fetch(`https://www.dnscheck.co/api/v2/dns-records?${params}`, {
    headers: { Authorization: `Bearer ${process.env.DNSCHECK_API_KEY}` },
    signal: AbortSignal.timeout(30000),
  });
  if (response.headers.get("Content-Type")?.startsWith("application/problem+json")) {
    const problem = await response.json();
    console.error(`${problem.code}: ${problem.detail}`);
    process.exit(1);
  }
  if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
  const page = await response.json();
  for (const record of page.data) console.log(record.name, record.type, record.web_url);
  if (!page.has_more) break;
  params.set("cursor", page.next_cursor);
}

Using only the standard library. Save it as failing-records.go and run it with go run failing-records.go:

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

func main() {
	client := &http.Client{Timeout: 30 * time.Second}
	params := url.Values{"status": {"failing"}, "limit": {"200"}}
	for {
		req, err := http.NewRequest("GET", "https://www.dnscheck.co/api/v2/dns-records?"+params.Encode(), nil)
		if err != nil {
			log.Fatal(err)
		}
		req.Header.Set("Authorization", "Bearer "+os.Getenv("DNSCHECK_API_KEY"))
		response, err := client.Do(req)
		if err != nil {
			log.Fatal(err)
		}
		if response.StatusCode >= 400 && !strings.HasPrefix(response.Header.Get("Content-Type"), "application/problem+json") {
			log.Fatalf("HTTP %s", response.Status)
		}
		var page struct {
			Data []struct {
				Name, Type string
				WebURL     string `json:"web_url"`
			}
			HasMore      bool   `json:"has_more"`
			NextCursor   string `json:"next_cursor"`
			Code, Detail string
		}
		err = json.NewDecoder(response.Body).Decode(&page)
		response.Body.Close()
		if err != nil {
			log.Fatal(err)
		}
		if response.StatusCode >= 400 {
			log.Fatalf("%s: %s", page.Code, page.Detail)
		}
		for _, record := range page.Data {
			fmt.Println(record.Name, record.Type, record.WebURL)
		}
		if !page.HasMore {
			break
		}
		params.Set("cursor", page.NextCursor)
	}
}

This uses the requests library (pip install requests):

import os

import requests

response = requests.post(
    f"https://www.dnscheck.co/api/v2/record-groups/{os.environ['GROUP_ID']}/dns-records",
    headers={
        "Authorization": f"Bearer {os.environ['DNSCHECK_API_KEY']}",
    },
    json={"name": "example.com", "type": "MX", "values": ["10 mail.example.com."]},
    timeout=30,
)
if response.headers.get("Content-Type", "").startswith("application/problem+json"):
    problem = response.json()
    print(f"{problem['code']}: {problem['detail']}")
    for error in problem.get("errors", []):
        print(error["message"])
    raise SystemExit(1)
response.raise_for_status()
record = response.json()
print(record["id"])

This needs Node.js 18 or later. Save it in a .mjs file, so top-level await works:

const response = await fetch(`https://www.dnscheck.co/api/v2/record-groups/${process.env.GROUP_ID}/dns-records`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.DNSCHECK_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({ name: "example.com", type: "MX", values: ["10 mail.example.com."] }),
  signal: AbortSignal.timeout(30000),
});
if (response.headers.get("Content-Type")?.startsWith("application/problem+json")) {
  const problem = await response.json();
  console.error(`${problem.code}: ${problem.detail}`);
  for (const error of problem.errors ?? []) console.error(error.message);
  process.exit(1);
}
if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
const record = await response.json();
console.log(record.id);

Using only the standard library. Save it as add-record.go and run it with go run add-record.go:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {
	body, err := json.Marshal(map[string]any{
		"name": "example.com", "type": "MX", "values": []string{"10 mail.example.com."},
	})
	if err != nil {
		log.Fatal(err)
	}
	req, err := http.NewRequest("POST", "https://www.dnscheck.co/api/v2/record-groups/"+os.Getenv("GROUP_ID")+"/dns-records", bytes.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("DNSCHECK_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	client := &http.Client{Timeout: 30 * time.Second}
	response, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode >= 400 && !strings.HasPrefix(response.Header.Get("Content-Type"), "application/problem+json") {
		log.Fatalf("HTTP %s", response.Status)
	}

	var record struct {
		ID, Code, Detail string
		Errors           []struct{ Message string }
	}
	if err := json.NewDecoder(response.Body).Decode(&record); err != nil {
		log.Fatal(err)
	}
	if response.StatusCode >= 400 {
		fmt.Fprintf(os.Stderr, "%s: %s\n", record.Code, record.Detail)
		for _, e := range record.Errors {
			fmt.Fprintln(os.Stderr, e.Message)
		}
		os.Exit(1)
	}
	fmt.Println(record.ID)
}

This uses the requests library (pip install requests):

import os

import requests

url = f"https://www.dnscheck.co/api/v2/dns-records/{os.environ['RECORD_ID']}"
headers = {"Authorization": f"Bearer {os.environ['DNSCHECK_API_KEY']}"}

current = requests.get(url, headers=headers, timeout=30)
current.raise_for_status()
response = requests.patch(
    url,
    headers={**headers, "If-Match": current.headers["ETag"]},
    json={"values": ["20 mail.example.com."]},
    timeout=30,
)
if response.headers.get("Content-Type", "").startswith("application/problem+json"):
    problem = response.json()
    print(f"{problem['code']}: {problem['detail']}")
    for error in problem.get("errors", []):
        print(error["message"])
    raise SystemExit(1)
response.raise_for_status()
record = response.json()
print(record["values"])

This needs Node.js 18 or later. Save it in a .mjs file, so top-level await works:

const url = `https://www.dnscheck.co/api/v2/dns-records/${process.env.RECORD_ID}`;
const auth = { Authorization: `Bearer ${process.env.DNSCHECK_API_KEY}` };

const current = await fetch(url, { headers: auth, signal: AbortSignal.timeout(30000) });
if (!current.ok) throw new Error(`HTTP ${current.status} ${current.statusText}`);
const response = await fetch(url, {
  method: "PATCH",
  headers: { ...auth, "Content-Type": "application/json", "If-Match": current.headers.get("ETag") },
  body: JSON.stringify({ values: ["20 mail.example.com."] }),
  signal: AbortSignal.timeout(30000),
});
if (response.headers.get("Content-Type")?.startsWith("application/problem+json")) {
  const problem = await response.json();
  console.error(`${problem.code}: ${problem.detail}`);
  for (const error of problem.errors ?? []) console.error(error.message);
  process.exit(1);
}
if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
const record = await response.json();
console.log(record.values);

Using only the standard library. Save it as update-record.go and run it with go run update-record.go:

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"strings"
	"time"
)

func main() {
	url := "https://www.dnscheck.co/api/v2/dns-records/" + os.Getenv("RECORD_ID")
	auth := "Bearer " + os.Getenv("DNSCHECK_API_KEY")
	client := &http.Client{Timeout: 30 * time.Second}

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", auth)
	current, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	current.Body.Close()
	if current.StatusCode != http.StatusOK {
		log.Fatalf("HTTP %s", current.Status)
	}

	body, err := json.Marshal(map[string]any{"values": []string{"20 mail.example.com."}})
	if err != nil {
		log.Fatal(err)
	}
	req, err = http.NewRequest("PATCH", url, bytes.NewReader(body))
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", auth)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("If-Match", current.Header.Get("ETag"))
	response, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode >= 400 && !strings.HasPrefix(response.Header.Get("Content-Type"), "application/problem+json") {
		log.Fatalf("HTTP %s", response.Status)
	}

	var record struct {
		Values       []string
		Code, Detail string
		Errors       []struct{ Message string }
	}
	if err := json.NewDecoder(response.Body).Decode(&record); err != nil {
		log.Fatal(err)
	}
	if response.StatusCode >= 400 {
		fmt.Fprintf(os.Stderr, "%s: %s\n", record.Code, record.Detail)
		for _, e := range record.Errors {
			fmt.Fprintln(os.Stderr, e.Message)
		}
		os.Exit(1)
	}
	fmt.Println(record.Values)
}

This uses the requests library (pip install requests):

import os
import time

import requests

url = f"https://www.dnscheck.co/api/v2/dns-records/{os.environ['RECORD_ID']}"
session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['DNSCHECK_API_KEY']}"

response = session.post(f"{url}/check", timeout=30)
if response.headers.get("Content-Type", "").startswith("application/problem+json"):
    problem = response.json()
    print(f"{problem['code']}: {problem['detail']}")
    raise SystemExit(1)
response.raise_for_status()
record = response.json()
before = record["checked_at"]
if response.status_code == 202:
    deadline = time.monotonic() + 30
    while True:
        time.sleep(5)
        poll = session.get(url, timeout=30)
        poll.raise_for_status()
        record = poll.json()
        if record["checked_at"] != before or time.monotonic() >= deadline:
            break

if response.status_code == 202 and record["checked_at"] == before:
    print("The check hasn't run yet. Read the DNS record again in a minute.")
else:
    print(record["status"], record["error"], record["checked_at"])

This needs Node.js 18 or later. Save it in a .mjs file, so top-level await works:

import { setTimeout as sleep } from "node:timers/promises";

const url = `https://www.dnscheck.co/api/v2/dns-records/${process.env.RECORD_ID}`;
const headers = { Authorization: `Bearer ${process.env.DNSCHECK_API_KEY}` };

const response = await fetch(`${url}/check`, {
  method: "POST",
  headers,
  signal: AbortSignal.timeout(30000),
});
if (response.headers.get("Content-Type")?.startsWith("application/problem+json")) {
  const problem = await response.json();
  console.error(`${problem.code}: ${problem.detail}`);
  process.exit(1);
}
if (!response.ok) throw new Error(`HTTP ${response.status} ${response.statusText}`);
let record = await response.json();
const before = record.checked_at;
if (response.status === 202) {
  const deadline = Date.now() + 30000;
  while (true) {
    await sleep(5000);
    const poll = await fetch(url, { headers, signal: AbortSignal.timeout(30000) });
    if (!poll.ok) throw new Error(`HTTP ${poll.status} ${poll.statusText}`);
    record = await poll.json();
    if (record.checked_at !== before || Date.now() >= deadline) break;
  }
}

if (response.status === 202 && record.checked_at === before) {
  console.log("The check hasn't run yet. Read the DNS record again in a minute.");
} else {
  console.log(record.status, record.error, record.checked_at);
}

Using only the standard library. Save it as check-record.go and run it with go run check-record.go:

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"
)

type dnsRecord struct {
	Status    string
	Error     any
	CheckedAt any `json:"checked_at"`
}

var client = &http.Client{Timeout: 30 * time.Second}

// Sends a request with the key, and returns the DNS record and status code
func call(method, url string) (dnsRecord, int) {
	req, err := http.NewRequest(method, url, nil)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Authorization", "Bearer "+os.Getenv("DNSCHECK_API_KEY"))
	response, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode >= 400 {
		var problem struct{ Code, Detail string }
		if err := json.NewDecoder(response.Body).Decode(&problem); err != nil {
			log.Fatalf("HTTP %s", response.Status)
		}
		log.Fatalf("%s: %s", problem.Code, problem.Detail)
	}
	var record dnsRecord
	if err := json.NewDecoder(response.Body).Decode(&record); err != nil {
		log.Fatal(err)
	}
	return record, response.StatusCode
}

func main() {
	url := "https://www.dnscheck.co/api/v2/dns-records/" + os.Getenv("RECORD_ID")
	record, status := call("POST", url+"/check")
	before := record.CheckedAt
	deadline := time.Now().Add(30 * time.Second)
	for status == http.StatusAccepted {
		time.Sleep(5 * time.Second)
		record, _ = call("GET", url)
		if record.CheckedAt != before || time.Now().After(deadline) {
			break
		}
	}

	if status == http.StatusAccepted && record.CheckedAt == before {
		fmt.Println("The check hasn't run yet. Read the DNS record again in a minute.")
	} else {
		fmt.Println(record.Status, record.Error, record.CheckedAt)
	}
}