---
title: Minecraft server status for Java and Bedrock: SRV records, proxies and port 19132
description: Your Minecraft server says it's online, a status checker says it's offline, and a player on Bedrock can't see it at all. Each of those answers comes from a different question asked of a different port. Here's how Java and Bedrock actually report their status, what SRV records, proxies and DDoS shields do to that answer, and how to check it properly.
canonical: https://watchfor.io/blog/minecraft-server-status-java-bedrock
---

# Minecraft server status for Java and Bedrock: SRV records, proxies and port 19132

2026-11-16 · WatchFor Team · Game servers · game-servers, minecraft, dns, networking

Your Minecraft server says it's online, a status checker says it's offline, and a player on Bedrock can't see it at all. Each of those answers comes from a different question asked of a different port. Here's how Java and Bedrock actually report their status, what SRV records, proxies and DDoS shields do to that answer, and how to check it properly.

Three people look at the same Minecraft server and get three answers. The
host panel says **running**. A status checker website says **offline**. A
friend on a phone can't find it in the Bedrock server list at all, and two
players on Java are happily mining.

None of them is lying. Each one asked a different question, often of a
different port, sometimes over a different protocol. To know whether a
Minecraft server is really up you need to ask the question its players'
clients ask, from where those players are. This post covers how Java and
Bedrock report their status, what SRV records, proxies and DDoS shields do
to that answer, and how to check it in a way you can trust.

## Two editions, two protocols

Java Edition and Bedrock Edition are different games on the wire. A tool
that treats them the same will be wrong about one of them.

| | Java Edition | Bedrock Edition |
| --- | --- | --- |
| Transport | TCP | UDP (RakNet) |
| Default port | 25565 (`server-port`) | 19132, and 19133 for IPv6 (`server-portv6`) |
| Status question | Server list ping: handshake, status request, JSON reply, then ping/pong | Unconnected ping, one datagram out, one "pong" back |
| What comes back | Version name and protocol, players online and max, an optional player sample, MOTD, favicon | MOTD, protocol, version, players online and max, level name, game mode |
| SRV records | Yes, `_minecraft._tcp` | No |
| Player names | Sometimes (the sample is optional and often replaced) | Never |

**Java's server list ping** is what fills the multiplayer screen. The
client opens a TCP connection, sends a handshake with "next state: status",
asks for the status and gets a JSON document back. Then it sends a ping with
a timestamp and the server echoes it; that round trip is the latency bar
you see in the list. The protocol is documented on the
[Minecraft wiki](https://minecraft.wiki/w/Java_Edition_protocol/Server_List_Ping).

**Bedrock's unconnected ping** is a single UDP packet. The server answers
with one semicolon-separated string that starts with `MCPE;` and carries the
MOTD, the protocol number, the version, players online and max, and the game
mode. There is no player list in it, and no way to ask for one.

The practical consequence: a TCP port check on 19132 tells you nothing about
a Bedrock server, and a UDP check on 25565 tells you nothing about a Java
one. "Port open" is not "server answering" for either.

## SRV records: the port players never type

Players type `play.example.com`. The Java client doesn't connect to port
25565 straight away: it first looks up an SRV record named
`_minecraft._tcp.play.example.com`, and if one exists, it connects to the
host and port the record names.

```text
_minecraft._tcp.play.example.com. 3600 IN SRV 0 5 25566 mc1.example.com.
mc1.example.com.                  3600 IN A   203.0.113.20
```

That is how one IP can host several servers on different ports while every
community keeps a clean address. It is also the first reason status checks
disagree: a tool that skips the SRV lookup asks `play.example.com:25565`,
finds nothing, and reports the server offline while every player is fine.

Things that go wrong with SRV records, roughly in order of how often we see
them:

- **The target is proxied.** On Cloudflare, the A record the SRV points to
  must be DNS-only (grey cloud). Cloudflare's normal proxy only carries web
  traffic, so an orange-clouded target sends Minecraft to an address that
  doesn't speak it.
- **The target is a CNAME or an IP.** The SRV target should be a hostname
  with its own A or AAAA record.
- **Bedrock players expect it to work.** Bedrock clients don't read SRV
  records. They need the real host and port, 19132 unless you changed it.
- **The record was never saved where you think.** Look it up yourself:

```bash
dig +short SRV _minecraft._tcp.play.example.com
# 0 5 25566 mc1.example.com.
```

If that prints nothing, the client falls back to port 25565 on the name you
typed.

## When the server is up but the status says it isn't

### enable-status is off

`enable-status=false` in `server.properties` makes the server stop answering
status requests. Players who already know the address can still connect,
but the multiplayer screen, every status checker and every monitor see a
server that never answers. If you turned it off to hide from scanners, know
that you also turned off the one signal outside tools can read.

### A proxy answers for the server

Most networks put [Velocity](https://docs.papermc.io/velocity/) or
BungeeCord in front of their backends. The proxy owns the public address and
**answers the server list ping itself**, from its own config: its MOTD, its
player count (the sum across backends), its version range. That has two
consequences:

1. A backend that crashed while the proxy keeps running still "looks
   online". Players get kicked to a lobby or see a connection error, but the
   ping is green.
2. A broken proxy config can produce an answer that doesn't parse, while
   connections still route fine.

You are monitoring what players connect to, which is the right thing to
watch first. If your backends have their own reachable addresses, watch
them as well, so a dead survival server behind a healthy lobby is visible.

On the Bedrock side, [Geyser](https://geysermc.org/) lets Bedrock players
join a Java server and answers the Bedrock ping on 19132 for it; it can pass
the Java server's MOTD and player counts through. A healthy Geyser pong
means Geyser is up, not necessarily the Java server behind it.

### A DDoS shield drops data-centre addresses

Minecraft networks attract attacks, so many sit behind a shield such as
TCPShield or a host's own filter. Some of those filters only let through
traffic that looks like a player and silently drop status pings from cloud
and data-centre ranges. The server is fine in-game and **every** outside
check times out. If that is your setup, allow your monitor's probe addresses
in the shield (WatchFor publishes them on the [IP ranges](/ip-ranges) page),
or accept that outside checks can't see past the filter.

### The server sleeps

Free hosts like Aternos stop a server when nobody is online. It is then
genuinely offline, and a monitor that pages on it will page every night.
Monitoring is for servers that are supposed to be up.

## What a good status check reads

A ping that comes back proves the server process is alive and answering.
The reply carries more than that, and the useful parts are:

- **Players online and max.** The number to chart. Big networks sometimes
  report more players than slots, or a fake max; show it as reported rather
  than drawing a full bar.
- **MOTD.** Minecraft servers have no separate name field, so the first MOTD
  line is effectively the name. Strip the `§` colour codes and flatten the
  chat-component JSON before showing it.
- **Version name and protocol number.** Paper builds, proxy ranges like
  "1.20–1.21" and the year-based names Mojang has used since 2026 (Java
  26.1, 26.3; see [version formats](https://minecraft.wiki/w/Version_formats))
  all arrive here. A
  version that changes after an update is your cue that the clients and the
  server may no longer match.
- **Latency.** Time the ping/pong after the status (Java) or the pong itself
  (Bedrock). Measured from one place it says little; measured from the
  regions your players live in, it shows who is lagging.
- **The player sample, carefully.** It is optional, capped, and many servers
  replace it with custom text or hide it entirely. Never infer "zero
  players" from an empty sample: the count is in the `online` field.

## Checking it by hand

For a one-off look, the [mcstatus](https://github.com/py-mine/mcstatus)
Python tool speaks both protocols. Here it is against a large public
network, today:

```bash
pip install mcstatus
dig +short SRV _minecraft._tcp.cubecraft.net
# 0 0 25565 play.cubecraft.net.
mcstatus cubecraft.net status                 # Java, follows the SRV record
# version: Java We support: 1.20-1.21 (protocol 340)
# players: 1018/5000
#   CubeCraft (00000000-0000-0000-0000-000000000000)
#   Forums > cubecraft.net (00000000-0000-0000-0000-000000000000)
mcstatus --bedrock play.cubecraft.net status  # Bedrock, UDP 19132
# version: Bedrock 1.26.60 (protocol 2225)
# players: 7492/55000
# ping: 23.79 ms
```

Two things worth noticing. The "player sample" is custom text with all-zero
UUIDs, not players: exactly why a sample can't be used to count anyone. And
the version field is free text the network chose, so it says what the
network supports, not what it runs.

To separate "nothing listening" from "status disabled":

```bash
nc -vz mc1.example.com 25566              # TCP connect only
```

A successful connect with no status reply points at `enable-status`, a
proxy or a filter. A refused connection points at the process or the
firewall.

## Watching it all the time

A one-off check answers "is it up right now, from here". Your players care
about 2 a.m. on a Sunday, from their side of the ocean. That is what a
monitor is for: the same question, asked every minute or few, from the
regions your players are in, with a record of every answer.

In WatchFor, a **Game server** monitor has two Minecraft presets. **Java
Edition** takes `play.example.com` with no port and follows the
`_minecraft._tcp` SRV record exactly as the client does, falling back to
25565. **Bedrock Edition** sends the unconnected ping to 19132 (19133 when you
check over IPv6). Neither needs `enable-query` or RCON.

![WatchFor game server monitor for a Minecraft Java server: players online out of the slots, the MOTD as the server name, the supported versions and the latency, above the population chart.](/marketing/game/minecraft.webp)

Every check stores players, slots, MOTD, version and latency, so the monitor
page builds a population chart and a busy-hours heatmap without anything
installed on the server. A failed check is not an outage on its own: it is
repeated before an incident opens (from your other locations when the
monitor has several, which depends on your plan), so one dropped connection
doesn't wake anyone. When the server is confirmed down, the alert goes to a
Discord channel through a webhook, no bot to invite, with the last player
count and the address to copy; Slack, Telegram, Teams and email work the
same way. A [status page](/docs/monitors/game#status-pages) can show players
and a **Copy address** button, and never shows player names.

Game server monitoring is part of the paid plans from Starter, where each
server counts toward the plan's normal monitor total. See
[pricing](/pricing) for intervals and regions per plan, and the
[game server docs](/docs/monitors/game) for every reading and alert rule.

## Checklist

1. Know which edition you're checking: TCP 25565 for Java, UDP 19132 for
   Bedrock.
2. Let SRV do its job: check the name players type, and confirm the record
   with `dig`.
3. Keep `enable-status` on if you want anyone outside to see the server.
4. Behind a proxy, watch the public address and, where you can, the
   backends.
5. Behind a shield, allow the monitor's addresses or expect blind spots.
6. Judge players by the `online` count, never by the sample.

## Frequently asked questions

### What port does a Minecraft server use?

Java Edition listens on TCP 25565 by default (`server-port` in server.properties). Bedrock Edition listens on UDP 19132 for IPv4 and UDP 19133 for IPv6 (`server-port` and `server-portv6`). A Java server can use any port if you publish an SRV record that points to it.

### Why does my Minecraft server show as offline in a status checker but players can join?

The usual causes, in order: the checker asked the wrong port (no SRV lookup, or Bedrock checked over TCP), `enable-status=false` in server.properties, a DDoS shield that drops status pings from data-centre addresses, or a proxy whose ping answer is broken while connections still work. Check from where your players are and with the same protocol their client uses.

### Do I need enable-query to check a Minecraft server's status?

No. The server list ping that every Java client sends works with default settings. `enable-query` turns on a separate UDP query (GameSpy 4) that some tools use for full player lists; a status check doesn't need it, and leaving it off is one less open port.

### How do I set up an SRV record for a Minecraft server?

Create a record named `_minecraft._tcp.play` (for play.example.com) with priority 0, weight 5, the port your server listens on and the target host, for example `0 5 25566 mc1.example.com.`. The target needs its own A or AAAA record and, on Cloudflare, must be DNS-only. Bedrock clients don't read SRV records.

### Can I monitor a Minecraft server behind Velocity or BungeeCord?

Yes, but know what you're monitoring: the proxy answers the ping itself, so the address players use shows the proxy's health. A crashed backend behind a healthy proxy still looks online. If your backends have their own reachable addresses, monitor those too.

---

Canonical page: https://watchfor.io/blog/minecraft-server-status-java-bedrock · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt
