View Webhook Request History

The webhook requests API provides visibility into every delivery attempt, helping you debug issues, monitor performance, and verify webhook behavior.

List Webhook Requests

Get request history for a webhook:

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

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

const data = await response.json();

import requests

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

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests')
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/webhooks/wh_abc123/requests", 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/webhooks/wh_abc123/requests');
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/webhooks/wh_abc123/requests"))
    .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/webhooks/wh_abc123/requests");

Response

{
  "limit": 20,
  "after": "req_xyz789",
  "before": null,
  "has_more": true,
  "data": [
    {
      "uuid": "req_def456",
      "webhook_uuid": "wh_abc123",
      "event_uuid": "evt_ghi789",
      "created": "2026-01-08T14:25:30Z",
      "status_code": 200,
      "response_body": "OK",
      "error_message": null
    },
    {
      "uuid": "req_jkl012",
      "webhook_uuid": "wh_abc123",
      "event_uuid": "evt_mno345",
      "created": "2026-01-08T13:10:15Z",
      "status_code": 500,
      "response_body": "Internal Server Error",
      "error_message": "Connection timeout"
    }
  ]
}

Pagination

Webhook requests use cursor-based pagination:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?after=req_xyz789&limit=50 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?after=req_xyz789&limit=50', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?after=req_xyz789&limit=50',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?after=req_xyz789&limit=50')
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/webhooks/wh_abc123/requests?after=req_xyz789&limit=50", 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/webhooks/wh_abc123/requests?after=req_xyz789&limit=50');
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/webhooks/wh_abc123/requests?after=req_xyz789&limit=50"))
    .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/webhooks/wh_abc123/requests?after=req_xyz789&limit=50");

Query Parameters

Parameter	Type	Description
`limit`	integer	Results per page (1-100, default: 20)
`after`	string	Cursor for next page
`before`	string	Cursor for previous page
`order_by`	string	Sort field (e.g., `created`)
`order_way`	string	Sort direction (`asc` or `desc`)
`created_after`	integer	UTC timestamp - requests created after this time
`created_before`	integer	UTC timestamp - requests created before this time
`delivered_after`	integer	UTC timestamp - requests delivered after this time
`delivered_before`	integer	UTC timestamp - requests delivered before this time
`last_attempt_after`	integer	UTC timestamp - last delivery attempt after this time
`last_attempt_before`	integer	UTC timestamp - last delivery attempt before this time
`status_code`	integer	Filter by HTTP status code (e.g., `200`, `500`)

Filtering Requests

Filter by Creation Time

Get requests based on when they were created, using UTC timestamps (seconds since epoch).

Requests created after a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661')
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/webhooks/wh_abc123/requests?created_after=1767793661", 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/webhooks/wh_abc123/requests?created_after=1767793661');
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/webhooks/wh_abc123/requests?created_after=1767793661"))
    .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/webhooks/wh_abc123/requests?created_after=1767793661");

Requests created before a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_before=1767880061')
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/webhooks/wh_abc123/requests?created_before=1767880061", 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/webhooks/wh_abc123/requests?created_before=1767880061');
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/webhooks/wh_abc123/requests?created_before=1767880061"))
    .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/webhooks/wh_abc123/requests?created_before=1767880061");

Requests created within a time range:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061')
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/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061", 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/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061');
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/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061"))
    .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/webhooks/wh_abc123/requests?created_after=1767793661&created_before=1767880061");

Filter by Delivery Time

Get requests based on when they were successfully delivered.

Requests delivered after a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661')
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/webhooks/wh_abc123/requests?delivered_after=1767793661", 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/webhooks/wh_abc123/requests?delivered_after=1767793661');
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/webhooks/wh_abc123/requests?delivered_after=1767793661"))
    .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/webhooks/wh_abc123/requests?delivered_after=1767793661");

Requests delivered before a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_before=1767880061')
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/webhooks/wh_abc123/requests?delivered_before=1767880061", 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/webhooks/wh_abc123/requests?delivered_before=1767880061');
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/webhooks/wh_abc123/requests?delivered_before=1767880061"))
    .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/webhooks/wh_abc123/requests?delivered_before=1767880061");

Requests delivered within a time range:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061')
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/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061", 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/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061');
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/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061"))
    .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/webhooks/wh_abc123/requests?delivered_after=1767793661&delivered_before=1767880061");

Filter by Last Attempt Time

Get requests based on when the last delivery attempt was made.

Requests with last attempt after a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661')
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/webhooks/wh_abc123/requests?last_attempt_after=1767793661", 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/webhooks/wh_abc123/requests?last_attempt_after=1767793661');
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/webhooks/wh_abc123/requests?last_attempt_after=1767793661"))
    .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/webhooks/wh_abc123/requests?last_attempt_after=1767793661");

Requests with last attempt before a specific time:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_before=1767880061')
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/webhooks/wh_abc123/requests?last_attempt_before=1767880061", 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/webhooks/wh_abc123/requests?last_attempt_before=1767880061');
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/webhooks/wh_abc123/requests?last_attempt_before=1767880061"))
    .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/webhooks/wh_abc123/requests?last_attempt_before=1767880061");

Requests with last attempt within a time range:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061')
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/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061", 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/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061');
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/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061"))
    .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/webhooks/wh_abc123/requests?last_attempt_after=1767793661&last_attempt_before=1767880061");

UTC Timestamps: All timestamp parameters use UTC time in seconds since epoch.

Filter by Status Code

Get requests by HTTP response status code.

Successful requests only (200-299):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200')
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/webhooks/wh_abc123/requests?status_code=200", 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/webhooks/wh_abc123/requests?status_code=200');
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/webhooks/wh_abc123/requests?status_code=200"))
    .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/webhooks/wh_abc123/requests?status_code=200");

Server errors (500-599):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500')
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/webhooks/wh_abc123/requests?status_code=500", 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/webhooks/wh_abc123/requests?status_code=500');
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/webhooks/wh_abc123/requests?status_code=500"))
    .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/webhooks/wh_abc123/requests?status_code=500");

Unauthorized requests (401):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401')
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/webhooks/wh_abc123/requests?status_code=401", 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/webhooks/wh_abc123/requests?status_code=401');
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/webhooks/wh_abc123/requests?status_code=401"))
    .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/webhooks/wh_abc123/requests?status_code=401");

Not found errors (404):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=404 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=404',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=404')
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/webhooks/wh_abc123/requests?status_code=404", 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/webhooks/wh_abc123/requests?status_code=404');
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/webhooks/wh_abc123/requests?status_code=404"))
    .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/webhooks/wh_abc123/requests?status_code=404");

Rate limit errors (429):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=429 \
  -H "X-API-Key: YOUR_API_KEY"

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

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=429',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=429')
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/webhooks/wh_abc123/requests?status_code=429", 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/webhooks/wh_abc123/requests?status_code=429');
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/webhooks/wh_abc123/requests?status_code=429"))
    .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/webhooks/wh_abc123/requests?status_code=429");

Sorting Options

Sort by creation timestamp.

Sort by creation time (descending, newest first):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc')
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/webhooks/wh_abc123/requests?order_by=created&order_way=desc", 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/webhooks/wh_abc123/requests?order_by=created&order_way=desc');
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/webhooks/wh_abc123/requests?order_by=created&order_way=desc"))
    .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/webhooks/wh_abc123/requests?order_by=created&order_way=desc");

Sort by creation time (ascending, oldest first):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=asc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=asc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=asc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=asc')
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/webhooks/wh_abc123/requests?order_by=created&order_way=asc", 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/webhooks/wh_abc123/requests?order_by=created&order_way=asc');
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/webhooks/wh_abc123/requests?order_by=created&order_way=asc"))
    .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/webhooks/wh_abc123/requests?order_by=created&order_way=asc");

Combining Filters

Combine multiple filters to create powerful queries.

Recent failures (last 24 hours):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50')
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/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50", 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/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50');
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/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50"))
    .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/webhooks/wh_abc123/requests?status_code=500&created_after=1767793661&order_by=created&order_way=desc&limit=50");

Successful requests in a time range:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc')
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/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc", 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/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc');
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/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc"))
    .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/webhooks/wh_abc123/requests?status_code=200&created_after=1767793661&created_before=1767880061&order_by=created&order_way=asc");

Latest 100 requests, sorted newest first:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100')
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/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100", 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/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100');
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/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100"))
    .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/webhooks/wh_abc123/requests?order_by=created&order_way=desc&limit=100");

Recent authorization failures:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20')
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/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20", 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/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20');
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/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20"))
    .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/webhooks/wh_abc123/requests?status_code=401&created_after=1767793661&limit=20");

Successfully delivered requests in last hour:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc')
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/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc", 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/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc');
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/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc"))
    .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/webhooks/wh_abc123/requests?status_code=200&delivered_after=1767880061&order_by=created&order_way=desc");

Failed delivery attempts in specific period:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc')
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/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc", 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/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc');
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/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc"))
    .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/webhooks/wh_abc123/requests?status_code=500&last_attempt_after=1767793661&last_attempt_before=1767880061&order_by=created&order_way=desc");

Recent retry attempts (last attempt in last 30 minutes):

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50 \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50')
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/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50", 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/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50');
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/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50"))
    .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/webhooks/wh_abc123/requests?last_attempt_after=1767878261&order_by=created&order_way=desc&limit=50");

Requests created but not delivered yet:

curl -X GET https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc \
  -H "X-API-Key: YOUR_API_KEY"

const response = await fetch('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc', {
  method: 'GET',
  headers: {
    "X-API-Key": "YOUR_API_KEY"
  }
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc',
    headers={
        'X-API-Key': 'YOUR_API_KEY',
    }
)

require 'net/http'
require 'json'

uri = URI('https://api.dnsradar.dev/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc')
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/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc", 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/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc');
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/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc"))
    .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/webhooks/wh_abc123/requests?created_after=1767793661&delivered_before=1767793661&order_by=created&order_way=desc");

Request Fields

Field	Description
uuid	Unique request identifier (req_)
webhook_uuid	Associated webhook ID
event_uuid	Associated event ID
created	ISO 8601 timestamp
status_code	HTTP status code from endpoint
response_body	Response body (truncated to 4000 chars)
error_message	Error description (if failed)

Identifying Issues

Common Error Messages

Error	Cause	Solution
Connection timeout	Endpoint slow/unresponsive	Optimize response time
DNS resolution failed	Invalid hostname	Verify webhook URL
SSL certificate error	Invalid/expired cert	Update SSL certificate
Connection refused	Endpoint not listening	Start endpoint server