# Insurgency: Sandstorm Server Hosting - everything RE:NODE has published

> A Insurgency: Sandstorm server on RE:NODE: plans, how the panel runs it, and every tutorial RE:NODE has published about it.

Generated from https://www.renode.space/game-servers/insurgency-sandstorm, the live catalogue, the deploy docs, the panel guides and the RE:NODE blog. English. Source of truth for anything that changes: https://www.renode.space/game-servers/insurgency-sandstorm.

Contents: what it is, plans and prices, panel how-to, tutorials, rules for the assistant.

## What it is

Insurgency: Sandstorm servers -- Push, Firefight, Checkpoint and co-op against bots, with mod.io content supported. Add a free Steam token on the Startup tab to appear in the public server browser.

- Genres: Action
- Developer: New World Interactive
- Released: 12 Dec, 2018
- Steam: https://store.steampowered.com/app/581320/

### What comes with every Insurgency: Sandstorm server

- Configured before you see it: The install runs, the configuration is written and the server starts. No first-boot checklist, and nothing left on a default password shared with every other Insurgency: Sandstorm server on the internet.
- The real console: Live output, command input and the server's own logs - not a filtered summary. Web-server noise is folded behind a counter you can switch off.
- Files and SFTP: A full file manager with an editor, plus SFTP credentials. Upload mods, edit configs, pull a world down to your machine.
- 2-2 backup slots: Taken on demand or on a schedule, restored with a button. Deleting a server takes its backups with it, on purpose.
- 2 ports allocated: Add and remove ports yourself from the Network tab, including the query and RCON ports where the game wants them.
- People on the same server: Invite friends or staff with granular permissions - console only, files only, no billing - through subusers, roles and teams.

### Which Insurgency: Sandstorm plan do you need?

Memory is what decides whether a server holds together, so start there. The Starter tier gives 2 GB and 1.5 vCPU, which suits a private group. The Advanced tier at 4 GB is where most public servers sit, and Premium at 6 GB exists for the servers that stay full.

Storage matters more than people expect once mods and backups are involved - plans here run from 15 GB to 40 GB of NVMe. Moving up or down a tier later does not rebuild your world; it changes the limits on the container you already have.

If you are not sure, take the middle tier. It is cheaper to move up after a busy weekend than to spend one explaining lag to your players.

More game servers: https://www.renode.space/ai/game-servers.md

### General questions

### Getting started

**How quickly is my server ready?**

Game, app, web and database servers are created the moment payment clears, usually inside a minute. The game or runtime is installed and started for you, and the console is live in your browser while it happens. VDS and dedicated servers are prepared by hand and delivered within 24 hours.

**Do I need to configure anything before it works?**

No. The install runs, the configuration is written, and admin passwords are generated for your server rather than shared with everybody else's. The exception is four games whose publisher issues a credential to a person - those say so on the shop before you pay, and ask for it on a Setup tab afterwards.

**Which games need a key from me?**

Counter-Strike 2 needs a Steam game-server token, Don't Starve Together a Klei cluster token, FiveM a Cfx.re licence, and DayZ, Project Zomboid, 7 Days to Die, Arma 3 and Unturned need a Steam account or token of your own. We cannot create any of them and we never share one between customers. Your server is built immediately and the installation waits until you paste yours in.

**Can I try before buying?**

There is no free tier. The entry plans start at $1.50 a month precisely so that trying something costs about as much as a coffee.

**Can Claude or ChatGPT set my project up?**

Yes, and the panel gives it what it needs. On a server's Console tab, pick a purpose and press Connect AI: the panel copies a private link with the runtime, the port the code must read from SERVER_PORT, the code path, the GitHub branch, the databases and the limits. Paste it into Claude, ChatGPT or any assistant that can open links; the same link followed by /mcp works as an MCP server URL. It stops by itself after 7 days unused. You can also connect Claude, or any MCP client, to your whole account at https://panel.renode.space/api/client/mcp. Linked repositories get a pre-flight check that shows what will break before a deploy, no AI needed. No password or token is ever shown to the assistant - the AI setup page explains it all.

### Running the server

**Do I get full file access?**

Yes - a complete file manager with an in-browser editor, plus SFTP credentials. There is no plan on which the file manager is disabled or read-only.

**Can I install mods and plugins?**

Yes. Upload them through the file manager or SFTP, or use the game's own workshop support where it has any. Nothing here whitelists which mods you are allowed to run.

**Can other people help me run it?**

Yes. Invite subusers with granular permissions - console only, files only, no billing - or build a team with a role and grant it access to several servers at once. Permissions are a union, so nobody loses access they were given elsewhere.

**What happens if my server runs out of memory?**

New servers are configured so the kernel stops the container and it restarts clean, rather than swapping and dragging the whole machine down. If a server restarts repeatedly we warn you on the server page and open a support ticket before anything is suspended - you get told twice before it stops.

**Is the CPU limit a hard limit?**

Yes, and it cannot be breached: the container is throttled to the share you bought. A server sitting at 100% is slow, not broken, and is never suspended for it.

### Backups and safety

**Are backups included?**

Every plan carries backup slots - two on the entry tiers, more further up. Take them on demand or on a schedule, and restore with a button rather than a support ticket.

**Where are backups stored?**

Off the machine they protect. A backup sitting on the same disk as the thing it is insuring covers you deleting your world and covers nothing at all about the disk failing.

**What happens to my backups if I cancel?**

Deleting a server deletes its backups with it, deliberately and including locked ones. Download anything you want to keep first - the panel lets you.

### Billing

**How do I pay?**

PayPal, card, your wallet balance, or bank transfer. Every method produces a proper invoice you can download or print, with our details and the bank account on it while it is unpaid.

**Can I pay in Georgian lari?**

The panel displays every figure in lari at the National Bank of Georgia's published rate, marks converted figures as approximate, and always shows the amount that will actually be charged. Invoices stay in the currency they were raised in, because an invoice is a demand for a specific amount.

**What happens when my subscription is due?**

An invoice is raised and emailed to you seven days before expiry, and again on the day. Paying it settles that same document rather than raising a second one.

**Can I upgrade or downgrade later?**

Yes, and it does not rebuild anything. Changing plan changes the limits on the container you already have - your world, files and database stay exactly where they are.

**Do you offer refunds?**

There is no automatic refund button. If a server cannot do what it was sold to do, open a ticket and we will sort it out - including refunding you. We would rather fix the plan than argue about the policy.

### Support and the honest bits

**How do I get help?**

Open a ticket from the panel - it reaches every member of staff and every administrator, not a queue aimed at nobody in particular. Attach a screenshot if it helps; attachments are private to your ticket rather than sitting at a guessable public URL. Discord is there for faster, less formal questions.

**Where are the servers?**

Germany, on hardware we run. That is one location: if you need players in another region on a low ping, say so before buying rather than after.

**Is there an uptime guarantee?**

We measure node availability every five minutes and report it in the panel rather than printing a number with four decimal places we have not earned. If something is down you will usually hear it from us first.

**Who actually runs this?**

A small team that writes the panel, the shop and the automation itself. When something is wrong the fix is a code change, which is why the list of things wrong keeps getting shorter.

## Plans and prices

Read from the live catalogue at 2026-10-15 02:50 UTC. Prices are in US dollars per month; checkout also takes Georgian lari and bills for 1, 3, 6, 12 or 24 months. Prices change - re-check on https://www.renode.space/game-servers/insurgency-sandstorm or in the panel shop at https://panel.renode.space before quoting one.

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $9 | 2 GB | 1.5 vCPU | 15 GB | 1 | 2 | 2 |
| Standard | $12 | 3 GB | 2 vCPU | 20 GB | 1 | 2 | 2 |
| Advanced | $15 | 4 GB | 2.5 vCPU | 25 GB | 1 | 2 | 2 |
| Pro | $19 | 5 GB | 3 vCPU | 30 GB | 1 | 2 | 2 |
| Premium | $24 | 6 GB | 3.5 vCPU | 40 GB | 1 | 2 | 2 |


## Panel how-to

From the panel guides at https://www.renode.space/guides.

### Ordering a server

Ordering takes about a minute and happens in three screens: find what you want to run, pick a plan, and pay. Pay by card or PayPal and the server is set up the moment the payment goes through - you can watch it install in its console.

- Takes: About a minute
- Pay with: Card, PayPal or bank transfer
- Billed for: 1, 3, 6, 12 or 24 months
- Prices in: US dollars or Georgian lari

Open the shop and find what you want to run:

1. Sign in to the panel and open the shop. The tabs along the top are the product lines: VDS, Game Servers, App Hosting, Web Hosting and Databases.
2. Find your game - there is a search box - and press View plans. The card already shows the lowest price and the range of memory on offer.

Compare the plans and pick one:

3. Every plan lists its memory, CPU and NVMe storage, roughly how many players it suits, and what is included - updates, backup slots, file and SFTP access.
4. Press Get Started on the one you want. Not sure? Start smaller: you can move to a bigger plan later without losing your world.

Choose how long, then pay:

5. Pick a billing period - 1, 3, 6, 12 or 24 months. The total for the whole period is shown before you pay, so there are no surprises.
6. Pay with PayPal, or press Debit or Credit Card - paying by card does not need a PayPal account. The server is created as soon as the payment completes.

Paying by bank transfer instead: Prefer to pay from your bank? Choose bank transfer at checkout. The server is set up once the payment arrives, usually the next working day.

1. Switch the payment tab to Bank transfer. The account details for Bank of Georgia and TBC Bank appear, each with a Copy button.
2. Press Order & get invoice, then pay that invoice from your banking app, quoting the reference on it.

After you pay:

- The server appears under My Servers and installs itself. Open it to watch the install in the console.
- Your orders, invoices and subscriptions are under Finances in the side menu.
- Stuck at any step? Open Support in the side menu and raise a ticket.

### The console

Live output, a command line, power controls and the resource graphs. It is the server's own output rather than a filtered summary - if the game prints it, you see it.

- Start, stop, restart and kill, with the current state always visible.
- Command history with the arrow keys, and tab completion for common commands.
- Web-server noise - the internet knocking on doors that are not there - is folded behind a count you can switch off. A real error always prints.
- Graphs for memory, CPU and disk against your limits, so whether it is the plan or the mod is answerable.

### Files and SFTP

A complete file manager with an editor in the browser, plus SFTP credentials for the tools you already use. Upload a modpack, fix a config, pull a world down to your machine.

- Drag files in, or upload a folder. Archives can be unpacked in place.
- Edit any text file with syntax highlighting and save without downloading it.
- PDFs and images preview in the panel rather than downloading first.
- SFTP on the same credentials - use FileZilla, WinSCP or your editor's remote mode.

### Backups

Take one before you try something. Restore it when the something goes wrong. Lock the ones that matter so they are not rotated away.

- Slots on every plan - two on the entry tiers, more further up.
- Take one on demand, or on a schedule you set.
- Download any backup to your own machine.

> Important: Deleting a server deletes its backups, including the locked ones. A lock stops you removing a backup by accident; it is not a claim on the disk after the server is gone. Download what you want to keep before you cancel.

### Subusers, roles and teams

Give somebody the console without giving them your files, or the files without your billing. Three separate ideas, kept apart deliberately.

- A role holds permissions - what may be done.
- A team holds people.
- A grant joins a team to a server with a role, so adding a moderator to the team gives them the same access everywhere at once.
- Invite by link, by a join code, or by email address - and require approval on the codes if you would rather vet people.
- Access can be time-boxed, and expiry stops working immediately rather than overnight.

### Scheduled tasks

Restart nightly, back up before the restart, announce it to players first. Tasks run in order with delays between them, so a schedule can be a small routine rather than one action.

- Send a console command - a warning to players, a save, a world flush.
- Take a backup.
- Power actions: start, stop, restart.

### Games that need a key from you

A few games want a credential their publisher issues to a person - a Steam game-server token, a Steam account that owns the server files, a Klei cluster token, a Cfx.re licence. We cannot create one and we never share one between customers.

> Note: Those games say so on the shop before you pay. Your server is built immediately, and the game installation is held until you paste the value into a Setup tab, because installing without it produces a server with no game files in it and no explanation.

## Tutorials

2 posts, newest first. Each one follows in full after the list.

- [Insurgency: Sandstorm game modes and mods](https://www.renode.space/blog/insurgency-sandstorm-mods-and-game-modes) (2026-10-07): Choose and run Insurgency: Sandstorm game modes on a server: co-op and PvP modes, scenario names, map cycles, mutators, mod.io mods and modded scenarios.
- [Insurgency: Sandstorm server setup and config](https://www.renode.space/blog/insurgency-sandstorm-server-guide) (2026-09-21): Run an Insurgency: Sandstorm dedicated server: the launch line and scenarios, Game.ini, map cycles, mutators, admins, RCON, ports, stats tokens and mod.io.

---

### Insurgency: Sandstorm game modes and mods

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/insurgency-sandstorm-mods-and-game-modes

An Insurgency: Sandstorm server runs one game mode at a time, chosen by the scenario name in the launch line or the map cycle - `Scenario_Hideout_Checkpoint_Security` is Checkpoint co-op on Hideout as Security. The decision that shapes everything else is co-op or PvP: co-op modes (Checkpoint, Outpost, Survival) are capped at eight humans and their load comes from bots, while PvP modes (Push, Firefight, Skirmish, Frontline, Domination and others) take up to 28 players. On top of that you can stack the shipped mutators with `-mutators=` for free, and add mods through mod.io, which the server downloads itself once it is authorised. Pick the mode for your group size first, then mutators, then mods.

The install, `Game.ini` basics, admins, RCON and ports are in [the Insurgency: Sandstorm server guide](https://www.renode.space/blog/insurgency-sandstorm-server-guide). This post is about what the server plays: each mode and who it suits, how scenarios are named, building a cycle that mixes them, what the mutators actually do, and running mod.io content without breaking the server.

#### Choosing a mode for your group

The modes are not interchangeable flavours. They need different player counts, cost different amounts of CPU, and attract different players.

| Mode | Type | Players | What happens | Suits |
| --- | --- | --- | --- | --- |
| Checkpoint | Co-op | Up to 8 | Capture objectives in order against bots, defend counter-attacks | The default co-op choice |
| Hardcore Checkpoint | Co-op | Up to 8 | Checkpoint with a stripped HUD and harsher rules | Experienced groups |
| Outpost | Co-op | Up to 8 | Defend against waves of attacking bots | Short sessions, defensive play |
| Survival | Co-op | Up to 8 | Push through the map with limited respawns and supplies | Small, coordinated groups |
| Push | PvP | Up to 28 | Attackers take objectives in sequence, reinforcement waves | Large public servers |
| Firefight | PvP | Up to 28 | No individual respawns; capturing a point revives your team | Tactical communities |
| Skirmish | PvP | Up to 28 | Destroy the enemy cache; captures earn respawn waves | Mid-size servers |
| Frontline | PvP | Up to 28 | Tug of war over a line of objectives | Public servers |
| Domination | PvP | Up to 28 | Hold three points to drain enemy tickets | Casual public play |
| Team Deathmatch | PvP | Up to 28 | Kills only | Warm-up and casual |
| Ambush | PvP | Smaller | One side escorts a VIP, the other intercepts | Events and variety |
| Defusal | PvP | Small teams | Bomb plant and defuse, no respawns | Competitive groups |

The single most important fact on that table is the eight-player cap on co-op. It is hard-coded; setting `MaxPlayers` higher on a co-op scenario changes nothing. A Discord of twenty who want to play co-op together needs three servers, not one bigger one. A group that wants everyone on one server needs a PvP mode, or Checkpoint with friendly bots filling the gaps.

Co-op is also where the server's work happens. Every enemy bot is simulated on the server's game thread, and Checkpoint scales bot counts between `MinimumEnemies` and `MaximumEnemies` in the `[/Script/Insurgency.INSCoopMode]` section of `Game.ini`. A co-op server with those values raised is heavier than a full 28-player Push server. If a co-op server stutters in firefights, look at the enemy count before the plan. [What tick rate actually means](https://www.renode.space/blog/what-tick-rate-actually-means) explains why one busy thread decides how the whole server feels.

#### Scenario names and how to find them

A scenario bundles map, mode and side into one token: `Scenario_<Map>_<Mode>[_<Side or layout>]`. The map part is the display name (Hideout, Refinery, Crossing), not the internal level name used in the travel URL - the mismatch between the two is covered in the main guide.

```text
Scenario_Hideout_Checkpoint_Security     Checkpoint, players as Security
Scenario_Hideout_Checkpoint_Insurgents   Checkpoint, players as Insurgents
Scenario_Refinery_Push_Security          Push, Security attacking
Scenario_Crossing_Skirmish               Skirmish
Scenario_Farmhouse_Firefight_West        Firefight, western layout
Scenario_Precinct_Domination             Domination
Scenario_Bab_Survival                    Survival
```

The side suffix means different things per mode: for Checkpoint it is the side the players are on; for Push it is the side that attacks. Not every map has every mode, and NWI adds maps and scenarios in updates, so do not build a cycle from memory. The server will tell you what exists:

```text
scenarios
scenarios Checkpoint
scenarios Hideout
```

The `scenarios` command (also answered to `maps`) lists every scenario the server knows, filtered by whatever text you give it. Run it over RCON or from the console after each game update and build your cycle from the output. A scenario name that does not exist is skipped in the cycle, and a launch line naming one fails to start.

#### Map cycles that mix modes and lighting

`Insurgency/Config/Server/MapCycle.txt` is the rotation, used when `bUseMapCycle=True` in `[/Script/Insurgency.INSMultiplayerMode]`. The simple form is one scenario per line. The tuple form lets each entry override lighting and mode, which is how one map becomes several distinct rounds:

Insurgency/Config/Server/MapCycle.txt:

```text
(Scenario="Scenario_Hideout_Checkpoint_Security",Lighting="Day")
(Scenario="Scenario_Refinery_Checkpoint_Security",Lighting="Night")
(Scenario="Scenario_Crossing_Checkpoint_Insurgents",Lighting="Day")
(Scenario="Scenario_Hideout_Checkpoint_Security",Mode="CheckpointHardcore")
(Scenario="Scenario_Farmhouse_Checkpoint_Security",Lighting="Day")
```

What makes a cycle work:

- **Do not mix co-op and PvP in one cycle.** The player counts and the audiences differ. A PvP server that suddenly travels to a co-op scenario kicks everyone above eight; a co-op group dropped into Push with nobody on the other team has a bad evening.
- **Ration night.** Night rounds with night vision are distinctive and divisive. One in four or five is a good starting ratio; if the server empties on night rounds, you have your answer.
- **Use the hardcore override deliberately.** `Mode="CheckpointHardcore"` on the same scenario gives a harder round without a second map in the list. Interleave it for a group that asks for it rather than running a whole hardcore cycle on a public server.
- **Check after updates.** Scenario renames break cycles silently.

If you keep several cycles - a weekday co-op cycle and a weekend event cycle - select one with `-MapCycle=` on the command line and keep each as its own file. Swapping cycles is then a startup parameter change and a restart, which on a panel is one field on the Startup tab.

For live changes, `travelscenario <scenario>` moves the server immediately, and `travel <map>?Scenario=<scenario>?Lighting=Night` gives full control over one round without touching the cycle.

#### Per-mode settings

Beyond the shared sections, each mode has its own `Game.ini` section named after its game mode class, following the pattern `[/Script/Insurgency.INS<Mode>GameMode]`. The Checkpoint section is the one most servers tune:

Insurgency/Saved/Config/LinuxServer/Game.ini:

```ini
[/Script/Insurgency.INSCheckpointGameMode]
DefendTimer=90
RetreatTimer=10
RespawnDelay=20
CounterAttackRespawnDelay=20
```

Counter-attack timing is what makes Checkpoint feel frantic or measured. Longer defend timers with fewer enemies produce a slower, more tactical game; short timers with high `MaximumEnemies` produce a horde shooter.

Rather than trust any list of keys - including this one - ask the server. Over RCON, `listgamemodeproperties` prints every property the current mode exposes, and `gamemodeproperty <name> <value>` changes one on the running server. That is the right way to tune: change a value live, play a round, keep it or put it back, then write the winner into `Game.ini` so it survives a restart. Live changes are lost when the server restarts.

> [!TIP]
> Tune with the group that will play, during a real session. A `MaximumEnemies` value that felt fine with four players becomes a wall at eight, because bot counts scale with players between the minimum and maximum you set.

#### Mutators: free variety with no downloads

Mutators ship with the game and need nothing from players. They change rules for the whole server and are enabled on the command line:

```bash
-mutators=Hardcore,HeadshotOnly
```

Several can be combined with commas. The shipped set has grown over updates; the commonly used ones include:

| Mutator | Effect |
| --- | --- |
| `Hardcore` | Harsher rules and a reduced HUD |
| `Competitive` | Competitive ruleset for organised play |
| `HeadshotOnly` | Only headshots deal damage |
| `BoltActionsOnly`, `PistolsOnly`, `ShotgunsOnly` | Restrict loadouts to one weapon class |
| `Frenzy` | Co-op enemies become fast, close-range attackers |
| `Vampirism` | Kills restore health |
| `LowGravity` | Lower gravity |
| `FastMovement`, `SlowMovement` | Change movement speed |
| `BulletSponge` | Everyone takes much more damage to kill |
| `HotPotato` | Dropped live grenades on death |
| `SoldierOfFortune` | Earn supply through kills |

A few observations from running them:

- **Mutators are for events, not every night.** `Frenzy` on a Friday is memorable; `Frenzy` every round empties a server within a week.
- **Combinations interact.** `HeadshotOnly` plus `BulletSponge` is pointless; `Hardcore` plus `BoltActionsOnly` is a legitimate niche server. Test combinations before announcing them.
- **Mutator settings live in `Engine.ini`.** The official server guide notes this inconsistency; if a mutator's tuning is ignored, check which file it is in before anything else.
- **Mod mutators work the same way.** A mutator delivered by a mod.io mod is enabled by name in the same `-mutators=` list once the mod is installed. The mod's page gives the exact name.

On a panel host, the mutator list is a startup parameter, so changing the event of the week is editing one field and restarting.

##### A weekly event pattern

A pattern that works for co-op communities: run the normal Checkpoint cycle all week, and on one fixed evening switch to an event configuration - a different cycle file selected with `-MapCycle=`, a mutator or two, perhaps night lighting throughout. Announce it in your Discord a few days ahead with the exact rules, and switch back the next morning.

The mechanics are simple and worth getting right:

1. Keep the event as its own cycle file, so the normal cycle is never edited.
2. Change only the startup parameters for the event - the cycle and the mutators - then restart.
3. Use a scheduled restart to switch back at a fixed time, so nobody has to remember.
4. Take a backup of both config trees before the first event, so a mistake costs one restore.

Events built this way are cheap to run and give regulars a reason to come back on a particular night, which matters more to a small server's population than any setting. [Scheduled tasks worth having](https://www.renode.space/blog/scheduled-tasks-worth-having) covers the scheduling side.

#### mod.io mods: maps, mutators and overhauls

Sandstorm's mods come from mod.io, not the Steam Workshop. They fall into three kinds:

- **Maps** with their own scenarios, played by travelling to the mod's map and scenario names.
- **Mutators**, enabled with `-mutators=`.
- **Overhauls** that change weapons, factions or rules across the game.

The current server workflow registers the server with mod.io and manages its subscriptions on the mod.io website. The first launch passes an emailed security code, every later launch uses `-SecurityCode=none`, and `-mods` enables mod support. The full launch syntax and the older token-based scheme are in [the main Sandstorm guide](https://www.renode.space/blog/insurgency-sandstorm-server-guide); the operational detail that matters here is what happens at each start:

```diagram
title: How a Sandstorm server gets its mods
portal = mod.io portal | server subscriptions
server = Sandstorm server | -mods
cache = Mod cache | downloaded files
travel = Download map | ModDownloadTravelTo
player = Player | gets mods on join
portal -> server : subscription list
server -> cache : downloads updates
server -> travel : loads after download
player -> server : joins
cache --> player : same mod set
```

`-ModDownloadTravelTo=` names the map and scenario the server travels to once its downloads are done. Point it at the first round you actually want played, not a test map, or every restart starts on a scenario nobody chose.

To play a mod map, you need two names from its mod.io page: the map name and at least one scenario name. Put them in the cycle like any other scenario, or travel to them directly:

```text
travel ModMapName?Scenario=Scenario_ModMapName_Checkpoint_Security
```

Mod authors choose these names, and the page is the authority. Watch the log on the first travel; a misspelled name fails the travel and the server stays on the current map.

##### Keeping a modded server stable

- **Mods update when their authors publish.** The server picks up updates on restart. An update that breaks a map breaks your cycle the morning after a restart, with no change on your side. Keep a list of what is subscribed and when it last changed.
- **Players must have the same versions.** Clients are prompted to get the server's mods when they join; a player whose download fails cannot join and will blame the server.
- **Fewer mods attract more strangers.** Each mod is a download standing between a new player and the first round.
- **Stats and XP are an official-content feature.** A server built around mods should not promise progression; check the current NWI rules for whether a particular mod or mutator affects stats eligibility before advertising XP.

When a game update lands, update the server first, then check each mod has been updated for the new version, and drop any that have not from the cycle. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) has the general playbook, and [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) the argument for a short mod list.

#### Sizing by mode

The plan you need depends more on the mode than on the player count.

| Setup | RAM | CPU | Why |
| --- | --- | --- | --- |
| Checkpoint, defaults, 4-8 players | 2-3 GB | 1.5-2 cores | Bots are the load |
| Checkpoint, high enemy counts or Frenzy | 3 GB | 2 cores | More bots, more pathfinding |
| PvP, 16-28 players, vanilla | 2-3 GB | 1.5-2 cores | Humans are cheap next to bots |
| Any mode with large mod maps | 3-4 GB | 2 cores | Map size and assets |

Disk grows with mods: each mod map adds to the cache, and old versions linger until cleared. Keep headroom for an update, when old and new files briefly coexist. On RE:NODE the console graphs show CPU against the limit live, which is the fastest way to see whether a new mutator or mod map is what pushed the server over.

#### Troubleshooting

**More than eight players cannot join co-op.** That is the cap; no setting changes it. Use PvP or run a second server.

**A scenario in the cycle is skipped.** It was renamed or never existed. Check with `scenarios`.

**The server starts on a test map after every restart.** `-ModDownloadTravelTo=` still points at the mod test map. Point it at a real scenario.

**A mutator does nothing.** Its name is misspelled, or its settings are in `Game.ini` instead of `Engine.ini`. Mod mutators also need the mod installed.

**Mod maps stopped loading after a restart.** An author published an update that is broken or renamed a scenario. Read the log, then check the mod page.

**Players disconnect while downloading mods.** A large mod set or a slow mod.io download on their side. Trim the list.

**Live tuning reverted.** `gamemodeproperty` changes last until restart. Write them into `Game.ini`.

#### FAQ

##### What is the best game mode for a small Insurgency: Sandstorm group?

Checkpoint. It is built for up to eight players against bots, scales enemy counts with the number of humans, and can be made harder with the hardcore override or mutators as the group improves.

##### Can I run co-op and PvP on the same server?

Not sensibly in one cycle - co-op is capped at eight and PvP expects many more. Run two servers, or switch cycles with `-MapCycle=` and a restart for scheduled events.

##### Do players need to download mutators?

Not the shipped ones; they are part of the game. Mutators from mod.io mods are downloaded like any other mod when players join.

##### How do I list every scenario my server can run?

Use the `scenarios` command over RCON or the console, optionally with a filter such as `scenarios Push`. It reflects the server's current version and installed mods.

##### Why did my modded server break without me changing anything?

A mod author published an update and the server picked it up on its last restart. Check the mod's page and changelog, and keep a list of subscribed mods so you can remove the broken one quickly.

##### How many bots should a Checkpoint server run?

Start with the defaults and change `MaximumEnemies` live with `gamemodeproperty` during a real session. The right number depends on your group's skill and on how much CPU the server has, so tune by playing rather than copying a value.

Insurgency: Sandstorm servers on RE:NODE start at 2 GB with the game and query ports allocated, launch options on the Startup tab, and both config trees editable in the browser. Backup slots cover your cycle files before an experiment, and an extra RCON port is added on the Network tab.

[See Insurgency: Sandstorm plans](https://www.renode.space/game-servers/insurgency-sandstorm)

---

### Insurgency: Sandstorm server setup and config

Published 2026-09-21 by RE:NODE Team. https://www.renode.space/blog/insurgency-sandstorm-server-guide

The Insurgency: Sandstorm dedicated server is a free SteamCMD download (app id `581330`) with a native Linux build, it listens on two UDP ports, and it wants 2 to 3 GB of memory and one fast core. Almost everything that makes it behave the way you want is in two places: a long travel URL appended to the map name on the command line, and a `Game.ini` that does not exist until you create it. That second point catches nearly everyone - a fresh install has no config directory at all, so the first hour is often spent editing files the server has never read.

#### What the dedicated server gives you

One server runs one scenario at a time. A scenario is a map, a game mode and usually a faction bundled into one name, and changing between them is a travel rather than a restart, either through the map cycle or an admin command.

The two families are worth separating, because they size and configure differently:

- **Co-op**, which is Checkpoint, Outpost, Survival and their hardcore variants. Humans against bots. **Eight human players is a hard cap** here; setting a higher number is ignored. Bot counts, not player counts, decide what it costs to run.
- **PvP**, which is Push, Firefight, Skirmish, Frontline, Domination, Team Deathmatch, Ambush and Defusal. Twenty-eight players is the number in every official example.

Out of the box you also get a real RCON implementation over the Source protocol, an admin file of Steam IDs with an in-game admin menu, a ban file the server maintains itself, a map cycle, a message of the day, and twenty-odd shipped mutators that change the rules without any third-party code. Mods on top of that come through mod.io, and the way that works changed recently enough that most of what you will find written about it is wrong.

#### Requirements and resource usage

New World Interactive publishes no official figures, so these come from measurement rather than a spec sheet. Bots are the expensive thing, not humans.

| Setup | RAM | CPU | Notes |
| --- | --- | --- | --- |
| 8-player Checkpoint co-op | 2 GB | 1.5 cores | Bot count is the variable |
| Co-op with high enemy counts | 3 GB | 2 cores | `MaximumEnemies` drives both |
| 16-24 player PvP | 2-3 GB | 1.5-2 cores | Cheaper than co-op at the same player count |
| 28-player PvP | 3 GB | 2 cores | The largest supported setup |

- **CPU**: an Unreal Engine 4 dedicated server runs its game thread on one core. Clock speed is what holds the tick rate together during a firefight; extra cores mostly help the engine's worker threads and the operating system.
- **Disk**: the install is several gigabytes and mods add to it. Fifteen to twenty gigabytes is a comfortable floor for a modded server.
- **Network**: modest. Sandstorm is not a bandwidth-hungry game, and latency between the players and the server matters far more than throughput - see [latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) for how to tell which of the three you have.

The uncomfortable version of the sizing question: a co-op server with `MaximumEnemies` pushed up is a much heavier server than the same box running 28-player Push, and no amount of memory fixes a bot count that a single core cannot simulate.

#### Installing, and the config folder that does not exist

Anonymous on SteamCMD, no account needed:

```bash
$ steamcmd +force_install_dir /home/sandstorm/server +login anonymous \
    +app_update 581330 validate +quit
```

[SteamCMD explained](https://www.renode.space/blog/steamcmd-explained) has the general form, including update scripts. The binaries:

| Platform | Binary |
| --- | --- |
| Linux | `Insurgency/Binaries/Linux/InsurgencyServer-Linux-Shipping` |
| Windows | `InsurgencyServer.exe` in the install root |

Now the part that is not obvious. The ini configuration lives in `Insurgency/Saved/Config/LinuxServer/` (or `WindowsServer/` on Windows), and **neither the directory nor the files exist on a fresh install**. You create them:

```bash
$ mkdir -p Insurgency/Saved/Config/LinuxServer
$ touch Insurgency/Saved/Config/LinuxServer/Game.ini
$ touch Insurgency/Saved/Config/LinuxServer/Engine.ini
```

A second, separate directory holds the plain-text server files, and this one does ship with the install:

```text
Insurgency/Config/Server/
  Admins.txt      one SteamID64 per line
  MapCycle.txt    the rotation
  Motd.txt        the message of the day
  Mods.txt        mod ids, on the older mod scheme
  Bans.json       written and read by the server itself
```

Two config trees with different rules is unusual and it is the main reason people put settings in the wrong file. Ini settings go in `Saved/Config/<platform>Server/`. Lists of things go in `Config/Server/`. On RE:NODE both are in the file manager and over SFTP, and the in-browser editor will highlight the ini syntax so a missing bracket is visible.

#### The launch line: maps, scenarios and lighting

The server is started with a map name, a travel URL of `?`-separated parameters, and then command-line switches:

```bash
$ ./Insurgency/Binaries/Linux/InsurgencyServer-Linux-Shipping \
    Oilfield?Scenario=Scenario_Refinery_Push_Security?MaxPlayers=28 \
    -Port=27102 -QueryPort=27131 -log -hostname="Frankfurt Push"
```

Look at that line carefully, because it contains the single most confusing thing about this game. The map token is `Oilfield`. The scenario token says `Refinery`. They are the same place. Sandstorm's maps have an internal name and a display name, and the travel URL wants the internal one while the scenario wants the display one:

| Internal name | Display name |
| --- | --- |
| `Oilfield` | Refinery |
| `Town` | Hideout |
| `Canyon` | Crossing |
| `Compound` | Outskirts |
| `Sinjar` | Hillside |
| `Mountain` | Summit |
| `Buhriz` | Tideway |

`Farmhouse`, `Ministry`, `Precinct`, `PowerPlant`, `Tell` and `Bab` are the same in both. Everything else in the pair table is a trap you will fall into once.

Scenario names follow `Scenario_<DisplayName>_<Mode>` with a faction or layout suffix where the mode needs one: `Scenario_Refinery_Push_Security`, `Scenario_Hideout_Checkpoint_Security`, `Scenario_Crossing_Skirmish`, `Scenario_Farmhouse_Firefight_West`, `Scenario_Precinct_Domination`, `Scenario_Bab_Survival`. For Checkpoint the faction is the side you play; for Push it is the side you attack as.

The travel parameters worth knowing, each prefixed with `?`:

| Parameter | Effect |
| --- | --- |
| `Scenario=` | The scenario, as above |
| `MaxPlayers=` | Humans. 28 for PvP, capped at 8 for co-op |
| `Password=` | Join password. Note that setting one disqualifies the server from stats |
| `Lighting=` | `Day` or `Night` |

#### Game.ini: the settings that matter

Three sections carry most of it, and which section a key belongs to is not always intuitive.

Insurgency/Saved/Config/LinuxServer/Game.ini:

```ini
[/Script/Insurgency.INSGameMode]
bKillFeed=False
bKillFeedSpectator=True
TeamKillLimit=3
TeamKillGrace=0.2
bDeadSay=False
bVoiceAllowDeadChat=False

[/Script/Insurgency.INSMultiplayerMode]
bAllowFriendlyFire=True
FriendlyFireModifier=0.2
FriendlyFireReflect=0
bAutoBalanceTeams=True
bMapVoting=True
bUseMapCycle=True
TeamSwitchTime=10
IdleLimit=150
bBots=False

[/Script/Insurgency.INSCoopMode]
AIDifficulty=0.5
FriendlyBotQuota=4
MinimumEnemies=6
MaximumEnemies=12
bUseVehicleInsertion=True
```

The four keys in `[/Script/Insurgency.INSCoopMode]` are the whole of co-op tuning. `AIDifficulty` is a float from 0 to 1 and `0.5` is the default; small changes to it are felt immediately, and pushing it to 1 makes bots unpleasantly accurate rather than tactically smarter. `MinimumEnemies` and `MaximumEnemies` set the band the server scales bot counts inside, and they are the numbers that decide whether your plan is big enough. `FriendlyBotQuota` adds AI teammates, which is how a server of three friends still feels like a squad.

Some placements are worth memorising because they are commonly got wrong:

- Friendly fire, `RoundLimit`, `bBots` and the team-switch timer are in `INSMultiplayerMode`, not `INSGameMode` and not `INSCoopMode`.
- The key is `TeamSwitchTime`, not `TeamSwitchTimer`.
- There is no family of `bVoteX` keys. Voting is `[/Script/Insurgency.TeamInfo] bVotingEnabled` plus a `[/Script/Insurgency.VoteIssueKick]` section with `MinimumPlayersRequired`, `VotePassRatio`, `VoteTimeout` and friends. Vote kick is still the only supported vote issue.

Per-mode sections exist too, named after the mode: `[/Script/Insurgency.INSCheckpointGameMode]` holds `DefendTimer`, `RetreatTimer`, `RespawnDelay`, `CounterAttackRespawnDelay` and the rest of the Checkpoint pacing. Those are the knobs for a co-op server that feels too frantic or too slow.

> [!TIP]
> Mutator settings are the exception to all of this: they go in `Engine.ini`, not `Game.ini`, and the official guide notes that this inconsistency is known and may change. If a mutator setting is being ignored, check which file you put it in before you check anything else.

#### Map cycles and mutators

`MapCycle.txt` accepts two forms. One scenario per line is enough for most servers:

Insurgency/Config/Server/MapCycle.txt:

```text
Scenario_Crossing_Skirmish
Scenario_Hideout_Skirmish
Scenario_Refinery_Push_Security
```

The tuple form lets you override the mode or the lighting per entry, which is how you get the same map in the rotation both by day and by night:

```text
(Scenario="Scenario_Town_Checkpoint_Security",Lighting="Day")
(Scenario="Scenario_Town_Checkpoint_Security",Lighting="Night")
(Scenario="Scenario_Town_Checkpoint_Security",Mode="CheckpointHardcore")
```

The cycle needs `bUseMapCycle=True` to be used at all, and the file is selected with `-MapCycle=` if you keep more than one. With no cycle file the server rotates through every PvP scenario, which is almost never what a co-op server wants.

Mutators are the other half of this, and they are a genuinely good feature that costs nothing to try. Around two dozen ship with the game and are selected by name on the command line: `-mutators=Hardcore`, or several comma-separated. The list includes `Competitive`, `Hardcore`, `Frenzy`, `BoltActionsOnly`, `PistolsOnly`, `ShotgunsOnly`, `HeadshotOnly`, `Vampirism`, `LowGravity`, `FastMovement`, `SlowMovement`, `BulletSponge`, `HotPotato`, `Warlords` and `SoldierOfFortune`. A server running `Hardcore` plus a night-time Checkpoint cycle is a completely different experience from the default, with no mods involved.

#### Admins, RCON and the commands

`Admins.txt` is one SteamID64 per line, no blank lines, in `Insurgency/Config/Server/`. It is read at start-up and on a level change, so adding somebody mid-round means waiting for the next map rather than restarting.

An admin in game opens the admin menu, bound by default to Keypad Subtract. The same commands go over RCON or the server console. RCON is the real remote administration here, and unlike Killing Floor 2 or Valheim it is a proper implementation of the Source protocol - which means it is TCP, and the familiar clients work with it.

Insurgency/Saved/Config/LinuxServer/Game.ini:

```ini
[Rcon]
bEnabled=True
Password=a-long-random-string
ListenPort=27015
bAllowConsoleCommands=True
MaxPasswordAttempts=3
IncorrectPasswordBanTime=30
```

> [!WARNING]
> `[Rcon]` goes in `Game.ini`. A great many guides put it in `Engine.ini`, where it does nothing. There is also no shipped default RCON port - `27015` is only the example in the official guide, and you have to choose and open one deliberately. Everything in [RCON safely](https://www.renode.space/blog/rcon-safely) applies: the password is unencrypted on the wire, so restrict the port rather than trusting the password alone.

The command set, with `<>` mandatory and `[]` optional:

| Command | Syntax |
| --- | --- |
| `help` | `help` |
| `listplayers` | `listplayers` |
| `kick` | `kick <id/netid/name> [reason]` |
| `ban` | `ban <id/netid/name> [minutes] [reason]` |
| `banid` | `banid <netid> [minutes] [reason]` |
| `permban` | `permban <id/netid/name> [reason]` |
| `unban` / `listbans` | `unban <netid>` |
| `say` | `say <message>` |
| `restartround` | `restartround [0 keep teams, 1 swap]` |
| `maps` / `scenarios` | `scenarios [filter]` |
| `travelscenario` | `travelscenario <scenario>` |
| `travel` | `travel <travel url>` |
| `gamemodeproperty` | `gamemodeproperty <property> [value]` |
| `listgamemodeproperties` | `listgamemodeproperties [filter]` |

`gamemodeproperty` is the one that repays learning. It changes a `Game.ini` value on the running server, so you can raise `MaximumEnemies` mid-session and watch what it does rather than editing, restarting and guessing. `listgamemodeproperties` prints the ones the current mode exposes.

Anything the server does not recognise as an admin command is passed through as a console command, which is why `bAllowConsoleCommands` exists and why an RCON password deserves the same care as a root password.

#### Ports, the server browser and stats

| Port | Protocol | Purpose |
| --- | --- | --- |
| `27102` | UDP | Game traffic |
| `27131` | UDP | Steam query - the server browser |
| your choice | TCP | RCON, only if you enabled it |

Set the first two with `-Port=` and `-QueryPort=`. The official guidance is to open the game and query ports for both TCP and UDP, and there is no cost to following it. A server that runs but never appears is the query port nine times out of ten - [game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why that pair exists and how to test each half separately.

```diagram
title: What a Sandstorm server needs open, and for what
player = Player | Steam client
admin = Admin | RCON client
query = Query 27131 | UDP, browser
game = Game 27102 | UDP, play
rcon = RCON port | TCP, chosen
server = Sandstorm server | 8 coop / 28 PvP
player -> query : finds the server
player -> game : plays
admin -> rcon : commands
query -> server
game -> server
rcon -> server
```

Stats and XP are a separate thing from being listed, and this is where the tokens come in. Any community server can host a stats-enabled game, and the requirements are specific: a Steam game server login token, the `-GameStats` switch, a second token generated on New World's own game stats site and passed as `-GameStatsToken=`, and **no server password**. A password disqualifies the server from stats entirely. The GSLT is created for app id `581320`, which is the game rather than the server tool - [Steam game server tokens](https://www.renode.space/blog/steam-game-server-tokens-gslt) covers what a GSLT is and how bans against one work. If you do not care about XP, you need none of this; the server runs and lists perfectly well without a token.

#### Mods through mod.io

Sandstorm's mods come from mod.io rather than the Steam Workshop, and how a server subscribes to them changed. Both schemes are documented on the internet and only one of them currently works, so check which you are reading.

The **older scheme** put a mod.io OAuth access token in `Engine.ini` under `[/Script/ModKit.ModIOClient]`, listed numeric mod ids in `Insurgency/Config/Server/Mods.txt`, and added `-Mods` to the command line. Almost every hosting knowledge base still describes this.

The **current scheme** registers the server itself as a mod.io user. You authorise it once with a security code emailed to your mod.io account, pass that code on the first launch only, and manage which mods the server runs from the mod.io web portal rather than from a text file:

```bash
$ ./InsurgencyServer-Linux-Shipping -mods -SecurityCode=34678 \
    -ModDownloadTravelTo=Mod_Test?Scenario=Scenario_Mod_Test \
    -Port=27102 -QueryPort=27131 -hostname="Modded"
```

Every launch after that uses `-SecurityCode=none`. There is one constraint that catches people running a server on their own gaming PC: the mod.io client does not support more than one instance under one account on one machine, so a co-located game client has to subscribe to the mods separately under its own account.

When mods stop downloading after an update, the fix is almost always to re-authorise and clear the mod.io caches - there is one under the public user directory and one in the local application data folder. The general playbook for the day a mod breaks is in [what to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks), and the hygiene argument for not installing everything you find is in [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean).

#### Troubleshooting

**Nothing in my config does anything.** The `Saved/Config/LinuxServer` directory or the ini files inside it do not exist. The server does not create them.

**A setting is ignored but the file is right.** Check the section. Friendly fire and `bBots` belong to `INSMultiplayerMode`; mutator settings belong to `Engine.ini`; `[Rcon]` belongs to `Game.ini`.

**More than eight people cannot join my co-op server.** That is the cap. `?MaxPlayers=` above eight and `[/Script/Engine.GameSession] MaxPlayers=` are both ignored for co-op, whatever a config template claims.

**The server is running but not in the browser.** Query port. Open `27131` inbound, and open both protocols if you are unsure.

**The log is full of `LogSkinnedMeshComp` warnings about a head socket.** Harmless noise. Suppress it with a `[Core.Log]` section in `Engine.ini` setting that category to `Error`.

**RCON refuses my correct password.** You are banned. Three failed attempts trigger a thirty-minute block by default, tuned with `MaxPasswordAttempts` and `IncorrectPasswordBanTime`.

**No XP on the server.** A missing GSLT, a missing `-GameStats`, a missing stats token, or a server password. The last one surprises people.

**Mods worked last month and do not now.** The mod.io scheme changed. Re-authorise with a security code and manage subscriptions on the portal.

**Complaints about editor packages in the log at start-up.** A map referencing editor-only content, or a stale install. Re-run `app_update` with `validate`.

On RE:NODE the game and query ports come with the server and an extra port for RCON is added on the Network tab. The console is the server's own output with a command line attached, backup slots cover the two config trees, and the Schedules tab will run a nightly backup and a restart on a cron expression - useful here because an Unreal server that has travelled through twenty maps is not in the same state as one that just started. If it hits its memory limit the container is stopped and restarted clean instead of swapping.

#### FAQ

##### How many players can an Insurgency: Sandstorm server hold?

Twenty-eight in PvP, which is the number in every official example. Co-op is capped at eight human players and no setting lifts it; the bots are what make a co-op round feel full, and their count is set with `MinimumEnemies` and `MaximumEnemies`.

##### Do I need a Steam game server token?

Only for stats and XP. The server runs, lists and plays without one. If you do want XP on your server you need the token, the `-GameStats` switch, a separate game stats token, and no server password.

##### Where does RCON go, Game.ini or Engine.ini?

`Game.ini`. This is the most commonly repeated mistake about Sandstorm server configuration. There is also no default RCON port, so pick one, set `ListenPort`, and open it on TCP.

##### Why does the launch line say Oilfield but the scenario say Refinery?

Because several maps have an internal name that differs from the one players see. The travel URL takes the internal name, the scenario token takes the display name. Oilfield is Refinery, Town is Hideout, Canyon is Crossing.

##### How do I change bot difficulty?

`AIDifficulty` in `[/Script/Insurgency.INSCoopMode]`, a float between 0 and 1 with `0.5` as the default. You can also change it live with `gamemodeproperty AIDifficulty 0.6` over RCON, which is a much better way to find the number your group actually wants.

##### Can I run mods without the mod.io portal?

Not on the current scheme. Subscriptions are managed on the mod.io web portal under the server's own registered account, and the older token-and-`Mods.txt` workflow has been replaced. Any guide still describing an `AccessToken` in `Engine.ini` is out of date.

Insurgency: Sandstorm servers on RE:NODE start at 2 GB on NVMe in Germany, with the game and query ports allocated and the Startup tab holding the scenario, map and player count. Add a port for RCON on the Network tab, and keep both config trees in a backup slot before you change anything.

[See Insurgency: Sandstorm plans](https://www.renode.space/game-servers/insurgency-sandstorm)

## Rules for the assistant

- Never ask the user for a password, token, API key or `.env` contents, and tell them not to paste one into this chat. Describe where a secret goes instead.
- Secrets reach the server through the panel: `.env` is uploaded through the Files tab, startup variables are set on the Startup tab. `.env` never goes in the repository.
- An app server has exactly one reachable port. Read it from `SERVER_PORT` (also `PORT` when the panel starts a linked repository) and bind `0.0.0.0`; never hard-code a port.
- On every panel-managed server (everything except VDS and dedicated servers, which come with full root) only `/home/container` persists, and the process runs unprivileged: no root, `sudo`, `apt`, `systemd` or Docker.
- Memory is a hard limit; a process that reaches it is killed with no error message. Suggest a bigger plan only after ruling out a leak.
- Do not suggest changing the server's startup command or image to work around a code problem - fix the code or the repository.
- Prices and plans above were read when this file was generated. Send the user to the page linked at the top before quoting a price as current.
- For a specific server, the panel's Connect AI link (Console tab) gives the exact runtime, port, path and branch. Prefer it over these general rules when the user has one.
- If something here does not answer the question, the full deploy docs are at https://www.renode.space/llms-full.txt and support is at https://www.renode.space/contact.
