How to set up domain auto-renewal so you never lose your domain?

To set up domain auto-renewal, log in to your registrar, open the domain's settings, and switch Auto-renew on, then make sure a valid payment method or enough account credit is on file so the charge succeeds. Most registrars try to take payment a few days to a few weeks before the expiry date, and email you if it fails. Auto-renew on its own isn't quite enough, though: expired cards, outdated contact emails and domains spread across several accounts are what actually cause lapses. Back it up with a secondary payment method, a contact email on a different domain, and a simple expiry check you run independently of the registrar.

This guide covers how auto-renewal works, how to turn it on at a typical registrar, how to make sure the payment actually goes through, how long to renew for, and how to monitor expiry dates yourself with a short script, so that a missed renewal never takes your website and email offline.

Why Auto-Renewal Matters

When a domain expires, the registrar suspends it and your website, email and any logins that depend on the domain stop working. You usually get a grace period to renew, followed by a more expensive redemption period, and then the domain is released for anyone to register. The full sequence is covered in what happens when a domain name expires and the domain redemption and grace periods.

Most lost domains aren't stolen. They lapse because:

• The card on file expired or was replaced.
• Renewal reminders went to an old employee, an agency, or an email address on the expired domain itself.
• The domain was in a forgotten account at a different registrar.
• Someone assumed auto-renew was on when it wasn't.

Auto-renewal removes the need to remember. The rest of this guide is about making sure it actually works.

How Auto-Renewal Works

Auto-renew is a registrar setting, not a registry one. When it's on, the registrar attempts to renew the domain for you, usually for one year, before it expires.

• Timing: Registrars choose when to charge. Some try 30 days or more before expiry, some a week before, and some on the day itself. Many retry several times if the first attempt fails.
• Payment source: Usually the default card or PayPal account on file, or prepaid account credit.
• Notifications: Most registrars email you before the charge, after a successful renewal, and after any failure.
• Price: You're charged the registrar's current renewal price at that time, which may be higher than what you originally paid.

Don't confuse this with the registry-level automatic renewal that happens to most gTLDs on the expiry date. That's an internal step between the registry and the registrar, and if your registrar isn't paid, it reverses it and deletes the domain.

Step 1: Turn On Auto-Renew

The wording differs between registrars, but the steps are the same:

1. Log in to the account where the domain is registered.
2. Open your domain list, usually under Domains, My Domains or Domain List.
3. Select the domain and open its settings or overview page.
4. Find the renewal setting, labelled Auto-renew, Automatic renewal or Renewal settings.
5. Switch it on and save. Some registrars ask you to confirm the payment method at this point.

If you have many domains, look for a bulk action in the domain list. Most registrars let you select all domains and enable auto-renew in one step.

Some registrars turn auto-renew on by default for new registrations, but don't assume it's on for domains you transferred in, bought years ago, or inherited from someone else. Transfers in particular don't always carry the setting over.

Step 2: Make Sure the Payment Will Succeed

A failed payment is the most common reason auto-renew doesn't save a domain.

Keep a Valid Card on File

• Check the expiry date of the card linked to your registrar account and update it before it expires.
• Update it after a card replacement: Banks reissue cards after fraud or loss, and the old number stops working immediately.
• Use a business card for business domains rather than an employee's personal card, which can disappear when the person leaves.

Add a Backup Payment Method

Many registrars let you add a second card or PayPal account to use if the first fails. If yours does, add one.

Use Account Credit for Critical Domains

Some registrars let you prepay funds into your account. Keeping enough credit to cover a year of renewals protects you against card problems entirely. Check whether your registrar uses credit before trying the card, as the order varies.

Watch for Price Changes

If the renewal price is higher than a limit you've set, or a premium domain has a high renewal fee, some payment methods may decline the charge. Know the renewal price of each domain in advance, especially for premium names.

Step 3: Keep Contact Emails Working

Reminders and failure notices are only useful if someone reads them.

• Account email: Make sure the registrar account's login and billing email is monitored.
• Registrant email: This is where ICANN-required expiry reminders are sent for gTLDs. Keep it up to date. See how to change the registrant contact details.
• Use an address on a different domain: If admin@example.com is the only contact for example.com, you won't receive any warning once the domain stops resolving.
• Use a shared mailbox for teams: An address such as domains@ on another company domain, read by more than one person, survives staff changes.

Step 4: Choose How Long to Renew For

Auto-renew usually extends a domain by one year at a time. For important domains, it's worth adding more years manually.

Renewal term	Pros	Cons
1 year	Lowest upfront cost, easy to change registrar	One renewal event every year that can fail
2 to 5 years	Fewer renewal events, some price certainty	Higher upfront cost
Up to 10 years	Maximum protection for core domains	Largest upfront cost; prices can still change for other services

Most gTLDs allow a maximum of ten years of registration at any one time. Some ccTLDs have shorter limits. Multi-year renewal doesn't replace auto-renew: keep auto-renew on as well, so the domain renews again when the term eventually runs out.

Step 5: Monitor Expiry Dates Independently

Auto-renew depends on one company's billing system working perfectly. An independent check catches the cases where it doesn't, such as a domain in an account you forgot about.

Check a Single Domain

RDAP, which has replaced port-43 WHOIS for gTLDs, returns the expiry date as JSON:

curl -sL https://rdap.org/domain/example.com \
  | jq -r '.events[] | select(.eventAction == "expiration") | .eventDate'

2027-03-18T11:04:52Z

Or with WHOIS:

whois example.com | grep -i "expir"

A Python Expiry Checker

This script reads a list of domains from a text file, looks up each expiry date over RDAP, and flags anything due soon. It uses only the Python standard library, so there's nothing to install.

#!/usr/bin/env python3
"""Warn about domains that expire soon. Usage: check_expiry.py domains.txt [days]"""
import json
import sys
import time
import urllib.error
import urllib.request
from datetime import datetime, timezone


def expiry_date(domain: str) -> datetime | None:
    req = urllib.request.Request(
        f"https://rdap.org/domain/{domain}",
        headers={"Accept": "application/rdap+json", "User-Agent": "domain-check/1.0"},
    )
    with urllib.request.urlopen(req, timeout=20) as resp:
        data = json.load(resp)
    for event in data.get("events", []):
        if event.get("eventAction") == "expiration":
            return datetime.fromisoformat(event["eventDate"].replace("Z", "+00:00"))
    return None


def main() -> int:
    path = sys.argv[1]
    threshold = int(sys.argv[2]) if len(sys.argv) > 2 else 45
    now = datetime.now(timezone.utc)
    problems = 0

    with open(path) as fh:
        domains = [line.strip() for line in fh if line.strip() and not line.startswith("#")]

    for domain in domains:
        try:
            expires = expiry_date(domain)
        except urllib.error.HTTPError as err:
            print(f"ERROR    {domain}: RDAP returned HTTP {err.code}")
            problems += 1
            continue
        except urllib.error.URLError as err:
            print(f"ERROR    {domain}: {err.reason}")
            problems += 1
            continue

        if expires is None:
            print(f"UNKNOWN  {domain}: no expiration date published (check the registry)")
            continue

        days_left = (expires - now).days
        label = "WARNING" if days_left <= threshold else "OK"
        if days_left <= threshold:
            problems += 1
        print(f"{label:<8} {domain}: expires {expires:%Y-%m-%d} ({days_left} days)")
        time.sleep(1)  # be polite to RDAP servers

    return 1 if problems else 0


if __name__ == "__main__":
    sys.exit(main())

Create a file listing your domains:

# domains.txt
example.com
example.net
example.org

Then run it:

python3 check_expiry.py domains.txt 45

OK       example.com: expires 2027-03-18 (142 days)
WARNING  example.net: expires 2026-11-20 (24 days)
OK       example.org: expires 2027-08-30 (307 days)

The script exits with status 1 when anything needs attention, which makes it easy to use in automation. Some ccTLD registries don't publish RDAP or don't include an expiry date. The script reports these as errors or unknown, so you can check them manually at the registrar.

Run It Automatically With Cron

On a Linux server or a Mac that's always on, schedule the check weekly and email yourself the output when something is wrong:

crontab -e

0 8 * * 1 /usr/bin/python3 /home/me/check_expiry.py /home/me/domains.txt 45 > /tmp/expiry.txt || mail -s "Domain expiry warning" domains@example.org < /tmp/expiry.txt

This runs every Monday at 08:00. The || sends the email only when the script exits with a non-zero status. It assumes a working mail command on the machine. If you don't have one, a scheduled job in a CI service such as GitHub Actions, which notifies you when a run fails, works just as well.

A Node.js Version

If you'd rather use JavaScript, Node 18 and later include fetch, so no packages are needed:

// check-expiry.mjs  Usage: node check-expiry.mjs example.com example.net
const THRESHOLD_DAYS = 45;

for (const domain of process.argv.slice(2)) {
  const res = await fetch(`https://rdap.org/domain/${domain}`, {
    headers: {
      Accept: "application/rdap+json",
      "User-Agent": "domain-check/1.0",
    },
  });
  if (!res.ok) {
    console.log(`ERROR    ${domain}: HTTP ${res.status}`);
    continue;
  }
  const data = await res.json();
  const event = (data.events ?? []).find((e) => e.eventAction === "expiration");
  if (!event) {
    console.log(`UNKNOWN  ${domain}: no expiration date published`);
    continue;
  }
  const expires = new Date(event.eventDate);
  const days = Math.floor((expires - Date.now()) / 86_400_000);
  const label = days <= THRESHOLD_DAYS ? "WARNING" : "OK";
  console.log(
    `${label.padEnd(8)} ${domain}: expires ${expires.toISOString().slice(0, 10)} (${days} days)`,
  );
}

node check-expiry.mjs example.com example.net

Step 6: Keep an Inventory

Auto-renew only protects the domains you know about. Keep a simple inventory, such as a spreadsheet or the domains.txt file above, with:

• Domain name
• Registrar and account login (the account, not the password)
• Expiry date and renewal term
• Auto-renew status
• Payment method used
• Who is responsible for it

Review it at least once a year, and consolidate domains into as few registrar accounts as practical. If you have many domains, how to manage DNS for multiple domains and what a domain portfolio is cover ways to keep them organised.

Auto-Renewal and Security

Renewal and security go together. An attacker who gets into your registrar account can switch off auto-renew, change the payment method, or transfer the domain away. Protect the account with:

• Two-factor authentication using an authenticator app or security key.
• A unique password stored in a password manager.
• A registrar lock on every domain.

Be wary of emails claiming your domain is about to expire and asking you to pay through a link. "Domain renewal" scams and phishing emails are common, and some come from companies that try to get you to transfer the domain to them at an inflated price. Always log in to your registrar directly by typing its address. More advice is in how to protect your domain from hijacking.

When to Turn Auto-Renew Off

There are a few legitimate reasons to switch it off:

• You've decided to let a domain lapse and don't want to be charged.
• You're about to transfer the domain to another registrar. In that case the transfer usually adds a year, so you may not want the old registrar to renew it first. See how to transfer a domain to another registrar.
• You're selling the domain and the buyer will take over renewal.

For any domain you still use, especially one that handles email, leave it on.

---

FAQ: Domain Auto-Renewal

---

Conclusion

Setting up domain auto-renewal takes a few minutes: turn it on for each domain in your registrar account, keep a valid payment method and ideally a backup or account credit on file, and make sure renewal emails reach an inbox that doesn't depend on the domain itself. For your most important domains, add several years to the registration so a single failed payment can't put them at risk.

Then verify it independently. A simple RDAP-based script run on a schedule, plus an up-to-date inventory of every domain you own and where it's registered, catches the expired cards and forgotten accounts that auto-renew can't. With those pieces in place, losing a domain to an accidental lapse becomes very unlikely.