# BeamMP (BeamNG.drive) Server Hosting - everything RE:NODE has published

> A BeamMP (BeamNG.drive) 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/beammp, 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/beammp.

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

## What it is

BeamMP servers for BeamNG.drive -- drive with friends on any stock map, with Lua server mods supported. Every player needs BeamNG.drive.

- Genres: Racing, Simulation, Early Access
- Developer: BeamNG
- Released: 29 May, 2015
- Steam: https://store.steampowered.com/app/284160/

### You supply one thing yourself

BeamMP (BeamNG.drive) is only sold with a credential its publisher issues to a person, so you need to own the game yourself and provide it after checkout. We cannot create it for you and we never share one between customers. Your server is built immediately; the game installation waits until you paste it into the Setup tab, then runs itself.

### What comes with every BeamMP (BeamNG.drive) 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 BeamMP (BeamNG.drive) 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.
- 1 port 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 BeamMP (BeamNG.drive) plan do you need?

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

Storage matters more than people expect once mods and backups are involved - plans here run from 10 GB to 30 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 00:44 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/beammp or in the panel shop at https://panel.renode.space before quoting one.

- You supply: BeamMP authentication key - BeamMP issues a free key per server from its keymaster, signed in with a BeamMP account. Without it the server starts and never appears in the in-game list, so we hold the installation until you paste one in. Takes about a minute to get. (https://keymaster.beammp.com)

| Plan | Price / month | Memory | CPU | NVMe disk | Databases | Backups | Ports |
|---|---|---|---|---|---|---|---|
| Starter | $6 | 2 GB | 1 vCPU | 10 GB | 1 | 2 | 1 |
| Standard | $9 | 3 GB | 1.5 vCPU | 15 GB | 1 | 2 | 1 |
| Advanced | $12 | 4 GB | 2 vCPU | 20 GB | 1 | 2 | 1 |
| Pro | $16 | 6 GB | 2.5 vCPU | 25 GB | 1 | 2 | 1 |
| Premium | $21 | 8 GB | 3 vCPU | 30 GB | 1 | 2 | 1 |


## 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

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

- [BeamMP Keymaster: creating and managing auth keys](https://www.renode.space/blog/beammp-keymaster-auth-key) (2026-10-15): Use the BeamMP Keymaster to create, rotate and revoke server auth keys, where AuthKey goes, key limits, private servers and the errors a bad key causes.
- [How to play BeamMP: install the launcher and join servers](https://www.renode.space/blog/beammp-launcher-and-joining-servers) (2026-10-15): Install the BeamMP launcher, match your BeamNG.drive version, sign in or play as guest, find, favourite and direct-connect to servers, and fix common errors.
- [BeamMP mods and custom maps on a server](https://www.renode.space/blog/beammp-mods-and-custom-maps) (2026-10-15): Add vehicle mods and custom maps to a BeamMP server: Resources/Client zips, the Map path format, join times, bandwidth, consistent packs and broken mods.
- [BeamMP server not showing or players cannot join: fixes](https://www.renode.space/blog/beammp-server-not-showing-and-connection-errors) (2026-10-15): Diagnose a BeamMP server missing from the list or refusing players: port 30814 TCP and UDP, auth key errors, version mismatch, stuck mod downloads, launcher faults.
- [BeamMP server on Linux: install, systemd and ufw](https://www.renode.space/blog/beammp-server-on-linux) (2026-10-15): Run BeamMP-Server on Ubuntu or Debian: pick the right release binary, install liblua5.3-0, generate ServerConfig.toml, add a systemd unit and open port 30814.
- [BeamMP max players: server limits, MaxCars and lag](https://www.renode.space/blog/beammp-server-performance-and-player-limits) (2026-10-15): How many players and cars a BeamMP server can really take: MaxPlayers and MaxCars, bandwidth per player, client-side physics limits, desync causes and a sizing table.
- [BeamMP Lua plugins: commands and races](https://www.renode.space/blog/beammp-lua-plugins-and-races) (2026-10-07): Write BeamMP server plugins in Lua: the event lifecycle, chat commands, timers, vehicle rules, saving data and a working checkpoint race plugin with lap timing.
- [BeamMP server setup: config, maps, mods](https://www.renode.space/blog/beammp-server-guide) (2026-09-21): Host a BeamMP server for BeamNG.drive: auth key, ServerConfig.toml line by line, port 30814, client mods, Lua plugins and why players desync.

---

### BeamMP Keymaster: creating and managing auth keys

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-keymaster-auth-key

The BeamMP Keymaster at `keymaster.beammp.com` is where server auth keys come from. You sign in with Discord, open **Keys**, press the green **+**, give the key a label, and copy the 36-character string into `AuthKey` under `[General]` in `ServerConfig.toml`. One key runs one server at a time, your account only gets a handful, and a BeamMP server with an empty `AuthKey` will not start at all - private or not. Most of the problems people have with BeamMP keys come down to three things: a key that was never pasted, a key pasted with a stray space or into the wrong line, and one key shared between two servers.

This guide covers the Keymaster itself and everything around the key. Installing the server, the rest of `ServerConfig.toml`, maps and mods are in the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide); scripting is in [BeamMP Lua plugins and races](https://www.renode.space/blog/beammp-lua-plugins-and-races).

#### What the auth key actually does

A BeamMP server is not a standalone island. While it runs, it sends a heartbeat to the BeamMP backend over HTTPS - its name, map, player count, version and player list - and the key travels with every heartbeat as the server's identity. The backend answers with a status, and the server logs whether it was accepted. That is how a server gets into the in-game server list, and how the backend knows which account a server belongs to.

```diagram
title: The key travels with every heartbeat
km = Keymaster | keymaster.beammp.com
you = You | copy the key
cfg = ServerConfig.toml | AuthKey
srv = BeamMP server
be = BeamMP backend | heartbeat, list
km -> you : create key
you -> cfg : paste
cfg -> srv : read at start
srv -> be : HTTPS 443, key
be -> srv : accepted or refused
```

Three consequences follow from that design, and they are worth having in your head before you touch anything:

- **The key belongs to an account, not to a machine or a host.** It is created under your Discord login. A host cannot generate one for you; any provider will ask you to paste yours, because there is no other legitimate way to get one.
- **The server needs outbound HTTPS.** The heartbeat goes out on port `443`. A server behind a firewall that blocks outbound traffic will start, but never authenticate, and never appear in the list.
- **The key is a credential.** Anyone who has it can run a server that the backend believes is yours. The BeamMP documentation says it plainly: treat it like a password and never show it to anyone.

#### Signing in to the Keymaster

The Keymaster uses Discord for sign-in. BeamMP states the reason as spam prevention: tying keys to a Discord account makes it expensive to create thousands of junk servers. It is worth joining the BeamMP Discord server too - support, including the route for a compromised key, runs through it.

A few things that catch people out at this step:

- **The Discord account is the owner.** Keys created under one Discord account are not visible from another. If a club runs its servers, decide which account owns the keys before you create them, and make it one that will still exist in two years - not a member who might leave.
- **Your Discord security is your key security.** Somebody who gets into that Discord account can see and delete every key you own. Turn on two-factor authentication in Discord; the reasoning in [two-factor on your panel account](https://www.renode.space/blog/two-factor-on-your-panel-account) applies to any account that holds credentials for a server.
- **The BeamMP forum account is a separate login.** Donation perks are matched using the email on your forum account and the Discord account linked on Patreon, which matters for the key limits below.

#### Creating a key step by step

1. Open `keymaster.beammp.com` and sign in with Discord.
2. Click **Keys** in the menu on the left.
3. Click the green **+** button in the top right.
4. Enter a **Server Name**. This is only the key's label inside the Keymaster - it is not the name players see. That comes from `Name` in `ServerConfig.toml`.
5. Click **Create**.
6. Copy the value in the **Key** field with the clipboard icon to its right.

Use the clipboard icon rather than selecting the text by hand. Hand-selection is how a trailing space or a missing last character ends up in the config, and both give you a server that starts but never authenticates.

Name the key after where it will live: `cruise-de-prod`, `drift-test`, `league-season-3`. When you have three keys and need to revoke the one that leaked, a label that tells you which server it belongs to saves you from guessing - and from taking the wrong server off the list on a race night.

The key itself is a UUID: 36 characters, five groups of hexadecimal separated by hyphens. That length is a useful sanity check, because the server checks it too.

```text
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
```

#### How many keys you get

Every account has a limited number of keys, and every key can run exactly one server at a time. The free allowance is small - hosting providers' guides consistently describe it as two keys per Discord account - and the exact number is shown in the Keymaster when you reach it, which is the place to check because the policy is BeamMP's to change.

Extra keys come from supporting the project. The official player FAQ states the rates:

| Support | Extra keys |
| --- | --- |
| Donation or Patreon tier | 1 per US$ donated |
| Boosting the BeamMP Discord | +5 in total, not per boost |

Both routes also grant early-access perks. For the keys to arrive, your Patreon account must be linked to the same Discord account you use on the Keymaster, and the email on Patreon should match the one on your BeamMP forum account. BeamMP says syncing can take a few hours and sometimes up to 12; if nothing has arrived after that, their support is the next step, not a second donation.

Before paying for more keys, look at whether you need them:

- **A test server does not need its own permanent key** if it never runs at the same time as the live one. It does, however, need to stop before the live server starts, or one of them will be refused.
- **Old keys for servers you shut down still count.** Delete them. A dead key in your list is a slot you are not using and a credential that could still be abused.
- **One key per running server is the rule, not one key per machine.** Two BeamMP servers on one box need two keys.

#### Where the key goes

The key lives in one line of `ServerConfig.toml`, under `[General]`, in quotes because it is a TOML string:

ServerConfig.toml:

```toml
[General]
Port = 30814
AuthKey = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
Private = false
Name = "Sunday Night Cruise"
```

On first start the server writes a fresh `ServerConfig.toml` with a comment pointing at the Keymaster and an empty `AuthKey`, then stops. That is expected: fill the key in and start again. The file layout and every other key are in the [server guide](https://www.renode.space/blog/beammp-server-guide).

##### Environment variables instead of the file

Current 3.x server builds also read the key from the environment. If `BEAMMP_AUTH_KEY` is set and not empty, it overrides whatever is in the file; `BEAMMP_PRIVATE` does the same for `Private`, and is treated as true only when it is `1` or `true`.

```bash
$ export BEAMMP_AUTH_KEY="xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
$ export BEAMMP_PRIVATE=false
$ ./BeamMP-Server
```

This is the better pattern for containers and for anyone who keeps the config file in Git: the file can be committed and shared, and the secret stays out of it. [Environment variables and secrets](https://www.renode.space/blog/environment-variables-and-secrets) covers why that separation is worth the small extra effort. The one trap is precedence - if the variable is set, editing `AuthKey` in the file does nothing, which looks very much like the server ignoring you. Older server versions predate these variables, so check the release notes for the build you run before relying on them.

##### On a hosted panel

On a panel-based host the key is usually a field rather than a line you type into the file, and the panel writes it into the config or the environment for you. On RE:NODE, BeamMP is one of the games that needs a credential of your own: the server is built as soon as payment clears and the install waits on the Setup tab until you paste the key there, which is also where you go to replace it later.

#### Private and public servers

`Private` decides whether the server is advertised, not whether it needs a key. The server refuses to start with an empty `AuthKey` regardless of `Private`, so even a server for four friends needs a key from the Keymaster.

| Setting | In the server list | Joining |
| --- | --- | --- |
| `Private = false` | Yes, once authenticated | List or direct connect |
| `Private = true` | No | Direct connect only |

Two details matter more than they look:

- **`Private = true` is not a password.** It keeps the server out of the list. Anyone who knows the address and port can still connect. Real access control is a Lua check in `onPlayerAuth`; the [plugins guide](https://www.renode.space/blog/beammp-lua-plugins-and-races) shows how, and [whitelist vs password](https://www.renode.space/blog/game-server-whitelist-vs-password) explains why an identifier list beats a shared secret anyway.
- **Private mode silences the authentication messages.** In current builds a private server still sends heartbeats, but it does not print the "Authenticated" line, the refusal reason or the warning about an unreachable backend. A private server with a bad key therefore looks perfectly healthy in the console. If you are testing a key, test it with `Private = false` first, read the result, and then make the server private.

#### Managing, rotating and revoking keys

The Keys page is the whole management interface: your keys, their labels, the value of each, and the option to delete one. Deleting a key is how you revoke it. Once it is gone the backend no longer recognises it: a server started with it will be refused, and one already running under it should not be expected to stay listed. Treat a deleted key as dead everywhere at once.

Rotate a key when it has been exposed - pasted in a Discord channel, visible in a screenshot or stream, committed to a public repository, or held by an admin who has since left. The order matters, because you do not want the server unlisted for longer than a restart:

1. Create a new key in the Keymaster and give it a clear label.
2. Replace `AuthKey` in `ServerConfig.toml` (or the panel field, or `BEAMMP_AUTH_KEY`) with the new value.
3. Restart the server and confirm the "Authenticated" line in the console.
4. Delete the old key in the Keymaster.

You need one free slot for step 1. If every slot is in use, you have to delete the old key first and accept a short gap. If you believe a key has been abused rather than merely exposed - a server you do not recognise appearing under your name, for example - BeamMP asks you to open an Account Support ticket through their Discord as well as deleting the key.

Keep the key out of the places that leak: support tickets to third parties, screenshots of the config editor, shared config templates, and Git history. If somebody on your team needs to edit the server, give them file access without giving them the Discord account; [subusers and least privilege](https://www.renode.space/blog/subusers-and-least-privilege) is the general principle. And keep a backup of `ServerConfig.toml` that does not travel with the key in plain sight - [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) is about the rest of that habit.

#### Errors from a bad, missing or reused key

Every key problem shows up in the server console within the first heartbeat, if you are looking. These are the messages current 3.x builds print, and what each one means:

| Console message | Cause |
| --- | --- |
| `No AuthKey specified in the "ServerConfig.toml" file...` | `AuthKey` is empty. Server stops |
| `AuthKey specified is the wrong length and likely isn't valid.` | Not 36 characters. Server continues |
| `Authenticated!` | The backend accepted the key |
| `Backend REFUSED the auth key. Reason: ...` | Key unknown, deleted or in use |
| `Backend failed to respond to a heartbeat.` | Backend unreachable from the server |

Message wording shifts a little between releases, so search the console for `AuthKey`, `Authenticated` and `REFUSED` rather than for an exact sentence. [Reading the console](https://www.renode.space/blog/reading-the-console) has the habits that make this quick.

##### The server stops straight after starting

The key is empty. Either the file was never saved, the key was pasted into a comment line, or you edited a different `ServerConfig.toml` from the one the server reads - easy to do when an old copy sits in a backup folder next to it. Open the file the server actually loads and check the line under `[General]`.

##### The wrong-length warning

The value is not a 36-character UUID. The usual causes are a leading or trailing space, a missing final character from hand-selection, quotes pasted inside the quotes, or a Discord message ID copied by mistake. The server keeps running after this warning, so it is easy to scroll past; it will then be refused by the backend.

##### "Backend REFUSED the auth key"

The backend saw the key and rejected it. The reason after the colon comes from BeamMP, so read it before guessing. In practice it is one of three things: the key was deleted in the Keymaster, it was mistyped in a way that still has the right length, or it is already in use by another running server. The fix for the last one is a key per server - a test copy left running on a home PC is the classic culprit.

##### "Backend failed to respond to a heartbeat"

This is a network problem, not a key problem. The server could not reach the backend over HTTPS, so it never got an answer either way. Check that outbound traffic on port `443` is allowed, that DNS resolves on the machine, and whether BeamMP's backend is having a bad day. Direct connections still work while this is happening; only the list is affected.

##### Running, authenticated, but not in the list

Check `Private` first - it is the most common cause by a distance. Then give the list a minute or two to refresh. If you still cannot see it, connect directly by address and port: if that works, the key and the server are fine and the issue is listing or filtering in the client. If players cannot connect at all, that is a port problem on `30814` TCP and UDP, covered in [game server ports explained](https://www.renode.space/blog/game-server-ports-explained), not anything the Keymaster can fix.

#### FAQ

##### Is the BeamMP Keymaster free?

Yes. Every Discord account gets a small allowance of keys at no cost, which is enough for most people running one or two servers. More keys come with donations or a Discord boost, at the rates in the official FAQ.

##### Can two servers share one auth key?

No. A key can be used by one running server at a time, and the backend refuses the other. Two servers, including a test copy, need two keys - or the test copy has to be stopped while the real one runs.

##### Do I need an auth key for a private server?

Yes. The server will not start with an empty `AuthKey`, whatever `Private` is set to. Private mode only keeps it out of the public list, and it also hides authentication messages, so verify the key with the server public first.

##### What happens to my server if I delete its key?

The process does not crash and players already on it are not kicked, but the key is no longer valid with the backend: expect the server to lose its place in the list, and to be refused on its next start. Paste a new key and restart to bring it back properly.

##### Can I move a key to a different host?

Yes. The key belongs to your account, not to the machine, so moving a server is a matter of copying the key into the new config and shutting the old server down first. If both run at once, one is refused.

##### Can somebody else create the key for my server?

They can create one under their own Discord account, but then they own it and can delete it whenever they like. For a server you are responsible for, create the key yourself and paste it in yourself.

BeamMP servers on RE:NODE start from $6 a month with port `30814` allocated, `ServerConfig.toml` editable in the browser and SFTP for mod packs. The server is built as soon as payment clears, and the install waits on the Setup tab for your own Keymaster key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### How to play BeamMP: install the launcher and join servers

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-launcher-and-joining-servers

To play BeamNG.drive online you need three things: a legitimate copy of BeamNG.drive (the Steam version is the one BeamMP supports), the BeamMP launcher from `beammp.com`, and either a BeamMP account or a server that lets guests in. You start the game through the launcher, never from Steam directly, then open Multiplayer from the main menu, pick a server from the list or type its address into Direct Connect, and wait while the server's mods download. Almost every "it does not work" report comes down to one of four causes: the game was started from Steam instead of the launcher, the game version and BeamMP do not match, a firewall or antivirus got between the launcher and the game, or a large mod download timed out.

This page is written for players, so a server owner can send the link to anyone joining for the first time. The server side - auth keys, `ServerConfig.toml`, ports and mods - is in the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide).

#### What you need before you start

BeamMP is not a separate game. It is a community multiplayer mod for BeamNG.drive plus a small program, the launcher, that keeps the mod up to date, starts the game with it loaded and handles the network connection to servers. Nothing about your single-player game is replaced; if you start BeamNG.drive from Steam afterwards, it runs as it always did.

| Requirement | Detail |
| --- | --- |
| BeamNG.drive | Owned on Steam, installed, updated to the current release |
| Operating system | Windows is the main platform; Linux support exists but changes often |
| BeamMP launcher | Downloaded from `beammp.com` only |
| Account | A BeamMP forum account, or guest mode on servers that allow it |
| PC performance | Enough to simulate several cars at once - see below |

The performance line is the one people skip. BeamNG.drive simulates soft-body physics for every vehicle on your own machine, and in multiplayer that includes everyone else's cars as well. A server with ten players and two cars each means twenty vehicles running physics on your CPU. A PC that is comfortable with one car in single player can struggle on a busy server, and no amount of server hardware changes that, because the server does not simulate vehicles at all. If your frame rate collapses when people gather in one spot, that is your CPU doing the work it has been asked to do. Smaller servers, or servers with a lower car limit per player, are the fix.

A pirated or cracked copy of the game is not supported, and asking for help with one on the official channels gets you nowhere. Beta branches of BeamNG.drive on Steam are a quieter version of the same problem: BeamMP is built against the public release, so a copy opted into an experimental branch can fail to load the multiplayer mod. In Steam, open BeamNG.drive's Properties, then Betas, and make sure no beta is selected.

#### Installing the launcher

1. Go to `beammp.com` and download the installer. Do not use copies from video descriptions, file mirrors or Discord attachments - the project itself warns that redistributed builds may be tampered with, and a launcher is exactly the kind of program an attacker would like to swap.
2. Run the installer and let it finish. It creates a BeamMP launcher shortcut.
3. Start BeamMP through that shortcut. On first run the launcher checks for its own updates, downloads the BeamMP mod into the game's mods folder and then starts BeamNG.drive.
4. If Windows Firewall asks whether to allow the launcher on private or public networks, allow it. Refusing here is one of the most common reasons a fresh install cannot connect to anything.
5. Leave the launcher's console window open for as long as you play. It is not an installer that has finished its job; it is the bridge between the game and the server, and closing it drops you out of multiplayer.

The launcher keeps itself and the mod current on every start, which is why you should always launch through it rather than through Steam. Starting from Steam loads the game without the launcher running, the Multiplayer screen cannot reach anything, and you get a "launcher not connected" style message.

> [!WARNING]
> Some antivirus products flag the BeamMP launcher as suspicious because it downloads files and opens a local network port, which is what launchers do. If yours quarantines it, restore it and add an exclusion for the launcher's folder - but only for a copy you downloaded from `beammp.com` yourself.

##### Where things end up

The launcher lives in the folder the installer chose. Next to it, it keeps a `Resources` folder used as a cache for mods downloaded from servers, and a small config file. The BeamMP mod itself is placed in BeamNG.drive's user folder under `mods/multiplayer`. The user folder moved in newer versions of BeamNG.drive - it used to sit under Documents and now normally sits under `%LOCALAPPDATA%\BeamNG.drive` with a subfolder per game version - so the quickest way to find yours is the "Open user folder" option in BeamNG.drive's launcher or the game's own settings, rather than guessing a path.

#### BeamNG.drive versions and why updates break things

BeamMP works by hooking into BeamNG.drive's Lua and networking. Every BeamNG.drive release can change the parts it hooks into, so BeamMP has to be updated after game releases. In practice that produces a predictable pattern:

- **The game updates, BeamMP has not caught up yet.** The multiplayer mod fails to load, or loads and misbehaves. The BeamMP team announces compatibility on its Discord and site; the answer is to wait for their update, which the launcher then installs on its own.
- **BeamMP updated, the server did not.** You can launch fine, but joining a particular server fails with a version complaint. That is for the server owner to fix, not you.
- **You are on a beta branch or an old copy.** Switch off betas in Steam and let Steam update the game.

The version that matters is the one BeamMP currently supports, not simply "the newest". In the day or two after a major BeamNG.drive release, the newest game version may be ahead of BeamMP. Turning off Steam's automatic updates to avoid that is possible, but it tends to leave you behind instead, so most players simply accept a short gap after big patches.

#### Signing in: account or guest

When the game opens through the launcher, the Multiplayer screen asks you to log in. You have two choices.

**A BeamMP account.** This is a forum account on `forum.beammp.com`, registered once and used to log in from the game. Signing in gives you a stable identity: your name is the account name, and server owners can identify you by your BeamMP account rather than a display name you could change. Owners who run whitelists, bans or role plugins key them on that identity, so if a server says it is whitelisted, it means your account, not your Steam name.

**Guest mode.** Choosing to play as a guest skips the login and gives you a generated guest name. It is enough to try BeamMP out, but many servers turn guests off - the server setting is `AllowGuests` - and an owner cannot whitelist, promote or reliably ban a guest. If you intend to play on a particular community regularly, make an account.

| | Account | Guest |
| --- | --- | --- |
| Name | Your account name | A generated guest name |
| Joins servers with `AllowGuests = false` | Yes | No |
| Can be whitelisted or given a role | Yes | Not reliably |

If logging in fails while the forum itself works in your browser, check that the launcher window is still open and not reporting an error - authentication goes through the launcher, so a launcher that has stopped or been blocked by a firewall looks like a wrong password from the game's side.

#### Finding servers, filtering and favourites

The server browser is the Multiplayer screen inside the game. It lists every public BeamMP server: name, map, player count, and tags the owner set. The interface has changed across BeamMP versions, but the tools have stayed the same:

- **Search and filters.** Search by name, and filter by map, by empty or full servers and by tags. Owners set tags such as `Freeroam`, `Race` or a region, so the tag filter is the fastest way to find the kind of server you want.
- **Favourites.** Mark a server as a favourite and it stays in its own tab, so you do not have to search for it again. Favourites are saved on your machine, against the server's address and port.
- **Recents.** Servers you joined recently are listed separately, which is handy when you forgot to favourite one.

Look at the map and the server description before you click. A server on a map mod will download that map on join, and a description that says something like "1.5 GB of mods" is warning you about a long first join. The player count also tells you something about your own performance: twenty players on a server with no car limit is a lot of physics for a mid-range CPU.

Ping shown in a list is a rough guide, not a guarantee. What actually makes other cars jitter is packet loss and unstable latency between you and the server, not a big number on its own - [latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) explains the difference, and [game server ping by region](https://www.renode.space/blog/game-server-ping-by-region) explains why a server across an ocean will never feel like a local one.

##### Why a server is missing from the list

A server you were told about may simply not be listed. Owners can mark a server as private, which keeps it out of the public list without locking it - anyone with the address can still join. A brand-new server can take a minute or two to appear. And a list that has gone quiet altogether usually means the launcher cannot reach the BeamMP backend, not that every server went offline at once. In every one of these cases Direct Connect is the way in.

#### Direct Connect

Direct Connect joins a server by its address, bypassing the list entirely. It is in the Multiplayer screen, and asks for two values:

```text
IP:   203.0.113.10
Port: 30814
```

The address is the server's IP or a domain name the owner set up, and the port is the one the server listens on. `30814` is BeamMP's default, but a hosted server often runs on a different port because several servers share one machine, so use exactly what your server owner gave you. Enter the two in separate fields, without `http://`, without spaces and without a colon in the IP field.

Direct Connect is the right tool in three situations: the server is private, the list is slow or broken, or you want to test whether a problem is the server or the list. If Direct Connect works and the list does not show the server, the server is fine. If Direct Connect fails too, the problem is between you and the server, or the server is down.

Owners who hand out a name instead of a number point a DNS A record at the server's address - [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) covers it. You still type the port separately.

#### What happens when you join

Joining is not instant, and knowing the stages makes the waiting easier to read:

1. **Authentication.** The launcher contacts the server, which checks your identity with the BeamMP backend. Servers that refuse guests, run a whitelist or have banned you stop you here.
2. **Mod download.** The server sends every mod in its client folder that you do not already have. They are stored in the launcher's `Resources` cache, so the second join is much faster than the first.
3. **Map load.** The game loads the server's map, which on a large map mod can take a while.
4. **Spawn.** You are placed in the world and can spawn vehicles up to the server's per-player car limit.

The mod download is where most first joins go wrong. A big mod pack on a slow connection can run into a client timeout and drop you back to the menu. Joining again usually continues from what was already cached. If the same download fails repeatedly, the cached copy may be damaged: close the game and the launcher, delete the server's mods from the launcher's `Resources` folder (or the whole folder, which only costs a re-download), and try once more.

> [!NOTE]
> Mods from a server only load while you are on that server. They do not appear in your single-player game, and they do not need to be installed or removed by hand. Your own mods from the BeamNG.drive repository can conflict with a server's mods, though, so if one server misbehaves and others are fine, disable your local mods in the game's mod manager and try again.

#### Common client errors and what fixes them

Exact message wording changes between BeamMP versions, so match on the meaning rather than the text.

| Symptom | Usual cause |
| --- | --- |
| Launcher not connected, or Multiplayer menu empty | Game started from Steam, or launcher closed or blocked |
| Mod fails to load after a game update | BeamMP not yet updated for the new release |
| Version mismatch on one server only | That server's build is out of date |
| Kicked straight after joining | Guests not allowed, whitelist, ban, or server full |
| Stuck on downloading or loading | Large mod pack, slow connection, damaged cache |
| Connected but nobody moves | UDP traffic not getting through |
| Other cars jitter and teleport | Packet loss, yours or theirs |
| Frame rate collapses near other players | CPU cannot simulate that many vehicles |

**Launcher not connected.** Close the game, start it through the BeamMP shortcut, and leave the launcher window open. The launcher and the game talk to each other over a local port on your own machine - `4444` by default, changeable with the launcher's `--port` option, in which case the game has to be set to match. Another program sitting on that port, or a security suite blocking local connections, gives the same symptom.

**Launcher closes immediately or will not update.** Antivirus quarantine or a failed self-update. Restore it from quarantine if needed; if the update itself is broken, download the launcher again from `beammp.com` and install over the top.

**Connected, map loaded, nobody moves.** BeamMP uses TCP to set up the connection and send mods, and UDP for vehicle positions. If UDP is blocked anywhere between you and the server - a strict work or school network, some VPNs, an aggressive router firewall - you load in and everything stays frozen. Try another network to confirm. If every player has this on the same server, the server's UDP port is not open, and that is for the owner. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why games split traffic this way.

**Other cars teleport, everyone else says it looks fine.** The jitter you see is your own connection's packet loss; the jitter everyone sees around one player is theirs. Wired connections help more than anything else. A VPN rarely helps and often hurts - [does a VPN lower ping in games](https://www.renode.space/blog/does-a-vpn-lower-ping-in-games) explains when it might.

**Crashes on join.** Usually a mod from the server clashing with the current game version or with your own mods. Try with local mods disabled, then tell the server owner which server and when, because if it is their mod pack, everybody is having the same crash.

#### For server owners: what to send your players

The most useful thing an owner can do is answer the first-join questions before they are asked. A short pinned message in your Discord saves a lot of repetition:

Pinned message:

```text
How to join:
1. Install BeamMP from beammp.com (only from there).
2. Start the game with the BeamMP shortcut, not from Steam.
   Keep the launcher window open while you play.
3. Log in with a BeamMP account (guests are not allowed here).
4. Multiplayer > search "Sunday Night Cruise", or
   Direct Connect: IP 203.0.113.10, port 30814.
5. First join downloads about 800 MB of mods. Be patient.
Rules: max 2 cars, no ramming. Problems? Post in #help
with a screenshot of the launcher window.
```

Say the mod pack size honestly, give the address and the port even if the server is listed, and say whether guests are allowed. Asking for a screenshot of the launcher window rather than a description of the game is the single best support tip: the launcher log shows authentication, download and connection errors that the game's interface summarises as "failed". If you want ideas for structuring the help channel, [game server Discord setup](https://www.renode.space/blog/game-server-discord-setup) covers it.

On RE:NODE, BeamMP servers come with the port allocated on both TCP and UDP and the address shown in the panel, so the values in that message are copied straight from the server page. The auth key is your own, pasted in on the Setup tab.

#### FAQ

##### Is BeamMP free?

Yes. The launcher, the multiplayer mod and joining servers cost nothing. You need to own BeamNG.drive, which is a paid game, and anyone who wants to run their own server pays for wherever it runs.

##### Can I play BeamMP without an account?

Yes, as a guest, on servers that allow guests. Many do not, and guests cannot be whitelisted or given roles, so an account is worth the minute it takes if you plan to stay on one community.

##### Why does BeamMP stop working after a BeamNG.drive update?

Because the multiplayer mod hooks into parts of the game that change between releases. BeamMP publishes an update after each release, and the launcher installs it the next time you start it. Until then, multiplayer may not load.

##### Can I use my own BeamNG.drive mods on a server?

Only the server's mods are loaded for everyone. Your local mods can still be active, but other players will not see a vehicle they do not have, and local mods are a common source of conflicts, so disable them when a server misbehaves.

##### Does BeamMP work on Linux or Steam Deck?

People do run it, but Windows is the main supported platform and the details change with each launcher release. Check the BeamMP documentation and Discord for the current state rather than an old guide.

##### The server is in the list but I cannot join. Is the server down?

Try Direct Connect with the owner's address and port. If that fails too and other people are playing, the problem is on your side: launcher, firewall or network. If nobody can join, tell the owner.

Running the server your players join? BeamMP on RE:NODE starts at 2 GB, with the port allocated on both protocols, `ServerConfig.toml` editable in the browser and SFTP for mod packs. The install waits on the Setup tab for your own Keymaster auth key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP mods and custom maps on a server

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-mods-and-custom-maps

Adding mods to a BeamMP server is one folder and one line. Every vehicle or map mod goes into `Resources/Client` as the original `.zip`, unopened, and the server sends it to each player as they join. A custom map additionally needs the `Map` key in `ServerConfig.toml` pointed at that map's `info.json`, written as `/levels/<folder>/info.json`, where `<folder>` is the folder name inside the zip, not the name on the download page. Restart, and you are done.

The part nobody warns you about is the cost. Every byte in `Resources/Client` is downloaded by every player who does not already have it, through your server's upstream, before they can drive. A 3 GB pack is a five-minute wait for a first-time joiner on a good connection and a lost player on a bad one. This guide is about doing the simple part correctly and keeping the expensive part under control: the zip rules, the map path, how pack size turns into join time and traffic, how to keep a pack consistent across updates, and how to find and remove the mod that broke everything.

If the server itself is not running yet, start with the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide), which covers the auth key, the rest of `ServerConfig.toml`, ports and Lua basics.

#### How BeamMP distributes mods

BeamMP has no workshop integration and no mod manager on the server. The model is deliberately blunt: the server owns a folder of zips, and a client that joins must end up with exactly those zips loaded.

```diagram
title: A mod reaches a player on join
pack = Resources/Client | your mod zips
server = BeamMP server | TCP 30814
launcher = BeamMP launcher | compares, downloads
game = BeamNG.drive | loads the zips
pack -> server : read at start
server -> launcher : mod list, then files
launcher -> game : multiplayer mods
```

On join, the server tells the client which files it serves. The launcher compares that list against what it already holds and downloads whatever is missing or different over the TCP side of port `30814`. Only when every file has arrived does the game load the level and drop the player in. A returning player who already has an identical copy downloads nothing, which is why the first join is slow and later ones are not - and why changing a file, even slightly, puts every player back on the slow path.

Two consequences follow from this design:

- **There is no partial pack.** A player cannot skip a mod they do not want. If it is in `Resources/Client`, it is a mandatory download for everyone.
- **Server-side and client-side are separate worlds.** `Resources/Client` is content for players. `Resources/Server` holds Lua plugins, which are never sent to anyone. A mod zip dropped into `Resources/Server` does nothing, and a Lua plugin dropped into `Resources/Client` is shipped to every player as a useless download. The [BeamMP Lua plugins guide](https://www.renode.space/blog/beammp-lua-plugins-and-races) covers the server side.

#### The zip rules for Resources/Client

BeamNG.drive mods are zip archives with the game's own folder layout at their root. A vehicle mod looks like `vehicles/<model>/...`, a map looks like `levels/<mapname>/...`, and some mods carry `ui/`, `art/` or `lua/` folders beside them. BeamMP sends these archives as they are, so the rules are the game's rules plus one of its own.

| Rule | Why it matters |
| --- | --- |
| Keep the `.zip` packed | The server sends archives, not folders |
| Layout at the zip root | `vehicles/` or `levels/` must be top level |
| No zip inside a zip | The game will not look inside it |
| One copy of each mod | Two versions fight over the same paths |
| Plain file names | Spaces and odd characters cause grief |

The first rule catches people on every host with a web file manager. Upload a mod, see an archive, click "unpack" out of habit, and you now have a folder that the server does not send and a player base that cannot see the car. If you unpacked something by accident, delete the folder and upload the zip again.

The second rule catches people who download from forums. A mod shared as `CoolCar_v2.zip` sometimes contains a folder `CoolCar_v2/` with the real `vehicles/` folder one level down, or contains `CoolCar.zip` itself because somebody zipped the zip. Neither loads. Open the archive before uploading it: the first thing you see inside must be `vehicles`, `levels` or another of the game's top-level folders. If it is not, repack it so it is. On Linux the fix looks like this:

```bash
$ mkdir fix && cd fix
$ unzip ../CoolCar_v2.zip
$ ls
CoolCar_v2
$ cd CoolCar_v2 && zip -r ../../coolcar.zip . && cd ../..
$ unzip -l coolcar.zip | head
```

The last command lists the repacked archive; the paths it prints should start with `vehicles/`.

Vehicle mods need nothing else. Once the zip is in `Resources/Client` and the server has restarted, the car appears in the vehicle selector for everyone who joined after the restart. If you want to stop people spawning a particular model, that is a Lua job at `onVehicleSpawn`, not something the mod folder can express.

> [!WARNING]
> Never extract a mod zip inside `Resources/Client`. An extracted folder is not sent to players, and the leftover copy can confuse you for hours. On RE:NODE the file manager unpacks archives in place, which is useful elsewhere and exactly wrong here.

#### Custom maps and the Map path

The `Map` key is a path into the game's virtual file system, pointing at the level's `info.json`. For a stock level that is the folder name from the base game:

ServerConfig.toml:

```toml
[General]
Map = "/levels/west_coast_usa/info.json"
```

A modded map works the same way. The zip goes into `Resources/Client`, and the path names the folder under `levels/` inside that zip. The steps, in order:

1. Upload the map zip to `Resources/Client`.
2. List the archive's contents and find the line ending in `info.json` under `levels/`.
3. Copy that folder name exactly, including case, into `Map`.
4. Restart the server and join it yourself before telling anyone.

```bash
$ unzip -l Resources/Client/some_map_v3.zip | grep info.json
      812  2026-08-02 14:10   levels/somemap/info.json
```

That output gives you `Map = "/levels/somemap/info.json"`. Note how little the folder name has to do with the zip name: `some_map_v3.zip` contains `somemap`. Guessing from the download page is how most "my map does not load" posts start.

Three details trip people up:

- **The leading slash and the `info.json` belong in the value.** `levels/somemap`, `/levels/somemap/` and `somemap` are all wrong. Copy the format of the default line and change only the folder.
- **Case matters.** BeamMP servers usually run on Linux, where `SomeMap` and `somemap` are different folders. Use exactly what the archive says.
- **Only one map per server.** Every player is on the level named in `Map`. Changing it means editing the file and restarting, which drops everyone. Servers that rotate maps do it on a schedule with a restart, or run a second server.

Some maps depend on a separate content pack - shared assets that several maps from the same author use, published as their own zip. The map's page usually says so. If a map loads with missing textures, purple surfaces or absent buildings, a dependency is missing; it goes into `Resources/Client` beside the map.

When the path is wrong, what happens depends on the version: some builds fall back to a default level, others leave clients stuck on a loading screen. Either way, the fix is the same: list the zip again and compare character by character. When a map is too new or too old for the players' game version, it typically loads partly or throws errors in the game's own log; that is a version problem, not a path problem, and moving the zip aside proves it.

#### Mod size, join time and what players tolerate

Join time is arithmetic. The first-time download is the size of everything in `Resources/Client` divided by the slower of two numbers: what your server can push to that player, and what their connection can take in. Players joining at the same moment share the server's upstream between them.

| Pack size | At 50 Mbit/s | At 10 Mbit/s |
| --- | --- | --- |
| 300 MB | about 50 seconds | about 4 minutes |
| 1 GB | about 3 minutes | about 14 minutes |
| 3 GB | about 8 minutes | about 40 minutes |

Those are ideal figures for one player with the line to themselves; real downloads run slower. The numbers make the trade-off concrete. A 300 MB pack is invisible. A 1 GB pack is fine for a regular group who download it once. A 3 GB pack on a public server means that most people who click your name in the server list are gone before it finishes, and some of them will try again later and start from scratch.

What makes a pack large is usually not what server owners expect. A single detailed vehicle mod is commonly tens to a few hundred megabytes, and maps are the heavy items - a large custom map can be well over a gigabyte on its own. Sizes vary a great deal between authors, so check the zips rather than trusting a rule of thumb:

```bash
$ du -h Resources/Client/*.zip | sort -h
$ du -sh Resources/Client
```

Run that before and after every change. The list sorted by size tells you where the weight is, and it is very often one map and two enormous car packs that between them account for most of the total.

Practical limits that work:

- **Public servers**: keep the total under about 1 GB and say the size in the server description or `Description` text, so people know what they are agreeing to.
- **Private groups**: size matters less, because each person downloads once. Tell people to join the evening before an event to get the download out of the way.
- **Event servers**: one map, the event cars, nothing else. A race does not need forty spare vehicles in the pack.

If you are tempted to add "a few popular cars" to make a server more attractive, look at the join numbers first. A smaller, faster server tends to fill; a large, slow one tends to be skipped.

#### Bandwidth: who pays for the downloads

Every mod download goes out through the server's uplink. Multiply the pack by the number of first-time joiners and the figure gets large fast. A public server with a 2 GB pack and fifty new players in a week sends about 100 GB of mod traffic, on top of the ordinary vehicle state. After a restart that changes a file, every regular is a first-time joiner again.

On top of that sits the in-game traffic, which scales with players multiplied by cars, because each client receives updates for every vehicle. [Game server bandwidth per player](https://www.renode.space/blog/game-server-bandwidth-per-player) gives a method for estimating it; for BeamMP the useful lesson is that `MaxCars` affects both client performance and traffic.

The burst matters as much as the total. Ten people joining together after a restart all pull the pack at once, and they share the upstream between them, so each of them sees a slower download than they would alone. Players then time out, retry and add to the load. If you run scheduled restarts, put them at a quiet hour, and if you have to change the pack, do it once rather than in five small steps over an evening.

On a host that does not bill per gigabyte, none of this costs extra money, but it is still a shared uplink, and [bandwidth and fair use](https://www.renode.space/blog/bandwidth-and-fair-use) explains what "unmetered" means in practice. The disk side matters too: BeamMP plans on RE:NODE run from 10 GB of NVMe on the smallest plan up to 30 GB on the largest, and a pack plus its backups has to fit.

#### Keeping a mod pack consistent

Most mod trouble on BeamMP is version trouble: a mod updated by its author, a game patch that changed something the mod relied on, or two versions of the same mod in the pack at once. A little discipline avoids nearly all of it.

**Keep one copy of each mod.** When you update a mod, delete the old zip before uploading the new one. Two archives that both contain `vehicles/coolcar/` overwrite each other in an order you do not control, and the result is a car that sometimes has the new parts and sometimes does not. This is the same problem that [mod load order](https://www.renode.space/blog/mod-load-order-explained) describes for other games, with the difference that BeamNG gives you no load order to manage - you simply must not have duplicates.

**Name files with versions.** `coolcar_v2.1.zip` rather than `coolcar.zip`. When something breaks, you can see at a glance what changed since last week.

**Keep a manifest.** A plain text file beside the server, or in your Discord, listing each zip, its version, its size and where it came from. It is the thing you will reach for when a game update lands and you have to decide which mods to check first.

pack.txt:

```text
somemap_v3.zip        1.4 GB   map, requires somemap_assets
somemap_assets.zip    310 MB   dependency of somemap
coolcar_v2.1.zip      180 MB   vehicle
pickup_pack_v1.0.zip   95 MB   vehicle
```

**Mind the players' local mods.** A player who has their own copy of a mod in their regular BeamNG mods folder, at a different version from yours, can see odd behaviour. BeamMP keeps the files it downloads apart from a player's own mods, but how the two interact has changed between launcher versions. When one player reports a problem nobody else has, ask them to disable their local mods and rejoin before you touch the server.

**Update on purpose.** After a BeamNG.drive release, players update their game, BeamMP follows, and some vehicle and map mods stop working until their authors catch up. Do not chase updates on a night people are waiting to drive. Take a backup of `Resources/Client` and `ServerConfig.toml` first, update the server, then add mods back in a controlled way. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) describes the general routine.

#### Finding and removing a broken mod

A broken BeamMP mod shows itself on the players' side, not the server's. The server does not load the mods, it only sends them, so the server console usually looks clean while players see a car that will not spawn, a vehicle with missing parts, a Lua error box in the game, a level that never finishes loading, or a crash to desktop.

The fastest diagnosis is bisection, and it works because there is no world state to damage:

1. Stop the server and move everything out of `Resources/Client` into a folder beside it, such as `Resources/Disabled`.
2. Start the server with the stock map and confirm that a clean join works.
3. Move half the mods back, restart, test.
4. If the problem returns, the culprit is in that half. If not, it is in the other half. Repeat with the suspect half.

With twenty mods that is about five restarts. Keep the map in the first half you test if the map is a suspect, and set `Map` back to a stock level while you test the vehicles, so a map problem cannot hide a vehicle problem.

Players are your second source of evidence. The game writes a log, `beamng.log`, in the user folder, and the error near the end of it usually names the mod's folder. Ask one affected player to send it rather than describing what they saw.

To remove a mod for good:

1. Delete the zip from `Resources/Client`, not just rename it - a renamed `.zip` is still a zip and may still be sent.
2. If a map was removed, change `Map` back to a stock level or another map you still have.
3. Restart the server.
4. Update your manifest and tell your players, so nobody keeps reporting a car that no longer exists.

Moving files into a sibling folder like `Resources/Disabled` is a safe way to park a mod without deleting it; the server only reads the folders it is configured to read. Do not leave disabled mods inside `Resources/Client` with a changed extension and assume they are ignored on every version.

Before adding a replacement, think about where it came from. Every zip you serve runs on other people's PCs, and vehicle mods can contain Lua. Use mods from authors and sites you can name, and treat a mod that appeared only as a file in a chat with suspicion. [Malicious plugins and mods](https://www.renode.space/blog/malicious-plugins-and-mods) and [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) go into this properly.

#### Uploading packs and keeping backups

Uploading a multi-gigabyte pack through a browser works, but a browser upload that stalls at 90% is lost time. For anything over a few hundred megabytes, use SFTP: it resumes in most clients, and it lets you drop a whole set of zips in one go. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) covers the connection; on RE:NODE every server has its own SFTP credentials and the browser file manager is there for quick edits to `ServerConfig.toml`.

Because the server keeps no world state, a BeamMP backup is about the setup, and it is easy to forget until a bad update forces you to rebuild from memory. What is worth keeping:

- `ServerConfig.toml`, which holds your map choice and settings.
- `Resources/Server`, your Lua plugins, which you cannot download again.
- `Resources/Client`, the exact set of mod versions that last worked together, or at least the manifest that lists them.

Large packs make full backups heavy, so a sensible split is a backup of the config and plugins before every change, and a full backup including `Resources/Client` when the pack is in a known good state. On RE:NODE, game plans carry backup slots you can run on demand or on a schedule and restore with a button; they are stored off the machine, and the panel's [backups guide](https://www.renode.space/guides#backups) explains the controls. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) is the reminder to test one.

#### FAQ

##### Do players need to install the mods themselves?

No. Anything in `Resources/Client` is downloaded automatically by the BeamMP launcher when a player joins and loaded for that session. Players only need BeamNG.drive and BeamMP. Asking them to install mods by hand usually makes things worse, because their manual copy may be a different version.

##### Can I have two maps on one BeamMP server?

You can upload several map zips, but only the one named in `Map` is used, and everyone is on it together. The others are still sent to every player, so unused maps are pure download cost. Keep only the map you are running, and switch by editing `Map` and restarting.

##### Why does my custom map load the default level instead?

The `Map` path does not match a level that exists. List the zip, find the folder under `levels/` that holds `info.json`, and write it as `/levels/<folder>/info.json` with the same case. Check that the zip is still packed and sits directly in `Resources/Client`.

##### Does BeamMP support Steam Workshop or the in-game repository?

Not for servers. The server serves only the zips in its own `Resources/Client` folder. To use a mod from the BeamNG repository, download the zip yourself and upload it, keeping a note of the version.

##### Why do returning players have to download everything again?

Because a file changed. The launcher downloads any file that is missing or differs from the copy it has. Replacing, repacking or updating a zip counts as a change, so batch your pack changes together rather than making them one at a time.

##### How big can a BeamMP mod pack be?

There is no fixed limit beyond your disk, but join time sets a practical one. Under about 1 GB is comfortable for a public server; private groups can go larger because each person downloads once. Measure with `du -sh Resources/Client` and tell players the total.

BeamMP plans on RE:NODE start at $6 a month with port `30814` allocated, `ServerConfig.toml` editable in the browser, SFTP for uploading mod packs to `Resources/Client`, and backup slots for keeping a working pack. The server is built when payment clears; the install waits on the Setup tab for your own Keymaster auth key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP server not showing or players cannot join: fixes

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-server-not-showing-and-connection-errors

A BeamMP server that "does not work" is nearly always one of two separate failures that look the same from a player's chair. Either the server never registered with the BeamMP backend, so it is missing from the list - an auth key or `Private` problem - or it registered but cannot be reached on port `30814`, so it shows up and then refuses everyone. A third group of faults lives entirely on the player's PC: the launcher, the game version, the mod cache. The fastest way to tell which one you have is to try a direct connect by address and port, and to run the server's port through the CheckBeamMP tool. Those two tests split the problem before you edit a single file.

This post is the diagnosis order, with the evidence each step gives you. For setting the server up in the first place - `ServerConfig.toml` line by line, maps, Lua - see the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide). For the general version of this checklist that applies to any game, see [why players cannot connect to your server](https://www.renode.space/blog/why-players-cannot-connect-to-your-server).

#### Not in the list, or not reachable? Split the problem first

Two systems are involved every time somebody joins, and they fail independently.

```diagram
title: Listing and joining are two separate paths
server = BeamMP server | Server.log
backend = BeamMP backend | auth key, server list
launcher = Player launcher | localhost port 4444
game = BeamNG.drive | BeamMP client mod
server -> backend : outbound, registers
launcher -> backend : fetches list, logs in
game <-> launcher : local only
launcher -> server : TCP and UDP 30814
```

The server talks outbound to the backend to prove who it is and to appear in the list. The player's launcher talks to the backend to fetch the list and authenticate the player, then connects directly to your server on its port. The list is just a directory; being in it says nothing about whether your port is open, and being absent from it says nothing about whether the port is closed.

| What you see | Most likely layer |
| --- | --- |
| Server not in the list, direct connect works | Auth key, `Private`, backend registration |
| Server in the list, nobody can join | Port, protocol, firewall |
| Not in the list, direct connect also fails | Server not running, or both of the above |
| One player fails, others join | That player's launcher, game or network |
| Everyone fails right after a BeamNG patch | Version mismatch |
| Players connect, then hang on mod download | Mod pack size or a bad cached file |

If one player out of eight cannot join, leave the server alone. Seven successful joins prove the key, the list and the port.

#### The diagnosis order

Work through these in sequence. Each step takes a minute and rules out a layer, and skipping ahead - rewriting firewall rules before reading the log - is how an evening disappears.

1. Read the server log. Did it start, and did it authenticate?
2. Check `Private` and the list registration.
3. Direct connect by address and port from outside the server's network.
4. Test the port with CheckBeamMP.
5. Check versions: BeamNG, the BeamMP client, the server build.
6. Check the mod pack in `Resources/Client`.
7. Only then look at the player's launcher and PC.

The rest of this post takes each step apart.

#### Step 1: read Server.log before anything else

The server writes everything it prints to `Server.log` in its own directory. It mirrors the console, and it never contains your auth key, so it is safe to paste into a support channel without editing.

What you are looking for is whether the server reached the point of accepting players. A server that exits a second after starting is never a network problem. The usual causes, all visible in the log:

- **No auth key, or the placeholder.** The key is empty by default and the server will not run without it. This is the single most common first-start failure.
- **A TOML syntax error.** A missing quote around a string in `ServerConfig.toml` stops the server rather than being ignored. The log names the line.
- **An old `Server.cfg` beside the new file.** Older BeamMP servers used `Server.cfg`; current builds use `ServerConfig.toml` and warn if the old file is still there. The formats are not compatible, so editing the wrong one changes nothing.
- **A bind error.** Codes `10022` and `10048` mean the server could not take its port, usually because another program - often a second BeamMP server - already holds it. Give each server on a machine its own port.

On RE:NODE the console shows the live log, and the file manager opens `Server.log` and `ServerConfig.toml` in the browser, so this step is two tabs. If a server is restarting in a loop, [game server crash loops](https://www.renode.space/blog/game-server-crash-loops-diagnosis) covers reading that pattern.

#### Step 2: auth key failures

Every BeamMP server, private ones included, needs an auth key from the BeamMP Keymaster at `keymaster.beammp.com`. The key identifies the server to the backend; without a valid one it does not start or does not register. Auth failures come in a handful of shapes.

- **Mistyped or truncated.** The key is a long hyphenated string. Copying from a Discord message or a phone often loses a character or adds a trailing space inside the quotes. Paste it fresh from the Keymaster.
- **Regenerated or deleted.** If you, or someone with your account, regenerated the key in the Keymaster, the old string stops working at once. Every server still holding it fails on next start.
- **Shared between two servers.** One key per server. Two running servers presenting the same key will not both behave, and the symptom - a server that appears and disappears from the list - is confusing enough that it is worth ruling out early. Keep a test server on its own key.
- **Out of keys.** Accounts get a limited number of server keys; BeamMP's own FAQ lists supporter perks that add more. If you cannot create a new key, that is why, and the fix is to reuse a key from a server you have retired.
- **Leaked.** A key posted in a public channel can be used by somebody else's server. Regenerate it in the Keymaster, and if the account itself is compromised, BeamMP handles that through an Account Support ticket on its official Discord.

ServerConfig.toml:

```toml
[General]
AuthKey = "paste-the-whole-key-here"
Private = false
Port = 30814
```

The key must be inside double quotes, on one line, with nothing else between them. Treat it like a password, for the same reasons as any other secret a server holds - [environment variables and secrets](https://www.renode.space/blog/environment-variables-and-secrets) makes the general case.

> [!NOTE]
> No host can issue a BeamMP key for you. It belongs to your BeamMP account. On RE:NODE the server is built as soon as payment clears and the install waits on the Setup tab until you paste your own key in; that tab is also where you replace it after regenerating.

#### Step 3: the server is up but not in the list

If the log shows a clean start and the server is still missing from the in-game browser, check in this order.

**`Private` is `true`.** That setting hides the server from the list and does nothing else. It is not a password. Set it to `false`, restart, and wait a couple of minutes.

**The server cannot reach the backend.** Registration is an outbound connection from the server to BeamMP's backend. On a home machine, an outbound firewall rule or security suite blocking `BeamMP-Server` stops it silently. On a VPS with a default-deny outbound policy, the same. Hosted game panels allow outbound traffic, so this is mostly a self-hosting problem.

**You are looking for it from the same network.** BeamMP's own FAQ calls this out: joining your own home-hosted server through the list needs NAT loopback on your router, which many home routers do not support. From the PC running the server, use Direct Connect with `127.0.0.1` and the port; from another PC in the house, use the server's LAN address. Your friends outside use the public address. Your own view of the list is the least reliable test you have.

**The search is hiding it.** The list is long. Search for an unusual word from your server's `Name`, not a common one like "freeroam". Formatting codes in the name are fine but make it harder to match by eye.

**It just started.** Give a new or restarted server a couple of minutes before deciding it is missing. If it still is not there and direct connect works, the server is fine for anyone who has the address - hand that out while you sort the listing.

For the general mechanics of how master lists and server browsers work across games, [why a server does not show in the server list](https://www.renode.space/blog/server-browser-visibility-steam-master-server) is the companion piece.

#### Step 4: ports, protocols and firewalls

BeamMP needs one port number on two protocols, and both must reach the server.

| Port | Protocol | Carries |
| --- | --- | --- |
| `30814` | TCP | Join handshake, mod downloads |
| `30814` | UDP | Vehicle position and state |

If you changed `Port` in `ServerConfig.toml`, that number replaces `30814` everywhere below. Valid values are above `1024` and below `65535`.

##### Test the port from outside

BeamMP runs a checker that tries to reach your server from the internet. With the server running, open this in a browser, using your public IPv4 address and port:

```text
https://check.beammp.com/api/v2/beammp/203.0.113.10/30814
```

A `status` of `ok` means the port is reachable. An error means the connection failed - a closed port, a firewall, a wrong forward, or no public address at all. BeamMP does not support hosting over IPv6, so use the IPv4 address. A test from the server itself, or from a PC on the same network, proves nothing; the checker exists precisely so you do not have to find a friend on mobile data.

##### What the launcher error codes mean

Players see Windows socket codes in the launcher when a join fails. They are more useful than they look.

| Code | Meaning | Look at |
| --- | --- | --- |
| `10060` | Timed out, nothing answered | Forward, firewall, protocol |
| `10061` | Refused, machine answered, nothing listening | Server down or wrong port |
| `10038` | Socket operation failed | Firewall, then forward |
| `10051` / `10065` | Network or host unreachable | Address, forward, routing |
| `10048` | Port already in use | Another program on that port |

The distinction between `10060` and `10061` is the best clue you get. Refused means packets reached a machine and were rejected, so the address is right and the server is not listening there - wrong port, or the server is not running. Timed out means something dropped the packets on the way.

##### Opening the port on your own machine

On Windows, allow both protocols inbound. BeamMP's FAQ notes that switching the firewall off entirely usually does not help, so add rules instead:

PowerShell, as administrator:

```text
New-NetFirewallRule -DisplayName "BeamMP TCP" -Direction Inbound `
    -Protocol TCP -LocalPort 30814 -Action Allow
New-NetFirewallRule -DisplayName "BeamMP UDP" -Direction Inbound `
    -Protocol UDP -LocalPort 30814 -Action Allow
```

On a Linux VPS with ufw:

```bash
$ sudo ufw allow 30814/tcp
$ sudo ufw allow 30814/udp
$ sudo ufw status
```

At home, the router forward needs both protocols too - some routers make you add two separate rules - pointed at the server's LAN address, which should be fixed so it does not change on reboot. No forward will ever work behind CGNAT, and mobile 4G and 5G connections do not support forwarding at all. [NAT and CGNAT for game hosts](https://www.renode.space/blog/nat-and-cgnat-for-game-hosts) explains how to tell whether your connection has a public address, and [the ufw firewall guide](https://www.renode.space/blog/ufw-firewall-guide) covers the VPS side in more depth.

The classic half-open symptom: TCP open, UDP blocked. Players connect, download mods, the map loads, and then every other car is frozen or invisible because the state stream never arrives. If that is what people describe, check the UDP rule specifically.

##### On a hosted panel

There is no router and no Windows firewall to fight, but there is one equivalent mistake: `Port` in `ServerConfig.toml` set to a number that is not allocated to the server. On RE:NODE the allocated port is listed on the Network tab; if the config names any other port, the server listens where nothing routes. Make the two match, restart, and run the checker again. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) goes through why allocation matters.

#### Step 5: version mismatch after a BeamNG update

A large share of "nobody can join" reports arrive the day BeamNG.drive updates. Three moving parts have to agree: the game, the BeamMP client mod and launcher on each player's PC, and the server build.

- **The game updated before BeamMP did.** BeamMP has to release a compatible client after a BeamNG update. Until it does, players on the new game version cannot play multiplayer anywhere, and nothing you change on the server fixes it. Check BeamMP's announcements before debugging.
- **The server is older than the clients.** When BeamMP updates its protocol, an old server build rejects or confuses updated clients. Update the server; it is a small binary, and on a panel it is usually a reinstall or restart with updates enabled. Keep a copy of `ServerConfig.toml` and `Resources/Server` first.
- **One player is behind.** A player whose launcher did not update, or who is on an outdated game, fails while everyone else joins. BeamMP's FAQ is explicit that it does not work with pirated or outdated copies of BeamNG.drive.
- **A mod broke with the patch.** Vehicle and map mods in `Resources/Client` break with BeamNG updates regularly. The server starts, players join, and then crash or hang on load. Move the mod folder aside and start clean to prove it.

Do not update a working server on an evening when people are waiting to drive. The habits in [the game server update day checklist](https://www.renode.space/blog/game-server-update-day-checklist) apply here unchanged.

#### Step 6: mod downloads that stall or never finish

When a player joins, the server sends every `.zip` in `Resources/Client` over TCP before they can drive. That transfer is where most "stuck on loading" reports come from.

- **The pack is too big.** A several-gigabyte pack over the server's uplink, divided among several people joining at once, takes minutes. Players assume it has hung and quit, which restarts the download next time. Trim the pack, and state its size in your Discord so people know to wait.
- **One corrupt zip.** A file truncated during upload is sent faithfully to every player and fails to load on all of them. Re-upload over SFTP rather than a flaky browser upload; compare file sizes with the original.
- **Things in `Resources/Client` that are not mods.** Only mod zips belong there. Lua plugins go in `Resources/Server`, which is never sent to clients; a plugin dropped in the wrong folder is pushed to every player as if it were a mod.
- **A wrong map path.** If `Map` points at a level folder that does not exist inside any installed map or mod zip, the server starts and players load into nothing useful. Open the map zip and read the folder name under `levels/`.
- **A bad file in the player's cache.** The launcher caches downloaded server mods in a `Resources` folder inside its own install directory. If one player hangs on a mod that loads for everybody else, have them close the game and launcher and delete that `Resources` folder; it refills on next join.
- **The player's own mods.** Third-party mods installed locally can interfere with BeamMP. BeamMP's documented clean-slate method is to close the game and rename the `current` folder in the BeamNG userfolder to something like `current_old`, which gives a fresh profile and keeps the old one to move back.

Upload large packs with a proper client - [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the details - and test a join yourself with an empty cache after every mod change.

#### Step 7: the player's launcher and PC

When the server checks out and one player still cannot join, the fault is on their side. BeamMP's client is two pieces: the BeamMP launcher, and a mod inside BeamNG.drive that talks to it over a local port on the same PC.

- **The game was started on its own.** Multiplayer needs the launcher running; start the game through `BeamMP-Launcher`, not from Steam directly.
- **Antivirus removed or blocked the launcher.** Because it talks to the network, security software sometimes quarantines it. BeamMP's FAQ addresses this and documents adding a Windows Defender exclusion. If the launcher vanishes after a download, check quarantine.
- **The launcher's local port is taken.** The game and launcher talk over port `4444` on the player's own machine by default. If another program holds it, the launcher shows a bind error such as `10013` or `10048` and the game never connects. Change it in two places so they match: in BeamNG, Options, Multiplayer, show advanced options, Launcher port; then the `Port` value in `launcher.cfg` beside the launcher. Any number from about 2000 up works.
- **A VPN, school or hotel network.** VPNs cause trouble with BeamMP and restrictive networks often drop UDP. Have the player test on another connection.
- **Guest accounts.** With `AllowGuests = false`, players without a BeamMP account are refused. That is deliberate on most servers; tell them to sign in.
- **The server is full.** `MaxPlayers` reached. Obvious in hindsight, rarely obvious from "it won't let me in at 9pm".

The Linux client is not officially supported, so a player on Linux hitting launcher errors is outside what BeamMP itself will help with.

> [!TIP]
> Before asking anyone for help, collect the exact launcher error or code, the address and port the player used, whether anyone else can join, the last 50 lines of `Server.log`, and what changed since it last worked. The last item solves more cases than the other four.

#### FAQ

##### Why can I join my BeamMP server by IP but not see it in the list?

Because joining and listing are separate. Direct connect proves the port is open; the list depends on the server registering with the backend using its auth key and on `Private` being `false`. If you are on the same home network as the server, you may also simply be unable to use the list for it without NAT loopback.

##### Does BeamMP need TCP or UDP?

Both, on the same port number - `30814` unless you changed it. TCP carries the join and mod downloads; UDP carries vehicle state. With only TCP open, players load in but other cars freeze or never appear.

##### Can I run two BeamMP servers on one key?

No. Each server needs its own key from the Keymaster. Reusing one causes servers to fail to register or flicker in the list, and the cure is a second key or retiring the first server.

##### Players are stuck downloading mods. Is the server too small?

Rarely. The server is light on CPU and memory; the download is limited by the uplink, the pack size and how many people join at once. Shrink the pack first. If one player is stuck and others are not, clear that player's launcher `Resources` cache.

##### Do players need to open ports to join?

No. Players connect outbound. The only port a player might change is the launcher's local port `4444`, and only when another program on their PC is already using it.

##### Everyone failed to join right after a BeamNG update. What do we do?

Wait for BeamMP to release a client update for the new game version, then update the server build and check your client mods. Until BeamMP catches up, multiplayer does not work for anyone on the new version, on any server.

BeamMP servers on RE:NODE start at 2 GB with the port allocated on both TCP and UDP and shown on the Network tab, a live console, and `ServerConfig.toml` and `Server.log` in the browser. The install waits on the Setup tab for your own Keymaster auth key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP server on Linux: install, systemd and ufw

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-server-on-linux

BeamMP-Server on Linux is a single prebuilt binary per distribution, not a package and not something SteamCMD installs. Download the file that matches your release and CPU - `BeamMP-Server.ubuntu.24.04.x86_64`, `BeamMP-Server.debian.12.x86_64` and so on - install the one runtime library it needs, `liblua5.3-0`, mark it executable and run it once. It writes a default `ServerConfig.toml` beside itself and stops because the auth key is empty. Paste in a key from the BeamMP Keymaster, run it again under a dedicated user through a systemd unit, open `30814` on both TCP and UDP, and the server is in the public list within a minute or two. Updating is replacing that one file.

That is the whole job, and it takes ten minutes on a fresh machine. The rest of this post is the detail that decides whether it still works after the next reboot, the next BeamNG patch and the next time somebody else has to look at it. What goes inside `ServerConfig.toml` - maps, `MaxCars`, mods, the meaning of each key - is covered in the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide); this post is about the Linux side of running it.

#### What you need before you start

The BeamMP server is a small native C++ program. It does not simulate vehicles, it relays their state, so it is light on CPU and memory and heavy on upstream bandwidth. Any current VDS or VPS can run it; what matters is that the operating system is one the project builds for.

| Resource | Minimum | Comfortable |
| --- | --- | --- |
| RAM | 1 GB free | 2 GB free for 10-20 players |
| CPU | 1 core | 2 cores if Lua plugins do real work |
| Disk | 100 MB plus mods | Mod pack size times two |
| Network | TCP and UDP 30814 | Good upstream, low latency |

The disk line is not a typo. The server binary is a few tens of megabytes; the `Resources/Client` folder holding mod zips is what grows, and keeping a copy of the last working mod set for rollback doubles it. Bandwidth is the real constraint: every vehicle update goes to every client, and every joiner downloads the whole client mod pack.

You also need:

- **A supported distribution.** At the time of writing the official releases are built for Debian 12, Debian 13, Ubuntu 22.04 and Ubuntu 24.04, each in `x86_64` and `arm64`. Anything else means building from source.
- **sudo** on the machine, to install a library, create a user and write a unit file.
- **An auth key** from the BeamMP Keymaster, tied to your own BeamMP account. Without one the server will not start. How to get it is in the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide).

If the machine is brand new, do the basics before any game server goes on it - a non-root login, SSH keys, updates. [The first hour on a new VDS](https://www.renode.space/blog/first-hour-on-a-new-vds) and [SSH keys and hardening](https://www.renode.space/blog/ssh-keys-and-hardening) walk through both. If you are still deciding whether to run your own Linux box at all, [choosing between a VDS and a game panel](https://www.renode.space/blog/choosing-between-vds-and-a-game-panel) is the honest comparison.

#### Picking the right release binary

BeamMP publishes one file per distribution, release and architecture on the BeamMP-Server GitHub releases page. As of the v3.9 releases the Linux assets are named like this:

```text
BeamMP-Server.debian.12.x86_64
BeamMP-Server.debian.12.arm64
BeamMP-Server.debian.13.x86_64
BeamMP-Server.debian.13.arm64
BeamMP-Server.ubuntu.22.04.x86_64
BeamMP-Server.ubuntu.22.04.arm64
BeamMP-Server.ubuntu.24.04.x86_64
BeamMP-Server.ubuntu.24.04.arm64
```

Next to them sit matching `debuginfo.*` files. Those are debugging symbols for crash reports and you do not need them to run anything. `BeamMP-Server.exe` is the Windows build.

Two commands tell you which file is yours:

```bash
$ grep -E '^(ID|VERSION_ID)=' /etc/os-release
ID=ubuntu
VERSION_ID="24.04"
$ uname -m
x86_64
```

`ID` and `VERSION_ID` give the distribution and release; `uname -m` gives the architecture. `x86_64` is ordinary Intel and AMD hardware. `aarch64` is 64-bit ARM - Ampere cloud instances, a Raspberry Pi 4 or 5 on a 64-bit OS - and maps to the `arm64` asset.

The binaries are built against each release's system libraries, which is why there is one per distribution rather than one for all of Linux. A mismatched file usually fails on start with a complaint about a missing or too-old `GLIBC` or `GLIBCXX` symbol. On an interim release such as Ubuntu 24.10 or 25.04 the nearest older LTS build often runs, but nobody promises it; if it fails, either move to a supported release or build from source. Fedora, Arch and Alpine are source-build territory - the README lists the build dependencies, and the ARM build needs `VCPKG_FORCE_SYSTEM_BINARIES=1` exported first.

> [!NOTE]
> Asset names have changed between major versions before. If the names above do not match what you see on the releases page, trust the page. The pattern - one file per distro, release and architecture - has been stable.

#### Installing the dependency and a dedicated user

The release binary links against the system Lua 5.3 library, which minimal server images do not ship. On Debian and Ubuntu it is one package:

```bash
$ sudo apt update
$ sudo apt install liblua5.3-0 ca-certificates curl
```

`ca-certificates` and `curl` are there for downloading the binary and for the server's own HTTPS calls to the BeamMP backend; both are already present on most images. If you skip the Lua library, the server dies immediately with `error while loading shared libraries: liblua5.3.so.0: cannot open shared object file`. Running `ldd` against the binary lists every library it needs and marks the missing ones `not found`, which is the fastest way to check before you start debugging anything else.

Next, a user that owns the server and nothing else. The BeamMP documentation itself says not to run the server as root, with sudo, or as your personal account, and the reasoning is the usual one: Lua plugins execute with the server's privileges, so a malicious or careless plugin running as root owns the machine.

```bash
$ sudo useradd --system --create-home --home-dir /opt/beammp \
    --shell /usr/sbin/nologin beammp
```

A system account with no login shell cannot be used to SSH in, and everything the server writes lands under `/opt/beammp`. To work in that directory as the user, use `sudo -u beammp` in front of commands, or `sudo -u beammp -s /bin/bash` for a shell.

#### Download and first run

Fetch the binary straight into the server's directory. GitHub's `latest/download` path always resolves to the newest release, so the command below does not need a version number - change the file name for your distribution:

```bash
$ cd /opt/beammp
$ sudo -u beammp curl -fL -o BeamMP-Server \
    https://github.com/BeamMP/BeamMP-Server/releases/latest/download/BeamMP-Server.ubuntu.24.04.x86_64
$ sudo -u beammp chmod +x BeamMP-Server
$ sudo -u beammp ./BeamMP-Server --version
```

Saving it under the plain name `BeamMP-Server` rather than the long release name is deliberate. The systemd unit and any update script then point at one fixed path, and an update is a file replacement instead of an edit to the unit.

`--version` prints the version and exits, which proves the binary and its libraries load. The other flags the server accepts are `--help`, `--config=/path/to/ServerConfig.toml` and `--working-directory=/path/to/folder`. You will not need them if you run the server from its own directory, which is what the unit below does.

Now the first real run:

```bash
$ cd /opt/beammp
$ sudo -u beammp ./BeamMP-Server
```

The server creates its files, prints its start-up lines, and complains that the auth key is missing. Stop it with Ctrl+C if it has not exited on its own. The directory now looks like this:

```text
/opt/beammp/
  BeamMP-Server
  ServerConfig.toml
  Server.log
  Resources/
    Client/
    Server/
```

Open `ServerConfig.toml`, paste your key into `AuthKey`, set a `Name`, and leave `Port = 30814` unless you have a reason to change it:

```bash
$ sudo -u beammp nano /opt/beammp/ServerConfig.toml
```

ServerConfig.toml (the lines to touch first):

```toml
[General]
Port = 30814
AuthKey = "paste-your-keymaster-key-here"
Name = "Linux test server"
Private = true
MaxPlayers = 8
MaxCars = 2
```

`Private = true` while you are testing keeps the server out of the public list; you connect directly by address. Run `./BeamMP-Server` once more by hand. A healthy start stays running and prints no `[ERROR]` lines; `[WARN]` lines are worth reading but rarely fatal. Ctrl+C asks the server to shut down cleanly - it fires the Lua `onShutdown` event and gives plugins a few seconds to finish - and pressing it repeatedly forces the exit. Once that works interactively, hand it to systemd.

The file is generated by the binary, and that matters: the keys a given version writes are the keys it reads. Copying a `ServerConfig.toml` from an old forum post into a new server works for `[General]`, but sections such as `[Misc]` (update reminders) and the optional HTTP block vary by version. When in doubt, let the server generate a fresh file and move your values across.

#### A systemd service for BeamMP

A server started in an SSH session dies with the session, and one started in `tmux` dies with the reboot. A unit file fixes both and puts the output in the journal. [systemd services for your apps](https://www.renode.space/blog/systemd-services-for-your-apps) explains every directive; this is the BeamMP version:

/etc/systemd/system/beammp.service:

```ini
[Unit]
Description=BeamMP server
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=beammp
Group=beammp
WorkingDirectory=/opt/beammp
ExecStart=/opt/beammp/BeamMP-Server
KillSignal=SIGINT
TimeoutStopSec=30
Restart=on-failure
RestartSec=10
NoNewPrivileges=true
ProtectSystem=full
PrivateTmp=true

[Install]
WantedBy=multi-user.target
```

The lines that are specific to this server:

- **`WorkingDirectory=/opt/beammp`.** The server looks for `ServerConfig.toml` and the `Resources` folder relative to where it runs. Without this line it would start in `/`, find no config, and try to write a new one where it has no permission.
- **`After=network-online.target`.** The server contacts the BeamMP backend at start to validate the key. Starting before the network is up produces a confusing authentication failure on every boot.
- **`KillSignal=SIGINT`.** The same signal as Ctrl+C, which is the shutdown path the server documents. It lets plugins run their `onShutdown` handlers. `TimeoutStopSec=30` is how long systemd waits before it gives up and kills the process.
- **`Restart=on-failure`** restarts a crash, but not a deliberate stop. `RestartSec=10` stops a broken config from restarting the server in a tight loop - if the key is wrong, it fails, waits, fails again and hits systemd's start limit, which is what you want.

The three hardening lines are cheap. `NoNewPrivileges` stops anything the server spawns from gaining privileges, `ProtectSystem=full` makes `/usr`, `/boot` and `/etc` read-only to it, and `PrivateTmp` gives it its own `/tmp`. The server only writes inside its working directory, so none of them get in the way.

Load and start it:

```bash
$ sudo systemctl daemon-reload
$ sudo systemctl enable --now beammp
$ systemctl status beammp
```

`enable --now` starts it immediately and at every boot. After any edit to the unit, run `daemon-reload` again before restarting, or systemd keeps using the old version.

One trade-off to know about: the BeamMP console accepts commands - `list`, `kick <name> [reason]`, `say <message>`, `status`, `lua`, `exit` - but only in an interactive terminal. Under systemd there is no terminal attached, so day-to-day moderation goes through Lua plugins or in-game admin tools instead. If you need the console occasionally, stop the service and run the binary by hand as the `beammp` user. If you need it constantly, running the server inside `tmux` started from the unit is possible, but it brings back most of what the unit was supposed to remove; most server owners end up with a plugin instead. [BeamMP Lua plugins and races](https://www.renode.space/blog/beammp-lua-plugins-and-races) shows how chat commands are built.

#### Opening port 30814 with ufw

BeamMP uses one port number on two protocols: TCP for connection setup and mod downloads, UDP for vehicle state. Open only TCP and players connect, load the map and then sit there with every other car frozen, because the state stream never arrives.

If ufw is not enabled yet, allow SSH before you turn it on, or you will lock yourself out:

```bash
$ sudo ufw allow OpenSSH
$ sudo ufw allow 30814/tcp comment 'BeamMP'
$ sudo ufw allow 30814/udp comment 'BeamMP'
$ sudo ufw enable
$ sudo ufw status verbose
```

Two rules rather than `ufw allow 30814` without a protocol, which would also work but is easier to misread later. The `comment` shows in `ufw status` and saves you guessing what a port was for six months from now. If you changed `Port` in the config, use the new number in both rules. The server also makes outgoing HTTPS connections to the BeamMP backend for authentication and the server list; ufw's default policy allows outgoing traffic, so there is nothing to add unless you have tightened that. [The UFW firewall guide](https://www.renode.space/blog/ufw-firewall-guide) covers default policies, rule order and the Docker trap in full.

ufw is only the firewall on the machine. Many cloud providers also have a network firewall or security group in front of the instance, and it needs the same two rules. If the server answers from the machine itself but not from outside, that outer layer is the usual reason. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) has the general picture.

To confirm the server is listening on both protocols:

```bash
$ sudo ss -tulpn | grep 30814
```

You should see one `tcp` line in `LISTEN` state and one `udp` line, both owned by `BeamMP-Server`. If only one appears, the server is not listening on the other protocol and no firewall rule will help - check the `IP` setting in the config, which should be `::` or `0.0.0.0` for all addresses.

```diagram
title: What a working BeamMP install on Linux looks like
players = Players | BeamMP launcher
ufw = ufw | TCP and UDP 30814
svc = beammp.service | user beammp
dir = /opt/beammp | config, Resources
backend = BeamMP backend | auth and list
players -> ufw : 30814
ufw -> svc
svc <-> dir
svc -> backend : HTTPS out
```

#### Logs: journalctl and Server.log

Logs end up in two places, and both are useful.

The journal holds everything the server prints to its console, with timestamps and service events such as crashes and restarts:

```bash
$ journalctl -u beammp -f
$ journalctl -u beammp --since "1 hour ago"
$ journalctl -u beammp -b -p warning
```

`-f` follows live, `--since` narrows the window, `-b` limits to the current boot. The journal is also where you see systemd's view of things - "Main process exited, code=exited, status=1/FAILURE", "Start request repeated too quickly" - which the server's own log cannot tell you.

`Server.log` in the working directory is the server's own file. On every start the server renames the previous one to `Server.old.log` and begins a fresh `Server.log`, so you always have the current run and the one before it, and no more. If the server crashed and restarted, the evidence from before the crash is in `Server.old.log`. If it restarted twice, the evidence is gone. That is the main reason to rely on the journal for history: it keeps every run, rotated by size rather than by restart.

`LogChat = true` in the config writes chat to the log, which is the cheapest moderation evidence there is. `Debug = true` makes the log far more verbose; turn it on to chase a problem and off afterwards, because it grows quickly.

If the journal on a small VDS gets large, cap it in `/etc/systemd/journald.conf` with `SystemMaxUse=` and restart `systemd-journald`. The [Linux commands for server admins](https://www.renode.space/blog/linux-commands-for-server-admins) post has the rest of the toolkit for reading logs - `grep`, `tail`, `less` - when you are digging through `Server.log` by hand.

#### Updating BeamMP-Server

BeamMP releases follow BeamNG.drive updates, and a client on a newer protocol may refuse to join an old server. Updates are usually needed within days of a game patch, which is exactly when people want to play, so the process is worth getting smooth.

An update is: stop, back up, replace the binary, start.

```bash
$ sudo systemctl stop beammp
$ cd /opt/beammp
$ sudo -u beammp cp BeamMP-Server BeamMP-Server.previous
$ sudo -u beammp cp ServerConfig.toml ServerConfig.toml.bak
$ sudo -u beammp curl -fL -o BeamMP-Server \
    https://github.com/BeamMP/BeamMP-Server/releases/latest/download/BeamMP-Server.ubuntu.24.04.x86_64
$ sudo -u beammp chmod +x BeamMP-Server
$ sudo -u beammp ./BeamMP-Server --version
$ sudo systemctl start beammp
$ journalctl -u beammp -f
```

The `.previous` copy is your rollback: if the new version misbehaves, stop the service, move the old binary back and start again. `curl -f` makes a failed download exit with an error rather than save a GitHub error page as your server binary, and `--version` before the start catches a bad file before systemd tries to run it.

Read the release notes before updating across a major version. Lua API signatures have changed between major versions before, and a plugin that worked on the old build can fail silently on the new one - the server starts, the plugin does nothing. The [Misc] section of recent configs has `ImScaredOfUpdates` and `UpdateReminderTime` keys that control the update reminder the server prints; they control the message, not the update itself. BeamMP does not update itself, and that is a good thing - you decide when a working server changes.

Resist the urge to put the download line in a cron job. An automatic update that lands mid-session, or one that pulls a release your plugins are not ready for, costs more than the two minutes the manual version takes. If the server is busy enough that update timing matters, announce a window, update, and test with a direct connect before you open it again. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the general discipline.

##### Backups worth keeping

There is no world save in BeamMP, which makes backups small and easy to skip. What you cannot re-download is `ServerConfig.toml`, everything under `Resources/Server` (your plugins and whatever data they store) and the exact set of mod zips in `Resources/Client` that currently work together. A nightly `tar` of `/opt/beammp` minus the binary, copied off the machine, covers all of it. [Backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) explains why off the machine is not optional.

#### Troubleshooting on Linux

**`error while loading shared libraries: liblua5.3.so.0`.** The runtime dependency is missing. `sudo apt install liblua5.3-0`, then try again. On a non-Debian distribution, install that distribution's Lua 5.3 library or build from source.

**`version 'GLIBC_2.xx' not found` or `GLIBCXX` errors.** You downloaded the binary for a newer distribution than you are running. Check `/etc/os-release` and fetch the matching file.

**`Exec format error`.** Architecture mismatch - an `arm64` binary on `x86_64` or the reverse. Check `uname -m`.

**`Permission denied` when starting.** The file is not executable, or the directory is not owned by the user running it. `chmod +x BeamMP-Server` and `sudo chown -R beammp:beammp /opt/beammp`.

**The service fails with "Start request repeated too quickly".** The server is exiting on every start, and systemd has stopped trying. The real reason is a few lines above in `journalctl -u beammp` - almost always the auth key or a TOML syntax error. Fix it, then `sudo systemctl reset-failed beammp` and start again.

**The server starts by hand but not as a service.** Usually `WorkingDirectory` is missing or wrong, so the service cannot find the config, or files were created by root during a manual run and the `beammp` user cannot write them. `ls -l /opt/beammp` tells you which; `chown` fixes the second.

**It runs, players cannot join.** Check `ss -tulpn` for both protocols, then `ufw status`, then the provider's firewall. Test with a direct connect from outside before you suspect the server list.

**Address already in use.** Something else holds `30814` - often a copy you started by hand in another terminal and forgot about. `ss -tulpn | grep 30814` names the process.

**The server is killed with no error.** On a small VDS this is often the kernel's OOM killer, usually because of something else on the machine. `journalctl -k | grep -i oom` confirms it. [Linux swap and the OOM killer](https://www.renode.space/blog/linux-swap-and-the-oom-killer) explains what to do about it.

#### Running it on RE:NODE

Everything above applies to any Linux machine you control, including the [i9-9900K VDS line](https://www.renode.space/dedicated-servers#intel-i9-9900k), which is prepared by hand within 24 hours and is a sensible home if you want to run BeamMP next to other services of your own.

If you only want the BeamMP server, the [BeamMP game line](https://www.renode.space/game-servers/beammp) does the Linux part for you: the server is created when payment clears, the port is allocated on both protocols, `ServerConfig.toml` is edited in the browser file manager and mod packs go up over SFTP. It is one of the games that needs your own credential, so the install waits on the Setup tab until you paste your Keymaster key. At the memory limit the container is stopped and restarted clean rather than left to swap, and a server that crashes repeatedly raises a warning and a ticket. What you give up compared with a VDS is root access and the choice of distribution, which for BeamMP rarely matters.

#### FAQ

##### Which BeamMP-Server file do I download for Ubuntu 24.04?

`BeamMP-Server.ubuntu.24.04.x86_64` on ordinary Intel or AMD hardware, or `BeamMP-Server.ubuntu.24.04.arm64` on ARM. `uname -m` tells you which; `aarch64` means the `arm64` file.

##### Does BeamMP run on Linux without Wine?

Yes. BeamMP-Server is a native Linux program with official builds for Debian and Ubuntu. Only the players need BeamNG.drive, which the server never runs.

##### Why does the server exit straight after the first run?

Because it has just written a default `ServerConfig.toml` with an empty `AuthKey`. Add a key from the Keymaster and start it again. If it still exits, the log line will say whether it is the key or the TOML syntax.

##### Can I run more than one BeamMP server on one machine?

Yes. Give each its own directory, its own `Port` in its config, its own auth key, its own unit file and its own pair of firewall rules. [Multiple game servers on one VDS](https://www.renode.space/blog/multiple-game-servers-on-one-vds) covers the layout.

##### Should I use the console or Lua for admin commands?

Under systemd the console is not attached to anything, so in practice Lua plugins handle kicks, bans and announcements. Keep the console for testing by hand.

##### Does BeamMP-Server update itself?

No. It can remind you that a newer version exists, but replacing the binary is your job. That is a stop, a download and a start, and it is worth doing by hand.

BeamMP servers on RE:NODE start from $6 a month with port 30814 allocated on both protocols, `ServerConfig.toml` editable in the browser and SFTP for mod packs. The server is created when payment clears and waits on the Setup tab for your own Keymaster auth key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP max players: server limits, MaxCars and lag

Published 2026-10-15 by RE:NODE Team. https://www.renode.space/blog/beammp-server-performance-and-player-limits

A BeamMP server has no hard player cap of its own. `MaxPlayers` accepts any number from 1 upwards, and the server program will relay for as many people as you let in. The limit you actually hit is somewhere else: every player's PC has to simulate every car on the server, so the real ceiling is the total vehicle count, `MaxPlayers` multiplied by `MaxCars`, measured against the weakest PC in the session. For a mixed public crowd that means roughly 10-12 players with 1-2 cars each. A group of friends with strong CPUs can run 20 or more with one car each. Past about 30 vehicles in the same area, almost nobody's machine keeps real-time physics.

The server itself is the cheap part. It uses little CPU and memory, and its cost grows with bandwidth, which rises with the square of the player count. This post covers where each limit comes from, how to estimate traffic, what causes the stutter and teleporting people call lag, and how to size `MaxPlayers` and `MaxCars` for the server you want to run. For installation, the auth key and the rest of `ServerConfig.toml`, start with the [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide).

#### Why the limit is on the players' PCs

BeamNG.drive simulates every vehicle as a soft-body structure of hundreds or thousands of nodes and beams, at a physics rate far above the frame rate. That is what makes the crashes look right, and it is expensive. A modern desktop CPU can keep a handful of vehicles in real time. Past that, BeamNG does not drop detail - it slows the simulation down, and you see cars moving in slow motion while the clock ticks normally.

BeamMP does not change that model. Each client runs its own vehicles authoritatively and also runs a local simulation of every other player's vehicles, corrected by the position and state updates that arrive through the server. The server sees none of the physics. It authenticates players, keeps track of who owns which vehicle, relays updates and runs Lua plugins.

```diagram
title: Every client simulates every vehicle on the server
a = Player A | own cars + all others
b = Player B | own cars + all others
c = Player C | own cars + all others
server = BeamMP server | relay, no physics
a <-> server : state of A's cars
b <-> server : state of B's cars
c <-> server : state of C's cars
```

So when ten players each have two cars out, every one of the ten PCs is simulating twenty vehicles. A player with a fast CPU and a player with a five-year-old laptop are asked to do exactly the same work, and the laptop decides how the session feels for its owner. Nothing on the server side can take that load off them. A larger hosting plan does not help a client whose CPU is pinned.

Two consequences are worth stating plainly:

- **Doubling the players roughly quadruples the total work.** Twice as many PCs each simulate twice as many cars. That is why a server that felt fine at 8 feels broken at 16, and why lowering `MaxCars` buys more headroom than any other change.
- **Server-side performance graphs will usually look calm while players complain.** The server's CPU is not where the work is. Before upgrading anything, ask what the complaining players' frame rates and simulation speed look like.

#### MaxPlayers and MaxCars: what they actually do

Both settings live in the `[General]` section of `ServerConfig.toml`. The defaults written by current server builds are conservative:

ServerConfig.toml:

```toml
[General]
MaxPlayers = 8
MaxCars = 1
Private = true
```

| Key | Default | What it limits |
| --- | --- | --- |
| `MaxPlayers` | `8` | Connected players, server-wide. Does not limit vehicles |
| `MaxCars` | `1` | Vehicles per player. Extras are deleted as soon as they spawn |
| `Private` | `true` | Not a limit, but a new server is unlisted until you set `false` |

`MaxCars` is per player, not per server. There is no built-in server-wide vehicle cap, so the worst case is always the product of the two numbers. A server with `MaxPlayers = 20` and `MaxCars = 3` permits 60 vehicles, and on a crowded evening it will get close.

A few details catch people out:

- **Everything a player spawns is a vehicle.** Trailers, props and AI traffic spawned from the client each take a slot against `MaxCars`. So, on most versions, does the walking mode (the unicycle), which is why a player on a `MaxCars = 1` server who gets out to walk can find their car removed. If your server is built around trailers or towing, `MaxCars = 2` is the practical minimum.
- **Spawning is the expensive moment.** When a vehicle spawns or is edited, every client has to load and build it, and BeamNG freezes briefly while it does. On a busy server, players resetting or swapping cars produce a stream of small hitches for everybody else. BeamMP's client offers a queue in its multiplayer options that holds remote spawns and edits until a convenient moment; option names have changed between client versions, so look in the Multiplayer section of the in-game settings for yours.
- **The limits are enforced, not advisory.** A vehicle over the `MaxCars` limit is deleted rather than refused politely, and a player over `MaxPlayers` is turned away at the door.

If you want rules smarter than "N per player" - a server-wide cap, different limits for staff, no heavy trucks after a certain player count - that is a Lua plugin, covered below.

#### Bandwidth per player and how it scales

The server's traffic is easy to model once you see the shape. Every vehicle's owner sends a stream of position, rotation, velocity and input updates to the server. The server forwards each of those streams to every other player. Electrics and damage updates add more when something happens - lights, horn, a crash - and spawn and edit events carry the full vehicle configuration.

That gives the server's outbound traffic a quadratic shape:

```text
outbound ≈ players × (players - 1) × cars per player × per-vehicle stream
inbound  ≈ players × cars per player × per-vehicle stream
```

The per-vehicle figure depends on the client version, how fast cars are moving and how often they are damaged, so measure it rather than trusting a number from a forum. What you can rely on is the scaling. Holding everything else equal:

| Players x cars | Streams the server sends | Relative to 8 x 1 |
| --- | --- | --- |
| 8 x 1 | 56 | 1x |
| 10 x 2 | 180 | about 3x |
| 16 x 1 | 240 | about 4x |
| 20 x 2 | 760 | about 14x |
| 30 x 2 | 1,740 | about 31x |

The jump from 8 to 16 players at one car each costs four times the upload, and 30 players with two cars each costs thirty times what the default config does. Inbound traffic stays linear and small; as with nearly every game, outbound is the side that fills. [Game server bandwidth per player](https://www.renode.space/blog/game-server-bandwidth-per-player) covers that asymmetry across games, and why steady-state traffic is rarely the real problem.

The bursts matter more than the steady state. Every byte in `Resources/Client` is sent to each joining player who does not already have it. A 2 GB mod pack with five people joining at the start of an event is 10 GB going out in a few minutes, competing with the vehicle streams of everyone already driving. That is often the moment a session that was smooth suddenly rubber-bands for all, and it has nothing to do with player count. Keep the pack lean, tell people its size in advance, and ask regulars to join early before an organised event.

On your own Linux machine, the quickest way to see the real numbers is to watch the port while a session is running:

```bash
$ sudo iftop -i eth0 -f "port 30814"
$ vnstat -l -i eth0
```

`iftop` shows live traffic per connection, which also reveals which player is downloading the mod pack. `vnstat -l` gives a running total for the interface. Note the figures at a busy moment with a known player and car count, divide, and you have your own per-vehicle number to plug into the formula.

For a home host, the upload is the wall. A residential line with 20-40 Mbit/s up is fine for a small group and runs out quickly at the top of that table, especially while somebody is downloading mods. A datacentre uplink has headroom for any realistic BeamMP server, but [unmetered is not unlimited](https://www.renode.space/blog/bandwidth-and-fair-use), and a public server pushing a multi-gigabyte pack to strangers all day is the kind of traffic that question is about.

#### Sizing table: players, cars and server resources

Two different things need sizing, and they are easy to mix up. The first is the session - how many vehicles you ask players' PCs to simulate. The second is the server - RAM, CPU and bandwidth for the relay program.

Start with the session. These are working figures for a public or semi-public server where you do not control the players' hardware:

| Server type | MaxPlayers x MaxCars | Vehicles per client |
| --- | --- | --- |
| Small group, strong PCs | 6-8 x 3 | Up to 24 |
| Public freeroam, mixed PCs | 10-12 x 2 | Up to 24 |
| Busy public cruise | 16-20 x 1 | Up to 20 |
| Large event, single car each | 25-30 x 1 | Up to 30, needs strong PCs |
| Derby or close racing | 8-12 x 1 | Up to 12, all close together |

Close racing and demolition derby deserve their own row. Crashes are the most expensive thing BeamNG simulates, collisions between remote vehicles are where desync shows up most, and in a derby every car is in the same small arena. A twelve-car derby is a harder load than a forty-car cruise spread over Italy, because in the cruise most vehicles are far away and moving smoothly.

Then the server. The relay is light, and memory is mostly the program, the Lua state and buffers for in-flight mod transfers:

| Players | RAM | vCPU |
| --- | --- | --- |
| Up to 10 | 2 GB | 1 |
| 10-20, a mod pack | 3-4 GB | 1.5-2 |
| 20-40, heavy plugins | 4-6 GB | 2 |

CPU on the server is single-thread work most of the time. If it is high with a modest player count, the cause is almost always a Lua plugin running a fast timer or doing heavy JSON work in a spawn handler, not the number of players. [BeamMP Lua plugins and races](https://www.renode.space/blog/beammp-lua-plugins-and-races) shows how to time handlers with `Util.DebugExecutionTime()`. Disk is whatever your mod pack weighs plus a little; see [how much storage a game server needs](https://www.renode.space/blog/how-much-storage-does-a-game-server-need) for the general picture.

On RE:NODE the BeamMP plans run from 2 GB with one vCPU up to 8 GB with three, on NVMe, and the CPU is a hard share rather than a burst. For BeamMP the lower tiers cover nearly every server, because the expensive part happens on the players' machines; a bigger plan is worth it for a large mod pack's disk space or plugins doing real work, not for raising `MaxPlayers`.

#### What causes lag and desync

"Lag" covers at least five different problems on a BeamMP server, and they need different fixes. Telling them apart takes a minute of asking the right questions.

**Slow motion for one player.** Their CPU cannot keep the physics in real time with the number of vehicles nearby. BeamNG slows the simulation rather than skipping, so on their screen everything moves slowly, and on everyone else's screen their car moves strangely. This is the most common complaint on a busy server and it is entirely client-side. Fewer vehicles fixes it; nothing else does.

**Remote cars jittering, teleporting or driving through walls.** Missing or late updates. Each remote car is simulated locally between updates and then corrected, and when updates are lost the correction is large and visible. If one player's car does it on everyone's screen, the problem is that player's connection. If every remote car does it on one player's screen, it is the viewing player's connection. If everyone sees it from everyone at the same moment, look at the server's upload - often a mod download or a burst of joins. [Latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) explains how to tell the three apart with a ping test.

**Collisions that do not agree.** Two players crash, and each sees a different result. This is built into the architecture: each car's owner is authoritative for its own physics, and the other car on their screen is a prediction from slightly old data. At 100 ms of latency between two players, a car at 100 km/h is nearly three metres away from where the other player thinks it is. Contact sports on BeamMP work best between players with low ping to the same server, which is the real argument for hosting near your players. Some servers turn collisions off for public cruising for exactly this reason, through a plugin or a client mod; check what your version offers.

**Everyone freezes for a second.** A vehicle spawn or edit, almost always. Heavy modded vehicles with high node counts make it worse. A server where people constantly respawn because they keep crashing will feel stuttery for everyone. The client-side queue helps; a plugin that limits spawn frequency per player helps more.

**Stutter that started after adding a mod.** Some vehicle and map mods are much heavier than the stock content, or are broken for the current BeamNG version and spam errors every frame. Test by moving a mod out of `Resources/Client` and restarting. If a map mod is the problem, the cost is paid by every player for the whole session.

> [!WARNING]
> TCP open and UDP blocked looks like lag rather than a fault: players connect, the map loads, and remote cars never move or move once and freeze. Port `30814` must be open on both protocols. If one player has this and nobody else does, their own firewall or network is dropping UDP.

#### Controlling vehicle count with a Lua plugin

`MaxCars` is a blunt tool. A plugin can enforce a total for the whole server, which is the number that actually matters to the clients. `onVehicleSpawn` fires before the vehicle is accepted, and returning `1` cancels it:

Resources/Server/VehicleCap/main.lua:

```lua
local SERVER_CAP = 24

local function countVehicles()
    local total = 0
    for id, _ in pairs(MP.GetPlayers() or {}) do
        local vehicles = MP.GetPlayerVehicles(id)
        if vehicles then
            for _ in pairs(vehicles) do total = total + 1 end
        end
    end
    return total
end

function capSpawn(playerID, vehicleID, data)
    if countVehicles() >= SERVER_CAP then
        MP.SendChatMessage(playerID, "Server vehicle limit reached. Remove a car first.")
        return 1
    end
end

MP.RegisterEvent("onVehicleSpawn", "capSpawn")
```

With this in place you can set `MaxCars = 3` so that players have room for a trailer, and still be sure the server never asks a client to run more than 24 vehicles. The same handler is where you would refuse specific heavy models, or allow a higher count for staff by checking the `beammp` identifier. Test any plugin against your server version first - the API has changed between major releases, and [the Lua plugin guide](https://www.renode.space/blog/beammp-lua-plugins-and-races) covers the event signatures in detail.

Keep handlers like this cheap. A spawn handler that loops over a few dozen vehicles costs nothing; one that decodes every vehicle's full configuration JSON on every spawn starts to show up in the server's CPU on a busy night.

#### Raising the limit safely

When a server feels full, the order of changes matters. Most of the useful levers are free:

1. **Lower `MaxCars` first.** Going from 2 to 1 halves the client load and the bandwidth. Add a plugin cap if people need trailers.
2. **Pick a larger map for bigger crowds.** Cars far apart are cheaper to have around than cars in the same intersection, and they generate fewer collisions to disagree about. Gridmap and small arenas are for small groups.
3. **Trim the mod pack.** Every heavy vehicle mod raises the per-vehicle cost on every client, and the pack size decides how painful joins are.
4. **Set expectations in the server description.** "Recommended: 6-core CPU" in `Description` or your Discord saves you from players who join, run at half speed and blame the host.
5. **Raise `MaxPlayers` in small steps.** Go from 10 to 14, watch a full evening, then decide. Watch for players reporting slow motion, not just the server's own numbers.
6. **Only then look at the plan.** If server CPU is genuinely high, find the plugin first. If upload is the limit at home, a datacentre host fixes it.

A restart before a big session is good hygiene rather than a performance fix: it clears any stuck vehicle state and makes sure everyone starts on the same server version. [Restart schedules that help](https://www.renode.space/blog/restart-schedules-that-help) covers when to schedule it. On RE:NODE the Schedules tab can run that restart, and a backup before it, on a cron expression.

#### Troubleshooting

**Players report slow motion as soon as the server fills.** Too many vehicles for their CPUs. Lower `MaxCars` or `MaxPlayers`; a bigger server plan will not change it.

**Everybody rubber-bands at the same moment.** Check whether someone was joining and downloading the mod pack. If not, check the server's upload, especially on a home connection.

**One player's car teleports on everyone's screen.** That player's connection. Ask them to test packet loss to the server address over a wired link.

**New vehicles disappear immediately after spawning.** The player is at `MaxCars`, possibly counting a trailer or the walking unicycle. Or a plugin returned `1` from `onVehicleSpawn`.

**Server CPU at 100% with a handful of players.** A plugin. Remove plugins from `Resources/Server` one at a time, or time their handlers.

**The server is full but the list shows free slots.** The list refreshes on a delay. Players connecting by address get the real answer.

#### FAQ

##### What is the maximum number of players on a BeamMP server?

There is no fixed maximum in the server; `MaxPlayers` takes any positive number. The working limit is client performance: busy public servers usually run 10-20, and very large events need one car each and players with strong CPUs.

##### Should I raise MaxPlayers or MaxCars?

For a public server, players. Each extra car per player adds a full vehicle to every client for every player connected, so `MaxCars` is the more expensive of the two. Keep it at 1-2 and raise player slots instead.

##### Does a better server plan reduce BeamMP lag?

Only when the server is the bottleneck, which is uncommon: a plugin using too much CPU, or a home connection running out of upload. Slow motion and collision disagreements come from players' PCs and connections.

##### Does the walking unicycle count as a car?

On most BeamMP versions, yes - it is spawned as a vehicle and counts against `MaxCars`. Allow at least two cars per player if you expect people to get out and walk.

##### How much upload does a BeamMP server need?

It grows with the square of the player count, so measure at a known load and scale from there. A small group fits on a home connection; twenty players with two cars each, plus mod downloads, needs a datacentre uplink.

BeamMP servers on RE:NODE start from $6 a month with 2 GB, port 30814 allocated on TCP and UDP, and `ServerConfig.toml` and `Resources/Server` editable in the browser or over SFTP. The install waits on the Setup tab for your own Keymaster key, and moving up a tier keeps the server you already have.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP Lua plugins: commands and races

Published 2026-10-07 by RE:NODE Team. https://www.renode.space/blog/beammp-lua-plugins-and-races

BeamMP has no game modes. A BeamMP server relays vehicle state and runs Lua, and everything that makes a server more than a car park - races, whitelists, vehicle rules, chat commands, a Discord bridge - is a Lua plugin in `Resources/Server`. The server-side API is small enough to learn in an evening: you register handlers for a dozen events, call a couple of dozen `MP.*` functions, and use timers for anything that happens over time. That is also enough to run real races, because the server can read every vehicle's last reported position with `MP.GetPositionRaw`, which is all a checkpoint system needs. This guide covers the plugin model, the events and functions you will actually use, and a complete race plugin with a countdown, gates, laps and finishing times.

The [BeamMP server guide](https://www.renode.space/blog/beammp-server-guide) covers installation, `ServerConfig.toml`, maps and client mods; read it first if your server is not running yet. Everything here targets the 3.x server, which uses Lua 5.3. Older plugins written for the 2.x API or for the long-retired community frameworks often do not load, and that is the first thing to check when a downloaded script does nothing.

#### How server plugins are loaded

A plugin is a folder under `Resources/Server`. The server loads every `.lua` file in the root of that folder, in alphabetical order, and runs the top-level code once. Files in subfolders are ignored unless you `require` them, which is the right place for helpers and data.

```text
Resources/
  Client/                 mod zips sent to players
  Server/
    RaceControl/
      main.lua            loaded at start
      lib/gates.lua       only if main.lua requires it
    Whitelist/
      main.lua
```

Each plugin runs in its own Lua state. Two plugins cannot read each other's variables; they talk through events, which is covered below. Within a plugin, the pattern is always the same: define global functions, then register them against event names with `MP.RegisterEvent(eventName, functionName)`. The second argument is the **name** of a global function as a string, not the function itself, which is why a handler declared `local` silently never fires.

The server also watches the plugin folder. Saving a file in the plugin's root fires `onFileChanged` and reloads that plugin's state, so you can iterate without restarting the server. Reloading wipes the plugin's variables, so a race in progress is gone when you save `main.lua`; edit between races, not during them.

Output goes to the server console. `print` writes with a `[LUA]` prefix, and `Util.LogInfo`, `Util.LogWarn`, `Util.LogError` and `Util.LogDebug` write at the matching level. A syntax error is reported at load with the file and line, and the plugin is skipped. If a plugin "does nothing", the console from the moment of loading is where the answer is - [reading the console](https://www.renode.space/blog/reading-the-console) covers doing that efficiently.

#### The events you will use

```diagram
title: A player's path through BeamMP plugin events
auth = onPlayerAuth | allow or deny
connect = onPlayerConnecting
join = onPlayerJoin | fully in
spawn = onVehicleSpawn | allow or cancel
chat = onChatMessage | commands
leave = onPlayerDisconnect
auth -> connect
connect -> join
join -> spawn
join -> chat
spawn -> leave
```

| Event | Arguments | Cancellable |
| --- | --- | --- |
| `onInit` | none | No |
| `onPlayerAuth` | name, role, is_guest, identifiers | Yes - return `1` or a reason string |
| `onPlayerConnecting` | player_id | No |
| `onPlayerJoining` | player_id | No |
| `onPlayerJoin` | player_id | No |
| `onPlayerDisconnect` | player_id | No |
| `onChatMessage` | player_id, player_name, message | Yes - return `1` to hide the message |
| `onVehicleSpawn` | player_id, vehicle_id, data | Yes - return `1` to refuse the spawn |
| `onVehicleEdited` | player_id, vehicle_id, data | Yes - return `1` to refuse the edit |
| `onVehicleReset` | player_id, vehicle_id, data | No |
| `onVehicleDeleted` | player_id, vehicle_id | No |
| `onConsoleInput` | input | No |
| `onShutdown` | none | No |

Three of these do most of the work. `onPlayerAuth` runs before a player has an ID, so it is where whitelists and bans live; it receives an `identifiers` table with the player's `beammp` ID, IP and, where linked, Discord ID. `onChatMessage` is how every chat command is implemented - there is no command registry, you parse the text yourself. `onVehicleSpawn` and `onVehicleEdited` are where vehicle rules go: the `data` argument contains the vehicle configuration as JSON, so you can refuse a model, a part or a spawn outside the pits.

Cancelling is done by return value, and only the return value. Returning `1` from `onChatMessage` hides the message from everyone, which is what you want for commands - nobody needs to see `/start` in chat. Returning nothing lets it through.

#### The functions worth knowing

| Function | What it does |
| --- | --- |
| `MP.SendChatMessage(id, text)` | Chat to one player, or everyone with `-1` |
| `MP.GetPlayers()` | Table of player ID to name |
| `MP.GetPlayerName(id)` | Name for an ID |
| `MP.GetPlayerIdentifiers(id)` | `beammp`, `ip` and `discord` where known |
| `MP.IsPlayerGuest(id)` | Whether the player has no BeamMP account |
| `MP.GetPlayerVehicles(id)` | Table of vehicle ID to vehicle data |
| `MP.GetPositionRaw(id, vid)` | Last reported `pos`, `rot`, `vel`, `rvel`, `ping` and `tim` |
| `MP.RemoveVehicle(id, vid)` | Deletes a vehicle |
| `MP.DropPlayer(id, reason)` | Kicks with a message |
| `MP.CreateEventTimer(name, ms)` | Fires the event `name` every `ms` milliseconds |
| `MP.CancelEventTimer(name)` | Stops it |
| `MP.TriggerLocalEvent(name, ...)` | Calls handlers in this plugin, synchronously |
| `MP.TriggerGlobalEvent(name, ...)` | Calls handlers in all plugins |
| `MP.TriggerClientEvent(id, name, data)` | Sends a string to a client-side mod |
| `MP.Set(MP.Settings.MaxCars, n)` | Changes a config value until restart |
| `MP.CreateTimer()` | A stopwatch with `:Start()` and `:GetCurrent()` in seconds |

Positions are vectors in Lua arrays, so `raw.pos[1]`, `raw.pos[2]` and `raw.pos[3]` are x, y and z. BeamNG uses z as up, so the ground plane is x and y. `Util.JsonEncode` and `Util.JsonDecode` turn tables into strings and back, which you need for both saving data and talking to client mods. `FS.Exists`, `FS.CreateDirectory` and `FS.ConcatPaths` handle files and paths portably.

Signatures do move between server versions, and the official scripting reference for the version you run beats any table on a blog, including this one.

#### Chat commands and admins

There is no built-in admin list, so a plugin decides who is an admin. Key it on the `beammp` identifier, never on the display name, which players can change:

Resources/Server/Admin/main.lua:

```lua
local ADMINS = { ["1234567"] = true }

local function isAdmin(pid)
    local ids = MP.GetPlayerIdentifiers(pid)
    return ids ~= nil and ADMINS[tostring(ids.beammp)] == true
end

function AdminChat(pid, name, msg)
    local cmd, arg = msg:match("^/(%S+)%s*(.*)$")
    if not cmd then return end
    if not isAdmin(pid) then return end
    if cmd == "kick" then
        for id, pname in pairs(MP.GetPlayers()) do
            if pname == arg then MP.DropPlayer(id, "Kicked by " .. name) end
        end
    elseif cmd == "cars" then
        MP.Set(MP.Settings.MaxCars, tonumber(arg) or 1)
        MP.SendChatMessage(-1, "Car limit is now " .. arg)
    else
        return
    end
    return 1
end

MP.RegisterEvent("onChatMessage", "AdminChat")
```

The pattern `^/(%S+)%s*(.*)$` splits `/kick SomeName` into a command and the rest of the line. Unknown commands fall through and appear in chat, which is the friendlier failure. `MP.Set` changes a setting for the running server only; the value in `ServerConfig.toml` returns on the next restart, which makes it ideal for event nights.

#### Vehicle rules on spawn

The `data` argument of `onVehicleSpawn` is a string with a prefix before the JSON, so cut from the first brace before decoding. Log one spawn before writing rules against it - the field names come from the game, and the safest way to know them is to look:

Resources/Server/CarRules/main.lua:

```lua
local ALLOWED = { covet = true, sunburst = true }

function CarSpawn(pid, vid, data)
    local start = data:find("{")
    if not start then return end
    local cfg = Util.JsonDecode(data:sub(start))
    print("spawn by " .. MP.GetPlayerName(pid) .. ": " .. tostring(cfg.jbm))
    if cfg.jbm and not ALLOWED[cfg.jbm] then
        MP.SendChatMessage(pid, "Only the race cars are allowed tonight.")
        return 1
    end
end

MP.RegisterEvent("onVehicleSpawn", "CarSpawn")
MP.RegisterEvent("onVehicleEdited", "CarSpawn")
```

Register the same handler on `onVehicleEdited` as well, or players spawn an allowed car and then swap it in the vehicle configurator. A refused spawn leaves nothing on other players' screens; a car removed afterwards with `MP.RemoveVehicle` flickers into existence first, so refuse at spawn whenever you can.

#### A checkpoint race plugin

Races need four things: a list of entrants, a countdown, a way to tell when a car passes a point, and a clock. The server has all four. Gates are points on the map with a radius; each racer must pass them in order, and passing the last gate completes a lap. Positions are polled on a timer.

Resources/Server/RaceControl/main.lua:

```lua
local ADMINS = { ["1234567"] = true }
local GATES = {                -- fill in with /pos, finish line last
    { x = 0.0, y = 0.0, r = 15 },
    { x = 0.0, y = 0.0, r = 15 },
}
local LAPS = 3
local race = { state = "idle", count = 0, racers = {}, finished = 0 }
local clock = MP.CreateTimer()

local function say(pid, text) MP.SendChatMessage(pid, "[Race] " .. text) end

local function isAdmin(pid)
    local ids = MP.GetPlayerIdentifiers(pid)
    return ids ~= nil and ADMINS[tostring(ids.beammp)] == true
end

local function firstVehicle(pid)
    local vehicles = MP.GetPlayerVehicles(pid)
    if vehicles == nil then return nil end
    for vid, _ in pairs(vehicles) do return vid end
end

local function reset()
    MP.CancelEventTimer("RaceCountdown")
    MP.CancelEventTimer("RaceTick")
    race = { state = "idle", count = 0, racers = {}, finished = 0 }
end

function RaceChat(pid, name, msg)
    local cmd = msg:match("^/(%S+)")
    if cmd == "join" and race.state == "idle" then
        race.racers[pid] = { gate = 1, lap = 1, done = false }
        say(-1, name .. " is on the grid")
    elseif cmd == "pos" then
        local vid = firstVehicle(pid)
        local raw = vid and MP.GetPositionRaw(pid, vid)
        if raw and raw.pos then
            say(pid, string.format("x=%.1f y=%.1f", raw.pos[1], raw.pos[2]))
        end
    elseif cmd == "start" and isAdmin(pid) and race.state == "idle" then
        race.state = "countdown"
        race.count = 5
        MP.CreateEventTimer("RaceCountdown", 1000)
    elseif cmd == "stop" and isAdmin(pid) then
        reset()
        say(-1, "Race cancelled")
    else
        return
    end
    return 1
end

function RaceCountdown()
    if race.count > 0 then
        say(-1, tostring(race.count))
        race.count = race.count - 1
        return
    end
    MP.CancelEventTimer("RaceCountdown")
    race.state = "running"
    clock:Start()
    say(-1, "GO")
    MP.CreateEventTimer("RaceTick", 200)
end

function RaceTick()
    for pid, r in pairs(race.racers) do
        local vid = firstVehicle(pid)
        local raw = vid and MP.GetPositionRaw(pid, vid)
        if raw and raw.pos and not r.done then
            local g = GATES[r.gate]
            local dx, dy = raw.pos[1] - g.x, raw.pos[2] - g.y
            if dx * dx + dy * dy <= g.r * g.r then
                r.gate = r.gate + 1
                if r.gate > #GATES then
                    r.gate = 1
                    if r.lap >= LAPS then
                        r.done = true
                        race.finished = race.finished + 1
                        say(-1, string.format("P%d %s %.2fs", race.finished,
                            MP.GetPlayerName(pid), clock:GetCurrent()))
                    else
                        r.lap = r.lap + 1
                    end
                end
            end
        end
    end
end

function RaceLeave(pid) race.racers[pid] = nil end

MP.RegisterEvent("onChatMessage", "RaceChat")
MP.RegisterEvent("RaceCountdown", "RaceCountdown")
MP.RegisterEvent("RaceTick", "RaceTick")
MP.RegisterEvent("onPlayerDisconnect", "RaceLeave")
```

To set it up, drive to each point on the track - a few hundred metres apart on corners nobody can cut - and type `/pos`. Copy the x and y into `GATES` in driving order, with the start-finish line as the **last** entry so that cars leaving the grid head for gate one first. Save the file, the plugin reloads, and racers type `/join` before an admin types `/start`.

##### How accurate this is, honestly

The server only knows where a car was in its last update, so the precision depends on two things. Polling every 200 ms means a car at 200 km/h moves about 11 metres between checks, which is why the gate radius is 15 metres rather than three. And each position is as old as that player's network delay, so a driver on 150 ms ping is timed slightly late. In practice that is a few tenths of a second, which is fine for a fun Sunday race and not fine for a championship decided by hundredths.

Two ways to tighten it. Lowering the tick to 100 ms halves the distance problem and doubles the work; with a handful of racers that cost is trivial, with forty it is not. For real precision, detection has to happen on each player's own machine: a client-side mod in `Resources/Client` watches for gate crossings locally and reports them with `TriggerServerEvent`, and the server plugin receives them through `MP.RegisterEvent` with a handler taking the player ID and a data string. That is more work and needs a client mod you maintain, which is why most community race servers use the simpler server-side approach for casual events and a dedicated timing mod for leagues.

##### Making races feel like races

A few additions that cost little:

- **Freeze the field before a race** by setting `MaxCars` to `1` with `MP.Set` so nobody spawns a second car mid-race, and restoring it afterwards.
- **Refuse resets during a race.** `onVehicleReset` is not cancellable, but you can disqualify: if a racer resets while `race.state` is `running`, set `done` and announce it.
- **Announce results to Discord** by writing them to a file a separate bot reads, or by using a plugin built for webhooks - [Discord webhooks for server status](https://www.renode.space/blog/discord-webhooks-for-server-status) covers the receiving side.
- **Keep layouts as data.** Put each track's gates in its own file under `lib/` and `require` the right one, so changing venue does not mean editing the plugin.

#### Saving data between restarts

Plugin variables die with the server. Anything that should survive - lap records, a ban list, race history - has to be written to disk. Lua's `io` library and `Util.JsonEncode` are enough:

```lua
local DIR = "Resources/Server/RaceControl/data"
local FILE = FS.ConcatPaths(DIR, "records.json")

local function loadRecords()
    if not FS.Exists(FILE) then return {} end
    local f = io.open(FILE, "r")
    local text = f:read("*a")
    f:close()
    return Util.JsonDecode(text) or {}
end

local function saveRecords(records)
    if not FS.Exists(DIR) then FS.CreateDirectory(DIR) end
    local f = io.open(FILE, "w")
    f:write(Util.JsonEncode(records))
    f:close()
end
```

Paths are relative to the server's working directory. Writing a file inside the plugin's own root folder can trigger a hot reload of that plugin, which will wipe the race that just wrote the record - so put data files in a subfolder such as `data/`, as above, which the server does not load as plugin code. That is the single most confusing bug in BeamMP plugin development, and it looks like the server restarting the plugin at random.

Those data files are the part of your server you cannot download again. Back up `Resources/Server` before every edit session and before every server update; [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) is the argument for actually testing one.

#### Talking between plugins and to client mods

Plugins are isolated, so a whitelist plugin cannot call a function in the race plugin. Events bridge them: `MP.TriggerGlobalEvent("RaceFinished", pid, time)` in one plugin calls every handler registered for `RaceFinished` in every plugin. `MP.TriggerLocalEvent` does the same within one plugin and returns synchronously, which is handy for splitting a large plugin into files.

Client mods are the other direction. A zip in `Resources/Client` can contain Lua that runs in each player's game, register handlers with `AddEventHandler`, and send data with `TriggerServerEvent`. The server sends with `MP.TriggerClientEvent(pid, name, data)` or `MP.TriggerClientEventJson` for a table. Everything travels as strings, so encode tables as JSON at both ends. Use this for user interface - a countdown on screen instead of in chat, a lap timer, a leaderboard - and keep the authority on the server: a client mod that reports its own lap times can be edited by the player running it.

#### Security, performance and keeping plugins working

Plugins run with the server's full permissions and see every chat line and connection. Read anything you download before dropping it into a folder that loads automatically, and prefer plugins with a public source repository. [Keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) is the general hygiene, and [malicious plugins and mods](https://www.renode.space/blog/malicious-plugins-and-mods) covers what a hostile one can do.

Performance problems in BeamMP are almost always a handler doing too much too often. A timer at 50 ms that loops over every player and decodes JSON will show up as CPU you did not expect. `Util.DebugExecutionTime()` returns per-handler timing statistics, which turns a guess into a number. Never call `MP.Sleep` for long inside a handler; it blocks that plugin.

On RE:NODE the BeamMP plan gives you the console with history for reading plugin output, the file manager's editor with syntax highlighting for `main.lua`, and SFTP if you prefer working locally. Saving a plugin file hot-reloads it, so the edit-and-test loop does not need a restart, and a backup slot taken before an edit session is the undo button for the whole `Resources` folder.

After a BeamMP server update, read the changelog for scripting changes before restarting a server full of plugins. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the recovery order if you find out the hard way.

#### Troubleshooting

**A handler never fires.** The function is `local`, misspelt in `MP.RegisterEvent`, or the event name has the wrong capitalisation. Event names are case-sensitive.

**The plugin resets itself at random.** It writes a file into its own root folder, triggering a hot reload. Move data into a subfolder.

**`attempt to index a nil value` on positions.** The player has no vehicle, or `MP.GetPositionRaw` returned an empty result. Check for `raw` and `raw.pos` before using them.

**Commands appear in chat.** The handler does not return `1` for handled commands.

**Gates are never triggered.** The coordinates were copied as x and z instead of x and y, or the radius is smaller than the distance a car travels between polls.

**An old plugin does nothing.** It targets the 2.x API. Look for `MP.RegisterEvent` with string handler names; anything else needs porting.

#### FAQ

##### Does BeamMP have built-in race modes?

No. The server has no game modes at all. Races, timing and leaderboards are Lua plugins, either written yourself or downloaded, sometimes with a client-side mod for on-screen timing.

##### Which Lua version does the BeamMP server use?

Lua 5.3 on the 3.x server. Plugins written for the old 2.x API need porting, mainly to the string-based `MP.RegisterEvent` handlers and the current event names.

##### Do players need to install anything for server plugins?

Not for server-side plugins in `Resources/Server`. Only client mods in `Resources/Client` reach players, and those are downloaded automatically when they join.

##### How accurate is server-side lap timing?

Within a few tenths of a second, limited by the polling interval and each player's ping. That is fine for casual races. Competitive timing needs detection on the client, reported to the server.

##### Can I add a password with a plugin?

There is no password field, but you can deny anyone at `onPlayerAuth` whose `beammp` identifier is not on your list, which is stricter than a password because it cannot be shared.

##### Do I need to restart the server after editing a plugin?

No. Saving a file in the plugin's root folder reloads that plugin. Its variables are reset, so do it between events rather than during one.

BeamMP servers on RE:NODE start at 2 GB with the port open on TCP and UDP, `Resources/Server` editable in the browser or over SFTP, and a console with command history for reading plugin output. The install waits on the Setup tab for your Keymaster key, and backup slots on every tier cover your plugins and their data.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

---

### BeamMP server setup: config, maps, mods

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

A BeamMP server is a small standalone program, not a copy of BeamNG.drive. It relays vehicle state between clients, hands out mods when people join, and runs Lua plugins. It does not simulate a single wheel. That one fact explains most of what follows: the server is cheap on CPU and memory, expensive on bandwidth, and the thing that actually limits your player count is what your players' PCs can simulate, not what you rent.

You need three things to start: the server binary, one port (`30814` by default, on both TCP and UDP), and an auth key from the BeamMP Keymaster. The key is not optional and it is not something a host can give you - it is tied to your own BeamMP account. Everything else is a single `ServerConfig.toml`.

#### What BeamMP is and what the server does

BeamNG.drive has no official multiplayer. BeamMP is the community project that adds it: a client-side mod and launcher for the players, and this server for everyone to meet on.

The architecture is worth internalising before you size anything or blame the host for lag:

- **Every client simulates its own vehicle authoritatively.** Your physics run on your machine.
- **Other people's vehicles are simulated locally too**, corrected by state updates arriving through the server. That is why a remote car that loses packets will jitter, snap or drive through a wall on your screen and look fine on theirs.
- **The server holds no physics state.** It authenticates players, tracks who owns which vehicle, relays updates and runs your Lua.

The consequences are immediate. A ten-player server with four cars each means forty vehicles being simulated on every player's PC, so `MaxCars` is a client performance setting that happens to be configured on the server. And a player complaining about "server lag" is usually describing packet loss or their own CPU, not a saturated host. [Latency, jitter and packet loss](https://www.renode.space/blog/latency-jitter-and-packet-loss) is the right vocabulary for that conversation.

```diagram
title: BeamMP relays vehicle state between clients
a = Player A | simulates own car
b = Player B | simulates own car
server = BeamMP server | TCP and UDP 30814
mods = Resources/Client | mod zips
backend = BeamMP backend | auth and listing
a <-> server : vehicle state
b <-> server : vehicle state
mods -> server : sent to joiners
server -> backend : auth key
```

#### Requirements and resource usage

By game server standards this one is tiny. The work it does is copying packets and, on join, pushing mod archives.

| Players | RAM | vCPU | Notes |
| --- | --- | --- | --- |
| Up to 8, no mods | 2 GB | 1 | Comfortable. The default case |
| 10-16, a few mods | 3 GB | 1.5 | Mod transfer is the only spike |
| 20-30, heavy mod pack | 4-6 GB | 2 | Bandwidth becomes the real constraint |

- **CPU**: low and mostly single-threaded. If your server is pinned at 100% with ten players, look at a Lua plugin doing something silly on every frame before you look at the plan.
- **Disk**: the server itself is a few tens of megabytes. Your `Resources/Client` folder is what grows - a serious mod pack is easily several gigabytes, and every one of those bytes is sent to every joining player.
- **Bandwidth**: this is the one to think about. Vehicle state for every car goes to every client, so traffic scales with players multiplied by cars, and mod downloads land in bursts whenever somebody joins. Expect noticeably more upstream than a Minecraft or Valheim server with the same head count. Unmetered is not the same as unlimited; [bandwidth and fair use](https://www.renode.space/blog/bandwidth-and-fair-use) explains the difference.

The practical advice is to cap `MaxCars` at 2 or 3 for a public server and raise it only for a group you know has the hardware. Nothing else you configure will affect how the server feels as much.

#### Getting an auth key

Every BeamMP server needs an auth key, including a private one. The key identifies the server to the BeamMP backend, which is what authenticates joining players. Without it the server refuses to start.

1. Go to the BeamMP Keymaster at `keymaster.beammp.com` and sign in with Discord.
2. Create a key, give it a name you will recognise later, and copy the string.
3. Paste it into `AuthKey` in `ServerConfig.toml`.

The key belongs to your account, not to your hosting provider. Nobody can issue one on your behalf, and you should treat it like a password: one key per server, never pasted into a public channel, regenerated if it leaks. The same reasoning applies to any credential a server holds - see [environment variables and secrets](https://www.renode.space/blog/environment-variables-and-secrets).

On RE:NODE this is one of the games that needs a credential of your own. The server is created as soon as payment clears, and the install waits on the Setup tab until you paste the key in, which is also where you go if you ever need to replace it.

#### Installing and first start

Download the server build for your platform from the BeamMP project, put it in its own directory, and run it once. It writes a default `ServerConfig.toml` beside itself, prints a complaint about the missing auth key and exits. That is expected - fill the key in and start it again.

```text
BeamMP-Server
ServerConfig.toml
Resources/
  Client/
  Server/
```

On a panel-based host the binary and the folder layout are already there; you edit `ServerConfig.toml` in the browser and drop mods into `Resources/Client` over SFTP or the file manager. [SFTP and the file manager](https://www.renode.space/blog/sftp-and-the-file-manager) has the connection details, and it is the sane way to upload a multi-gigabyte mod pack.

Keep the server version current. BeamMP updates alongside BeamNG releases, and a server running an older protocol is rejected by updated clients - the same trap every modded game has. [What to do when a mod update breaks](https://www.renode.space/blog/what-to-do-when-a-mod-update-breaks) is the general habit worth having: know your working version, keep a copy of the config, and do not update on a night you have people waiting.

There is no world state to lose here, which makes backups unusually simple and unusually easy to neglect. What is worth keeping is `ServerConfig.toml`, everything under `Resources/Server` and the list of what is in `Resources/Client`. The config is five minutes of work to rebuild; a set of Lua plugins tuned over a year is not, and neither is the exact combination of mod versions that currently works together. Take a backup before every mod change and before every server update, and keep it somewhere that is not the server - [backups that actually restore](https://www.renode.space/blog/backups-that-actually-restore) makes the case better than a bullet point can.

#### ServerConfig.toml line by line

The file is TOML, so strings need quotes and booleans do not. A syntax error stops the server rather than being ignored, which is a kindness.

ServerConfig.toml:

```toml
[General]
Port = 30814
AuthKey = "paste-your-keymaster-key-here"
Name = "Sunday Night Cruise"
Description = "Slow driving. No ramming. Italy."
Tags = "Freeroam,Cruise,Europe"
Map = "/levels/italy/info.json"
MaxPlayers = 10
MaxCars = 2
Private = false
AllowGuests = false
LogChat = true
Debug = false
IP = "::"
InformationPacket = true
ResourceFolder = "Resources"
```

| Key | What it does |
| --- | --- |
| `Port` | The port players connect to. Needs TCP and UDP both open |
| `AuthKey` | Your Keymaster key. The server will not start without it |
| `Name` | The name in the server list. Formatting codes are supported |
| `Description` | Two lines of text shown when the server is selected |
| `Tags` | Comma-separated categories used by the in-game filters |
| `Map` | Path to the level's `info.json`, see below |
| `MaxPlayers` | Slots |
| `MaxCars` | Vehicles per player. The single most important performance setting |
| `Private` | `true` keeps the server out of the public list |
| `AllowGuests` | Whether players without a BeamMP account may join |
| `LogChat` | Writes chat to the server log. Useful for moderation |
| `Debug` | Verbose logging. Leave off, it grows the log fast |
| `IP` | Which address to bind. `::` or `0.0.0.0` means all of them |
| `InformationPacket` | Lets unauthenticated clients query server details |
| `ResourceFolder` | Where the mod and plugin folders live |

Recent server versions add sections beyond `[General]`, typically a `[Misc]` block with update-reminder switches such as `ImScaredOfUpdates` and `UpdateReminderTime`, and an HTTP block for the optional built-in web endpoint. The file the server generates is the authority for which of those your build has; anything it did not write, your build probably does not read.

> [!NOTE]
> `Private = true` hides the server from the public list but does not password-protect it. Anyone who knows the address and port can still connect. Access control on BeamMP is done with a Lua plugin checking identifiers at `onPlayerAuth`, not with a password field, because there is not one.

#### Maps and client mods

The `Map` value is a path into the level structure, not a friendly name. The default is `/levels/gridmap_v2/info.json`, and the official levels use these folder names:

| Level | Folder |
| --- | --- |
| Gridmap v2 | `gridmap_v2` |
| Small grid | `smallgrid` |
| East Coast USA | `east_coast_usa` |
| West Coast USA | `west_coast_usa` |
| Italy | `italy` |
| Utah | `utah` |
| Johnson Valley | `johnson_valley` |
| Jungle Rock Island | `jungle_rock_island` |
| Small Island | `small_island` |
| Hirochi Raceway | `hirochi_raceway` |
| Automation Test Track | `automation_test_track` |
| Driver Training | `driver_training` |
| Industrial Site | `industrial` |
| Derby Arena | `derby` |

Mods work by upload, not by workshop. Drop a mod's `.zip` straight into `Resources/Client` and it is sent to every player as they join, then loaded automatically. Vehicles need nothing else. A map mod needs the zip in the same place plus the `Map` line changed to point at the level folder inside that zip - open the archive and look at the folder name under `levels/`, because it rarely matches the name on the download page.

Three things go wrong here, predictably:

- **The map path is wrong**, so the server starts on the default level or fails to load one. Read the zip, do not guess.
- **The mod pack is enormous**, so first-time joiners sit through a several-minute download and half of them give up. Keep the pack as small as the server concept allows, and say the size in your Discord.
- **A mod is incompatible with the current game version.** BeamNG updates break vehicle mods regularly. When a patch lands, the fastest diagnosis is to move the mod folder aside and start clean.

Server-side Lua plugins go in `Resources/Server`, and they are never sent to clients.

#### Lua plugins

A plugin is a folder under `Resources/Server` containing `main.lua`. The server loads it at start, and you hook the events you care about:

Resources/Server/Welcome/main.lua:

```lua
local function onInit()
    print("Welcome plugin loaded")
    MP.RegisterEvent("onPlayerJoin", "greet")
    MP.RegisterEvent("onChatMessage", "filter")
end

function greet(playerID)
    local name = MP.GetPlayerName(playerID)
    MP.SendChatMessage(-1, name .. " joined. Rules are in the Discord.")
end

function filter(playerID, name, message)
    if string.find(message, "badword") then
        MP.SendChatMessage(playerID, "That word is not welcome here.")
        return 1
    end
end

onInit()
```

The events you will use most are `onInit`, `onPlayerAuth`, `onPlayerConnecting`, `onPlayerJoining`, `onPlayerJoin`, `onPlayerDisconnect`, `onChatMessage`, `onVehicleSpawn`, `onVehicleEdited` and `onVehicleDeleted`. Returning `1` from a cancellable handler such as `onChatMessage` or `onVehicleSpawn` blocks the action. The functions you will reach for are `MP.SendChatMessage` (with `-1` for everyone), `MP.DropPlayer`, `MP.GetPlayerName`, `MP.GetPlayers`, `MP.GetPlayerIdentifiers` and `MP.CreateEventTimer` for anything periodic.

Signatures have changed between major server versions, so check the plugin you downloaded against the documentation for the version you are running rather than assuming a three-year-old script still works. This is also where whitelists, vehicle blacklists, anti-ram rules and Discord bridges come from - BeamMP has no built-in admin system worth the name, and every well-run server is well-run because somebody wrote or installed the Lua.

Access control hangs off `onPlayerAuth`, which fires before a player is admitted and receives their identifiers - the account name and the numeric BeamMP identifier the backend vouched for. A whitelist is a table of those identifiers checked in that handler, with `MP.DropPlayer` for anybody not in it. The reason to key on the identifier rather than the display name is the obvious one: names are changeable and identifiers are not. Log both when somebody misbehaves, because by the time you come to ban them the name in your screenshot may belong to nobody.

Be conservative about what you install. A server-side plugin runs with the server's privileges and sees every chat message and every connection, so a plugin from an anonymous forum post deserves a read before it is dropped into a folder that loads automatically at start. The same instinct applies to the client mods you push to other people's machines; [keeping a modded server clean](https://www.renode.space/blog/keeping-a-modded-server-clean) is about exactly this kind of hygiene.

Keep plugins in version control or at least keep copies off the server. They are the part of the setup you cannot re-download.

#### Ports, joining and firewalls

| Port | Protocol | Purpose |
| --- | --- | --- |
| `30814` | TCP | Connection setup, mod transfer |
| `30814` | UDP | Vehicle state |

One port number, both protocols, both directions. Opening only TCP gives the classic symptom: players connect, see the map load, and then nobody moves - because the state stream never arrives. [Game server ports explained](https://www.renode.space/blog/game-server-ports-explained) covers why games split traffic like this.

Players find the server in the in-game BeamMP list when `Private = false`, or connect directly by address and port. Direct connection works regardless of the list, which makes it the right test when you are not sure whether your server is broken or merely unlisted. If you would rather hand out a name than an address, an A record works fine - [connecting a domain to a game server](https://www.renode.space/blog/connecting-a-domain-to-a-game-server) has the details, and BeamMP does not need any SRV trickery.

#### Troubleshooting

**The server exits immediately on start.** Almost always the auth key: missing, mistyped, or still the placeholder. The log line says so, but it scrolls past quickly.

**The server is running and not in the list.** Check `Private`, then check that the machine can reach the BeamMP backend outbound, then wait a couple of minutes. Test with a direct connect meanwhile.

**Players connect, then time out at "loading".** Usually the mod transfer. A large `Resources/Client` over a slow uplink will hit a client-side timeout. Trim the pack or accept that first joins are slow.

**Everyone stutters near each other.** Too many cars. Drop `MaxCars`, then `MaxPlayers`. Remember the simulation happens on their PCs, so this is a client cost you are managing from the server.

**One player is unplayable and everyone else is fine.** That player's connection, or their CPU. Have them check packet loss to the server address before you change anything centrally.

**Version mismatch on join.** The server build is older than the client mod. Update the server. This happens after every BeamNG release, so plan for it rather than being surprised.

**Lua plugin does nothing.** Check that the function names you passed to `MP.RegisterEvent` are global, that `main.lua` is inside its own folder under `Resources/Server`, and that the server log has no syntax error from load time.

#### FAQ

##### Do I need BeamNG.drive installed on the server?

No. The BeamMP server is a standalone program that relays state and serves mods. Only the players need the game, plus the BeamMP client mod.

##### Can a host give me an auth key?

No. The key comes from the BeamMP Keymaster and is tied to your own BeamMP account. Any host will ask you to paste yours in, because there is no legitimate way for them to generate one for you.

##### How many players can a BeamMP server take?

Ten is a comfortable default and busy public servers run more, but the real limit is client performance: every player simulates every vehicle present. Lowering `MaxCars` raises the practical player ceiling far more than a bigger plan does.

##### Where do I put vehicle and map mods?

In `Resources/Client` as `.zip` files. They are pushed to players on join. For a map mod you also have to set `Map` to the level folder inside the archive, which often differs from the file name.

##### Does BeamMP support passwords?

Not as a config option. `Private = true` only removes the server from the public list. Real access control means a Lua plugin that checks player identifiers when they authenticate.

##### Why do other cars jitter or teleport?

Because remote vehicles are simulated locally and corrected from network updates. Packet loss between a player and the server shows up as exactly that, and it is a connection problem rather than a host capacity problem.

BeamMP servers on RE:NODE start at 2 GB with the port allocated on both protocols, `ServerConfig.toml` editable in the browser, and SFTP for dropping a mod pack into `Resources/Client`. The server is created as soon as payment clears and the install waits on the Setup tab for your own Keymaster auth key.

[See BeamMP plans](https://www.renode.space/game-servers/beammp)

## 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.
