# Preparing Your Domain for CorePanel

> A beginner-friendly walkthrough: register a domain, create your nameservers, delegate the domain to CorePanel, create the panel domain, and confirm everything works.

Source: https://www.corepanel.net/docs/domain-setup/
Last updated: 2026-07-28
Part of the CorePanel documentation — https://www.corepanel.net/docs

---

This guide takes you from *nothing* to a working panel you can open in your
browser at an address like `https://panel.example.com`. No prior experience with
domains, DNS, or name servers is assumed — every term is explained in plain
language as it comes up.

By the end you will have:

1. **Registered** a domain name.
2. **Created** two name servers for it.
3. **Delegated** the domain to your CorePanel server.
4. **Created** the panel domain.
5. **Confirmed** the panel loads over a secure connection.

## The big picture

Before the steps, here is what actually happens when someone opens your panel.
It helps to have this picture in mind — the steps below are just filling in the
pieces of it.

![How a browser reaches your server: it asks the domain's name servers where example.com lives, the name servers reply with the server's IP address, and the browser then opens the panel over HTTPS.](https://www.corepanel.net/_astro/domain-setup-overview.BI3mU3c8.svg)

- A **domain** (like `example.com`) is a friendly name. Computers don't use
  names — they use numeric **IP addresses** like `203.0.113.45`. Your server has
  one of these.
- **Name servers** are the internet's phone book. When a browser wants
  `example.com`, it asks that domain's name servers, "what's the address?" and
  they answer with your server's IP.
- **Delegation** is simply telling the world *which* phone book to use for your
  domain. When you delegate the domain to CorePanel, your own server becomes the
  phone book — it answers every DNS question about the domain itself.

That's the whole idea. Now let's build it.

> **Just need the panel and nothing else?**
>
> If your only goal is to reach the control panel — and you're not (yet) hosting
> websites or email for this domain on CorePanel — you can skip the name-server
> steps entirely and add a single **A record** instead. Jump to
> [The shortcut: one A record](#the-shortcut-one-a-record). The full route below is
> for when CorePanel will manage **everything** for the domain.
## Step 1 — Register the domain

A domain is rented, not bought outright — you register it for a year (or more)
through a **registrar**. Popular ones include Namecheap, Porkbun, Cloudflare
Registrar, GoDaddy, and many hosting companies. Any of them works; the screens
below are a generic example, but every registrar has the same ideas under
slightly different names.

Search for the name you want. If it's available, add it to your cart and check
out.

![A registrar's search screen showing example.com as available to register, with a price and a Register button.](https://www.corepanel.net/_astro/domain-setup-register.BUKn4T7U.svg)

> **Pick a name you'll keep**
>
> Changing domains later means redoing this whole guide, so choose a name you're
> happy with. A short `.com` is the safe default. The exact price varies by
> registrar and extension.
You'll also want your server's **public IP address** handy for the next step. If
you've already run the CorePanel setup wizard, it printed the IP; otherwise your
server provider shows it in their dashboard. In this guide we'll use
`203.0.113.45` as the example.

## Step 2 — Create your name servers

To make CorePanel the phone book for your domain, you first give your two name
servers a *name* and an *address*. By convention they're called `ns1` and `ns2`
on your own domain — so `ns1.example.com` and `ns2.example.com`.

The **address is the crucial part: each name server points at your server's own
public IP address** — the CorePanel machine. That's what makes your server the
one that answers DNS for the domain. Both name servers point at that same server
IP.

In your registrar's control panel, find the section for **registering name
servers**. Registrars label this differently — look for *Register nameservers*,
*Personal nameservers*, *Private nameservers*, *Host records*, or *Glue records*
— they all mean the same thing.

![A registrar's Register Nameservers screen: ns1.example.com and ns2.example.com are each pointed at the server's own public IP.](https://www.corepanel.net/_astro/domain-setup-glue.CuKtUgaH.svg)

Enter both, and point each one at your CorePanel server's public IP:

| Name server | Points to |
|---|---|
| `ns1.example.com` | your server's public IP |
| `ns2.example.com` | your server's public IP |

> **Use your server's real IP**
>
> Both name servers must point at **your** CorePanel server's public IP — the
> address your server provider assigned to the machine (the setup wizard also
> prints it). Don't copy any address from the screenshots above; they use a
> placeholder on purpose. If your server has more than one public IP, pointing both
> name servers at the same one is perfectly fine.
Save. You've now *created* the name servers, but the domain isn't using them yet
— that's the next step.

> **Why "glue"?**
>
> There's a small chicken-and-egg problem: to find `ns1.example.com`, the internet
> needs to know where `example.com`'s name servers are — but `ns1` *is* one of
> them. The registrar solves this by publishing the IP directly at the top-level
> (`.com`) level. That published IP is called a **glue record**. You don't have to
> manage it — creating the name server here *is* what creates the glue.
## Step 3 — Delegate the domain to CorePanel

Now tell the domain to actually *use* those name servers. In your registrar,
open the domain's **Nameservers** setting, switch from the registrar's defaults
to **Custom nameservers**, and enter the two names you just created.

![A registrar's Nameservers screen with Custom nameservers selected and set to ns1.example.com and ns2.example.com.](https://www.corepanel.net/_astro/domain-setup-delegate.BgkSr8SY.svg)

Save. This is the delegation: from now on, the world asks *your server* for
anything about `example.com`.

> **Give it time to spread**
>
> This change isn't instant. Name-server updates take anywhere from a few minutes
> to a few hours to spread across the internet — this waiting period is called
> **propagation**. It's normal. You can keep going with the next steps while it
> settles.
## Step 4 — Create the panel domain

The **panel domain** is the address you'll type to open CorePanel — for example
`panel.example.com`. You set it on the server with the one-time setup wizard:

```bash
corepanel system init
```

When it asks for the panel domain, enter `panel.example.com`. CorePanel takes
care of the DNS for you: because your server is now the phone book for
`example.com`, it automatically publishes the record that points
`panel.example.com` at itself, and it answers as `ns1`/`ns2` for the domain.
There are no DNS records to add by hand.

The wizard is covered in full — including how it handles SSL and what each prompt
means — in **[Initial Server Setup](https://www.corepanel.net/docs/initial-setup)**.

> **You can reach the panel before DNS is ready**
>
> While delegation is still propagating, you don't have to wait around. Open the
> panel directly by its IP at `https://<server-ip>` (your browser will warn about a
> self-signed certificate — that's expected). Once DNS resolves, use the real,
> trusted `https://panel.example.com`; the IP endpoint stays up as a fallback. See
> [Accessing the panel by IP](https://www.corepanel.net/docs/initial-setup#accessing-the-panel-by-ip).
## Step 5 — First sign-in and the setup assistant

Once propagation finishes, open your panel domain in a browser (or reach it by IP
right away — see the tip in [Step 4](#step-4--create-the-panel-domain)):

```
https://panel.example.com
```

Sign in with the user `coreadmin` and the password from the setup wizard.

### The initial configuration assistant

The **first** time you sign in, CorePanel greets you with the **Initial
configuration assistant** — a short, four-step wizard that confirms who runs the
server and, most importantly, the **name servers it will publish** for every
domain it hosts.

![CorePanel's Initial configuration assistant on Step 3 of 4, Name servers: two cards with Hostname fields ns1.example.com and ns2.example.com, each pointing at the server's public IP.](https://www.corepanel.net/_astro/domain-setup-wizard.DMU5gEuN.svg)

Walk through the four steps:

1. **Company** — your name and email, used for notifications and alerts.
2. **Server basics** — the server's host name and its main public IP address.
3. **Name servers** — the key step. Enter the **two name servers you created in
   [Step 2](#step-2--create-your-name-servers)** — `ns1.example.com` and
   `ns2.example.com` — each pointing at your server's public IP. CorePanel
   pre-fills sensible defaults from the previous step; just confirm they're right.
4. **Review** — check everything and click **Finish**.

> **These must match Steps 2 & 3**
>
> The name servers you enter here are the ones CorePanel publishes inside every
> domain's DNS. They must be **exactly the same** names — `ns1.example.com` and
> `ns2.example.com` — that you registered and delegated at your registrar. If they
> don't match, the delegation and the answers won't line up and domains won't
> resolve.
When you finish, the assistant closes and drops you on the dashboard. You should
see a **padlock** in the address bar — the connection is secure and the
certificate is trusted.

![A browser open at https://panel.example.com/dashboard with a padlock, showing the CorePanel dashboard live with healthy services.](https://www.corepanel.net/_astro/domain-setup-panel-live.XokaYdyU.svg)

### Confirm it's all wired up

If you'd like to confirm the plumbing from the command line, two quick checks
tell you everything:

```bash
# 1. Is the domain delegated to your name servers?
dig NS example.com +short
# Expected: ns1.example.com. and ns2.example.com.

# 2. Does the panel domain point at your server?
dig panel.example.com +short
# Expected: your server's public IP, e.g. 203.0.113.45
```

If both look right and the browser shows the padlock, you're done — the domain is
fully prepared and CorePanel is serving it.

## The shortcut: one A record

Don't need CorePanel to manage the whole domain — just want to reach the panel?
Skip Steps 2 and 3. Leave the domain on your registrar's default name servers and
add a single record in their DNS settings:

| Type | Name / Host | Value |
|---|---|---|
| `A` | `panel` | your server's public IP |

That creates `panel.example.com → your server`. Then do Step 4 (run
`corepanel system init` with `panel.example.com`) and Step 5 to test. This is the
fastest path when the panel is all you need; you can always delegate the full
domain later.

## If something's not working

- **The browser can't find the site.** DNS probably hasn't propagated yet. Wait a
  bit longer and re-run the `dig` checks above. Propagation can take a few hours.
- **`dig NS example.com` returns the registrar's name servers, not yours.** The
  delegation in Step 3 hasn't taken effect yet (still propagating), or wasn't
  saved. Re-open the registrar's Nameservers screen and confirm the custom name
  servers are set.
- **`dig panel.example.com` returns nothing.** Make sure you ran
  `corepanel system init` with the correct panel domain, and that the domain is
  delegated to your server (the previous check).
- **The padlock is missing / certificate warning on the panel domain.** CorePanel
  issues the trusted certificate automatically once the domain resolves publicly
  and ports **80** and **443** are open. Give it a minute after DNS resolves, and
  confirm those ports are reachable. Details in
  [Initial Server Setup → How SSL works](https://www.corepanel.net/docs/initial-setup#how-ssl-works).

## See also

- **[Initial Server Setup](https://www.corepanel.net/docs/initial-setup)** — the `corepanel system init`
  wizard, SSL, and reaching the panel before DNS resolves.
- **[Getting Started](https://www.corepanel.net/docs/getting-started)** — install CorePanel and learn the
  core concepts.
- **[SSL/TLS Certificates](https://www.corepanel.net/docs/ssl-certificates)** — how CorePanel obtains and
  renews certificates.