Install Pterodactyl Game Panel on a VPS

If you're running more than one game server, you've probably hit the wall: SSH into a different box for each one, manage configs in a text editor, restart with screen or tmux, share access by handing out root passwords. Pterodactyl Panel ends all of that — a single web GUI to manage Minecraft, Rust, ARK, CS2, Valheim, and 80+ other games, with per-server file managers, scheduled restarts, real cgroup-based resource isolation, and per-user permissions.

This guide installs the official Pterodactyl Panel (the web GUI) and Wings (the Docker daemon that actually runs game servers) on a single VPS, configures HTTPS via Let's Encrypt, deploys your first Minecraft server, and covers the operational pieces most tutorials skip: backups, resource limits, user accounts, and the difference between Pterodactyl and the Pelican fork that emerged in 2024.

1. Pterodactyl vs Pelican — pick one

Some context: in 2024, the Pterodactyl maintainer announced commercial pivots that didn't sit well with the community. A community-led fork named Pelican Panel emerged with the same codebase and stronger governance commitments. Both work fine. Both run the same eggs. Migration between them is straightforward.

This guide installs Pterodactyl (the original, larger ecosystem). If you want Pelican instead, swap the install URL — every other step is identical.

2. Prepare the VPS

Pterodactyl runs on a LEMP stack — Linux, Nginx, MariaDB, PHP. Wings runs game servers in Docker containers. Both go on the same VPS for small setups.

apt update && apt upgrade -y

# Add the PHP 8.3 PPA (Ubuntu) — Debian users can skip this
add-apt-repository -y ppa:ondrej/php
apt update

apt install -y nginx mariadb-server tar unzip git redis-server \
  php8.3 php8.3-{cli,common,fpm,mysql,gd,mbstring,xml,curl,zip,bcmath,tokenizer}

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

# Firewall
ufw allow 22/tcp
ufw allow 80/tcp
ufw allow 443/tcp
ufw allow 8080/tcp   # Wings SFTP daemon (game-server file access)
ufw allow 2022/tcp   # Wings SFTP port
ufw --force enable

3. Install the Panel

Pterodactyl Panel goes in /var/www/pterodactyl (their convention — stick with it for support compatibility):

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

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

Create the database:

mysql -u root -p
# At the MySQL prompt:
CREATE USER 'pterodactyl'@'127.0.0.1' IDENTIFIED BY 'a-strong-password-here';
CREATE DATABASE panel;
GRANT ALL PRIVILEGES ON panel.* TO 'pterodactyl'@'127.0.0.1' WITH GRANT OPTION;
EXIT;

Run the installer wizard:

php artisan key:generate --force
php artisan p:environment:setup
php artisan p:environment:database
php artisan p:environment:mail
php artisan migrate --seed --force
php artisan p:user:make    # Create your admin user

Set permissions:

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

Set up the queue worker and scheduler:

# Cron — runs Laravel scheduler every minute
(crontab -l 2>/dev/null; echo "* * * * * php /var/www/pterodactyl/artisan schedule:run >> /dev/null 2>&1") | crontab -

# Queue worker as systemd service
cat > /etc/systemd/system/pteroq.service <<'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

systemctl enable --now pteroq.service

4. HTTPS with Let's Encrypt

Configure Nginx as the reverse proxy in front of PHP-FPM:

rm /etc/nginx/sites-enabled/default

cat > /etc/nginx/sites-available/pterodactyl <<'EOF'
server {
    listen 80;
    server_name panel.example.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;

    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 \n post_max_size=100M";
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}
EOF

ln -s /etc/nginx/sites-available/pterodactyl /etc/nginx/sites-enabled/
nginx -t && systemctl reload nginx

# Get the cert
apt install -y certbot python3-certbot-nginx
certbot --nginx -d panel.example.com

Visit https://panel.example.com — you should see the Pterodactyl login. Sign in with the admin user you created earlier.

5. Install Wings

Wings is the Docker daemon that actually runs game servers. Install it (it ships as a single Go binary):

# Docker first
curl -sSL https://get.docker.com/ | sh
systemctl enable --now docker

# Wings binary
mkdir -p /etc/pterodactyl
curl -L -o /usr/local/bin/wings https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_amd64
chmod u+x /usr/local/bin/wings

Now go into the Pterodactyl Panel UI: Admin → Nodes → Create New. Fill in:

• Name: local
• FQDN: panel.example.com (same as panel — they share the VPS)
• Memory: total RAM minus 2 GB for the OS
• Disk: total disk minus 10 GB
• Communicate over SSL: yes

Create. Then Configuration tab → click Generate token. Copy the entire config.yml shown — paste into /etc/pterodactyl/config.yml on the VPS:

nano /etc/pterodactyl/config.yml  # paste the contents

# Test
wings --debug

# If it connects, run it as a service
cat > /etc/systemd/system/wings.service <<'EOF'
[Unit]
Description=Pterodactyl Wings Daemon
After=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=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target
EOF

systemctl enable --now wings

Back in the panel, your node should now show as online with a green dot.

6. Deploy your first game server

In the Panel: Admin → Servers → Create New Server. The form is dense; the key fields:

• Owner: yourself
• Nest + Egg: select Minecraft → Paper
• Allocation: pick an IP:port (panel auto-allocates if you set up the node's allocations correctly)
• Memory limit: 4096 MB for Paper
• Disk space: 10000 MB
• Server version: latest

Submit. The panel queues a job; Wings pulls the right Docker image, downloads paper.jar, starts the server. First boot takes ~60 seconds.

Connect to panel.example.com:25565 from your Minecraft client and you're in. For Minecraft-specific tuning (Aikar's flags, view distance, plugins), see our Minecraft server tutorial — the JVM flags and plugin advice apply identically through Pterodactyl.

7. Users, subusers, and permissions

Pterodactyl has three roles:

• Admin — can do anything in the panel
• User — has servers, can control them fully
• Subuser — has been granted scoped access to someone else's server

Create users under Admin → Users. To let a friend control a server without giving them root over it, go to the server's Subusers tab, add their email, and pick which permissions they get: start/stop, console access, file manager, schedule editing, etc. They sign in with their own credentials.

8. Backups and scheduled tasks

Pterodactyl has built-in backup support — local or S3-compatible remote.

Local backups: each server gets a backup quota (default 5 GB). Click Backups → Create Backup, name it, optionally lock it. Files compress to tar.gz in /var/lib/pterodactyl/backups/ on the VPS.

S3 backups: in Wings config.yml, configure the backups section with your S3 credentials. Restart Wings. Now every backup also uploads to S3.

Scheduled tasks let you automate restarts, command-runs, and backup creation. Common cron-like schedules:

Schedule	What it does
Daily 3 AM	backup action — full server backup
Daily 4 AM	power restart — fresh JVM, clears entity buildup
Hourly	send command: save-all — Minecraft world flushes to disk
Weekly Sunday	send command: gamerule keepInventory true — example one-off rule

9. Reference: eggs, limits, scaling

Egg ecosystem

Eggs are pre-configured Docker startup specs for a specific game/version. Pterodactyl ships with eggs for ~30 games out of the box; the community at github.com/parkervcp/eggs hosts ~200 more. Importing an egg is a JSON file upload in Admin → Nests.

Custom eggs are how you support new or modded games. Most are 30-line JSON files — copy an existing one and tweak.

Resource limits

Each server has a memory cap, swap cap, CPU cap (percentage of node, where 100% = 1 core), and disk cap. Enforced by Docker cgroups — a runaway server can't starve its neighbours. Set caps generously enough that the server can use what it needs during peak; too-tight caps cause stuttering.

Per-plan recommendations

OliveVPS plan	Game servers fit	Realistic mix
Starter ($7.99, 4 GB)	1–2 small	1× vanilla Minecraft (20 players)
Pro ($15.99, 16 GB)	4–6	2× Minecraft, 1× Valheim, 1× CS2
Premium ($35.99, 32 GB)	10–15	3× modded MC, 2× ARK, 3× small games

Multi-node setup

Outgrowing one box? Add additional nodes — each is just another VPS running Wings. The Panel manages all of them centrally; users see one dashboard regardless of which node their server lives on.

FAQ

Related posts

Tutorial

Set Up a Minecraft Server on Ubuntu

Minecraft-specific tuning (Aikar's flags, plugins) — works identically inside Pterodactyl eggs.

Pillar

VPS Game Server Setup Guide

How to pick the right VPS for game hosting — sizing, regions, networking.

Use Case

Best VPS for Game Servers

Per-game CPU/RAM requirements and why location matters more than core count.