Sale 40% off 109 products · ends Oct 15, 2026 Shop the sale

Velocity Setup: Connect Your Minecraft Servers into a Network

Install the Velocity proxy, turn on modern forwarding with a shared secret, and link a Paper lobby and a game server behind one address. Includes steps for a VPS and for Pterodactyl or Multicraft panels.

zArrowTan Resources Oct 3, 2026 7 min read
config

1 #!/bin/sh

2 java -Xms1G -Xmx1G -XX:+UseG1GC -XX:G1He...

3 chmod u+x start.sh

4 ./start.sh

5 bind = "0.0.0.0:25565"

6 player-info-forwarding-mode = "modern"

7 [servers]

On this page
  1. Plan the network before you install anything
  2. Install and start Velocity
  3. Register your servers in velocity.toml
  4. Turn on modern forwarding on each Paper server
  5. 1. server.properties
  6. 2. config/paper-global.yml
  7. 3. spigot.yml
  8. Close the backends to the public
  9. Start the network and test the first join
  10. Make the lobby worth landing in
  11. Add another game server later

Key takeaways

5
  • Players connect only to the Velocity proxy; lobby and game servers are Paper backends behind it.
  • Set player-info-forwarding-mode to modern and copy forwarding.secret into proxies.velocity.secret in each backend's paper-global.yml.
  • Backends need online-mode=false, so keep them private with a firewall (or a 127.0.0.1 allocation on Pterodactyl); forwarding is not a firewall.
  • Put the lobby first in the try list and register each server under [servers] in velocity.toml.
  • On Pterodactyl, Java comes from the Docker image, backends keep server-ip empty and the proxy reaches them through 172.18.0.1 plus their allocated port.

This guide is for server owners who want one address, such as play.example.com, that sends players to several servers: a lobby, a survival world, a minigame. By the end you will have a Velocity proxy running, a Paper lobby and a Paper game server connected to it with modern forwarding, and the backends closed to everyone except the proxy.

Plan the network before you install anything

A Velocity network has one public server (the proxy) and any number of backend servers behind it. Players only ever connect to the proxy. It logs them in with Mojang, then passes them to a backend. Every backend needs its own port, and the proxy needs the public one.

We will use this layout in the examples. Change the numbers to suit your machine.

ServerSoftwarePortReachable from
proxyVelocity25565Everyone
lobbyPaper25566The proxy only
survival (or any game server)Paper25567The proxy only

If you have not built a Paper server yet, start with our Paper server setup guide, then come back. You need two working Paper servers that start cleanly on their own.

Velocity is made by the PaperMC project. Its docs describe it as a modern, high-performance proxy and an alternative to Waterfall and BungeeCord.

Install and start Velocity

The Velocity docs say it needs at least Java 25. Check that first, because an older Java will refuse to start the jar. Download the latest stable Velocity jar from the PaperMC downloads page, put it in its own empty folder (not inside a Paper folder), and start it once so it creates its files.

  1. Run java -version. It should report 25 or higher. The PaperMC docs list a Java install route for Debian and Ubuntu.
  2. Create a folder such as ~/velocity and upload the jar there, renamed to velocity.jar.
  3. Create start.sh with only the start command from the Velocity docs:
#!/bin/sh
java -Xms1G -Xmx1G -XX:+UseG1GC -XX:G1HeapRegionSize=4M -XX:+UnlockExperimentalVMOptions -XX:+ParallelRefProcEnabled -XX:+AlwaysPreTouch -XX:MaxInlineLevel=15 -jar velocity*.jar

Then make it executable and run it from the shell, as separate commands:

chmod u+x start.sh
./start.sh

On first start Velocity listens on port 25565 and writes velocity.toml next to the jar. Stop it with shutdown in the console before editing.

  1. Create a new server for the proxy. Use a Velocity egg if your host offers one, or ask your host which egg to use.
  2. Open the Startup tab and check the Docker image. The Java version comes from that image, and you usually cannot install your own. If no Java 25 image is listed, ask your host.
  3. Upload the Velocity jar in the File Manager (or over SFTP) and point the egg's jar variable at it.
  4. Press Start in the Console. When velocity.toml appears in the File Manager, stop the server.
  1. Not every Multicraft host lets you pick a proxy jar. Ask your host whether Velocity is supported and which Java version it runs.
  2. Upload the Velocity jar on the Files / FTP page, then select it on the JAR selection page.
  3. Start it from the console, then stop it once velocity.toml has been created.

Register your servers in velocity.toml

Open velocity.toml. Three parts matter for a first network: the server list, the try order and the forwarding mode.

bind = "0.0.0.0:25565"
player-info-forwarding-mode = "modern"

[servers]
lobby = "127.0.0.1:25566"
survival = "127.0.0.1:25567"

try = ["lobby"]

The 127.0.0.1 addresses above suit servers running side by side on one machine without containers, such as a VPS. On Pterodactyl use the address from the note below instead.

  • [servers] maps a name you choose to an address and port.
  • try lists where players land when they join or when their server closes. Put the lobby first. The docs show it as an array, so you can add a fallback such as ["lobby", "survival"].
  • player-info-forwarding-mode set to modern is the setting Paper understands.
  • online-mode stays on for the proxy, so Mojang accounts are checked once, at the front door.

Velocity also supports [forced-hosts], which sends players to a chosen server depending on the hostname they typed, for example "survival.example.com" = ["survival"]. Skip it until the basics work.

Turn on modern forwarding on each Paper server

Velocity creates a forwarding.secret file. Its contents are a shared password between the proxy and every backend. Do the following on each Paper server (lobby and survival), with the server stopped.

1. server.properties

online-mode=false
server-port=25566

Use the right port for each server. Backends must run in offline mode because the proxy does the login.

  • VPS or your own machine (no containers): if the proxy and backends share the machine, you can also add server-ip=127.0.0.1, one of the options the Velocity docs suggest, so the backend only listens locally.
  • Pterodactyl: leave server-ip empty. The server runs inside its own container, so binding it to the container's own loopback address would stop the proxy reaching it. Set the port to the backend's allocated port, and control who can reach it with the allocation (see the next section).

2. config/paper-global.yml

proxies:
  velocity:
    enabled: true
    online-mode: true
    secret: "paste the contents of forwarding.secret here"

Paper documents these three keys: enabled defaults to false, online-mode should match the proxy's online-mode, and secret must equal the proxy's forwarding.secret. Modern forwarding works with Paper 1.14 or later, or Paper 1.13.1 and 1.13.2 from build 377 onwards. On Paper 1.18.2 or older the keys live under settings.velocity-support in paper.yml.

3. spigot.yml

Make sure settings.bungeecord is false. That switch is for the older forwarding method, and the Velocity docs say to turn it off when using modern forwarding.

Editing these files is the same on every host. On Pterodactyl use the File Manager, on Multicraft the Files page, on a VPS your editor of choice.

Close the backends to the public

With online-mode=false, anyone who can reach a backend directly could pretend to be any player. The Velocity docs call this extremely dangerous and say modern forwarding is not a replacement for a firewall.

  1. Keep server-ip=127.0.0.1 on the backends if they share the machine with the proxy.
  2. Use your operating system firewall (Windows Firewall, iptables or nftables) to allow only port 25565 from the internet.
  3. If backends live on other machines, allow their ports only from the proxy's IP address.
  1. Give the lobby and game servers a 127.0.0.1 allocation on the same node as the proxy. Only the proxy gets an allocation on the node's public IP.
  2. Leave server-ip empty in each backend's server.properties and set server-port to the allocated port.
  3. In velocity.toml, use 172.18.0.1 plus that port for each backend, as in the note above.
  4. Do not publish the backend ports in any other way.
  1. Ask your host how to keep backend ports private. Most shared Multicraft setups give you no firewall control.
  2. If the host cannot restrict ports, run your backends elsewhere or move to a panel that can.

Start the network and test the first join

  1. Start the lobby and the survival server first, and wait until both say they are done loading.
  2. Start Velocity.
  3. Join the proxy address in Minecraft. You should land on the lobby, because it is first in try.
  4. Type /server to see the configured servers, and use it to switch to survival.

If you change velocity.toml later, /velocity reload makes the proxy read it again. The built-in /send command moves other players, and /glist shows player counts per server, but it is granted to nobody by default, so give the permission to your staff.

Make the lobby worth landing in

The lobby is the first thing every player sees. Give it a spawn, a way to reach each game server and a few leaderboards. Our lobby design guide covers navigation with NPCs, holograms and menus.

If you would rather not build one from scratch, the store sells ready-made lobby schematics. One example is Fantasy Lobby, made by our team, which the catalogue describes as a fantasy minigame lobby with NPC hub and leaderboard zones, compact and adaptable.

Add another game server later

Adding a server to a running network takes four steps:

  1. Create a new Paper server with its own port and repeat the three Paper config steps, using the same forwarding secret.
  2. Add a line to [servers], for example minigames = "127.0.0.1:25568" (or the 172.18.0.1 address on Pterodactyl).
  3. Run /velocity reload or restart the proxy.
  4. Allow the new port only for the proxy, as in the firewall step.

Back up each server before you change anything, and when you update Minecraft, follow our guide to updating Paper without breaking plugins one backend at a time.

Frequently asked questions

What Java version does Velocity need?

The PaperMC docs say Velocity needs at least Java 25. Check with java -version. On a hosting panel the Java version is set by the Docker image on the Startup tab, so ask your host if no suitable image is listed.

What is modern forwarding in Velocity?

It is Velocity's own way of passing player information to backend servers, protected by a shared secret from forwarding.secret. Paper supports it from 1.14, or from build 377 on 1.13.1 and 1.13.2, while Spigot only supports the older BungeeCord method.

Why do the backend servers need online-mode=false?

The proxy logs players in with Mojang, so the backends must not do it again. That is why backends must never be reachable directly: use a firewall, or on Pterodactyl a 127.0.0.1 allocation, so only the proxy can reach them.

Can I run Velocity and my Paper servers on the same machine?

Yes. Give each server its own port and keep the proxy on 25565. Without containers you can bind the backends to 127.0.0.1 or firewall them. On Pterodactyl they must be on the same node, with 127.0.0.1 allocations reached through 172.18.0.1.

How do I send players to another server?

Players can use the built-in /server command to switch between configured servers. Staff with the right permission can use /send to move other players.

Share this post

Products from this post

Other plugins mentioned

Related posts

© zArrowTan Resources 2026
Forked and customised by zArrowTan · Powered by Light Store