ForHosting KIT · Web Scraping & Monitoring

Check DNS propagation

A DNS record you just changed does not appear everywhere at once — every resolver on the planet caches it on its own schedule. This DNS propagation checker API queries a spread of resolvers in parallel and hands back exactly what each one currently resolves, so you stop guessing and start reading real answers.

● StablePer request + per domain$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Why one lookup from your laptop lies to you

Your local machine talks to one resolver, usually your ISP's or a public one you configured once and forgot about. That single answer tells you nothing about the visitor in another region hitting a resolver with a stale cache. Support teams get 'it's not working' tickets that are really just an uncleared cache on one specific resolver, and without a wider view there is no way to tell the difference between a real misconfiguration and normal, temporary propagation lag.

What the endpoint actually returns

Send a domain and record type to POST /web/dns-propagation and the task fans out to a spread of resolvers, collecting the returned value, TTL and response time from each one independently. The result groups answers so you can see at a glance which resolvers already agree and which are still holding an older value, without you having to diff a dozen raw responses by hand.

A quirk of DNS worth knowing

DNS was designed in the 1980s around caching for efficiency, not instant consistency — a low TTL trades cache efficiency for faster updates, while a high TTL trades speed for fewer lookups. That tradeoff is exactly why propagation checks exist at all: the protocol was never meant to update everywhere the moment you press save, and understanding that saves a lot of unnecessary panic during a migration.

Where it fits your workflow

Teams call this endpoint right after changing nameservers, migrating a mail provider, or repointing an A record for a launch, then again a few hours later to confirm convergence. Because the task is async, you can trigger it from a deploy pipeline or a cron job and let the signed webhook tell you when the picture is clear, instead of someone refreshing a public checker in a browser tab.

Reading the result without overreacting

A handful of resolvers lagging behind the rest right after a change is expected and not a bug in your configuration; a majority disagreeing hours later, or an authoritative-looking answer that never matches, is the real signal to dig into your zone file or registrar settings.

What you can do with it

Nameserver migrations

Confirm that a domain moved to new nameservers is actually resolving through them worldwide before you decommission the old provider.

Mail routing cutovers

Check MX records across resolvers before a mail migration go-live so inbound mail does not silently bounce for part of your users.

Launch-day A record changes

Verify a repointed A record is visible broadly ahead of a marketing push, instead of hoping the cache clears on its own.

Support ticket triage

Attach a propagation snapshot to a 'site is down for me' ticket to quickly tell a real outage apart from one stale local resolver.

FAQ

What does a DNS propagation checker API actually check?

It queries a spread of DNS resolvers for the same record and reports the value, TTL and response time each one currently returns, so you can see where a change has taken effect and where it has not.

How long does DNS propagation really take?

It depends on the TTL set on the previous record plus each resolver's own caching behavior; low TTLs can clear in minutes, high TTLs can take up to 48 hours in edge cases.

Is there a free tier?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

What record types are supported?

Standard record types including A, AAAA, MX, TXT, NS and CNAME can be checked; specify the type in the request.

How do I get the results?

Via a signed webhook when the task completes, which we recommend, or through a signed link valid for 24 hours if you prefer to poll.

Am I charged if a lookup fails?

No. Failed tasks are retried automatically up to three times and are never charged; you only pay for requests that complete.

What does it cost?

$0.002 per request, billed only on completed tasks, with no hidden per-resolver surcharge.

Can I use this instead of manually checking DNS from different countries?

Yes, that is exactly the point: one async call replaces manually switching resolvers or asking contacts in other regions to check for you.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/web/dns-propagation

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/web/dns-propagation \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"domain":"ejemplo.com"}'

const res = await fetch("https://api.kit.forhosting.com/web/dns-propagation", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "domain": "ejemplo.com"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/web/dns-propagation",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "domain": "ejemplo.com"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/dns-propagation", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"domain":"ejemplo.com"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"domain":"ejemplo.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/dns-propagation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "domain": "ejemplo.com"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "web.dns_propagation",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`timeout_sec`	30
`max_crawl_pages`	25

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.

Read the full KIT documentation →