---
title: Game servers
description: Monitor CS2, Rust, Minecraft, FiveM, DayZ, Valheim and other game servers over their own status query — players, map, version, latency, packet loss and jitter from every location, confirmed before anyone is alerted.
canonical: https://watchfor.io/docs/monitors/game
---

# Game servers

Monitor CS2, Rust, Minecraft, FiveM, DayZ, Valheim and other game servers over their own status query — players, map, version, latency, packet loss and jitter from every location, confirmed before anyone is alerted.

A **game server monitor** asks your server the same question its game's
server browser asks, and reads the answer: is it online, how many players
are on, which map, which version, and how long the reply took. A host panel
that says "running" or a port that accepts packets doesn't prove that; a
server that answers its status query does.

**Target:** the server's **query port**, `host:port` — e.g.
`play.example.com:27015`. For IPv6 use `[2001:db8::1]:27015`. The query port
is often not the port players join on; the game picker fills in the usual
one and the [Test button](#find-the-query-port-with-test) checks it.

## Supported games

One monitor type, one preset per game. The preset picks the query protocol
and pre-fills the usual query port; you can change the port.

| Protocol | Games (preset) | Default query port |
| --- | --- | --- |
| Steam server query (A2S, UDP) | Counter-Strike 2, CS:GO, Team Fortress 2, Garry's Mod, Left 4 Dead 2 | 27015 |
| | Rust | 28017 (your `+server.queryport`) |
| | ARK: Survival Evolved | 27015 (game 7777) |
| | DayZ, Arma 3 | 2303 (game port + 1) |
| | Valheim | 2457 (game port + 1) |
| | 7 Days to Die | 26900 (the game port) |
| | Project Zomboid | 16261 |
| | V Rising | 9877 |
| | Enshrouded | 15637 |
| | Conan Exiles, Killing Floor 2, Mordhau, Soulmask | 27015 |
| | Unturned | 27015 (`Port`, the port players connect to) |
| | Space Engineers | 27016 (the server port) |
| | Insurgency: Sandstorm | 27131 |
| | Other Steam game | — (enter it) |
| Minecraft server list ping (TCP) | Minecraft: Java Edition | 25565, or the SRV record |
| Bedrock unconnected ping (UDP) | Minecraft: Bedrock Edition | 19132 (19133 on IPv6) |
| Cfx.re HTTP endpoints (TCP) | FiveM (GTA V), RedM | 30120 |
| SA-MP query (UDP) | SA-MP and open.mp | 7777 (the game port) |
| MTA All-Seeing Eye (UDP) | MTA: San Andreas | 22126 (game port + 123) |

**Other Steam game** covers any game whose servers appear in the Steam
server browser. Games without a public status query — ARK: Survival
Ascended, Palworld, Squad, vanilla Terraria — aren't presets: watch their
port with a [UDP or TCP monitor](/docs/monitors/network) instead.

## What each check reads

| Reading | Notes |
| --- | --- |
| Online | The server answered and the reply parsed. Anything else fails the check. |
| Latency | Round trip of the status query, per location, in milliseconds — what a server browser shows as ping. With **Measure packet loss** on, the median round trip of the check's queries ([why](#latency-and-the-first-query)). |
| Packet loss, jitter | Per check, from a short train of queries — UDP games with **Measure packet loss** on, see [below](#packet-loss-and-jitter). |
| Players / slots | As the server reports them. Rust uses its own `cp`/`mp` tags, the numbers its browser shows. Bots are counted separately on Steam servers. |
| Map, version, game | From the reply. Minecraft has no map: the MOTD is shown instead. |
| Password, VAC | Steam servers (and password on FiveM, SA-MP, MTA). |
| Player list | Names, scores and time played, where the server shares them. |

The monitor page turns these into a server card after Uptime and Incidents
(players out of slots, map, version, latency), a **Ping & packet loss**
section (just **Ping** when packet loss isn't measured) — a
tile per probe location (latency by region, jitter, loss), a strip with Avg,
Min, Max, **Packet loss** (with delivery) and **Jitter** of the locations on
the chart, and a chart with one line per location; click tiles to compare
locations, and with more than eight the chart draws one line per region —
a **busy hours** heatmap of when people play, the maps the server has run, and a
player population chart. On the population chart a violet dashed line marks
a server update (hover it for "Server updated · v1.41.9.7 → v1.41.9.8" and
the time) and small ticks along the bottom mark map changes (hover for
"Map: de_dust2 → de_mirage"); **Update** and **Map change** in its legend
switch them off, and games without a map (Minecraft) get no ticks. With
packet loss measured, the ping chart adds a dashed
loss line on a 0–100 % axis on the right (hover a point for "Packet loss
5.7% avg · peak 40% Querétaro · 33/35 answered" — the peak and where when one
check lost more than the average shows — and the jitter) and a thin amber band
along the top, over a faint amber tint, for each stretch where a single check
from a location lost 20 % or more — the level the Packet Loss alert's warning
judges each check at. Consecutive periods (one quiet period in between still
counts) make one band; hover it for what happened: **Packet loss spike** (one
or two periods) or **Sustained packet loss**, the time span, then each
location's worst check — "Querétaro, Mexico · 40% (2 of 5 packets lost)" for
one location, "2 locations · up to 60%" and the list worst first for several,
"all 8 at 20%" when every location lost about the same. Zoomed in, the figures
cover the part on screen, in whole periods. The red marks for checks nothing
answered stay as they are.

Averages round a single bad check away, so the tiles and the strip add the
**spikes**: a spike is one check that lost at least one packet. A tile reads
"\<0.1% loss · 1 spike (40%)" or "· 3 spikes, up to 60%" (on a phone just
"1 spike"; hover the tile for the worst check, when it ran and from where),
and the strip's **Packet loss** shows "peak 40%" next to the average.

On a latency tile, **loss** is the share of that location's query packets
that got no answer — including checks where nothing answered, since an
outage seen from one place is what players there feel (the strip's Packet
loss and the chart's loss line, like the alert, count answered checks only) — and **jitter** the swing in
round trip between consecutive packets within a check, leaving out the first. Checks that measure
no packet loss (Minecraft Java, FiveM, RedM, monitors with **Measure packet
loss** off, rate-limited and older checks) count as one packet each, and with
no packet-loss check in the range jitter falls back to the spread of latency
across checks. Without the setting, the strip says packet loss isn't
measured and points to Settings.

### Player names

Counts always come from the status reply. Names are read only for the check
details, from a sample taken about every 10 minutes per location, and shown
with the time they were taken. They never appear on status pages, in
incidents or in notifications. Many servers hide them on purpose
(`host_players_show` on CS2, Minecraft servers that replace the sample,
Bedrock never sends them, FiveM behind a proxy that blocks `players.json`) — the counts
stay exact either way. Turn **Read the player list** off in Settings if you
don't want them read at all.

## Packet loss and jitter

On the UDP protocols — Steam (A2S), Minecraft Bedrock, SA-MP / open.mp and
MTA — **Measure packet loss** (Settings → Advanced options) makes every check
send a short **train of queries**, 5 by default, and match the replies to
them. It is on for new game monitors — from the dashboard, the API, MCP or an
import — unless the API call sends `packetLoss: false`; monitors created
before it existed keep sending one status query per check until you switch
it on. With it on, each check gives, per location:

| Reading | Meaning |
| --- | --- |
| **Packet loss** | Unanswered ÷ sent, in percent — what players feel as rubber-banding and timeouts. |
| **Latency** | The median round trip of the answered queries. |
| **Round trip** | Min, average and max over the answered queries, the first one included. |
| **Jitter** | The mean absolute difference between the round trips of consecutive answered queries, leaving out the first answered one: how much the delay swings from one packet to the next (the RFC 3550 §6.4.1 idea, as a plain mean over one check). Needs at least three answers. A steady 80 ms plays fine; 40 ms jumping to 120 ms feels like lag spikes. |

### Latency and the first query

Some servers answer the first query of every check much slower than the
ones right after it — 450 ms, then a steady 120 ms, on every check. Each
check is a new client to the server, or to the DDoS filter in front of it,
and the first packet pays for the cold path. Players on an open connection
don't feel that. So with **Measure packet loss** on, latency is the median
of the check's round trips, and jitter starts at the second answer: one slow
first query moves neither. The slow first query still counts in the
**Round trip** max and in the loss, and when it is more than twice the
median the check details say so. On a Steam server the challenge round
trip is never counted: the round trip is timed from the query that carries
the challenge. With the setting off, latency is the round trip of the one
status query, as before.

What the train sends, per protocol:

| Protocol | Packets per check | Matching |
| --- | --- | --- |
| Steam (A2S) | The full `A2S_INFO` query (with its challenge), then the same query again, reusing the challenge | In send order |
| Minecraft Bedrock | Unconnected pings | Exact — the reply echoes each ping's time field |
| SA-MP / open.mp | The `i` info query, then `p` pings with 4 random bytes | Exact for the pings — the reply echoes the bytes |
| MTA | All-Seeing Eye `s` queries | In send order |
| Minecraft Java, FiveM, RedM | — | TCP / HTTP: no train, no loss or jitter |

Replies matched "in send order" pick the pairing with the steadiest round
trip, which is exact while the round trip moves by less than half the gap
between packets.

- **Settings.** With packet loss on: **Packets per check** (3–10, default 5)
  and **Spacing (ms)** (100–500, default 150). Whatever spacing you set,
  Steam (A2S) servers are queried at least 220 ms apart, because Valve's
  server query allows an optional limit of one query per client per 200 ms;
  a 100 ms setting still means 220 ms on a Steam server.
- **When a query counts as lost.** No reply within the larger of 500 ms and
  4 × the check's median round trip + 250 ms, never past the check's timeout.
- **Online and offline don't change.** A server is online when at least one
  query is answered, so with packet loss on a single lost packet no longer
  fails a check. When nothing answers, the server is offline and **Game
  Server Offline** alerts — total loss is that rule, not the packet-loss
  rule, and it shows as a failed check rather than 100 % loss.
- **What the loss figures average.** Loss on the Overview, the charts and
  the alert is taken over checks that got an answer and weren't
  rate-limited; failed checks show separately as "N checks failed".
- **Check time.** The train adds about (packets − 1) × spacing: 0.6 s with
  the defaults, about 0.9 s on Steam servers. Checks stay inside their
  timeout, and the latency chart shows each check's median round trip.
- **Rate limits are not loss.** Some servers answer only the first few
  queries of a burst (Steam query limits, DDoS filters in front of game
  hosts). When replies stop after the same first packets on two checks in a
  row from the same location, with at least two unanswered after them, the
  check is marked **rate-limited** and left out of the loss figures. Lower
  **Packets per check** or widen the spacing if your host limits queries.
- **Gentle on busy hosts.** Each probe location sends at most 50 packets per
  second to one destination address, across all monitors. When a check
  would go over that, it sends a single query for that run: online or
  offline as usual, but no loss or jitter for it. One organization can have
  at most 20 UDP and game monitors on the same `host:port`.

## Find the query port with Test

Next to the target, **Test** sends one status query from the nearest
location, through the same settings the scheduled check uses. When nothing
answers, it tries the game's other usual query ports (up to four) and offers
**Use query port N** for each one that replied, with the server's name and
the port it says players join on. When that join port is the one you typed,
Test says so — "28015 is the port players join, not the query port" — and
marks the server as the same one; a server reporting another join port is
flagged as possibly a different server on the same IP. Where the port lives,
per game:

- **Rust** — `+server.queryport` on the launch line. Hosts use 28015–28018
  or their own numbers.
- **DayZ** — usually the game port + 1; some servers set `steamQueryPort` in
  `serverDZ.cfg` (often 27016).
- **ARK: Survival Evolved** — `QueryPort` (27015); hosted servers often use
  the game port + 1.
- **Valheim** — the game port + 1, and only when the server starts with
  `-public 1`.
- **Minecraft Java** — leave the port empty to follow the
  `_minecraft._tcp` SRV record, like the game client.
- **MTA** — the game port + 123, and only with `ase=1` in `mtaserver.conf`.
- **FiveM / RedM** — the server port (30120); the status is read over HTTP.

## Alerts

| Rule | Default |
| --- | --- |
| **Game Server Offline** | On, critical, can't be removed. Fires when the server stops answering status queries — confirmed from several locations first. |
| **High Game Server Latency** | Off. Warning above 150 ms, critical above 300 ms. |
| **Game Server Packet Loss** | Off. Warning at 20 % or more, critical at 60 % or more, each after 3 checks in a row (rules created before 19 November 2026 keep critical after 2). UDP games with **Measure packet loss** on. |
| **High Game Server Jitter** | Off. Warning above 30 ms for 3 checks in a row. UDP games with **Measure packet loss** on. |
| **Game Server Empty** | Off. Nobody playing (for servers that should always have someone on). |
| **Game Server Full** | Off. Every slot taken. |
| **Game Server Password-Protected** | Off. A public server that started asking for a password. |
| **VAC Disabled** | Off. Only games that use Valve Anti-Cheat (CS2, TF2, Rust, DayZ…) — 7 Days to Die, Valheim and other Steam games without VAC always report it off. |

A rule on the same readings with your own threshold is worded by that
threshold: a fill rule at 90 % reads "player slots in use reached 90 %", not
"full", and a password rule that alerts when a private server stops asking
for its password says so.

A single lost UDP packet or one blocked network path is not an outage: with
packet loss on, a check with any answered query is online; a failed check is
re-checked from your other locations, and the incident opens
only once it is [confirmed](/docs/core-concepts#confirmation). The notification says what
the server last reported (players, map, version) and, for Steam and FiveM
servers, carries a join link to the [`/connect` page](#join-links) — Discord
and email don't open `steam://` links directly. Recovery messages read
"Back online", with the players and map on return.

### Alerts by region

Latency depends on where it is measured from. A server in Frankfurt answers a
European location in 20 ms and a location in Oregon in 160 ms — that is the
distance, not lag; a long path can also drop the odd packet the short one
never does. The **latency**, **packet loss** and **jitter** rules therefore
work by **region**:

- **Regions apply to latency, packet loss and jitter only.** **Game Server
  Offline** is always judged from every region — a server that doesn't
  answer is a problem wherever you look from — and so are the players,
  password and VAC rules. Those cards have no region settings.
- **All regions** (the default) judges every check, wherever it ran, and
  confirms a failure from any of your locations — as before.
- Give a region its own latency threshold (Europe, North America, South
  America, Asia, Middle East, Africa or Oceania), and that threshold is
  judged only from checks made there. A check from anywhere else is ignored
  by it: it doesn't count towards the confirmation and doesn't reset it, so
  "3 in a row" means 3 checks from that region in a row. Recovery counts the
  same checks.
- **Confirmation happens where the rule looks**: a region rule's extra
  confirmation re-checks run only from your locations in its regions —
  rotating across them, or repeat checks when there is just one — while the
  monitor's regular checks keep running from every location as usual.
- The **latency card** has thresholds by region. It starts with one warning
  and one critical value for all regions and a quiet "Now: Europe ~18 ms ·
  North America ~94 ms · Asia ~212 ms" line under the sliders, and a notice
  when one region is over the threshold while the others aren't (that
  region alone won't alert while all regions are judged together).
- **Suggest from data** fills the latency thresholds in from your own
  checks — each region's usual ping (its 7-day p95) plus headroom, own
  values for regions far from the rest — as an unsaved edit with **Undo**
  ([how it works](/docs/alerting#suggest-from-data)).
  **Different thresholds by region** turns it into a table: the All regions
  default, then each region you check from — inheriting the default until
  you type its own value — with an alerts switch per region (off = still
  monitored and charted, never alerted) and switches for the warning and
  critical columns. Under each region: its latency now and the 24 h p95.
  In the table **each region is judged on its own** — an incident in Africa
  is confirmed by your African checks only. **Use one threshold for all
  regions** goes back to the sliders, where all checks are judged together.
- The **packet loss card** works the same way, in percent: "Now: Europe
  ~0 % · Africa ~20 %", the notice, the table and **Suggest from data**.
  Its thresholds go from one lost packet's worth (20 % with 5 packets per
  check) to all but one lost — loss moves a packet at a time — and it
  needs **Measure packet loss** on ([details](/docs/alerting#the-packet-loss-card)).
- A location added in a **new region** starts with that region's alerts
  **off** when the card already has region settings (tagged **New**,
  with **Turn on**); without region settings it simply uses the defaults.
- Region settings stay as you set them when you change the monitor's
  locations. Regions you don't check from have no rows: one line under the
  table names them, with **Add a location**.

While a check is being confirmed, the **Confirming** chip says which rule and
where, e.g. "High Game Server Latency (critical, Europe) · 164 ms from
Frankfurt (Europe) · 2 of 3 · confirmed from Frankfurt, Vilnius"; the
incident names the region: "High Game Server Latency (Europe)". The full
explanation and a worked example for a CS2 server are in
[Alert rules by region](/docs/alerting#alert-rules-by-region); over the API
it is the rule's [`regions`](/docs/api/alert-rules#region-scoped-rules) field.

Alerts reach Discord through a channel webhook — nothing to invite or
authorise. See [Discord](/docs/notifications/discord) and the other
[notification channels](/docs/notifications).

## Status pages

Add the monitor to a [status page](/docs/status-pages) component and pick
what visitors see:

- **Status only** — online or offline, as for any other monitor.
- **Players and map** — players out of slots, the map and the game from the
  latest check, and when the server is usually busiest, in the visitor's own
  time zone.
- **Players, map and join** — the same plus **Connect** (Steam, FiveM, RedM)
  or **Copy address** (Minecraft, SA-MP, MTA). This publishes the server
  address.

Status pages never show player names, error texts, probe locations or the
query port (unless it is also the join port).

## Join links

`https://watchfor.io/connect?client=steam&host=<host>&port=<port>` opens a
small page with an **Open in Steam** button (`client=fivem` for FiveM and
RedM; no `client` for an address to copy). The page validates the address,
never redirects on its own and is not indexed. The join port is the one you
set in **Game port**, otherwise the one the server reports, otherwise the
game's default.

## Troubleshooting

- **Offline everywhere, but players can join.** Usually the wrong query
  port — run **Test**. Then the server's firewall or DDoS filter: some
  hosting firewalls (OVH's game firewall among them) drop status queries
  from data-centre addresses. Allow the
  [WatchFor probe addresses](/ip-ranges).
- **Offline from one location only.** A path problem from that region; the
  incident only opens if more locations agree.
- **Valheim never answers.** Start the server with `-public 1`.
- **MTA never answers.** Set `ase=1` in `mtaserver.conf` and query the game
  port + 123.
- **FiveM shows "Player count hidden".** Something in front of the server
  blocks `dynamic.json` / `players.json`; online and version still work.
- **FiveM "refused the status query".** With `sv_requestParanoia` 2 or higher
  the server answers "Nope." on `info.json`, `dynamic.json` and
  `players.json`. The server is up; lower the setting to 0 or 1 to monitor it.
- **Packet loss on most checks, yet players are fine.** Something in front
  of the server may drop queries that arrive close together without a clean
  cut-off the rate-limit detection can recognise. Widen the spacing or lower
  **Packets per check** under Settings → Advanced options.
- **Bedrock over IPv6.** Bedrock servers listen on 19133 for IPv6.
- **Player count above the slots.** Some servers report more players than
  slots (queues, proxies); the number is shown as the server sends it.

## Plans

Game servers are included from the **Starter** plan; the Free plan doesn't
include them (the Game server tile shows an Upgrade button there). On Starter,
Pro and Business game servers have no separate cap — each one counts toward
the plan's monitor total. The shortest check interval for a game server is
**1 minute on every plan**, Business and Enterprise included. Locations follow the
plan, as for every monitor: Starter checks from two regions, Pro from three and
Business from all seven (20 locations in total). Checking every location at once (the parallel
strategy) starts on Pro. See [Locations](/docs/monitors/scheduling#locations).

## API

`type: "game"` in the [REST API](/docs/api/monitors), the MCP server and the
SDKs. Config keys and alert metrics are listed in the
[monitor types reference](/docs/api/monitor-types#game-server).

---

Canonical page: https://watchfor.io/docs/monitors/game · All docs: https://watchfor.io/docs · Site guide: https://watchfor.io/llms.txt
