Enable and Disable Monitors

Individual monitors can be enabled or disabled to control DNS checking without losing configuration or event history.

Disabling a Monitor

Send a POST request to /monitors/{uuid}/disable:

curl -X POST https://api.dnsradar.dev/monitors/mon_abc123/disable \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

const response = await fetch('https://api.dnsradar.dev/monitors/mon_abc123/disable', {
  method: 'POST',
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({})
});

const data = await response.json();

import requests

response = requests.post(
    'https://api.dnsradar.dev/monitors/mon_abc123/disable',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={}
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors/mon_abc123/disable')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {}.to_json

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

data := {}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", "https://api.dnsradar.dev/monitors/mon_abc123/disable", bytes.NewBuffer(jsonData))
req.Header.Set("X-API-Key", "YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors/mon_abc123/disable');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');

$headers = [
    'X-API-Key: YOUR_API_KEY',
    'Content-Type: application/json'
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$data = json_encode({});
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

String json = """{}""";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors/mon_abc123/disable"))
    .header("X-API-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString(json))
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var data = new
{};

var json = JsonSerializer.Serialize(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync(
    "https://api.dnsradar.dev/monitors/mon_abc123/disable",
    content
);

The monitor immediately stops checking DNS and won't trigger webhooks.

Enabling a Monitor

Send a POST request to /monitors/{uuid}/enable:

curl -X POST https://api.dnsradar.dev/monitors/mon_abc123/enable \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{}'

const response = await fetch('https://api.dnsradar.dev/monitors/mon_abc123/enable', {
  method: 'POST',
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({})
});

const data = await response.json();

import requests

response = requests.post(
    'https://api.dnsradar.dev/monitors/mon_abc123/enable',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={}
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors/mon_abc123/enable')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {}.to_json

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

data := {}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", "https://api.dnsradar.dev/monitors/mon_abc123/enable", bytes.NewBuffer(jsonData))
req.Header.Set("X-API-Key", "YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors/mon_abc123/enable');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');

$headers = [
    'X-API-Key: YOUR_API_KEY',
    'Content-Type: application/json'
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$data = json_encode({});
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

String json = """{}""";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors/mon_abc123/enable"))
    .header("X-API-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString(json))
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var data = new
{};

var json = JsonSerializer.Serialize(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PostAsync(
    "https://api.dnsradar.dev/monitors/mon_abc123/enable",
    content
);

The monitor resumes DNS checking according to its frequency setting.

API Response

Both endpoints return the updated monitor:

{
  "uuid": "mon_abc123",
  "domain": "piedpiper.com",
  "record_type": "A",
  "is_active": false,
  "frequency": 15,
  ...
}

Bulk Operations

For bulk enable/disable, use group-level updates:

curl -X PATCH https://api.dnsradar.dev/groups/customer-123/monitors \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "is_active": false
}'

const response = await fetch('https://api.dnsradar.dev/groups/customer-123/monitors', {
  method: 'PATCH',
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "is_active": false
  })
});

const data = await response.json();

import requests

response = requests.patch(
    'https://api.dnsradar.dev/groups/customer-123/monitors',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
        'Content-Type': 'application/json'
    },
    json={
        "is_active": false
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/groups/customer-123/monitors')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'
request['Content-Type'] = 'application/json'
request.body = {
    "is_active": false
  }.to_json

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

data := {
    "is_active": false
}
jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("PATCH", "https://api.dnsradar.dev/groups/customer-123/monitors", bytes.NewBuffer(jsonData))
req.Header.Set("X-API-Key", "YOUR_API_KEY")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/groups/customer-123/monitors');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PATCH');

$headers = [
    'X-API-Key: YOUR_API_KEY',
    'Content-Type: application/json'
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$data = json_encode({
    "is_active": false
});
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

String json = """{
    "is_active": false
}""";

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/groups/customer-123/monitors"))
    .header("X-API-Key", "YOUR_API_KEY")
    .header("Content-Type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString(json))
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var data = new
{
    "is_active": false
};

var json = JsonSerializer.Serialize(data);
var content = new StringContent(json, Encoding.UTF8, "application/json");

var response = await client.PatchAsync(
    "https://api.dnsradar.dev/groups/customer-123/monitors",
    content
);

This disables all monitors in the group at once. See bulk updates documentation.

Monitoring State

You can check whether a monitor is currently active by retrieving its details.

Check Single Monitor Status

Get the monitor details to inspect the is_active field:

curl -X GET https://api.dnsradar.dev/monitors/mon_abc123 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/monitors/mon_abc123', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/monitors/mon_abc123',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors/mon_abc123')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

req, _ := http.NewRequest("GET", "https://api.dnsradar.dev/monitors/mon_abc123", nil)
req.Header.Set("X-API-Key", "YOUR_API_KEY")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors/mon_abc123');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

$headers = [
    'X-API-Key: YOUR_API_KEY',
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors/mon_abc123"))
    .header("X-API-Key", "YOUR_API_KEY")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var response = await client.GetAsync("https://api.dnsradar.dev/monitors/mon_abc123");

The response includes the is_active parameter:

{
  "uuid": "mon_abc123",
  "domain": "piedpiper.com",
  "subdomain": "www",
  "record_type": "A",
  "expected_value": ["1.2.3.4"],
  "is_active": true,
  "frequency": 15,
  "last_checked": "2026-01-09T10:30:00Z",
  "created": "2026-01-01T08:00:00Z"
}

Monitor State Field

Value	State	Description
`true`	Active	Monitor is checking DNS and triggering webhooks
`false`	Disabled	Monitor is paused and not performing checks

List Monitors with State

Get all monitors to see their active status:

curl -X GET https://api.dnsradar.dev/monitors \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/monitors', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/monitors',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

req, _ := http.NewRequest("GET", "https://api.dnsradar.dev/monitors", nil)
req.Header.Set("X-API-Key", "YOUR_API_KEY")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

$headers = [
    'X-API-Key: YOUR_API_KEY',
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors"))
    .header("X-API-Key", "YOUR_API_KEY")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var response = await client.GetAsync("https://api.dnsradar.dev/monitors");

Filter for only active monitors:

curl -X GET https://api.dnsradar.dev/monitors?is_active=true \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/monitors?is_active=true', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/monitors?is_active=true',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors?is_active=true')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

req, _ := http.NewRequest("GET", "https://api.dnsradar.dev/monitors?is_active=true", nil)
req.Header.Set("X-API-Key", "YOUR_API_KEY")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors?is_active=true');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

$headers = [
    'X-API-Key: YOUR_API_KEY',
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors?is_active=true"))
    .header("X-API-Key", "YOUR_API_KEY")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var response = await client.GetAsync("https://api.dnsradar.dev/monitors?is_active=true");

Filter for only disabled monitors:

curl -X GET https://api.dnsradar.dev/monitors?is_active=false \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/monitors?is_active=false', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/monitors?is_active=false',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/monitors?is_active=false')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['X-API-Key'] = 'YOUR_API_KEY'

response = http.request(request)

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

req, _ := http.NewRequest("GET", "https://api.dnsradar.dev/monitors?is_active=false", nil)
req.Header.Set("X-API-Key", "YOUR_API_KEY")

client := &http.Client{}
response, _ := client.Do(req)

<?php

$ch = curl_init();

curl_setopt($ch, CURLOPT_URL, 'https://api.dnsradar.dev/monitors?is_active=false');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');

$headers = [
    'X-API-Key: YOUR_API_KEY',
];

curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);

$response = curl_exec($ch);
curl_close($ch);

import java.net.http.*;
import java.net.URI;

HttpClient client = HttpClient.newHttpClient();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.dnsradar.dev/monitors?is_active=false"))
    .header("X-API-Key", "YOUR_API_KEY")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();

HttpResponse<String> response = client.send(request,
    HttpResponse.BodyHandlers.ofString());

using System.Net.Http;
using System.Text;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "YOUR_API_KEY");

var response = await client.GetAsync("https://api.dnsradar.dev/monitors?is_active=false");

Tip: Use the is_active filter when listing monitors to quickly identify which monitors are currently running or paused.