Dampak Resolusi DNS pada Performa API CAPTCHA

Call pertama ke ocr.captchaai.com di pagi hari terasa lambat, lalu beberapa saat kemudian normal lagi tanpa Anda mengubah apa pun — kemungkinan besar itu bukan API-nya yang lambat, tapi resolusi DNS yang belum ter-cache. Setiap kali koneksi baru dibuka ke ocr.captchaai.com, sistem operasi atau resolver Anda harus menerjemahkan hostname itu ke alamat IP lebih dulu, dan proses ini bisa menambah 5–200 ms tergantung provider DNS, status cache, dan kondisi jaringan. Untuk satu solve CAPTCHA yang melibatkan beberapa request polling, angka itu bisa terasa signifikan — atau nyaris tidak terasa sama sekali, tergantung cara koneksi Anda dikonfigurasi. Panduan ini membedah kapan DNS benar-benar jadi bottleneck dan kapan Anda aman mengabaikannya.

Kapan Resolusi DNS Benar-Benar Jadi Masalah

DNS baru layak dioptimalkan kalau setup Anda punya salah satu pola berikut:

• Koneksi baru dibuat di setiap request — tidak memakai Session di Python atau persistent agent di Node.js, sehingga setiap call mengulang proses resolve dari nol.
• Cold start di container atau serverless — instance baru (AWS Lambda, Google Cloud Functions) mulai tanpa cache DNS sama sekali.
• Resolver DNS bawaan ISP yang lambat — banyak ISP tidak menjalankan cache lokal yang optimal, terutama di jaringan mobile.
• Banyak worker paralel start bersamaan — semua worker melakukan lookup DNS di detik yang sama, menambah tekanan singkat ke resolver.

Tim otomatisasi yang menjalankan worker dari region seperti AWS ap-southeast-1 (Singapura) atau GCP asia-southeast2 (Jakarta) umumnya sudah punya rute jaringan yang relatif pendek ke resolver publik populer — tapi cold start tetap membuang cache instance itu, jadi keempat pola di atas tetap berlaku meski secara geografis Anda dekat dengan resolver-nya.

Seberapa Besar Dampak DNS terhadap Solve CAPTCHA

Satu solve CAPTCHA biasanya melibatkan 5–7 HTTP request: 1 untuk submit task, 4–6 untuk polling hasil. Tanpa cache DNS, setiap request berpotensi menambah lookup baru:

Yang perlu diingat: kalau Anda sudah memakai HTTP keep-alive (koneksi persisten), DNS bukan masalah Anda — koneksi TCP yang sama memakai IP yang sudah di-resolve sebelumnya. DNS baru jadi relevan ketika koneksi dibuat ulang di setiap request, bukan ketika koneksi dipertahankan.

Optimasi DNS di Python

Cek Dulu Perilaku DNS Anda Saat Ini

Sebelum mengubah apa pun, ukur dulu selisih waktu antara resolve pertama dan resolve kedua di environment Anda:

import socket
import time

# Measure DNS resolution time
hostname = "ocr.captchaai.com"

start = time.time()
ip = socket.getaddrinfo(hostname, 443)
first_resolve = time.time() - start

start = time.time()
ip = socket.getaddrinfo(hostname, 443)
second_resolve = time.time() - start

print(f"First resolve: {first_resolve*1000:.1f}ms")
print(f"Second resolve: {second_resolve*1000:.1f}ms (OS cached)")

Kalau resolve kedua jauh lebih cepat dari yang pertama, cache OS Anda sudah bekerja normal — tinggal pastikan koneksi Anda benar-benar reuse cache itu lewat keep-alive, bukan membuat koneksi baru tiap kali.

Pre-Resolve dan Simpan di Cache

Untuk workload volume tinggi, resolve hostname sekali di awal proses, lalu andalkan Session dengan keep-alive supaya lookup berikutnya tidak diulang:

import os
import socket
import requests
from urllib3.util.connection import create_connection

API_KEY = os.environ.get("CAPTCHAAI_KEY", "YOUR_API_KEY")

# Pre-resolve the API hostname
CAPTCHAAI_IP = socket.getaddrinfo("ocr.captchaai.com", 443)[0][4][0]
print(f"Resolved ocr.captchaai.com to {CAPTCHAAI_IP}")

# Patch connection to use cached IP
DNS_CACHE = {"ocr.captchaai.com": CAPTCHAAI_IP}

class CachedHTTPAdapter(requests.adapters.HTTPAdapter):
    def send(self, request, **kwargs):
        return super().send(request, **kwargs)

# Use with Session for fastest resolution
session = requests.Session()
session.headers.update({"Connection": "keep-alive"})

# The session already maintains keep-alive, so DNS is resolved once
# For the first request, the OS cache handles subsequent lookups
resp = session.get("https://ocr.captchaai.com/res.php", params={
    "key": API_KEY, "action": "getbalance", "json": "1",
})
print(f"Balance: {resp.json()}")

Session di atas sudah mempertahankan koneksi lewat keep-alive, jadi DNS hanya di-resolve sekali di awal — semua request setelahnya tinggal memakai koneksi yang sudah ada.

Pakai DNS Resolver yang Lebih Cepat

Kalau Anda mengendalikan konfigurasi DNS di level sistem atau aplikasi, arahkan ke resolver publik yang cepat:

# For systems where you control DNS configuration:
# /etc/resolv.conf (Linux) or system DNS settings
# Recommended: Cloudflare (1.1.1.1) or Google (8.8.8.8)

# In Python, you can also use dnspython for explicit resolution
import dns.resolver

resolver = dns.resolver.Resolver()
resolver.nameservers = ["1.1.1.1", "8.8.8.8"]

answers = resolver.resolve("ocr.captchaai.com", "A")
for answer in answers:
    print(f"Resolved: {answer}")

Optimasi DNS di JavaScript/Node.js

Ukur Waktu Resolusi DNS

Pola yang sama berlaku di Node.js — bandingkan waktu resolve pertama dan kedua sebelum memutuskan perlu optimasi lebih lanjut atau tidak:

const dns = require('dns');
const { performance } = require('perf_hooks');

const hostname = 'ocr.captchaai.com';

// First resolution
const start1 = performance.now();
dns.lookup(hostname, (err, address) => {
  const time1 = performance.now() - start1;
  console.log(`First resolve: ${time1.toFixed(1)}ms → ${address}`);

  // Second resolution (OS cached)
  const start2 = performance.now();
  dns.lookup(hostname, (err2, address2) => {
    const time2 = performance.now() - start2;
    console.log(`Second resolve: ${time2.toFixed(1)}ms → ${address2}`);
  });
});

Pre-Resolve dengan Cache DNS

Kombinasikan pre-resolve di awal proses dengan https.Agent yang keep-alive, supaya DNS hanya di-resolve sekali per lifetime proses:

const dns = require('dns');
const https = require('https');
const axios = require('axios');

const API_KEY = process.env.CAPTCHAAI_KEY || 'YOUR_API_KEY';

// Pre-resolve and cache
let cachedIP = null;

async function preResolve() {
  return new Promise((resolve, reject) => {
    dns.lookup('ocr.captchaai.com', (err, address) => {
      if (err) reject(err);
      cachedIP = address;
      console.log(`Cached IP: ${cachedIP}`);
      resolve(address);
    });
  });
}

// Use keep-alive agent (DNS resolved once per connection)
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 20,
  keepAliveMsecs: 60000,
});

const api = axios.create({
  baseURL: 'https://ocr.captchaai.com',
  httpsAgent: agent,
  timeout: 30000,
});

(async () => {
  await preResolve();
  const resp = await api.get('/res.php', {
    params: { key: API_KEY, action: 'getbalance', json: '1' },
  });
  console.log(`Balance: ${resp.data}`);
})();

DNS di Lingkungan Serverless dan Container

Di AWS Lambda, Google Cloud Functions, dan container Docker, cache DNS berperilaku berbeda dari server yang selalu menyala:

Untuk tim yang deploy dari Indonesia ke region seperti ap-southeast-1 atau asia-southeast2, cold start terasa lebih berat kalau jaringan sumbernya juga lebih lambat menjangkau resolver — misalnya saat testing dari koneksi mobile-first di lapangan. Di kondisi seperti itu, pre-resolve di kode inisialisasi tetap jadi perbaikan dengan dampak terbesar, lebih besar dari sekadar mengganti provider DNS.

Troubleshooting Masalah DNS

Pertanyaan Umum

Bagaimana cara memastikan yang lambat itu DNS, bukan API CaptchaAI itu sendiri?

Jalankan pengukuran seperti pada contoh kode di atas: bandingkan waktu resolve pertama dan kedua. Kalau resolve kedua jauh lebih cepat, DNS memang berkontribusi pada latensi call pertama. Kalau semua call tetap lambat meski resolve sudah ter-cache, penyebabnya ada di tempat lain — cek koneksi jaringan atau pola request Anda.

Apakah cold start di AWS Lambda atau Cloud Functions selalu bikin DNS lambat?

Tidak selalu, tapi instance baru memang mulai tanpa cache DNS apa pun. Dampaknya paling terasa pada request pertama setelah cold start; setelah itu, cache instance mengambil alih sampai instance tersebut didaur ulang.

DNS resolver mana yang paling cocok untuk call API dari Indonesia?

Cloudflare (1.1.1.1) dan Google (8.8.8.8) sama-sama jadi pilihan aman — keduanya resolve dalam <10 ms dari sebagian besar region, termasuk Singapura dan Jakarta. Pilih salah satu, pakai konsisten, dan hindari bolak-balik ganti resolver di tengah workload produksi.

Apakah IP ocr.captchaai.com berubah-ubah, dan apakah itu masalah?

Ya, DNS bisa mengembalikan IP berbeda di setiap lookup baru — ini load balancing normal, bukan tanda ada yang salah. Selama koneksi Anda memakai keep-alive, koneksi itu tetap melekat ke satu IP hasil resolve sampai koneksinya ditutup.

Berapa banyak worker paralel yang aman dijalankan sebelum DNS jadi bottleneck?

Ini lebih ditentukan oleh alokasi thread pada plan Anda daripada DNS itu sendiri. Dengan keep-alive aktif, DNS hanya jadi beban singkat di detik-detik awal saat semua worker start bersamaan — misalnya kalau Anda menjalankan worker sebanyak thread pada plan ADVANCE (50 thread), pre-resolve di awal proses menghindari lonjakan lookup serentak itu.

Langkah Selanjutnya

Hilangkan latensi DNS yang tersembunyi di pipeline Anda — dapatkan API key CaptchaAI di sini.

Panduan terkait:

• Keep-alive dan HTTP/2 untuk API CaptchaAI
• Data benchmark waktu solve CaptchaAI
• Panduan lengkap optimasi latensi API