Domain API Hız Limiti, Soft Quota ve Throttling Politikası

Bu sayfadaki her şey iki sayıya bakıyor: 5 ve 200. API anahtarı başına saniyede beş istek ve alan başına iki yüz puanlık kota eşiği. Bu ikisini bilirseniz politikayı zaten biliyorsunuz — gerisi dört işlem ve birkaç kod parçası.

Domain Name API her API anahtarına birbirinden bağımsız iki denetim uyguluyor. Birincisi katı bir hız limiti: aşarsanız HTTP 429 alırsınız. İkincisi soft quota ve birinciye hiç benzemiyor — hiçbir isteği reddetmiyor, yavaşlatıyor. Bu makalenin asıl konusu tam olarak bu fark, çünkü ikisini birbirine karıştıran bir entegrasyon var olmayan bir hatanın peşinde bir öğleden sonra harcıyor.

İçindekiler

• Bir bakışta kurallar
• İki katman: hız limiti ve soft quota
• Hangi istek kaç puan?
• Gerçek bütçeniz, sayılarla
• Kota dolduğunda ne oluyor?
• HTTP 429 hatası nasıl çözülür?
• Kod örnekleri: C#, PHP, Python, Node.js
• İstek akış diyagramı
• Gerçekten işe yarayan uygulamalar
• Sık yapılan entegrasyon hataları
• Sıkça sorulan sorular
• Bu limitler neden var?
• Daha yüksek limit nasıl talep edilir?

Bir Bakışta Kurallar

Politikanın söylediği her şey tek tabloda. Bu tabloyu entegrasyon ekibinize iletmeniz çoğu zaman yeterli oluyor.

İki Katman: Hız Limiti ve Soft Quota

Bu iki denetim farklı ölçülüyor, farklı tepki veriyor ve farklı çözülüyor. Bu konudaki neredeyse her destek talebi, ikisinin tek şey sanılmasıyla başlıyor.

Hangi İstek Kaç Puan?

Sorgular ucuz, çünkü salt okunur ve müşterileriniz neyi satın alacağına karar verirken sitenizde canlı olarak tetikledikleri çağrılar bunlar. Diğer her şey bir registry’ye, bir fatura kaydına ya da bir sertifika otoritesine ulaşıyor; asıl maliyeti onlar taşıyor.

Gerçek Bütçeniz, Sayılarla

İki limit birbiriyle etkileşiyor ve hangisine takılacağınız tamamen ne çağırdığınıza bağlı. Masanızın üstüne asmaya değer tablo bu.

Çalışılmış örnek: 500 domain sorgulamak

/domains/search ile tek tek sorgularsanız 500 çağrı ve 500 puan eder. Saniyede 2 sorguluk sınırla duvar saati en az 250 saniye; ilk 200 civarı sorgudan sonra puan kotası da gecikme eklemeye başlar. bulk-search ile 30’arlık gruplar hâlinde aynı iş 17 çağrı ve 170 puan — 200 puanlık eşiğin altında kaldığı için yaklaşık 9 saniyede tam hızda biter. Aynı cevap, çok daha hızlı ve 500 yerine 170 puan harcıyor.

Çalışılmış örnek: 100 domain kaydetmek

Yüz kayıt işlemi domain alanında 1.000 puan eder. Sıfırdan başlarken ilk 20 kadarı tam hızda geçer; sonrasında eşiğin üstünde kaldığınız sürece her yanıt bekletilir — yarım saniyeden başlayıp 5 saniyelik tavana kadar. Hiçbir istek reddedilmediği için iş yine tamamlanır; yalnızca saniyeler yerine dakikalar sürer ve paralellik bunu değiştirmez, çünkü aynı anahtarı kullanan her worker aynı puanlardan harcar. Buna göre planlayın: büyük grupları yoğun olmayan saatlerde çalıştırın, istemci zaman aşımını 5 saniyenin epey üstünde tutun ve daha sert yeniden denemek yerine X-Quota-Delay başlığını izleyin.

Kota Dolduğunda Ne Oluyor?

Dramatik hiçbir şey olmuyor; sorun da tam olarak bu — fren sessiz çalışıyor ve sessiz belirtiler insanın bir öğleden sonrasına mal olan belirtiler. Her yanıt nerede durduğunuzu söyler: X-Quota-Scope (alan), X-Quota-Cost (1 ya da 10), X-Quota-Used, X-Quota-Limit (200), X-Quota-Delay (uygulanan gecikme, saniye; 0 tam hız demektir) ve X-Quota-Reset (eşiğin altına dönmenize kalan saniye).

HTTP 429 Hatası Nasıl Çözülür?

Burada 429 her zaman tek bir anlama gelir: API anahtarınızın saniyelik sınırlarından biri aşılmıştır — aynı saniyede beşten fazla istek ya da ikiden fazla domain sorgusu. Puan kotasıyla ilgisi yoktur, kaç domain yönettiğinizle de ilgisi yoktur. Yanıtın gövdesi boştur, Retry-After başlığı taşır ve reddedilen istek puan harcamaz. Şu adımları sırayla uygulayın.

• Göndermeyi durdurun. Endpoint’i zorlamaya devam etmek sizi çizginin üstünde tutar ve bir 429’u 429 seline çevirir.
• Retry-After başlığındaki saniye kadar bekleyin (her zaman tam sayı, en az 1), sonra yeniden deneyin.
• Bir kez yeniden deneyin. Ani bir yığından sonra tek bir 429 normaldir ve tek deneme genelde yeterli olur.
• Tekrarlıyorsa yeniden denemek yerine hızı ayarlayın — istekleri yığın hâlinde değil, tek bir kuyruktan art arda gönderin.
• Sonra asıl sebebi bulun. On vakanın dokuzunda sebep, her biri kendi limiter’ını taşıyan paralel worker’lardır; “saniyede 5” diyen dört worker aslında yirmi gönderiyordur.

Kod Örnekleri

İşe yarayan kalıp her zaman aynı: tüm süreç için tek kapı, istekler arasında asgari bir aralık ve ısrar etmek yerine bekleyen bir yeniden deneme. Aşağıdaki örnekler saniyede iki istek hızında ilerliyor; bu hem saniyede 5’lik genel sınırın hem de saniyede 2’lik sorgu sınırının içinde kalır. Uzun 10 puanlık iş gruplarında yaklaşık 15 saniyelik aralık (dakikada 4) sizi puan eşiğinin süresiz altında tutar.

C# (.NET)

// Tum surec icin tek kapi. Her worker buradan geciyor.
private static readonly SemaphoreSlim Gate = new(1, 1);
private static DateTime _next = DateTime.UtcNow;

// 500 ms -> saniyede 2: 5/sn genel ve 2/sn sorgu sinirinin icinde.
private static readonly TimeSpan MinInterval = TimeSpan.FromMilliseconds(500);

async Task<HttpResponseMessage> SendAsync(Func<HttpRequestMessage> build)
{
    var backoff = TimeSpan.FromSeconds(1);

    for (var attempt = 1; attempt <= 6; attempt++)
    {
        await Gate.WaitAsync();
        try
        {
            var wait = _next - DateTime.UtcNow;
            if (wait > TimeSpan.Zero) await Task.Delay(wait);
            _next = DateTime.UtcNow + MinInterval;
        }
        finally { Gate.Release(); }

        // HttpRequestMessage tek kullanimliktir, her denemede yenisini uretin.
        var response = await _http.SendAsync(build());
        if ((int)response.StatusCode != 429) return response;

        var after = response.Headers.RetryAfter?.Delta ?? backoff;
        response.Dispose();
        await Task.Delay(after);
        backoff = TimeSpan.FromSeconds(Math.Min(backoff.TotalSeconds * 2, 30));
    }

    throw new HttpRequestException("Hiz limiti 6 denemede acilmadi.");
}

PHP (WHMCS, WordPress, cPanel)

<?php
// 500000 mikrosaniye = 0,5 sn -> saniyede 2 (5/sn ve 2/sn sorgu sinirinin icinde).
const DNA_MIN_INTERVAL_US = 500000;

function dna_request(string $method, string $path, ?array $body = null) {
    static $next = 0;

    $backoff = 1;
    for ($attempt = 1; $attempt <= 6; $attempt++) {
        $now = (int) (microtime(true) * 1000000);
        if ($now < $next) usleep($next - $now);
        $next = (int) (microtime(true) * 1000000) + DNA_MIN_INTERVAL_US;

        $ch = curl_init('https://api.domainresellerapi.com/api/v1' . $path);
        curl_setopt_array($ch, [
            CURLOPT_CUSTOMREQUEST  => $method,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT        => 30,   // 10'un altina asla inmeyin
            CURLOPT_HTTPHEADER     => [
                'Content-Type: application/json',
                '__reseller: ' . DNA_RESELLER_ID,
                'X-API-KEY: '  . DNA_API_KEY,
            ],
            CURLOPT_POSTFIELDS => $body === null ? null : json_encode($body),
        ]);

        $raw    = curl_exec($ch);
        $status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
        curl_close($ch);

        if ($status !== 429) return json_decode($raw, true);

        sleep($backoff);
        $backoff = min($backoff * 2, 30);
    }

    throw new RuntimeException('Hiz limiti 6 denemede acilmadi.');
}

Python (script ve otomasyon)

import threading, time, requests

BASE = "https://api.domainresellerapi.com/api/v1"
HEADERS = {"__reseller": RESELLER_ID, "X-API-KEY": API_KEY}

# 0,5 sn -> saniyede 2: 5/sn genel ve 2/sn sorgu sinirinin icinde.
MIN_INTERVAL = 0.5
_lock, _next = threading.Lock(), 0.0


def dna_request(method, path, **kwargs):
    global _next
    backoff = 1.0

    for _ in range(6):
        with _lock:                       # tek kapi, butun thread'ler
            wait = _next - time.monotonic()
            if wait > 0:
                time.sleep(wait)
            _next = time.monotonic() + MIN_INTERVAL

        # timeout, 5 sn'lik soft quota tavanini rahatca asmali
        r = requests.request(method, BASE + path, headers=HEADERS,
                             timeout=30, **kwargs)
        if r.status_code != 429:
            return r.json()

        time.sleep(float(r.headers.get("Retry-After", backoff)))
        backoff = min(backoff * 2, 30)

    raise RuntimeError("Hiz limiti 6 denemede acilmadi.")

Node.js (JavaScript / TypeScript)

const BASE = 'https://api.domainresellerapi.com/api/v1';
const MIN_INTERVAL = 500;          // saniyede 2: 5/sn ve 2/sn sorgu sinirinin icinde
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

// Node'da en basit tek kapi bir promise zinciridir: `tail`i beklemek
// kac cagiran paralel baslamis olursa olsun hepsini siraya sokar.
let tail = Promise.resolve();

function pace() {
  const turn = tail.then(() => sleep(MIN_INTERVAL));
  tail = turn;
  return turn;
}

export async function dnaRequest(method, path, body) {
  let backoff = 1000;

  for (let attempt = 1; attempt <= 6; attempt++) {
    await pace();

    const res = await fetch(BASE + path, {
      method,
      headers: {
        'Content-Type': 'application/json',
        __reseller: process.env.DNA_RESELLER_ID,
        'X-API-KEY': process.env.DNA_API_KEY,
      },
      body: body ? JSON.stringify(body) : undefined,
      signal: AbortSignal.timeout(30000),   // 10000'in altina asla inmeyin
    });

    if (res.status !== 429) return res.json();

    const after = Number(res.headers.get('Retry-After')) * 1000 || backoff;
    await sleep(after);
    backoff = Math.min(backoff * 2, 30000);
  }

  throw new Error('Hiz limiti 6 denemede acilmadi.');
}

İstek Akış Diyagramı

Her çağrı aynı yoldan geçiyor. İki kontrol noktası birbirinden bağımsız ve yalnızca biri sizi reddedebiliyor.

Gerçekten İşe Yarayan Uygulamalar

• Süreç başına tek limiter, worker başına değil. Her thread kendi limiter’ını taşıyorsa gerçek hızınız limit çarpı thread sayınızdır. 429’ların çoğunun tek sebebi bu.
• On ismin üstünde bulk-search’e geçin. Tek çağrı, 30 isme kadar, 10 puan, tek gidiş dönüş. Uzun listelerde tasarruf hızla katlanıyor.
• Agresif önbellekleyin ve göndermeden önce tekrarları ayıklayın. Dört saniye önce sorguladığınız isim değişmedi ve uzun girdi listeleri tekrarlarla dolu.
• İstemci zaman aşımını 10 saniye ya da üstünde tutun. 5 saniyelik tavanı rahatça aşması gerekiyor; yoksa fren size ağ hatası kılığında ulaşır.
• Zamanlanmış işlerinizi dağıtın. Filonuzdaki her cron dakikanın başında başlıyorsa ani yığını bilerek inşa etmişsiniz demektir. Birkaç saniyelik rastgele kaydırma bedava ve sorunu çözüyor.
• Kendi 429 oranınızı ve X-Quota-Delay başlığını izleyin. Elinizdeki en erken sinyaller bunlardır ve müşteri bir şey fark etmeden çok önce tırmanırlar.
• Kuyruklarınızı sayıya göre değil maliyete göre ayırın. Kayıt ve yenilemelere kendi yavaş şeridini verin, canlı müsaitlik sorguları tam hızda aksın. İkisini tek hızın arkasında karıştırmak, toplu işleriniz yüzünden sitenizi cezalandırır.

Sık Yapılan Entegrasyon Hataları

• Her biri kendi başına “saniyede 5” uygulayan paralel worker’lar çalıştırmak; aynı anahtardaki dört worker yirmi istek gönderir.
• On yedi bulk-search çağrısının aynı soruyu yanıtlayacağı yerde 500 isimlik listede /domains/search döngüsü kurmak.
• Soft quota gecikmesini ağ arızası sanıp zaman aşımını düşürmek; bu, yavaş bir başarıyı kesin bir hataya çevirir.
• 429 sonrası anında yeniden denemek; bu, bir 429 daha almayı garantiler.
• Aynı domain’i kısa bir pencere içinde defalarca yeniden sorgulamak.
• Birbiriyle ilgisiz pek çok işi tek bir API anahtarında toplayıp birbirlerini neden yavaşlattığını merak etmek — aynı anahtardaki her şey saniyelik sınırı, aynı alandaki her şey puanları paylaşır.
• async’in, thread’lerin ya da ayrı container’ların ayrı bütçe aldığını varsaymak. Almıyorlar; hepsi aynı API anahtarını gönderiyor.

Sıkça Sorulan Sorular

Bu Limitler Neden Var?

Sizi yavaşlatmak için değil — her şeyi otomatikleştirmeniz bizim için sorun değil, en büyük bayilerimizin çoğu da zaten öyle yapıyor. Kısıt daha yukarıda. API’mizin arkasında registry’ler var ve birkaçı bizden epey daha az hoşgörülü. Ani bir yığın bir registry’ye istediğinden hızlı ulaştığında kibarca yavaşlatmıyor; hata döndürmeye başlıyor. O hatalar da sizin müşterinizin kayıt denemesine düşüyor ve arıza registry’nin değil sizin görünüyor.

Soft quota, o basıncı size aktarmak yerine kendimiz soğurabilelim diye var. Yarım saniyelik ek gecikme, başarısız bir kayıttan çok daha iyi bir sonuç; çoğu API’nin tercih ettiği alternatiften, yani isteği doğrudan reddetmekten ise kat kat iyi. Toplu işinizin beş dakika sürmesini, iki dakika sürüp yolda on bir domain kaybetmesine tercih ederiz.

Ayrıca API’yi açık tutuyor. Freni olmayan ortak bir platform, sonunda otomasyona geçmek isteyen herkesin önüne onay kapıları ve manuel incelemeler koymak zorunda kalıyor. Fren, bizim “evet” demeyi sürdürebilmemizi sağlayan şey.

Daha Yüksek Limit Nasıl Talep Edilir?

İlgili Rehberler

• Global Fiyat Karşılaştırma Servisleri İçin Entegrasyon Rehberi
• API ile Domain Contact Doğrulama ve Mail Yeniden Gönderme
• WHMCS Kurulumu ve DomainNameAPI Entegrasyonu
• FOSSBilling Domain Entegrasyonu ve Kurulum Rehberi