---
title: Rust query port vs game port, wipe day, and tracking your server's population
description: A Rust server has at least three ports, and status tools need the one players never see: +server.queryport. Here's how to find it, why a server's player count differs between tools, what the cp, mp, qp and born tags in the Steam query mean, how forced wipes work, and how to monitor a Rust server without getting paged every wipe day.
canonical: https://watchfor.io/blog/rust-query-port-and-wipe-day
---

# Rust query port vs game port, wipe day, and tracking your server's population

2026-11-16 · WatchFor Team · Game servers · game-servers, rust, maintenance

A Rust server has at least three ports, and status tools need the one players never see: +server.queryport. Here's how to find it, why a server's player count differs between tools, what the cp, mp, qp and born tags in the Steam query mean, how forced wipes work, and how to monitor a Rust server without getting paged every wipe day.

Every Rust server owner eventually has this conversation. *"Your server is
offline on BattleMetrics."* It isn't: you're on it, sixty other people are on
it. Then someone posts a screenshot of a status bot showing 0 players, and
another of a tracker showing 160 when the in-game browser says 139.

All of these come from the same place, the **Steam server query**, asked on
different ports and read in different ways. This guide covers which port
that is, what the reply contains, how wipes change the picture, and how to
monitor a Rust server so the alerts you get are the ones that matter.

## Three ports, one of them invisible

A typical Rust launch line, following
[Facepunch's server guide](https://wiki.facepunch.com/rust/Creating-a-server):

```bash
./RustDedicated -batchmode \
  +server.port 28015 \
  +server.queryport 28017 \
  +rcon.port 28016 +rcon.web 1 \
  +app.port 28082 \
  +server.identity "main" +server.level "Procedural Map"
```

| Port | Protocol | Who uses it |
| --- | --- | --- |
| `server.port` (28015) | UDP | Players. This is what `client.connect` and the browser's Join use. |
| `server.queryport` | UDP | The Steam server browser, trackers and monitors. Answers the A2S query. |
| `rcon.port` (often 28016) | TCP | WebRCON admin tools (with `+rcon.web 1`). |
| `app.port` | TCP | The Rust+ companion app. |

The query port is the one that causes trouble, for two reasons.

**Its default isn't what people think.** Facepunch added a separate query
port in February 2023. The current wiki describes the default as one more
than the larger of `server.port` and `rcon.port`, so on the common
28015/28016 setup it lands on **28017**, not 28016. Older guides say
`server.port + 1`. Hosts pick yet other numbers: we have seen query ports of
28010, 28015 and 28018 on servers whose game port is 28015. Don't trust any
default; set it explicitly and write it down.

**Nobody types it.** Players see the game port. Your host panel shows the
game port. So when you paste the "server address" into a status tool, you
give it the one port that never answers a query, and the tool truthfully
reports silence.

### Finding your query port from the outside

Steam knows which query port your server registered. Its public API lists
every game server at an IP, with the query address in `addr` and the game
port in `gameport`:

```bash
curl -s "https://api.steampowered.com/ISteamApps/GetServersAtAddress/v1/?addr=203.0.113.10" | jq '.response.servers[] | {addr, gameport, appid}'
# { "addr": "203.0.113.10:28018", "gameport": 28015, "appid": 252490 }
```

`appid` 252490 is Rust. If your server isn't in that list, it isn't
registered with Steam and won't appear in the browser either: check the
launch line, the firewall for UDP on the query port, and the server log.

## What the Steam query says about a Rust server

Ask the query port directly, for example with the
[python-a2s](https://github.com/Yepoleb/python-a2s) library:

```python
import a2s
info = a2s.info(("203.0.113.10", 28018), timeout=5)
print(info.server_name, info.map_name, info.player_count, info.max_players)
print(info.keywords)
```

Here is what a large EU server answered while we wrote this (name left
out):

```text
map: Custom Map   players byte: 160   max: 175   version: 2636
keywords: mp175,cp139,ptrak,qp0,$ruk1,v2636,^w,^v,EU,^t,born1794495552,gmrust,cs170545,ts16,rustmaps
```

The keywords carry the numbers that matter. Facepunch documents the
[browser tags](https://wiki.facepunch.com/rust/server-browser-tags) you set
(wipe cadence, region, difficulty); the others are written by the game and
read by every tracker:

| Tag | Meaning | In the example |
| --- | --- | --- |
| `cp` | Current players, the number the Rust browser shows | 139 |
| `mp` | Max players | 175 |
| `qp` | Players in the queue | 0 |
| `born` | Time of the last wipe, as a Unix timestamp | 1794495552 = Thursday, November 12, 2026, 14:59 UTC |
| `gm` | Game mode (`gmrust`, `gmvanilla`…) | rust |
| `v` | Protocol / build | 2636 |
| `EU`, `NA`… | Region tag | EU |

Notice that the player **byte** said 160 and the `cp` tag said 139. On
another server we checked, the byte said 10 and `cp` said 68, while the
player list held 255 entries, many with empty names. The byte is a single
unsigned byte, so it can't go above 255, and servers fill it in different
ways. **`cp` is the number Rust's own browser displays**, so it's the one
to chart. That is the whole reason two trackers disagree about your
population.

`born` is useful too. It tells you, from outside, when the server last
wiped, and it changes exactly once per wipe.

## Wipe day is downtime you planned

Rust is built around wipes. Three kinds affect your uptime:

- **Forced wipes.** On the first Thursday of every month Facepunch ships the
  monthly update, and every server must update and start a fresh map. It
  lands at around **19:00 UK time (2 PM US Eastern)**, which is 19:00 UTC in
  winter and 18:00 UTC in summer, and can slip. The next one is
  **Thursday, December 3, 2026**. Blueprints are wiped only when Facepunch
  announces it.
- **Your own wipes.** Weekly, biweekly or monthly map wipes on your
  schedule, usually announced in your server's tags (`weekly`, `biweekly`).
- **Daily restarts.** Many servers restart once a day to clear memory.

For an outside observer, all three look the same: the query port stops
answering, then comes back with a different `born` or version. For a
monitor that alerts on "stopped answering", that means a page every wipe,
which is exactly how people learn to ignore alerts.

The fix is to tell the monitor what you planned:

1. Create a **recurring maintenance window** for the forced wipe: first
   Thursday of the month, from a little before 19:00 UK time to well after,
   generous enough for a slow update download.
2. Add your own wipe schedule and daily restart as their own windows.
3. Keep checks running during windows. The history then shows exactly how
   long the wipe took, which is worth knowing when you wonder why players
   went to another server.

Outside those windows, a server that stops answering is a real incident.

## Watching population, not just uptime

Uptime tells you the server was reachable. Population tells you whether it
was worth reaching. Charting `cp` on every check gives you:

- **The wipe curve.** The spike on wipe day and how fast it decays. A server
  that's empty by Sunday has a different problem from one that's down.
- **Busy hours.** Average and peak players by weekday and hour, which is
  when restarts hurt most and admins should be online.
- **Queue pressure.** `qp` above zero during peak means your slots, not your
  uptime, are the limit.

## Monitoring a Rust server with WatchFor

A WatchFor **Game server** monitor with the **Rust** preset queries your
`+server.queryport` over UDP from the regions you choose. Each check reads
the population **from the `cp` and `mp` tags**, the numbers Rust's browser
shows, and notes the raw byte when the two disagree. It also stores the map,
build, VAC and password state, and the latency from each location.

![WatchFor game server monitor for a Rust server: population out of 100 slots, the custom map, the build number and the latency, above the population chart.](/marketing/game/rust.webp)

When you add the monitor, the **Test** button asks the address once; if
that port stays silent, it tries the query ports Rust servers commonly use
and offers the one that answered. The game port the server announces is
used for the **Join** button.

- **Wipes stay quiet.** Recurring [maintenance windows](/docs/monitors/maintenance)
  cover the forced wipe and your own schedule.
- **Real outages are confirmed.** A failed check is repeated before an
  incident opens, from the monitor's other locations when it has several
  (how many depends on your plan), so one lost UDP packet doesn't page you.
- **Alerts in Discord without a bot**, through a channel webhook: offline
  with the last population, back online with how long it was down.
- **History built in.** The population chart, the 24-hour peak and the
  busy-hours heatmap come with every monitor.
- **A status page** for your community with a **Connect** button that opens
  Rust (through Steam) straight into the server.

No RCON password is involved; your WebRCON stays yours. Game server
monitoring is part of the paid plans from Starter, counted toward the plan's
normal monitor total. See [pricing](/pricing), and the
[Rust page](/game-server-monitoring/rust) for the port table.

## Quick reference

- Status tools need `+server.queryport`, not 28015. Set it explicitly.
- `GetServersAtAddress` shows the query port Steam registered.
- Chart `cp`, not the player byte or the length of the player list.
- `born` is the last wipe time; it changes once per wipe.
- Forced wipe: first Thursday, around 19:00 UK time. Put it in a maintenance
  window.

## Frequently asked questions

### What is the Rust query port?

It is the UDP port the server answers Steam server queries on, set with `+server.queryport`. It must differ from `+server.port` (28015 by default). Facepunch's wiki says that, when unset, it is one more than the larger of the game and RCON ports, which gives 28017 on the common 28015/28016 setup. Hosts often pick their own number, so check your launch line or panel.

### Why do Rust population trackers show different player counts?

The Steam query reply has a one-byte player field, and some servers report a different number there than in their own tags. Rust's server browser reads the `cp` (current players) and `mp` (max players) tags in the query's keywords. A tool that reads the byte, or counts names in the player list, can show a different number.

### When is the Rust forced wipe?

On the first Thursday of each month, when Facepunch ships the monthly update, at around 19:00 UK time (2 PM US Eastern). Every server's map is wiped then; blueprints only when Facepunch announces a blueprint wipe. The time is approximate and the update can be late.

### Do I need to give a monitoring tool my RCON password?

No. Population, map, version and uptime all come from the public Steam query that the Rust server browser uses. Keep WebRCON for your own admin tools, and keep its port closed to the world where you can.

### How do I stop downtime alerts on wipe day?

Add a recurring maintenance window for your wipe schedule, for example every first Thursday from 18:45 to 20:30 UK time, plus your own weekly or biweekly wipes. Checks keep running and the history stays honest, but nobody gets paged for a planned restart.

---

Canonical page: https://watchfor.io/blog/rust-query-port-and-wipe-day · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt
