How to Install Pterodactyl Panel + Wings on Ubuntu 24.04 VPS

Running your own game server hosting operation used to mean choosing between expensive commercial panels like Multicraft and TCAdmin (hundreds of dollars per year, per-server license fees) or cobbling together scripts and screen sessions that break every time someone uploads a modpack. Pterodactyl Panel changed that. It is a free, open-source game server management panel that isolates every instance inside its own Docker container, gives players a modern web UI for consoles and files, and scales from a single Minecraft server on a hobby VPS to thousands of game instances across a fleet of nodes.

This guide walks you through installing both components — the Panel (the Laravel web app your customers and admins log into) and the Wings daemon (the Go binary that actually spawns and manages game containers) — on a fresh Ubuntu 24.04 LTS VPS. By the end, you will have a working panel at https://panel.yourdomain.com, a Wings node registered against it, and your first Minecraft server running inside Docker.

Want to sell game server hosting? Pterodactyl is the platform behind most modern indie game hosts. Pair it with our CloudCore Business VPS — 8 vCPU, 24 GB RAM, 240 GB NVMe — and you have everything you need to launch a game-hosting brand in an afternoon.

Table of Contents

What is Pterodactyl?

Pterodactyl is an open-source game server management platform first released in 2017 and now maintained by a community of hundreds of contributors. It consists of two cleanly separated pieces: a Laravel-based web panel that handles authentication, billing integrations, permissions, and the browser UI; and a Go-based daemon called Wings that runs on each physical host and launches game servers inside Docker containers.

Every game server instance you create through the panel — a Minecraft Paper server, a Rust world, a CS2 match server, an ARK cluster — is started as an isolated Docker container with its own CPU, memory, disk, and network limits. Players and admins get a real-time web console streamed over WebSockets, a file manager, a scheduler, a backup system, and per-user SFTP access on port 2022. Behind the scenes, containers can be hard-killed, restarted, or migrated between hosts without touching the metal.

Pterodactyl is the panel of choice for a long list of well-known game hosts, and because it ships under a permissive MIT license you can white-label it, modify it, or build a billing integration on top. A recent community fork called Pelican Panel reorganizes the codebase around Filament and single-binary deployment; it is worth knowing about, but the original Pterodactyl remains the most battle-tested option for production today.

Why Self-Host with Pterodactyl?

Running Pterodactyl on your own VPS instead of renting pre-packaged game server slots offers concrete advantages:

• Unlimited game servers on one bill -- A single VPS can host dozens of small Minecraft servers or a handful of large Rust worlds. No per-slot pricing, no per-player fees.
• Docker isolation -- Every game server runs in its own container with enforced CPU, RAM, and disk quotas. One misbehaving modpack cannot take down the host.
• White-label ready -- Brand the panel with your own logo, theme, and domain. Your players never see "Pterodactyl" unless you want them to.
• Sell hosting -- Pair with a billing system like WHMCS, Blesta, or Paymenter to sell game server plans. Customer signs up → plan is provisioned as a Pterodactyl server automatically.
• Free and open-source -- MIT licensed, no hidden fees, no license checks. Compare to Multicraft at roughly $30-80/month for commercial licensing at scale.
• Full control of the stack -- Pick your own game eggs, Docker images, Java versions, and resource limits. Mod anything that annoys you.
• Scale horizontally -- One panel, many Wings nodes. Add a second server when you run out of RAM without rearchitecting anything.

Cost Comparison: Pterodactyl vs. Commercial Panels

Architecture Overview: Panel vs. Wings

Pterodactyl has two distinct components and understanding the split matters before you start installing.

The Panel is a PHP 8.3 Laravel application. It stores data in MySQL/MariaDB, uses Redis for caching and the job queue, and is served by Nginx + PHP-FPM. This is what admins and players open in their browser. The Panel never runs game servers itself — it issues signed API calls to Wings daemons.

Wings is a single Go binary that runs on every host where game servers will actually live. It talks to the Docker API to create, start, stop, and inspect containers. It streams console output and SFTP traffic back to the panel, enforces resource limits, and manages per-server filesystem storage at /var/lib/pterodactyl/volumes/<uuid>.

For small setups you can put both Panel and Wings on the same server. That is what this guide does. For larger operations you run one Panel and N Wings nodes, where each Wings node is its own VPS or bare-metal box dedicated to game workloads. The split also means you can put the Panel on a modest 4 GB VPS and move heavy RAM/CPU to Wings nodes sized to the games you host.

Communication between Panel and Wings happens over HTTPS on port 8080 (Wings) with WebSocket upgrades for live console streaming. SFTP lives on a separate port (2022 by default).

Prerequisites

Before you begin, make sure you have:

• A VPS running Ubuntu 24.04 LTS with root or sudo access
• SSH access to the server (PuTTY on Windows, or the built-in terminal on macOS/Linux)
• A domain name pointed at the server (for example panel.yourdomain.com) with DNS already propagated
• Ports open in your firewall: 80, 443 (panel), 8080 (Wings), 2022 (SFTP), plus whatever game ports you plan to allocate (25565 for Minecraft, etc.)
• At least 4 GB of RAM for the Panel + Wings on a shared host, 8 GB+ if you plan to run multiple game servers

Recommended Plan: CloudCore Business

For hosting Pterodactyl Panel plus a healthy fleet of game servers on a single node, we recommend the CloudCore Business plan:

- 8 vCPU cores

- 24 GB RAM

- 240 GB NVMe SSD

- 32 TB traffic included

- EUR 29.99/month

That gives you enough headroom for the panel, Wings, and roughly 8-15 concurrent Minecraft/Rust instances depending on player count and mods. Need more? Add a second VPS as an extra Wings node and keep the same panel.

Connect to your server via SSH to get started:

ssh root@your-server-ip

Step 1: Update System and Add Repositories

Start by updating your package index, upgrading installed packages, and adding the ondrej/php PPA that carries modern PHP builds for Ubuntu.

sudo apt update && sudo apt upgrade -y
sudo apt install -y software-properties-common curl ca-certificates gnupg lsb-release
sudo add-apt-repository -y ppa:ondrej/php
sudo apt update

Expected output (abbreviated):

Hit:1 http://archive.ubuntu.com/ubuntu noble InRelease
Get:2 https://ppa.launchpadcontent.net/ondrej/php/ubuntu noble InRelease [23.8 kB]
...
Reading package lists... Done

If the kernel was updated as part of the upgrade, reboot before continuing:

sudo reboot

Then reconnect via SSH after a minute.

Step 2: Install PHP 8.3 and Extensions

The Pterodactyl Panel is a Laravel 10 application that requires PHP 8.1 or later. We install PHP 8.3 along with every extension the panel needs: CLI, FPM, GD, MySQL, MBString, BCMath, XML, cURL, Zip, and Tokenizer.

sudo apt install -y php8.3 php8.3-{cli,fpm,gd,mysql,mbstring,bcmath,xml,curl,zip,tokenizer,intl}

Verify PHP was installed correctly:

php -v

Expected output:

PHP 8.3.14 (cli) (built: Nov 21 2025 12:00:00) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.3.14, Copyright (c) Zend Technologies
    with Zend OPcache v8.3.14, Copyright (c), by Zend Technologies

Confirm PHP-FPM is enabled and running:

sudo systemctl enable --now php8.3-fpm
sudo systemctl status php8.3-fpm

You want to see active (running) in the output.

Step 3: Install MariaDB and Create the Panel Database

Pterodactyl supports both MySQL 8 and MariaDB 10.6+. We use MariaDB here because it is lighter, ships in the default Ubuntu repositories, and works identically from the panel's perspective. If you already have MariaDB installed on this VPS, skip the install command and jump straight to creating the database.

sudo apt install -y mariadb-server
sudo systemctl enable --now mariadb
sudo mysql_secure_installation

The mysql_secure_installation wizard will ask you to set a root password, remove anonymous users, disallow remote root login, and drop the test database. Answer Y to all of them.

Next, create a dedicated database and user for the Panel:

sudo mysql -u root -p

Inside the MariaDB prompt:

CREATE DATABASE panel;
CREATE USER 'pterodactyl'@'127.0.0.1' IDENTIFIED BY 'REPLACE_WITH_STRONG_PASSWORD';
GRANT ALL PRIVILEGES ON panel.* TO 'pterodactyl'@'127.0.0.1' WITH GRANT OPTION;
FLUSH PRIVILEGES;
EXIT;

Save the password somewhere safe — you will need it in Step 5. Use a long random string (24+ characters), not panelpassword.

Step 4: Install Redis, Nginx, Composer, and Git

The Panel uses Redis for caching, sessions, and its queue backend; Nginx as the web server; Composer for PHP dependency management; and git to clone the release source.

sudo apt install -y redis-server nginx git unzip tar
sudo systemctl enable --now redis-server

Install Composer (the official one-liner from getcomposer.org):

curl -sS https://getcomposer.org/installer | sudo php -- --install-dir=/usr/local/bin --filename=composer
composer --version

Expected output:

Composer version 2.8.3 2025-01-01 00:00:00

Verify Redis is responding:

redis-cli ping

Expected output:

PONG

Step 5: Download and Configure the Panel

Pterodactyl ships release tarballs on GitHub. Create the panel directory, download the latest release, and extract it.

sudo mkdir -p /var/www/pterodactyl
cd /var/www/pterodactyl
sudo curl -Lo panel.tar.gz https://github.com/pterodactyl/panel/releases/latest/download/panel.tar.gz
sudo tar -xzvf panel.tar.gz
sudo chmod -R 755 storage/* bootstrap/cache/

Install the PHP dependencies with Composer:

sudo cp .env.example .env
sudo composer install --no-dev --optimize-autoloader

The --no-dev flag skips development packages. This step downloads roughly 120 MB of Laravel and Pterodactyl dependencies and typically takes 1-3 minutes.

Generate the Laravel application encryption key:

sudo php artisan key:generate --force

Now run the three interactive setup commands that populate .env with environment, database, and mail settings.

Environment Setup

sudo php artisan p:environment:setup

You will be prompted for:

• Application URL -- https://panel.yourdomain.com
• Timezone -- UTC or your preferred IANA timezone (e.g. Europe/Berlin)
• Cache driver -- redis
• Session driver -- redis
• Queue driver -- redis
• Enable UI-based settings editor? -- yes
• Redis host/port/password -- Defaults (127.0.0.1, 6379, no password) are fine for a single-server install.

Database Setup

sudo php artisan p:environment:database

Answer with the credentials from Step 3:

• Database host -- 127.0.0.1
• Database port -- 3306
• Database name -- panel
• Database username -- pterodactyl
• Database password -- the strong password you created

Mail Setup

sudo php artisan p:environment:mail

Pick a driver that matches your setup — smtp for Postmark/SES/Mailgun, or mail to use the local sendmail binary if you are testing. You can reconfigure this later from the admin UI.

Step 6: Run Database Migrations and Create the Admin User

With environment configured, run the migrations to create all 60+ Pterodactyl tables, then create your first admin user.

sudo php artisan migrate --seed --force

Expected output (abbreviated):

Migrating: 2017_07_26_131530_create_nests_table
Migrated:  2017_07_26_131530_create_nests_table (12.45ms)
...
Database seeding completed successfully.

Create the root admin account:

sudo php artisan p:user:make

You will be prompted:

• Is this user an administrator? -- yes
• Email address -- your login email
• Username -- pick something short
• First name / Last name -- display info
• Password -- minimum 8 characters, store it safely

sudo chown -R www-data:www-data /var/www/pterodactyl/*

Step 7: Configure Nginx with SSL

Create the Nginx site configuration that proxies PHP requests to PHP-FPM and serves static assets directly.

sudo tee /etc/nginx/sites-available/pterodactyl.conf > /dev/null <<'EOF'
server {
    listen 80;
    server_name panel.yourdomain.com;
    return 301 https://$server_name$request_uri;
}
server {
    listen 443 ssl http2;
    server_name panel.yourdomain.com;
    root /var/www/pterodactyl/public;
    index index.php;
    access_log /var/log/nginx/pterodactyl.app-access.log;
    error_log  /var/log/nginx/pterodactyl.app-error.log error;
    client_max_body_size 100m;
    client_body_timeout 120s;
    sendfile off;
    ssl_certificate     /etc/letsencrypt/live/panel.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/panel.yourdomain.com/privkey.pem;
    ssl_session_cache shared:SSL:10m;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    add_header X-Content-Type-Options nosniff;
    add_header X-XSS-Protection "1; mode=block";
    add_header X-Robots-Tag none;
    add_header Content-Security-Policy "frame-ancestors 'self'";
    add_header X-Frame-Options DENY;
    add_header Referrer-Policy same-origin;
    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }
    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/run/php/php8.3-fpm.sock;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param PHP_VALUE "upload_max_filesize=100M\nphp_post_max_size=100M";
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param HTTP_PROXY "";
        fastcgi_intercept_errors off;
        fastcgi_buffer_size 16k;
        fastcgi_buffers 4 16k;
        fastcgi_connect_timeout 300;
        fastcgi_send_timeout 300;
        fastcgi_read_timeout 300;
        include /etc/nginx/fastcgi_params;
    }
    location ~ /\.ht {
        deny all;
    }
}
EOF

Replace panel.yourdomain.com with your actual domain. Enable the site and obtain an SSL certificate from Let's Encrypt:

sudo rm -f /etc/nginx/sites-enabled/default
sudo ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d panel.yourdomain.com
sudo nginx -t && sudo systemctl reload nginx

Browse to https://panel.yourdomain.com in your browser. You should see the Pterodactyl login page. Log in with the admin user you created in Step 6.

Step 8: Set Up the Queue Worker and Cron

Pterodactyl uses Laravel's queue system for background jobs — sending emails, running scheduled server tasks, handling backups. You need two pieces: a systemd unit that keeps the queue worker alive, and a cron entry that runs the scheduler every minute.

Create the queue worker systemd unit:

sudo tee /etc/systemd/system/pteroq.service > /dev/null <<'EOF'
[Unit]
Description=Pterodactyl Queue Worker
After=redis-server.service
[Service]
User=www-data
Group=www-data
Restart=always
ExecStart=/usr/bin/php /var/www/pterodactyl/artisan queue:work --queue=high,standard,low --sleep=3 --tries=3
StartLimitInterval=180
StartLimitBurst=30
RestartSec=5s
[Install]
WantedBy=multi-user.target
EOF

Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable --now pteroq.service
sudo systemctl status pteroq.service

Add the Laravel scheduler to cron for the www-data user:

sudo crontab -u www-data -e

Add this single line:

    * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1

Save and exit. The scheduler is now running once a minute.

Step 9: Install Docker for Wings

Wings spawns every game server inside a Docker container, so Docker Engine has to be on every node that runs Wings. If you already followed our Docker on Ubuntu 24.04 guide, skip the install commands and jump to Step 10.

Install Docker from the official repository:

curl -fsSL https://get.docker.com/ | sudo sh
sudo systemctl enable --now docker
docker --version

Expected output:

Docker version 27.3.1, build ce12230

Enable swap accounting in the kernel so Wings can enforce memory+swap limits on containers. Edit /etc/default/grub:

sudo sed -i 's/GRUB_CMDLINE_LINUX_DEFAULT="quiet splash"/GRUB_CMDLINE_LINUX_DEFAULT="quiet splash swapaccount=1"/' /etc/default/grub
sudo update-grub
sudo reboot

Reconnect via SSH after the reboot, then confirm Docker is running:

sudo docker run --rm hello-world

You should see the "Hello from Docker!" banner.

Step 10: Install the Wings Daemon

With Docker in place, create the Wings directories, download the binary, and install the systemd unit.

sudo mkdir -p /etc/pterodactyl
sudo curl -L -o /usr/local/bin/wings \
  "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
sudo chmod u+x /usr/local/bin/wings

Verify the binary works:

sudo wings --version

Expected output:

wings v1.11.13

Create the systemd unit:

sudo tee /etc/systemd/system/wings.service > /dev/null <<'EOF'
[Unit]
Description=Pterodactyl Wings Daemon
After=docker.service
Requires=docker.service
PartOf=docker.service
[Service]
User=root
WorkingDirectory=/etc/pterodactyl
LimitNOFILE=4096
PIDFile=/var/run/wings/daemon.pid
ExecStart=/usr/local/bin/wings
Restart=on-failure
StartLimitInterval=600
[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable wings

Do not start Wings yet — it needs a configuration file generated by the Panel. That is the next step.

Step 11: Register the Node in the Panel

In your browser, log into https://panel.yourdomain.com as the admin user. Head to Admin → Locations and create a location (for example eu-central). Locations are logical groupings — useful once you have multiple Wings nodes in different datacenters.

Next, go to Admin → Nodes → Create New. Fill in:

• Name -- something like node-01
• Location -- the location you just created
• FQDN -- the hostname Wings is reachable at. For a single-server install this is the same as your panel domain, or a dedicated subdomain like node1.yourdomain.com pointed at the same IP.
• Communicate over SSL -- Yes (requires the FQDN to have an SSL cert)
• Daemon port -- 8080
• Daemon SFTP port -- 2022
• Total memory / disk -- how much of this VPS you are allocating to game servers (leave 2-4 GB for the OS and panel)

sudo certbot certonly --nginx -d node1.yourdomain.com

Save the node. Open the node page and click the Configuration tab. Pterodactyl generates a YAML config tied to this node. Copy the entire block, then on the server:

sudo nano /etc/pterodactyl/config.yml

Paste the config, save, and exit. Start Wings:

sudo systemctl start wings
sudo systemctl status wings

You want to see active (running). Back in the panel, the node status indicator should flip from red to green within a few seconds. If it stays red, jump to the Troubleshooting section.

Step 12: Create Allocations and Your First Server

Allocations are (IP, port) pairs that Pterodactyl can assign to game servers. On the node page, open the Allocations tab and add a block. For a Minecraft server, a common choice is:

• IP Address -- the node's public IP (or 0.0.0.0 if behind NAT, with proper port forwarding)
• Ports -- 25565-25580 (16 Minecraft slots)

• Server name -- My First MC Server
• Server owner -- your admin user (or a sub-user you created)
• Node -- the node you just set up
• Allocation -- pick one of the 25565-25580 ports
• Resource limits -- CPU %, Memory (MB), Disk (MB). For a vanilla Minecraft server: 200% CPU, 4096 MB RAM, 10240 MB disk.
• Nest -- Minecraft
• Egg -- Paper (best-performing modern Minecraft server)
• Docker image -- pick the Java version the egg suggests (Java 21 for recent Paper builds)
• Startup command -- leave the egg default unless you know what you are changing
• Service variables -- set the Minecraft version (e.g. 1.21.4) and server JAR build

Connect from Minecraft client at node1.yourdomain.com:25565. It works.

Common Eggs (Game Templates)

An egg in Pterodactyl is a JSON template that defines Docker image, startup command, config files, and installation script for a specific game. The panel ships with a nest of common eggs; thousands more are available at pterodactyl-eggs.com and on GitHub.

Some high-value ones to import from Admin → Nests → Import Egg:

• Minecraft Paper / Purpur / Fabric / Forge -- included by default in the Minecraft nest.
• Rust -- SteamCMD-based, needs roughly 8 GB RAM per 100-slot server. Nest is in the default "Source Engine" set.
• CS2 (Counter-Strike 2) -- community egg, SteamCMD-based, runs on port 27015/udp.
• ARK: Survival Ascended -- community egg, hungry: plan 16 GB+ RAM per cluster.
• Palworld, Valheim, Terraria, Garry's Mod, Factorio -- all maintained community eggs, easy to import.
• Discord bots / Python apps / Node.js apps -- Pterodactyl's "Generic" nest lets you run any long-running process in a container with resource limits, not just games.

SFTP Access for Players

Every Pterodactyl server automatically exposes SFTP on port 2022 (not 22 — that is your host's normal SSH). Players log in with their panel email and password, and their home directory is the specific server they have permission on.

Example connection string for FileZilla:

• Host -- node1.yourdomain.com
• Port -- 2022
• Protocol -- SFTP
• Username -- <panel-email>.<server-short-id> (the panel UI shows the exact format)
• Password -- panel password

sudo ufw allow 2022/tcp

SFTP traffic is brokered by Wings itself, not by OpenSSH. There is no separate SSH user per server — Wings handles authentication against the panel's API.

Scaling to Multiple Wings Nodes

When one VPS fills up, add a second one. The process is:

You now have one Panel managing two Wings nodes. When creating new servers you pick which node to deploy to. Servers cannot be migrated between nodes live via the UI (you can do it by stopping, rsyncing the volume, and editing the DB), but new servers go wherever you want.

A common architecture for a game-host business:

• 1x Panel node (cheap, 4 GB RAM, runs only Laravel + DB + Redis)
• N x Wings nodes (fat, 32-64 GB RAM each, runs only Docker + game containers)

Backups and Updates

Backing Up the Panel

The panel's state lives in MariaDB plus the .env file. Snapshot both daily:

sudo mysqldump -u root -p panel | gzip > /root/panel-backup-$(date +%F).sql.gz
sudo cp /var/www/pterodactyl/.env /root/panel-env-$(date +%F).backup

Wire that into a nightly cron job and ship the output to off-box storage (S3, Backblaze B2, rsync to another VPS).

Backing Up Wings Volumes

Every game server's files live under /var/lib/pterodactyl/volumes/<uuid>/. The panel also has a built-in Backup feature that writes per-server .tar.gz archives — enable it in Admin → Settings → Backups and configure an S3 bucket as the destination. Scheduled backups then run from the panel UI per server.

Updating the Panel

cd /var/www/pterodactyl
sudo php artisan down
sudo curl -L https://github.com/pterodactyl/panel/releases/latest/download/panel.tar.gz | sudo tar -xzv
sudo chmod -R 755 storage/* bootstrap/cache
sudo composer install --no-dev --optimize-autoloader
sudo php artisan view:clear
sudo php artisan config:clear
sudo php artisan migrate --seed --force
sudo chown -R www-data:www-data /var/www/pterodactyl/*
sudo systemctl restart pteroq.service
sudo php artisan up

Updating Wings

sudo systemctl stop wings
sudo curl -L -o /usr/local/bin/wings \
  "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_$([[ "$(uname -m)" == "x86_64" ]] && echo "amd64" || echo "arm64")"
sudo chmod u+x /usr/local/bin/wings
sudo systemctl start wings

Watch the Pterodactyl GitHub releases page for new versions and always read the release notes before a major-version update.

Troubleshooting

Viewing Logs

The single most useful debugging tool is tailing both service logs side by side:

sudo journalctl -u wings -f

And in another SSH session:

sudo tail -f /var/www/pterodactyl/storage/logs/laravel.log

FAQ

Is Pterodactyl really free?

Yes. Pterodactyl is MIT-licensed, open-source, and has no paid tiers, no license keys, and no per-server fees. The project is funded through donations and sponsorships, not sales. You can deploy it on commercial hosting, resell access to it, modify the source, and white-label it with no legal obligation beyond keeping the MIT copyright notice in the code.

What is Pelican Panel and should I use it instead?

Pelican is a community fork of Pterodactyl that re-architects the panel around the Filament admin framework and ships as a single binary with fewer PHP dependencies. It is well-maintained and has an active community, but it is newer than Pterodactyl and ecosystem support (third-party addons, themes, billing integrations) is still catching up. If you want the most battle-tested option today, install Pterodactyl. If you want to experiment with a more modern codebase and don't mind a rougher ecosystem, try Pelican — the concepts (Panel + Wings, eggs, nodes) are identical, so skills transfer.

Can I run Panel and Wings on the same server?

Yes, and this guide does exactly that. For small operations (up to ~10-15 game servers), a single VPS running both is perfectly fine. The main risk is resource contention: a runaway game server can briefly starve the panel of CPU. For production game hosting at scale, split them — cheap VPS for panel, beefy VPS for Wings — so you can reboot or resize Wings nodes without taking the admin UI offline.

How much RAM do I need per game server?

It depends heavily on the game and mods:

• Vanilla Minecraft (1-10 players) -- 1-2 GB per server
• Modded Minecraft (Forge/Fabric with 100+ mods) -- 4-8 GB per server
• Rust (100-slot wiped weekly) -- 6-10 GB per server
• ARK: Survival Ascended -- 8-16 GB per cluster
• CS2 match server -- 1 GB per server
• Discord bot / small Node.js app -- 256-512 MB

How do I integrate Pterodactyl with a billing system?

Pterodactyl exposes a well-documented Application API that billing systems use to create users, servers, and manage allocations. Popular integrations:

• WHMCS via the Pterodactyl WHMCS module — de facto standard for resellers
• Blesta via community modules
• Paymenter — an open-source billing system purpose-built for game server hosts
• Custom — roll your own using the Application API if you have a specific workflow

Next Steps

Now that Pterodactyl is running on your VPS, here are recommended next steps to build on your setup:

• Import more game eggs -- Browse pterodactyl-eggs.com and the Parker-Stafford/Pterodactyl-Eggs GitHub repo for a large catalog of Rust, ARK, Palworld, Valheim, and exotic eggs.

• Hook up a billing system -- Install Paymenter or the official WHMCS module to start selling game servers automatically. Customer pays → server is provisioned → credentials emailed.

• Add a second Wings node -- Spin up another VPS, install only Docker + Wings on it, register it in the panel, and start scaling horizontally. Fat Wings nodes are much more cost-efficient per server than many small ones.

• Harden the server -- Install UFW and Fail2Ban to limit brute-force attacks on SSH and SFTP, and run Lynis for a baseline security audit.

• Set up off-site backups -- Point the panel's built-in backup system at an S3 bucket (Backblaze B2, Cloudflare R2, or AWS S3) so server files survive a VPS failure. Add a nightly mysqldump of the panel database to the same bucket.

• White-label the panel -- Swap the logo, favicon, and theme colors in Admin → Settings → Branding, set a custom login background, and point your players at panel.yourbrand.com — nothing in the default UI references Pterodactyl.

Skip the Manual Install -- Launch a Game-Host-Ready VPS

Pterodactyl sings on our CloudCore Business plan — 8 vCPU, 24 GB RAM, 240 GB NVMe, 32 TB traffic for EUR 29.99/month. That's enough headroom for the panel, Wings, and a profitable fleet of Minecraft, Rust, and Palworld servers on a single node.

- Ubuntu 24.04 LTS pre-installed

- Full root access, deploy Pterodactyl in under an hour

- NVMe storage for fast world saves and chunk loading

- 32 TB traffic included (most game servers will never touch the cap)

- Scale to a multi-node fleet by adding more VPS instances with the same panel

Deploy Your Game-Host VPS Now — Plans start at EUR 29.99/month.