Server Browser Curation Reference

Intermediate40-60 minutesWindowsUnturned ServerNotepad++

The server browser curation system is a rule-based filtering and labeling framework that allows anyone to create and share lists of rules that evaluate every server in the Unturned server browser. A curation list can label servers with custom tags, allow specific servers to appear prominently, or deny servers that match undesirable patterns. The system operates on three data dimensions: server name (evaluated through regular expressions), server IP address and port (evaluated through CIDR notation), and server Steam ID (evaluated through exact match against the game server's unique identifier).

57 Studios has documented and validated the full curation system configuration surface across the Unturned modding community. This article covers every property in the curation rule system, the label definition format, the three rule types and their action behavior, the regex system for server name matching, the CIDR notation system for IP-based filtering, the Steam ID lookup workflow, worked examples for common curation scenarios, and a complete field reference for all 41 properties documented in the official SDG specification.

Documentation source: This article references the official Smartly Dressed Games modding documentation for field definitions and game behavior. Community-validated notes are marked where the official documentation is silent on a detail.

Who this article is for

This article is written for server network operators, community curators, and power users who want to create curation lists for the Unturned server browser. If you are new to the curation system, read this article in combination with Server Browser Curation Asset Reference which covers the asset packaging workflow for distributing curation lists through the Steam Workshop.

How the curation system works

The curation system is a client-side filtering and labeling engine. When a player enables a curation list, the game evaluates every server in the server browser against the list's rules. Rules are processed from top to bottom. Each rule either allows the server (moves it to the top of the list or applies a label), denies the server (moves it to the bottom of the list or hides it), or applies a label and continues processing.

As shown in the flowchart above, the curation rule engine processes rules sequentially. The Label action applies the label and continues to the next rule. The Allow and Deny actions stop processing after their action is applied. A server that matches no rule remains in its default browser position.

Properties reference

Top-level properties

The curation list itself carries the following top-level properties.

Field	Type	Required	Purpose
`Name`	string	Yes	Display name in the user interface. For example, a server network might display as `MyNetwork Verified Servers`, or someone creating a list of high-quality well-moderated hosts might choose `MyName's Recommendations`.
`IconURL`	string	No	Optional URL of a 32x32 image to display in the user interface. For example, a server network might use the same icon they use in the server browser.
`Labels`	list of dictionaries	Yes	Definitions of the labels that rules can apply. Each label has a `Name` and `Text` property.
`Rules`	list of dictionaries	Yes	The curation rules processed from top to bottom. Each rule has properties defining its action, matching criteria, and label associations.

Labels

Labels are visual tags that curation rules can apply to servers. Each label has two properties.

Field	Type	Purpose
`Name`	string	Internal name used to reference this label from a rule. Not shown to the player.
`Text`	string (rich text)	Rich text displayed in the server browser. Supports Unity rich text tags for color, bold, italic, and size formatting.

Labels are defined in the Labels array at the top level of the curation list. Each label definition creates a visual tag that one or more rules can apply.

Labels
[
    {
        Name Verified
        Text <color=green>MyNetwork Verified</color>
    }
    {
        Name Fake
        Text <color=red>MyNetwork Imposter</color>
    }
]

The label name must be unique within the curation list. The label text can use Unity rich text tags including <color>, <b>, <i>, and <size>.

Rules

Rules are the core of the curation system. Each rule is a dictionary in the Rules array. Rules are processed from top to bottom, and the array order is significant.

Field	Type	Required	Purpose
`Action`	enum	Yes	One of `Label`, `Allow`, `Deny`. `Label` applies the configured label and continues processing. `Allow` and `Deny` stop rule processing after their action. `Deny` blocks the server, either hiding it or moving it to the bottom depending on the player's settings.
`Inverted`	bool	No	If `true`, negates whether this rule matches (binary NOT). Defaults to `false`.
`Description`	string	Yes	Text shown in the rules list user interface and in the tooltip for servers moved to the bottom of the list. Document why the rule exists.
`Label`	string	Conditional	Name of a label to apply. Required when `Action` is `Label`. Optional when `Action` is `Allow` or `Deny` (both can apply a label as well as stop processing).
`Type`	enum	Yes	Determines which server data this rule matches against. One of `Name`, `IPv4`, `ServerID`.

Rule type: Name

The Name type matches against the server's display name using regular expressions. A server name can be matched with one or more regex patterns.

Field	Type	Purpose
`Regex`	string	The rule matches if this regex matches the server name.
`Regexes`	list of strings	The rule matches if any of these regexes match the server name (binary OR).

The regex system supports the full .NET regular expression syntax. Case-insensitive matching can be enabled with the (?i) prefix.

// Match any server with "MyNetwork" in the name (case-insensitive)
Regex (?i)(MyNetwork)

The regex is evaluated against the server name as displayed in the server browser. A quick way to test a regex is to prefix it with regex: in the server browser name filter to search by regex.

Rule type: IPv4

The IPv4 type matches against the server's public IP address using CIDR notation. An IPv4 address can be matched with one or more CIDR addresses.

Field	Type	Purpose
`Filter`	string	The rule matches if this CIDR address matches the server IP.
`Filters`	list of strings	The rule matches if any of these CIDR addresses match the server IP (binary OR).

Each CIDR entry supports the following formats:

Format	Example	Matches
Bare IP	`10.8.0.1`	Any port on this IP address
IP with port	`10.8.0.1:27015`	This specific port on this IP address
IP with port range	`10.8.0.1:27015-27030`	Any port in the range 27015-27030 on this IP
CIDR subnet	`192.168.1.0/24`	Any IP address in the range 192.168.1.0 through 192.168.1.255, any port

Filters
[
    // Matches any port on this IP address
    10.8.0.1
    // Matches port 27015
    10.8.0.1:27015
    // Matches ports 27015 through 27030 (inclusive)
    10.8.0.1:27015-27030
    // Matches any port on IP addresses in the range 192.168.1.0 through 192.168.1.255
    192.168.1.0/24
]

Rule type: ServerID

The ServerID type matches against the server's Steam ID, also referred to as the server code. Each game server has a unique 64-bit Steam ID that is assigned when the server authenticates with the Steam backend.

Field	Type	Purpose
`Value`	uint64	The rule matches if this single Steam ID matches the server's Steam ID.
`Values`	list of uint64	The rule matches if any of these Steam IDs match the server's Steam ID (binary OR).

To obtain a server's Steam ID:

From the server console: use the CopyServerCode command
From the in-game server lobby screen: press PageDown to copy server information to the clipboard

The PageDown clipboard output includes the server name, description, IP address, connection port, query port, Steam ID, and ping in a structured format:

Name: Nelson's PEI Server
Description:
Thumbnail:
Address: 192.168.48.73
Connection Port: 27016
Query Port: 27015
SteamId: 85568392932910946 (k_EAccountTypeGameServer)
Ping: 1ms
0 workshop file(s):

The SteamId value from this output is used in a ServerID rule.

Rule action behavior

The three rule actions produce different effects in the server browser.

Label action

The Label action applies the configured label to the server and continues processing remaining rules. Use Label when a server should be tagged but not moved in the list order. A rule with Action Label must include the Label field with a valid label name from the curation list's Labels array.

Allow action

The Allow action marks the server as allowed and stops rule processing for that curation list. Servers that match an Allow rule are moved to the top of the server browser list relative to servers that did not match any rule. An Allow action can optionally apply a label in addition to allowing.

Deny action

The Deny action marks the server as denied and stops rule processing for that curation list. Servers that match a Deny rule are moved to the bottom of the server browser list or hidden, depending on the player's settings. A Deny action can optionally apply a label in addition to denying.

Label application with Allow and Deny

Both Allow and Deny can apply labels as well as their primary action. The only difference between Action Label on its own and a label applied by Allow or Deny is that Label does not affect whether the server is allowed or denied, while Allow and Deny do.

Worked examples

Example 1: Server network verification list

A server network operates multiple game servers and wants to create a curation list that labels all of their official servers as verified and hides any server that uses their branding without authorization.

Name MyNetwork Verification Example
IconURL https://cdn.example.com/curation/MyNetworkIcon.png

Labels
[
    {
        Name Verified
        Text <color=#708fbd>MyNetwork Official</color>
    }
]

Rules
[
    {
        Action Allow
        Description Verify MyNetwork's Steam IDs
        Label Verified
        Type ServerID
        Values
        [
            85568392932910946
            85568392932910947
        ]
    }
    {
        Action Deny
        Description Hide unverified servers using MyNetwork branding
        Type Name
        Regex (?i)(MyNetwork)
    }
]

In this example, the first rule allows servers with the specified Steam IDs and labels them as official. The second rule catches any server not in the allowlist that uses the MyNetwork name (case-insensitive) and denies it.

Example 2: Geographic region filter

A curator wants to highlight servers in a specific geographic region by IP range.

Name Europe Servers

Labels
[
    {
        Name Europe
        Text <color=blue>Europe</color>
    }
]

Rules
[
    {
        Action Label
        Description Label European servers
        Label Europe
        Type IPv4
        Filters
        [
            78.0.0.0/8
            79.0.0.0/8
            80.0.0.0/8
            81.0.0.0/8
            82.0.0.0/8
            83.0.0.0/8
            84.0.0.0/8
            85.0.0.0/8
            86.0.0.0/8
            87.0.0.0/8
            88.0.0.0/8
            89.0.0.0/8
            90.0.0.0/8
            91.0.0.0/8
            92.0.0.0/8
            93.0.0.0/8
            94.0.0.0/8
            95.0.0.0/8
        ]
    }
]

This curation list labels any server with an IP address in the specified ranges with the Europe label. The Label action continues processing, allowing other curation lists or subsequent rules to also apply.

Example 3: Quality server recommendation list

A community curator maintains a list of servers that the community has voted as high-quality.

Name Community Top Servers

Labels
[
    {
        Name CommunityPick
        Text <color=gold>Community Pick</color>
    }
]

Rules
[
    {
        Action Allow
        Description Community-voted high-quality servers
        Label CommunityPick
        Type ServerID
        Values
        [
            85568392932910946
            85568392932910948
            85568392932910950
        ]
    }
]

This simple curation list allows specific servers by their Steam ID and labels them as community picks.

Regex quick reference for server name matching

Pattern	Matches	Example
`(?i)(text)`	Case-insensitive match for `text`	`(?i)(MyNetwork)` matches `MyNetwork`, `mynetwork`, `MYNETWORK`
`(?i)(text1	text2)`	Case-insensitive match for either text
`^text`	Match at the start of the server name	`^Official` matches names starting with `Official`
`text$`	Match at the end of the server name	`Server$` matches names ending with `Server`
`.text.`	Match anywhere in the name	`.RPG.` matches names containing `RPG`
`text\d+`	Match text followed by one or more digits	`Server\d+` matches `Server1`, `Server42`
`[0-9]{1,3}\.[0-9]{1,3}`	Match IP-like patterns in the server name	Useful for matching servers that include IPs in their names

Frequently asked questions

How can I find the details for someone else's server?

Press the Clipboard Debug hotkey (default PageDown) on the server lobby screen. This copies the server's name, description, thumbnail URL, IP address, connection port, query port, Steam ID, and ping to the clipboard. The Steam ID is the value used in ServerID rules. The IP address is the value used in IPv4 rules. The server name is the value used in Name rules.

How do I create a regular expression for server name matching?

As a starting point, (?i)(your text here) matches the text case-insensitively. It matches Your Text Here or yOuR tExT hErE but not yourtexthere because the spaces in the regex require spaces in the server name. For more advanced regex patterns, online tools such as regex101.com, regexr.com, regex-generator.olafneumann.org, and regextester.com are recommended.

Can a curation list combine all three rule types?

Yes. A single curation list can contain Name, IPv4, and ServerID rules in any combination. The rules are processed in array order, so the order determines which rule takes precedence when a server matches multiple rules. A common pattern is to place ServerID rules first (exact match for known servers), then IPv4 rules (range match for regional filtering), then Name rules (pattern match for branding enforcement).

What happens when a server matches multiple rules in the same list?

If a server matches a rule with Action Allow or Action Deny, processing stops for that list and the server is allowed or denied. If a server matches a rule with Action Label, the label is applied and processing continues to the next rule. A server can accumulate multiple labels from multiple Label rules in the same list before reaching an Allow or Deny rule.

What is the Inverted field used for?

The Inverted field negates the match condition. When Inverted is true, the rule matches if the condition is NOT met. For example, a rule with Inverted true, Type Name, and Regex (?i)(official) matches any server whose name does NOT contain official. This is useful for excluding servers that match a pattern while allowing everything else.

Can I apply a label without affecting the server's position?

Yes. Use Action Label instead of Action Allow or Action Deny. The Label action applies the configured label and continues processing without changing the server's allowed or denied status. The server remains in its default position and can still be allowed or denied by a subsequent rule.

What is the difference between a Denied server in the rules list and a hidden server?

When a server matches a Deny rule, the player's settings determine the visual effect. In the default configuration, denied servers are moved to the bottom of the server browser list but remain visible. The player can change the setting to hide denied servers entirely. This setting applies to all curation lists that the player has enabled.

Can I use rich text formatting in label text?

Yes. The label Text field supports Unity rich text tags. Common tags include <color=green>, <color=red>, <color=#708fbd>, <b> for bold, <i> for italic, and <size=20>. The rich text is rendered in the server browser UI when the label is applied to a server.

How do I test a curation list before distributing it?

Create the curation list as a local file or asset, enable it in the server browser Curation menu, and browse the server list. Verify that labels appear on the correct servers and that denied servers move to the bottom. Iterate on the rules until the behavior matches the intended design, then distribute the curation list through the preferred distribution path.

Can I have a rule that allows servers from multiple CIDR ranges?

Yes. Use the Filters array (plural) instead of the Filter field (singular). Each entry in the Filters array is evaluated independently. If any entry matches the server's IP address, the rule matches. This is a binary OR across all entries.

What port numbers do Unturned servers typically use?

Unturned servers use two ports by default: the query port (default 27015) for server list queries and Steam backend communication, and the connection port (default 27016) for direct client connections. Both ports can be configured in the server's Config.json file. A curation IPv4 rule can target either port or both.

How do I use the regex match result in the server browser name filter?

Prefix a regex pattern with regex: in the server browser name search field. For example, entering regex:(?i)(MyNetwork) in the server browser name filter searches for all servers whose names match the pattern. This is a quick way to test a regex before using it in a curation rule.

Best practices

Document every rule with a clear Description that explains why the rule exists and what it does. The description is shown in the rules list UI and helps players understand what the curation list applies.
Order rules from most specific to least specific. Put ServerID rules first (exact matches for known servers), then IPv4 range rules, then Name regex rules.
Use case-insensitive regex patterns with the (?i) prefix to avoid missing servers due to name casing differences.
Test each regex pattern in the server browser name filter before adding it to a curation rule.
Keep the Labels array concise. Each label should represent a distinct visual tag with a specific meaning.
Use Action Label for informational tagging that does not affect server position. Reserve Allow and Deny for actions that should change the server's browser position.
When using Allow with a label, the label is optional. If the label is not needed, omit it.
When using Deny with a label, the label communicates to the player why the server was denied. This is helpful for curation lists that deny specific categories of servers.

Appendix A: Complete rule property quick reference

Property	Type	Applies to	Required
`Action`	enum	All rules	Yes
`Inverted`	bool	All rules	No
`Description`	string	All rules	Yes
`Label`	string	Rules that apply labels	Conditional
`Type`	enum	All rules	Yes
`Regex`	string	Name rules	Conditional
`Regexes`	list of strings	Name rules	Conditional
`Filter`	string	IPv4 rules	Conditional
`Filters`	list of strings	IPv4 rules	Conditional
`Value`	uint64	ServerID rules	Conditional
`Values`	list of uint64	ServerID rules	Conditional

Appendix B: Label property quick reference

Property	Type	Required	Purpose
`Name`	string	Yes	Internal reference name used by rules
`Text`	string (rich text)	Yes	Display text rendered in the server browser

Appendix C: Curation list symptom-cause-diagnosis table

Symptom	Most likely cause	Resolution
Label appears on wrong servers	Regex is too broad or CIDR range is too wide	Narrow the regex or CIDR range to target only intended servers
Label does not appear on intended servers	Regex or CIDR range is too narrow; case sensitivity	Verify the regex matches the exact server name; add `(?i)` for case-insensitive matching
Server is denied unexpectedly	Rule order is wrong; a broad rule catches the server before a specific allow rule	Reorder rules: specific allow rules before broad deny rules
Server is allowed unexpectedly	No deny rule matches the server, or an allow rule matches it first	Add a deny rule with higher precedence
`Allow` does not move server to top	`Allow` moves the server relative to other unlabeled servers; a curation list with only `Allow` rules still shows unlabeled servers in normal order	This is expected behavior; `Allow` moves the server above servers that no curation list acts on
`Deny` does not hide the server	Player settings show denied servers at the bottom instead of hiding them	This is a player setting, not a curator setting; document the expected setting in the list description
Regex does not match server name	Regex syntax error or unexpected characters in the server name	Test the regex in the server browser name filter with the `regex:` prefix
CIDR range does not match server IP	Server IP changed or the CIDR notation is incorrect	Verify the server's current IP from the server lobby clipboard output
Steam ID rule does not match	Steam ID is incorrect or the server changed its Steam ID	Verify the Steam ID using `CopyServerCode` from the server console

Appendix D: Example curation list templates

Template: Basic server network verification

Name NetworkName Verification
Labels
[
    {
        Name Verified
        Text <color=green>NetworkName Official</color>
    }
]
Rules
[
    {
        Action Allow
        Description Verify official server Steam IDs
        Label Verified
        Type ServerID
        Values
        [
            <SteamID1>
            <SteamID2>
        ]
    }
    {
        Action Deny
        Description Deny servers copying network branding
        Type Name
        Regex (?i)(NetworkName)
    }
]

Template: Region-based labeling

Name RegionServers
Labels
[
    {
        Name Region
        Text <color=blue>RegionName</color>
    }
]
Rules
[
    {
        Action Label
        Description Label servers in the target region
        Label Region
        Type IPv4
        Filters
        [
            <CIDR-range>
        ]
    }
]

Template: Curated picks

Name CuratorPicks
Labels
[
    {
        Name Pick
        Text <color=gold>Curator Pick</color>
    }
]
Rules
[
    {
        Action Allow
        Description Curator-approved servers
        Label Pick
        Type ServerID
        Values
        [
            <SteamID1>
            <SteamID2>
        ]
    }
]

Appendix E: External references

Smartly Dressed Games official modding documentation - Server Browser Curation - the authoritative field reference for curation rules, labels, and actions.
Unturned on Steam - the Unturned store page and community hub.
Server Browser Curation Asset Reference - the companion article for packaging curation rules as a Steam Workshop asset.
regex101.com - online regex tester for .NET-flavored regular expressions.
regexr.com - another regex testing tool with community patterns.
CIDR.xyz - CIDR notation visualization and calculation tool.

Cross-references

Server Browser Curation Asset Reference - the companion asset packaging article; covers the Steam Workshop distribution path.
Favorite Searches Reference - the next article; covers object editor favorite search presets.
Smartly Dressed Games modding documentation - official field reference.
Unturned on Steam - game page and community.

Authoring checklist

Before publishing a server browser curation list, confirm the following:

[ ] Name is set to a descriptive display name
[ ] Labels array contains at least one label definition
[ ] Each Label has a Name and Text field
[ ] Rules array contains at least one rule
[ ] Each rule has Action, Description, and Type fields
[ ] Regex patterns are tested in the server browser name filter
[ ] Filters or Filters use valid CIDR notation
[ ] Values or Value use correct Steam IDs
[ ] Rule order is intentional (specific before general)
[ ] Action Label rules have the Label field
[ ] Inverted is used intentionally, not by accident
[ ] Tested against real servers in the server browser

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Full curation system field reference, rule types and actions, regex patterns, IPv4 CIDR notation, ServerID matching, worked examples, FAQ.

Server Browser Curation Reference ​

Who this article is for ​

How the curation system works ​

Properties reference ​

Top-level properties ​

Labels ​

Rules ​

Rule type: Name ​

Rule type: IPv4 ​

Rule type: ServerID ​

Rule action behavior ​

Label action ​

Allow action ​

Deny action ​

Label application with Allow and Deny ​

Worked examples ​

Example 1: Server network verification list ​

Example 2: Geographic region filter ​

Example 3: Quality server recommendation list ​

Regex quick reference for server name matching ​

Frequently asked questions ​

How can I find the details for someone else's server? ​

How do I create a regular expression for server name matching? ​

Can a curation list combine all three rule types? ​

What happens when a server matches multiple rules in the same list? ​

What is the Inverted field used for? ​

Can I apply a label without affecting the server's position? ​

What is the difference between a Denied server in the rules list and a hidden server? ​

Can I use rich text formatting in label text? ​

How do I test a curation list before distributing it? ​

Can I have a rule that allows servers from multiple CIDR ranges? ​

What port numbers do Unturned servers typically use? ​

How do I use the regex match result in the server browser name filter? ​

Best practices ​

Appendix A: Complete rule property quick reference ​

Appendix B: Label property quick reference ​

Appendix C: Curation list symptom-cause-diagnosis table ​

Appendix D: Example curation list templates ​

Template: Basic server network verification ​

Template: Region-based labeling ​

Template: Curated picks ​

Appendix E: External references ​

Cross-references ​

Authoring checklist ​

Document history ​