Rate Limiting - DNSRadar API Documentation

Overview

The DNSRadar API implements rate limiting to ensure fair usage and maintain service quality for all users. Rate limits are applied per API key and reset at fixed intervals.

All rate limits use a sliding window algorithm, meaning limits reset continuously rather than at fixed intervals.

Rate Limit Tiers

Standard Endpoints

Most API endpoints follow these rate limits:

Read Operations

20 requests per minuteApplies to all GET requests

Write Operations

5 requests per minuteApplies to POST, PUT, PATCH, and DELETE requests

Bulk Import Endpoints

The following endpoints have higher limits to support bulk operations:

Monitor Creation

250 requests per minuteApplies to:

POST /monitors
POST /monitors/bulk

The POST /monitors/bulk endpoint accepts up to 1,000 monitors per request, allowing you to theoretically import 250,000 monitors per minute when used efficiently.

Rate Limit Headers

Every API response includes headers that provide information about your current rate limit status:

integer

The maximum number of requests you can make per minute for this endpointExample: 20

integer

The number of requests remaining in the current rate limit windowExample: 15

integer

Unix timestamp (in seconds) indicating when the rate limit window resetsExample: 1704636000

Example Response Headers

HTTP/1.1 200 OK
X-RateLimit-Limit: 20
X-RateLimit-Remaining: 15
X-RateLimit-Reset: 1704636000
Content-Type: application/json

Handling Rate Limits

Rate Limit Exceeded Response

When you exceed the rate limit, you’ll receive a 429 Too Many Requests response:

{
  "code": 429,
  "error": "Rate limit exceeded. Please try again in 45 seconds."
}

Best Practices

Monitor Rate Limit Headers

Always check the X-RateLimit-Remaining header and proactively slow down requests before hitting the limit.

const remaining = parseInt(response.headers.get('X-RateLimit-Remaining'));

if (remaining < 3) {
  console.warn('Approaching rate limit. Slowing down requests...');
  await sleep(5000); // Wait 5 seconds
}

Implement Exponential Backoff

When you receive a 429 response, wait before retrying with increasing delays between attempts.

async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);

    if (response.status !== 429) {
      return response;
    }

    const resetTime = parseInt(response.headers.get('X-RateLimit-Reset'));
    const waitTime = (resetTime * 1000) - Date.now();

    console.log(`Rate limited. Waiting ${waitTime}ms before retry...`);
    await new Promise(resolve => setTimeout(resolve, waitTime));
  }

  throw new Error('Max retries exceeded');
}

Use Bulk Endpoints

When creating multiple monitors, use the POST /monitors/bulk endpoint instead of making individual requests.Instead of this:

// 1000 requests = exceeds rate limit
for (const monitor of monitors) {
  await createMonitor(monitor);
}

Do this:

// 1 request = efficient
await createMonitorsBulk(monitors); // up to 1000 at once

Cache GET Requests

Cache responses from GET requests when appropriate to reduce unnecessary API calls.

const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getCachedMonitors() {
  const cached = cache.get('monitors');

  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const data = await fetchMonitors();
  cache.set('monitors', { data, timestamp: Date.now() });
  return data;
}

Distribute Requests Over Time

Instead of sending bursts of requests, distribute them evenly across the rate limit window.

// Spread 20 requests over 60 seconds (1 per 3 seconds)
const delayBetweenRequests = 60000 / 20; // 3000ms

for (const item of items) {
  await processItem(item);
  await sleep(delayBetweenRequests);
}

Rate Limit Examples

Checking Rate Limit Status

const response = await fetch('https://api.dnsradar.dev/monitors', {
  headers: { 'X-Api-Key': apiKey }
});

const limit = response.headers.get('X-RateLimit-Limit');
const remaining = response.headers.get('X-RateLimit-Remaining');
const reset = response.headers.get('X-RateLimit-Reset');

console.log(`Rate Limit: ${remaining}/${limit} requests remaining`);
console.log(`Resets at: ${new Date(reset * 1000).toISOString()}`);

import requests
from datetime import datetime

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

limit = response.headers.get('X-RateLimit-Limit')
remaining = response.headers.get('X-RateLimit-Remaining')
reset = int(response.headers.get('X-RateLimit-Reset'))

print(f"Rate Limit: {remaining}/{limit} requests remaining")
print(f"Resets at: {datetime.fromtimestamp(reset).isoformat()}")

curl -i https://api.dnsradar.dev/monitors \
  -H "X-Api-Key: your_api_key"

# Look for these headers in the response:
# X-RateLimit-Limit: 20
# X-RateLimit-Remaining: 15
# X-RateLimit-Reset: 1704636000

Need higher rate limits? Contact our sales team to discuss enterprise plans with custom rate limits.

​Overview

​Rate Limit Tiers

​Standard Endpoints

Read Operations

Write Operations

​Bulk Import Endpoints

Monitor Creation

​Rate Limit Headers

​Example Response Headers

​Handling Rate Limits

​Rate Limit Exceeded Response

​Best Practices

​Rate Limit Examples

​Checking Rate Limit Status

Overview

Rate Limit Tiers

Standard Endpoints

Bulk Import Endpoints

Rate Limit Headers

Example Response Headers

Handling Rate Limits

Rate Limit Exceeded Response

Best Practices

Rate Limit Examples

Checking Rate Limit Status