---
title: CS2 community server not showing up? Check GSLT, the A2S query and host_players_show
description: Your CS2 server runs, you can connect by IP, and it still isn't in the community server browser, or it shows up with no players listed. Almost every case comes down to one of four things: the login token, the UDP port, the Steam query, or a cvar. Here's how to check each from the outside, how A2S works since the 2020 challenge change, and how to watch the server once it's listed.
canonical: https://watchfor.io/blog/cs2-community-server-not-showing-up
---

# CS2 community server not showing up? Check GSLT, the A2S query and host_players_show

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

Your CS2 server runs, you can connect by IP, and it still isn't in the community server browser, or it shows up with no players listed. Almost every case comes down to one of four things: the login token, the UDP port, the Steam query, or a cvar. Here's how to check each from the outside, how A2S works since the 2020 challenge change, and how to watch the server once it's listed.

You started the server, you can join it with `connect` in the console, your
friends can join it by IP. Then someone searches the community server
browser for it and it isn't there. Or it's there, with 14 players, and the
player list in the browser is empty.

CS2 community servers fail to appear for a small set of reasons, and every
one of them can be checked from outside the machine. This guide walks
through them in the order they usually turn out to be the problem, shows how
to ask the server what the browser asks, and ends with how to keep watching
it once it's listed.

## How a CS2 server gets into the browser

Two separate things have to work:

1. **Steam has to know the server exists.** On start, the server logs in to
   Steam with its token and registers its address. The browser's list comes
   from Steam, not from scanning the internet.
2. **The server has to answer the Steam server query.** For every entry in
   the list, the browser sends an `A2S_INFO` packet to the server's address
   and port over UDP, and draws the row from the reply: name, map, players,
   ping. No reply, no row (or a row that never fills in).

The first is a registration problem, the second a network problem, and they
have different fixes. So the first job is to find out which one you have.

## Step 1: does Steam know about it?

Steam has a public, keyless API that lists every game server registered at
an IP address:

```bash
curl -s "https://api.steampowered.com/ISteamApps/GetServersAtAddress/v1/?addr=203.0.113.10" | jq
```

```json
{
  "response": {
    "success": true,
    "servers": [
      { "addr": "203.0.113.10:27015", "appid": 730, "gamedir": "csgo",
        "secure": true, "lan": false, "gameport": 27015, "specport": 0 }
    ]
  }
}
```

What to read:

- **Your server is missing.** Steam doesn't have it. Look at the token and
  `sv_lan` (below), then the server log for the Steam login.
- **`appid` is 730.** CS2 servers register under the game's own app ID; the
  dedicated server is installed from the same app with SteamCMD
  (`app_update 730`), as Valve's
  [CS2 dedicated server page](https://developer.valvesoftware.com/wiki/Counter-Strike_2/Dedicated_Servers)
  describes.
- **`secure: false`.** VAC is off, usually because the server was started with
  `-insecure`. Many players filter those out.
- **`lan: true`.** The server thinks it's a LAN server and won't be listed.
- **`addr` port differs from what you expected.** The registered port is the
  one to query and to give players.

If the server is listed here but not in the browser, Steam knows about it
and the problem is either the query (step 3) or the browser's filters
(region, "has players", "not full", map, password, and the tags you set with
`sv_tags`).

## Step 2: the token and the LAN flag

Since CS:GO, a server that others can find needs a **Game Server Login
Token**. Create one for **app ID 730** at
[steamcommunity.com/dev/managegameservers](https://steamcommunity.com/dev/managegameservers)
and pass it at launch:

```bash
./cs2 -dedicated -port 27015 +map de_mirage +sv_setsteamaccount ABCDEF0123456789 +sv_lan 0
```

Things that go wrong with tokens:

- **No token, or a typo.** The server starts and you can connect locally,
  but it never registers publicly. The log says so near the top.
- **One token on two servers.** Each instance needs its own token; the
  second login kicks the first.
- **A banned or expired account.** Tokens belong to a Steam account in good
  standing. If the account loses that standing, its tokens stop working.
- **`sv_lan 1`.** Left over from local testing, it keeps the server off the
  public list no matter what the token says.

## Step 3: does it answer the query?

Now ask the server directly what the browser asks. The Python
[python-a2s](https://github.com/Yepoleb/python-a2s) library speaks the
Steam query, including the challenge step:

```bash
pip install python-a2s
python3 - <<'EOF'
import a2s
addr = ("203.0.113.10", 27015)
i = a2s.info(addr, timeout=5)
print(i.server_name, i.map_name, f"{i.player_count}/{i.max_players}",
      "bots", i.bot_count, "VAC", i.vac_enabled, "v", i.version)
print("names:", [p.name for p in a2s.players(addr, timeout=5)][:5])
EOF
```

Against a busy public bhop server while writing this, that printed the
server's name, the map, `23/64`, `bots 1`, `VAC True`, version `1.41.9.7`
and five player names, in about 40 ms. Against your own server, the result
tells you where to look:

| What you get | What it means |
| --- | --- |
| A reply with name, map and players | The query works. If the browser still doesn't show it, it's registration or a browser filter. |
| A timeout | Nothing answered on that UDP port from where you are: the server's firewall, your host's firewall, a DDoS filter, or the wrong port. |
| A reply, but player names are empty or missing | Normal. See `host_players_show` below. |
| A reply only after a second packet | Also normal: that's the challenge (next section). |

Test from **outside** the machine and outside its network. A query from the
server itself, or from the same data centre, can succeed while the rest of
the internet is blocked.

### The A2S challenge, and why old tools time out

The Steam query used to be one packet out, one reply back. Because the reply
is much larger than the request, that made game servers useful for
reflection attacks, so in December 2020 Valve added a **challenge**: the
server may answer the first `A2S_INFO` with a short `0x41` packet holding
four challenge bytes, and the client must send the request again with those
bytes appended. Valve's
[server query documentation](https://developer.valvesoftware.com/wiki/Server_queries)
describes the exchange.

Every CS2 server we queried while building our probe asked for the
challenge. A tool written before 2020 sends one packet, reads the `0x41`,
doesn't understand it, and reports the server as broken or silent. If an
old script or bot says your server is down while the browser shows it,
suspect the tool first.

## Step 4: players are there, the list is empty

This one isn't an outage, but it generates more "your server is broken"
reports than anything else. CS2 answers the player list query according to
`host_players_show`:

| Value | The player query returns |
| --- | --- |
| `0` | Nothing |
| `1` | Only max players and uptime, no names |
| `2` | The full list: names, scores, time played |

Community and host documentation give 1 as the default, carried over from
CS:GO, which is why names are blank on many servers. Set it in your
`server.cfg` if you want browsers and tools to show who's on:

```text
host_players_show 2
```

The **count** comes from the server info, not from the list, so it's exact
whatever the setting. A tool that counts names to get the number of players
will report an empty server; that's a bug in the tool.

## Step 5: is it the port?

CS2 uses **one UDP port** for both game traffic and the query, 27015 by
default, set with `-port`. That makes CS2 easier than games with a separate
query port, but it also means:

- A firewall rule for **TCP** 27015 does nothing. It has to be UDP.
- A second server on the same machine needs its own port (27016, 27017…),
  its own token and its own firewall rule.
- SourceTV listens on its own port, `tv_port`, 27020 by default. Opening it
  isn't needed for the server to be listed.

If the query times out from outside but works from the machine, the port is
closed somewhere between the two. If it times out from everywhere you try,
including the machine, the server isn't running, isn't bound to that
address, or isn't on that port.

### When a DDoS filter is the reason

Many game hosts sit behind filters that only let through traffic that looks
like a player. Some of them drop or answer status queries from data-centre
ranges differently from home connections. Symptom: your friends see the
server, every outside tool and monitor says it's down. The fix is in the
filter: allow the query from the addresses that need it.

## Keeping it listed: watch it from the outside

Once the server is in the browser, the questions change: is it still there
at 3 a.m., did the last Valve update leave it a version behind, is it fast
for players in another region? The checks above answer that once. A monitor
answers it every minute.

A WatchFor **Game server** monitor with the Counter-Strike 2 preset asks the
same `A2S_INFO` question as the browser, challenge included, on 27015 or
your `-port`. Each check records the name, map, players out of slots with
bots counted apart, VAC, password and version, and the latency from each
location the monitor checks from.

![WatchFor game server monitor for a CS2 bhop server: players online out of 64 slots with one bot, the current map, VAC, the latency and a Connect button, above the population chart.](/marketing/game/cs2.webp)

What that gives a server owner:

- **"Offline" means 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). One lost UDP packet doesn't page you.
- **Alerts where your community lives.** The offline alert goes to a Discord
  channel through a webhook, with no bot to invite. It names the server, the
  map and the last player count, and carries a Join link. Slack, Telegram,
  Teams and email work the same way.
- **Opt-in rules for the quiet failures**: VAC switched off, a password that
  appeared, a server that's full or empty, latency above a threshold.
- **History.** A population chart, a busy-hours heatmap and the maps the
  server ran, so a map that empties the server is easy to spot.
- **A status page** with a **Connect** button that opens CS2 straight into
  the server.

It never asks for RCON and can't change anything on the server; it only
watches. Game server monitoring is part of the paid plans from Starter,
counted toward the plan's normal monitor total; see [pricing](/pricing). The
[CS2 page](/game-server-monitoring/cs2) covers ports and the details the
monitor reads.

## The short version

1. `GetServersAtAddress` on your IP: is it registered with Steam?
2. Token for app 730, one per instance, `sv_lan 0`.
3. Query it from outside with an A2S tool that handles the challenge.
4. Names missing? `host_players_show 2`. Counts are fine either way.
5. UDP, not TCP, on the `-port` you started with.

## Frequently asked questions

### Why is my CS2 server not showing in the community server browser?

Check, in order: that it runs with a Game Server Login Token (`+sv_setsteamaccount`, created for app 730), that `sv_lan` is 0, that UDP 27015 (or your `-port`) is open from the internet, and that Steam has it registered. Steam's `GetServersAtAddress` API lists what Steam knows about your IP, which separates a registration problem from a filter in the browser.

### What port does a CS2 server use?

UDP 27015 by default, set with `-port`. Game traffic and the Steam server query share that one port. SourceTV uses its own port, 27020 by default (`tv_port`). Extra servers on the same machine usually count up: 27016, 27017 and so on.

### What does host_players_show do?

It controls what the server returns to a player query. 0 answers nothing, 1 returns only the max players and uptime, 2 returns the full list with names, scores and time played. The player count in the server info is exact either way; only the list depends on it.

### Does a CS2 server need a GSLT?

Yes, for other people to find and join it. Create a Game Server Login Token for app ID 730 at steamcommunity.com/dev/managegameservers and pass it with `+sv_setsteamaccount <token>`. Use one token per server instance.

### Can I monitor a CS2 server without RCON?

Yes. The Steam server query (A2S) is public: every server browser uses it. It returns the name, map, players, bots, VAC and version without any password. RCON is only needed to change things, never to watch them.

---

Canonical page: https://watchfor.io/blog/cs2-community-server-not-showing-up · All articles: https://watchfor.io/blog/all.md · Site guide: https://watchfor.io/llms.txt
