Check domain expiry
Enter a domain and get its registration expiry date, the days remaining and its basic status, read from the registration record, so a lapsed renewal never takes your site down. You pay per check, with no subscription.
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.
Domains rarely die from disaster; they die from a payment card that expired the same month, an email that went to spam, or nobody owning the renewal.
The most avoidable outage there is
Losing a production domain to a lapsed renewal is one of the few outages that is entirely self-inflicted, and yet it happens constantly — to individuals, to agencies managing client portfolios, to companies where the domain was registered years ago by someone who has since left. The registrar sends renewal reminders, sure, but to whatever inbox was on file at signup, which is exactly the kind of detail that goes stale.
Where it belongs in an automated workflow
Run it weekly across your full domain portfolio and only fire an alert when days-remaining drops below a threshold you choose — 60 days, 30 days, whatever gives your team enough runway to act. Agencies use it to keep a single source of truth across every client domain instead of trusting each registrar's own dashboard; individual site owners use it as a lightweight tripwire on the two or three domains that actually matter to them.
What you can do with it
Agency-wide expiry dashboard
A web agency checks every client domain weekly and builds a single dashboard instead of logging into a dozen different registrar accounts.
Early-warning alerting
A company sets a 45-day threshold so finance gets a heads-up with enough time to process a renewal payment before anything lapses.
Domain portfolio audit
An investor acquiring a bundle of domains checks expiry dates in bulk before closing, to know exactly what needs immediate renewal.
Abandoned-project cleanup
A team auditing old side projects checks which forgotten domains are about to expire, deciding case by case whether to renew or let them go.
FAQ
Does it work for any domain extension?
It covers standard generic and widely used country-code extensions with public registration data; extremely restricted or privacy-locked registries may return limited fields.
Is this free to use?
There's no free tier — free tiers get abused and slow everyone down. No subscription, no tokens, no invented credits, and a failed task is never charged.
How is this different from WHOIS?
It's built specifically to surface the expiration date and days remaining as first-class fields, so you don't have to parse a raw WHOIS or RDAP response yourself.
Am I charged if the domain is already expired?
Yes, that's a valid, informative result and is billed normally. You're only not charged when the task itself fails to execute on our end, which is retried automatically up to three times.
How often should I check my domains?
Weekly works well for a whole portfolio. Raise an alert only when the days remaining fall below a threshold you choose, such as 60, 45 or 30 days, so your team has time to process the renewal payment.
Related tools
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
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/web/domain-expiry \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"domain":"example.com"}'const res = await fetch("https://api.kit.forhosting.com/web/domain-expiry", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"domain": "example.com"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/domain-expiry",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"domain": "example.com"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/domain-expiry", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"domain":"example.com"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"domain":"example.com"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/domain-expiry", 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": "example.com"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.domain_expiry",
"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
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. |
Technical notes
This endpoint pulls the registration expiry date straight from the authoritative record, so 'we'll renew it eventually' becomes a date you can actually track.
How the check works
POST /web/domain-expiry with a domain name and the task queries the domain's registration data to extract the expiration date and compute days remaining, along with basic registration status. The task runs asynchronously and returns its result via signed webhook or a 24-hour signed link, so it fits naturally into automated monitoring rather than a manual lookup you have to remember to run.
A problem as old as the registry system itself
Domain expiration policies date back to the earliest days of commercial domain registration, when registrars first introduced grace periods and redemption windows precisely because so many registrants missed renewals. Decades later the underlying human behavior hasn't changed much — busy people forget dates — but the tooling to track it automatically has gotten much better, and that's the gap this endpoint closes.
Cost that scales with how paranoid you want to be
Only tasks that actually run are billed — if the check fails to execute on our end it's retried up to three times automatically at no charge, so you're never paying for silence. At $0.002 per request, checking a domain daily costs a fraction of a cent a month, so there's no real reason to under-check.
Technical questions
What does the domain expiration API actually return?
The domain's expiration date, the number of days remaining, and basic registration status pulled from the authoritative registration data.
How do I get notified before a domain expires?
Schedule the check on a recurring basis and compare the returned days-remaining against your own threshold, then route the webhook result into your alerting tool of choice.
Can I check many domains in bulk?
You call the endpoint once per domain, but scripting it across a full list on a schedule is exactly the intended pattern, and at $0.002 per check it stays affordable at scale.
Is the result delivered instantly?
The check runs asynchronously and is typically fast; you get the result via signed webhook or a signed link valid for 24 hours.