---
title: "How to Give Your Server a Custom Address"
description: "Point a domain at your game server. How A and SRV records differ, which games actually read SRV, the exact record syntax, and how to verify it with dig."
url: "https://www.gameserverkings.com/knowledge-base/general/custom-server-address/"
category: "General"
category_url: "https://www.gameserverkings.com/knowledge-base/general/"
published: "2026-08-19T08:57:50.295Z"
updated: "2026-08-19T09:00:15.734Z"
source_format: "markdown"
site: "GameServerKings"
---

# How to Give Your Server a Custom Address

Every server owner reaches the same moment. You have a working server, players want to join, and the thing you have to give them is `203.0.113.10:27049`. It gets mistyped, it gets truncated in Discord, and the day you move the server it is worthless. What you want is for people to type `play.example.com` and land in the right place.

That is a DNS job, not a panel job, and it is one of the few server tasks where the honest answer depends entirely on which game you run. This guide covers what DNS can and cannot do for a game server, the exact record syntax, and — the part most guides skip — which games actually read those records.

## What DNS Can and Cannot Do

DNS turns a name into an IP address. That is the whole job of the record type most people reach for first, and it is why a domain on its own is usually not enough.

A game server needs two things: an address and a **port**. Your server almost certainly does not run on its game's default port — on shared hosting a single machine runs many servers, so each gets its own port from the allocation pool. You can see yours on the **Address** at the top left of the Console tab, and every port your server holds is listed on the **Network** tab. If either of those is unfamiliar, [How to Use Your Server Panel](/knowledge-base/general/how-to-use-your-server-panel/) is the tab-by-tab tour.

An `A` record carries the address and nothing else. So pointing `play.example.com` at your server's IP gets players to the right machine, but they still have to type `play.example.com:27049` — the port has not gone anywhere. That is fine, and it is still worth doing, but it does not deliver the thing people actually want.

A `SRV` record is the one that carries a port. It is a general DNS mechanism for saying *"this service, for this domain, lives on this host and this port"*, and a client that knows to look for it gets both halves in one lookup. Then the player types just `play.example.com`.

The catch is in that last sentence: **a client that knows to look for it**. SRV is not something DNS applies to a connection; it is something the game's client code has to go and ask for. Most games never ask.

| | `A` / `CNAME` record | `SRV` record |
|---|---|---|
| Carries the IP | Yes | Via its target |
| Carries the port | **No** | **Yes** |
| Players type | `play.example.com:27049` | `play.example.com` |
| Works for | Every game | Only games that look it up |
| Needed for SRV to work | Yes — the SRV target needs one | — |

> [!NOTE] DNS records live at your registrar, not in your panel
> Nothing in this guide is configured on the server itself. The records are created wherever your domain's DNS is hosted — the registrar you bought it from, or a DNS provider you moved it to. The panel's only role is telling you the IP and port to put in them.

## The SRV Record, Written Out Properly

SRV is defined by [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782.txt), and the format is precise:

```text title="RFC 2782, section: The format of the SRV RR"
_Service._Proto.Name TTL Class SRV Priority Weight Port Target
```

Two things trip people up. The name is not the name players type — it has a service label and a protocol label prepended, both with a leading underscore. And the value has **four** parts, not three. A great many published examples drop the priority field, which produces a record that either fails validation or silently resolves to the wrong port.

A complete, correct pair of records for a Minecraft: Java server on port `25566` looks like this:

```text title="Zone file form"
mc.example.com.                    300  IN  A    203.0.113.10
_minecraft._tcp.play.example.com.  300  IN  SRV  0 5 25566 mc.example.com.
```

Field by field:

| Field | Value above | What it means |
|---|---|---|
| Service | `_minecraft` | The service name the game looks up. Game-specific, always underscore-prefixed |
| Proto | `_tcp` | The transport. `_tcp` or `_udp` — game-specific, and getting it wrong means no lookup at all |
| Name | `play.example.com` | The name players type |
| TTL | `300` | How long resolvers may cache the answer, in seconds |
| Priority | `0` | Lowest-numbered reachable target wins. Range 0–65535 |
| Weight | `5` | Relative share between targets of equal priority. RFC 2782 advises `0` when there is nothing to balance |
| Port | `25566` | Your server's game port, from the panel |
| Target | `mc.example.com.` | A hostname that has its own `A` record pointing at the server |

> [!IMPORTANT] The target must be a real hostname, not the name players type and not a CNAME
> RFC 2782 is explicit: the target "MUST have one or more address records" and "MUST NOT be an alias". So create a separate `A` record — `mc.example.com` above — and point the SRV at that. Pointing an SRV at itself, at an IP address, or at a CNAME are the three most common ways to build a record that resolves and still does not work.

With one server there is nothing to balance, so `0 5` or `0 0` for priority and weight is fine. The fields exist for the case where a service has several hosts, which is not the situation you are in.

## Which Games Actually Read SRV Records

This is the part that matters, and it is not intuitive: SRV support is a per-game decision made by the developer, and most have not made it. Below is what each game's own documentation says, checked on 19 August 2026.

### Confirmed supported

| Game | Service and protocol | Documented by |
|---|---|---|
| **Minecraft: Java Edition** | `_minecraft._tcp` | The Minecraft Wiki's [Java server tutorial](https://minecraft.wiki/w/Tutorial:Setting_up_a_Java_Edition_server#SRV_record). Support was added in Java Edition 1.3.1 |
| **Rust** | `_rust._udp` | Facepunch's own [Server DNS Records](https://wiki.facepunch.com/rust/dns-records) page |
| **Factorio** | `_factorio._udp` | The [Official Factorio Wiki](https://wiki.factorio.com/Multiplayer#DNS_SRV_Records). Added in 1.1.67; the Nintendo Switch version is excluded |

Note the protocol differences. Minecraft uses `_tcp`, Rust and Factorio use `_udp`, and copying one game's record shape onto another is a guaranteed failure. Facepunch also specifies that a Rust server should have only one SRV entry — multiple records for the same server are explicitly called out as unsupported.

> [!TIP] Rust has a second reason to set this up
> With a domain in place, setting the `server.favoritesEndpoint` convar to your **`A` record** — not the `_rust._udp` name — makes players' favourites entries follow the domain rather than the IP. Your server can then change IP or port without dropping off everyone's favourites list. That is Facepunch's own recommendation on the page linked above.

### Confirmed not supported

| Game | What the documentation says |
|---|---|
| **Minecraft: Bedrock Edition** | The Bedrock Dedicated Server's documented limitations include not supporting "SRV record for a domain name, which allows connecting to a server using an Internet domain name without specifying a port manually". Our own [Bedrock server guide](/knowledge-base/minecraft/bedrock/) says the same |
| **FiveM** | Cfx's [Proxy Setup](https://docs.fivem.net/docs/server-manual/proxy-setup/) documentation sets out the client's full connect-endpoint resolution: a bare host in a `connect` command resolves to `http://host.example:30120/`, a host with a port resolves to that port, and a URL with a scheme is used as-is. There is no DNS SRV step anywhere in that sequence. FiveM's supported route to a clean address is an HTTPS reverse proxy on port 443 in front of the server, after which `connect https://play.example.com/` works with no port |

### No SRV support documented

For these, we searched each game's own wiki or developer documentation and found no reference to SRV at all, and the documented way to join is an address with a port:

- ARK: Survival Evolved
- Conan Exiles
- Don't Starve Together
- DayZ
- Garry's Mod, Counter-Strike 2, Counter-Strike: Source, Team Fortress 2 *(Source-engine `connect ip:port`)*
- Palworld
- Project Zomboid
- Satisfactory
- Space Engineers
- Starbound
- Terraria
- Unturned
- Valheim — Iron Gate's own [dedicated server guide](https://www.valheimgame.com/support/a-guide-to-dedicated-servers/) lists the join methods as public IP with port number, a join code, or the server list
- 7 Days to Die

> [!WARNING] "No documentation" is not the same as "proven impossible"
> For the games above we can say that no developer documentation describes SRV support and that every documented join path includes a port. We cannot say we have read the client's source. If you want certainty for one of them, create the record and test it — a five-minute experiment beats an assumption either way.

For the remaining titles in our catalogue — Abiotic Factor, Enshrouded, Hytale, Icarus, Once Human, SCUM, Soulmask, Sons of the Forest, The Forest, V Rising, Vintage Story and Windrose — we could not confirm a position from a primary source at the time of writing, so we are not claiming one. Treat them as port-required until you have tested otherwise.

> [!NOTE] Where SRV does not work, the `A` record still earns its keep
> A memorable name plus a port (`play.example.com:27049`) is far better than a raw IP plus a port. More importantly, if you ever move the server you re-point one DNS record instead of asking every player to re-add the address. That is the argument for setting a domain up even for a game that will never read SRV — see [How to Move an Existing Minecraft Server to GameServerKings](/knowledge-base/minecraft/migrating-your-server-to-gsk/) for how much that matters on a move.

## Minecraft Bedrock Is a Genuine Special Case

Bedrock deserves its own section because it fails differently from the games above, and because a Java owner's instincts are exactly wrong here.

Bedrock Dedicated Server does not read SRV records. That is a documented limitation of the server software, listed alongside the absence of RCON and of a settable MOTD. A hostname still resolves — you can put `play.example.com` in the address field — but the port has to be supplied separately and it will not be found for the player.

The client asks for both halves regardless. On Windows, Android and iOS you add a server from the **Servers** tab under **Other Server**, using the IP and port from the **Address** at the top left of your panel; a hostname is accepted in place of the IP, but the port still has to be supplied by hand. Xbox, PlayStation and Switch do not offer that screen at all, which is a platform limitation rather than an addressing problem. The full picture is in [Setting up your Bedrock Minecraft server](/knowledge-base/minecraft/bedrock/).

Two further Bedrock-specific traps, both covered in [Minecraft Bedrock server.properties: The Complete Key Reference](/knowledge-base/minecraft/bedrock-server-properties/):

- Leave `server-port` and `server-portv6` alone. The panel binds your allocated port on boot, and editing those keys by hand breaks the next start rather than moving the server.
- `enable-lan-visibility=true` makes the server additionally bind the default ports 19132 and 19133, which can collide with other servers on the same host. Setting it to `false` avoids that.

If a bare domain with no port is important to you and most of your players are on Windows or mobile, the practical route is a Java server running Geyser rather than a standalone Bedrock server, because the Java side does read SRV.

## Setting It Up at Your Registrar

Every DNS panel exposes the same eight values; they just disagree about how to lay them out. Facepunch's DNS page documents this difference directly, with Cloudflare putting service, protocol and name into a single Name box, and GoDaddy giving each its own field.

**Step 1 — Create the `A` record first.**

| Field | Value |
|---|---|
| Type | `A` |
| Name / Host | `mc` (giving `mc.example.com`) |
| Value / Points to / IPv4 address | Your server's IP, from the panel's **Address** |
| TTL | 300, or the panel's lowest option while you are still testing |

**Step 2 — Create the `SRV` record.** Depending on the panel you will either see separate boxes:

| Field | Value |
|---|---|
| Type | `SRV` |
| Service | `_minecraft` (or `_rust`, or `_factorio`) |
| Protocol | `_tcp` for Minecraft: Java, `_udp` for Rust and Factorio |
| Name / Host | `play` — the label players will type, or `@` for the bare domain |
| Priority | `0` |
| Weight | `5` |
| Port | Your server's game port |
| Target | `mc.example.com` |
| TTL | 300 |

…or a single Name box, into which the whole thing goes as `_minecraft._tcp.play`, with priority, weight, port and target either as separate fields or as one space-separated value.

> [!CAUTION] Do not proxy the record
> On Cloudflare, only `A` and `AAAA` records can be proxied — the orange cloud — and Cloudflare's own DNS record reference confirms an SRV record is not proxiable. More importantly, the `A` record your SRV points at **must be DNS-only (grey cloud)**. The proxy handles HTTP and HTTPS; a game port sent through it does not arrive. An orange-clouded target is the single most common reason a technically perfect SRV record produces a server that will not connect.

**Step 3 — Wait.** DNS changes are not instant. A resolver that has already cached the old answer, or cached the *absence* of a record, keeps serving that until the TTL expires. Ten minutes is usually enough with a 300-second TTL; a first-time record on a domain whose negative-cache TTL is long can take longer.

> [!TIP] Set a low TTL before you change anything
> If you know a move is coming, drop the TTL to 300 a day in advance. TTL governs how long the *old* answer survives, so lowering it after you make the change does nothing for the people already holding a stale copy.

## Checking It Worked

Query the record directly rather than trusting the game to tell you. On macOS and Linux:

```bash title="Verifying from a terminal"
# The SRV record — note the underscore-prefixed name
dig +short SRV _minecraft._tcp.play.example.com

# The A record the SRV target points at
dig +short A mc.example.com

# Ask a public resolver explicitly, bypassing your local cache
dig SRV _minecraft._tcp.play.example.com @1.1.1.1
```

A healthy answer looks like this — priority, weight, port, target, in that order:

```text title="Expected dig output"
0 5 25566 mc.example.com.
```

On Windows, `nslookup` does the same job:

```text title="Windows"
nslookup -q=srv _minecraft._tcp.play.example.com
nslookup -q=a mc.example.com
```

Then do the real test: connect the way a player would, typing the bare domain with no port. If that works, you are done. If it does not, the two `dig` queries above have already told you whether the problem is DNS or the game.

## Common Failures

- **Nothing resolves at all.** Check the underscores and the exact service name. `minecraft._tcp` without the leading underscore, or `_minecraft._udp` with the wrong protocol, are silent failures — the client asks for a name that does not exist and falls straight back to treating your domain as a plain hostname on the default port.
- **The trailing dot.** In zone-file syntax the target must be fully qualified with a trailing dot: `mc.example.com.` Most web DNS panels add it for you and will show it back with the dot; some accept a relative name and quietly append your zone, turning `mc.example.com` into `mc.example.com.example.com`. If a lookup returns a doubled domain, that is what happened.
- **The target is a CNAME, or an IP.** RFC 2782 requires the target to be a name with address records and not an alias. An SRV pointing at an IP address is invalid; an SRV pointing at a CNAME is out of spec and behaves inconsistently across resolvers.
- **The `A` record is proxied.** Grey-cloud it. See the caution above.
- **It works for you and not for a friend.** Different resolvers, different caches. Test with `dig ... @1.1.1.1` and `dig ... @8.8.8.8` to see whether the record has propagated everywhere, and give it the TTL before concluding anything.
- **You changed the record and nothing happened.** The old answer is cached for the length of the *previous* TTL, not the new one.
- **The domain works but the port is wrong.** You changed the server's port, or the panel reallocated it, and the SRV still carries the old one. The port lives in two places now — the record and the panel — and only one of them updates itself.
- **Multiple SRV records for one server.** Facepunch explicitly documents this as unsupported for Rust, and it is a bad idea generally: with several records the client picks one by priority and weight, so a stale entry becomes an intermittent failure rather than a clean one.
- **The domain resolves but nobody can join.** That is no longer a DNS problem. Work through [Players Can't Connect to My Server](/knowledge-base/general/players-cant-connect/) — the server may simply be stopped, or the address may be right and the game port wrong.

## What a Domain Does Not Fix

- **Server browser listings.** How and whether your server appears in an in-game browser is a separate mechanism, usually driven by the game's master list and a query port. A domain changes nothing there.
- **The query and RCON ports.** SRV carries one port — the game port. Tools that talk to a query or RCON port still need the real address and their own port from the **Network** tab.
- **Proxy setups.** If you run a Minecraft proxy, the SRV interacts with it in a way worth knowing about: since Java Edition 1.17.1, a client that resolved an SRV record sends the SRV *target and port* in its handshake rather than the name the player typed. That is precisely why Velocity forced hosts have to be keyed on the target the SRV points at, not the address in the player's server list — the full explanation is in [Minecraft Server Networks: Setting Up a Velocity Proxy](/knowledge-base/minecraft/multi-server-networks-with-velocity/).

If none of the above is what you are after and you simply want players to type an address with no port at all in a game that ignores SRV, the only mechanism that achieves it is running on the game's default port, which requires a dedicated IPv4 address rather than a shared one. That trade-off is covered in [Players Can't Connect to My Server](/knowledge-base/general/players-cant-connect/).

## What to Read Next

- [How to Use Your Server Panel](/knowledge-base/general/how-to-use-your-server-panel/) — where the Console **Address** and the **Network** tab live
- [Players Can't Connect to My Server](/knowledge-base/general/players-cant-connect/) — when the name resolves and the connection still fails
- [Setting up your Bedrock Minecraft server](/knowledge-base/minecraft/bedrock/) — the platform-by-platform connection picture for Bedrock
- [Minecraft Bedrock server.properties: The Complete Key Reference](/knowledge-base/minecraft/bedrock-server-properties/) — the port keys to leave alone
- [Minecraft Server Networks: Setting Up a Velocity Proxy](/knowledge-base/minecraft/multi-server-networks-with-velocity/) — SRV and forced hosts on a proxy network
- [Minecraft Players Can't Connect: Every Error Message Explained](/knowledge-base/minecraft/players-cant-connect/) — what `Can't resolve hostname` and `Unknown host` actually mean
- [How to Move an Existing Minecraft Server to GameServerKings](/knowledge-base/minecraft/migrating-your-server-to-gsk/) — why a domain is worth having before you move

**Primary sources used for this guide** (all checked 19 August 2026): [RFC 2782](https://www.rfc-editor.org/rfc/rfc2782.txt) for the record format and target rules; the Minecraft Wiki's [Setting up a Java Edition server](https://minecraft.wiki/w/Tutorial:Setting_up_a_Java_Edition_server#SRV_record), [Java Edition 1.3.1](https://minecraft.wiki/w/Java_Edition_1.3.1) and [Java Edition 1.17.1](https://minecraft.wiki/w/Java_Edition_1.17.1) changelogs, and the [Bedrock Dedicated Server](https://minecraft.wiki/w/Bedrock_Dedicated_Server) limitations list; Facepunch's [Server DNS Records](https://wiki.facepunch.com/rust/dns-records); the Official Factorio Wiki's [Multiplayer](https://wiki.factorio.com/Multiplayer#DNS_SRV_Records) page; Cfx's [Proxy Setup](https://docs.fivem.net/docs/server-manual/proxy-setup/) documentation; Iron Gate's [A Guide to Dedicated Servers](https://www.valheimgame.com/support/a-guide-to-dedicated-servers/); and Cloudflare's [DNS record types](https://developers.cloudflare.com/dns/manage-dns-records/reference/dns-record-types/) reference.

---

Made with 💜 by GameServerKings