Pterodactyl Panel Install & Setup Guide on Ubuntu 22.04/24.04

This is the full production-grade Pterodactyl install — not the copy-paste one that breaks on Ubuntu 24.04. We cover PHP 8.3, Redis, Docker, the Wings daemon, the queue worker, the cron, SSL, firewall, and a game egg walkthrough so you finish with a working server, not just a login page. If you were expecting PHP 8.1 commands like other guides have, those are outdated — Pterodactyl 1.11+ requires PHP 8.2 or 8.3.

01 // What Pterodactyl actually is (and isn't)

Pterodactyl is a free, open-source, Docker-based control panel for game servers. It was created by Dane Everitt in 2015 and has been maintained by the Pterodactyl community ever since. The panel itself is a Laravel web application; the real magic is Wings, the daemon that launches every game server inside an isolated Docker container. That isolation is why one misbehaving Minecraft modpack can't crash the whole node and why one tenant can't read another tenant's files.

What makes Pterodactyl genuinely special:

• Docker isolation per server — every game server gets its own container with defined CPU, RAM and disk limits. This is the feature AMP and WindowsGSM don't have.
• Multi-node support — one panel can manage dozens of physical servers (called "nodes"). Perfect for hosting businesses.
• Egg system — community JSON configs let you add new game support in 30 seconds. There are 200+ eggs on GitHub covering everything from Rust to obscure voice servers.
• Granular subusers — give a friend console access without giving them the file manager. Give a dev full file access without billing rights.
• Real API — proper REST API with application and client keys. Tons of Discord bots, billing integrations (Blueprint, Pterodactyl Market) and auto-deployers build on it.
• It is free forever — MIT license. No "per-instance" fees like AMP. Self-host, rebrand, resell (AMP has commercial restrictions; Pterodactyl does not).

What Pterodactyl isn't:

• Not beginner-friendly for install — this guide is 45 minutes long for a reason. If that scares you, use WindowsGSM (free, Windows) or Nitrado (fully managed).
• Not Windows-native — Wings only runs on Linux. The panel itself can technically run on Windows under WSL but nobody does that in production.
• Not actively developed by its original author — Dane Everitt stepped back in 2023. The v1.x branch gets security patches but feature development slowed. This is why Pelican (a friendly fork) was created. We'll compare the two below.

02 // System requirements (the real ones)

The official docs list minimums that will technically let you log in but will be painful in practice. Here's what actually works:

03 // Prepare the server

Everything below assumes Ubuntu 22.04 or 24.04 LTS with root access. If you're using a non-root user, prefix every command with sudo or run sudo -i once and follow along as root.

Set a hostname (optional but nice):

hostnamectl set-hostname panel.yourdomain.com

Update the system and install the base tooling:

apt update && apt upgrade -y
apt install -y curl wget git unzip tar ca-certificates gnupg lsb-release software-properties-common apt-transport-https

04 // Install PHP 8.3 and extensions

Ubuntu 22.04 ships PHP 8.1 by default; 24.04 ships 8.3. Either way we add the ondrej/php PPA for the current version plus all the extensions Pterodactyl needs:

add-apt-repository ppa:ondrej/php -y
apt update
apt install -y php8.3 php8.3-{cli,fpm,gd,mysql,mbstring,bcmath,xml,curl,zip,intl,sqlite3,redis,tokenizer}

Sanity check — Pterodactyl will refuse to install without these:

php -v
# should say PHP 8.3.x
php -m | grep -Ei 'bcmath|curl|gd|mbstring|mysql|openssl|pdo|tokenizer|xml|zip|redis'
# should list all of them

05 // Install MariaDB

MariaDB 10.11 LTS is the stable pick in 2026 (official repo):

curl -LsS https://r.mariadb.com/downloads/mariadb_repo_setup | bash -s -- --mariadb-server-version="mariadb-10.11"
apt update
apt install -y mariadb-server
systemctl enable --now mariadb

Harden it:

mariadb-secure-installation

Answer roughly: press enter (no password yet) → switch to unix_socket auth No → set root password Yes → strong password → remove anonymous users Yes → disallow remote root Yes → remove test DB Yes → reload privileges Yes.

Now create the Pterodactyl database and user. Log into MariaDB:

mariadb -u root -p

Then inside the prompt:

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

Write that password down. You'll need it in step 08.

06 // Install Redis

Redis backs the panel's queue and cache. Skipping this is the #1 reason people see "500 Internal Server Error" after install.

apt install -y redis-server
systemctl enable --now redis-server
redis-cli ping
# expect: PONG

07 // Install Nginx and Composer

apt install -y nginx
systemctl enable --now nginx

# Composer 2 — required for panel install
curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
composer --version
# expect: Composer version 2.x.x

08 // Download and install Pterodactyl Panel

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
rm panel.tar.gz
chmod -R 755 storage/* bootstrap/cache/

Install PHP dependencies with Composer:

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

Run the environment setup wizard. This generates the APP_KEY and sets the panel URL, cache driver, session driver and queue driver:

php artisan key:generate --force
php artisan p:environment:setup

When asked, use these answers:

• Application URL: https://panel.yourdomain.com (or http://your-ip if no domain yet)
• Timezone: your timezone, e.g. Europe/Amsterdam
• Cache driver: redis
• Session driver: redis
• Queue driver: redis
• Redis host/port/password: press enter to accept defaults (127.0.0.1, 6379, none)
• Enable UI-based settings editor: yes

Now wire the database credentials you created in step 05:

php artisan p:environment:database

Answers: host 127.0.0.1, port 3306, database panel, username pterodactyl, password the one you set in step 05.

Run migrations and seed the database (game egg presets, default nest, etc.):

php artisan migrate --seed --force

This step takes 30–60 seconds and prints dozens of lines. If it finishes without a red error, you're good.

09 // Create the admin user

php artisan p:user:make

Choose:

• Super administrator: yes
• Email: your email (Pterodactyl sends password resets here)
• Username: admin (or whatever you like)
• First / Last name: anything
• Password: a strong one — this is your panel login

10 // Set ownership and cron

Nginx runs as www-data. Give it ownership of the panel files:

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

Pterodactyl needs a cron job to process scheduled tasks. Open crontab:

crontab -e

Add this line at the bottom, save and exit:

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

11 // Queue worker systemd service

Without this, emails don't send, password resets don't work, and some server actions silently fail. Create the service file:

nano /etc/systemd/system/pteroq.service

Paste:

[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

Enable it:

systemctl daemon-reload
systemctl enable --now pteroq.service
systemctl status pteroq.service
# expect: active (running)

12 // Configure Nginx for the panel

Remove the default site and create one for Pterodactyl:

rm /etc/nginx/sites-enabled/default
nano /etc/nginx/sites-available/pterodactyl.conf

Paste this configuration (replace panel.yourdomain.com):

server_tokens off;

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_ciphers "HIGH:!aNULL:!MD5";
    ssl_prefer_server_ciphers on;

    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header Strict-Transport-Security "max-age=15768000; preload" always;

    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;
        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;
    }

    location ~ /\.ht {
        deny all;
    }
}

Enable the site:

ln -s /etc/nginx/sites-available/pterodactyl.conf /etc/nginx/sites-enabled/pterodactyl.conf

13 // Get a free SSL certificate

Before we test Nginx, get a Let's Encrypt cert (Nginx above references the cert paths, so this must come first):

apt install -y certbot python3-certbot-nginx

# Temporarily comment out the SSL lines in the nginx config, then:
systemctl reload nginx
certbot certonly --nginx -d panel.yourdomain.com --non-interactive --agree-tos -m you@example.com

Once the cert exists, uncomment those SSL lines and reload:

nginx -t
systemctl reload nginx

Auto-renew is installed by the certbot package as a systemd timer — verify it:

systemctl list-timers | grep certbot

Open the panel URL in your browser. You should see the Pterodactyl login screen. Log in with the admin account you created in step 09.

14 // Install Docker (required by Wings)

Wings launches every game server inside a Docker container. No Docker, no game servers. The official Docker repo gives you the current version:

curl -sSL https://get.docker.com/ | CHANNEL=stable bash
systemctl enable --now docker
docker --version
# expect: Docker version 27.x or similar

On some kernels (notably OVH's custom kernel) you need to enable swap accounting so Wings can enforce RAM limits. Edit GRUB:

nano /etc/default/grub

Find GRUB_CMDLINE_LINUX_DEFAULT and append swapaccount=1. Save, then:

update-grub
reboot

If docker info doesn't complain about swap limit after a reboot, you're fine. If it does, do the GRUB edit above.

15 // Install the Wings daemon

Wings is a single Go binary. Install it:

mkdir -p /etc/pterodactyl
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")"
chmod u+x /usr/local/bin/wings

Now the critical part: do not hand-write /etc/pterodactyl/config.yml. The panel generates it for you.

1. In the panel, go to Admin → Nodes → Create New.
2. Fill in: Name, Description, FQDN (e.g. panel.yourdomain.com if Wings is on the same server, otherwise the Wings server's hostname), Communicate Over SSL, RAM and Disk limits (the max you'll let games use).
3. Set the Daemon Port to 8080 and Daemon SFTP Port to 2022 (defaults).
4. Click Create. Then go to the Configuration tab of the new node and copy the auto-generated YAML.
5. Paste it into /etc/pterodactyl/config.yml on the Wings server.

Create the Wings systemd service:

nano /etc/systemd/system/wings.service

Paste:

[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=180
StartLimitBurst=30
RestartSec=5s

[Install]
WantedBy=multi-user.target

systemctl daemon-reload
systemctl enable --now wings
systemctl status wings
# expect: active (running)

Back in the panel, the node should now show a green heartbeat. If it's red, jump to section 20 — red Wings nodes are the most common install issue and we cover the fixes there.

16 // Firewall (UFW)

Open exactly the ports you need, nothing more. Replace game ports with whatever your servers will use:

ufw allow 22/tcp        # SSH
ufw allow 80/tcp        # HTTP (redirects to HTTPS)
ufw allow 443/tcp       # HTTPS (panel)
ufw allow 8080/tcp      # Wings daemon
ufw allow 2022/tcp      # Wings SFTP
ufw allow 25565/tcp     # Minecraft (example)
ufw allow 28015/udp     # Rust (example)
ufw --force enable
ufw status numbered

17 // Add your first game server (the part most guides skip)

You've installed Pterodactyl. You've installed Wings. The node is green. But you still don't have a game server. Here's the walkthrough nobody writes:

Step 1 — Add an allocation to your node

Every game server needs a (IP, port) pair Wings can bind to. Go to Admin → Nodes → [your node] → Allocations.

• IP: your server's public IP
• Ports: the game port(s). For one Minecraft server: 25565. For Rust: 28015,28016 (query port is +1).

Click Submit. You now have unassigned allocations waiting.

Step 2 — Pick an egg

Pterodactyl ships with built-in eggs for Paper Minecraft, Vanilla Minecraft, Forge, Spigot, Rust, CS2, TF2, Terraria, Factorio, Valheim and ~20 others. For games that aren't preloaded (Palworld, Project Zomboid, Satisfactory, etc.), grab a community egg from github.com/pelican-eggs (despite the name, these are Pterodactyl-compatible JSON files).

To import a community egg: Admin → Nests → Import Egg, upload the JSON, pick the target nest.

Step 3 — Create the server

Go to Admin → Servers → Create New. Fill in:

• Name: anything. Shown to the client-side owner.
• Server Owner: pick a user. You can make a non-admin user if you're running a small community and handing control to someone else.
• Node: the one you created.
• Allocation: pick the (IP, port) you created in step 1.
• Memory, CPU, Disk limits: what Wings enforces via Docker cgroups. Minecraft Paper on 10 players — 4096 MB is plenty. Rust community server — 12288 MB minimum. Leave CPU at 0 to allow full access across all cores, or cap it (100 = one core).
• Nest → Egg: e.g. Minecraft → Paper.
• Docker Image: auto-picked based on the egg. Leave it alone unless you know you need a specific Java version.
• Startup Variables: version, JAR name, max players, etc. For Paper just pick the Minecraft version; defaults are sane.

Click Create. Wings pulls the Docker image, downloads the JAR, and the server appears in the client-facing dashboard within ~30 seconds.

Step 4 — Start it

Log out of /admin and go to the normal panel URL. You'll see the server card. Click it, click Start, and watch the console. First start downloads the JAR/build; after that it's seconds.

18 // Backups — you will need them

Pterodactyl has backups built in. Two backend options:

• Wings-stored (default) — zipped tarballs saved to /var/lib/pterodactyl/backups on the node. Fast. No extra setup. Vulnerable if the node itself dies.
• S3-compatible — push backups to Backblaze B2, AWS S3, Wasabi, Cloudflare R2 or any S3 API. Survives the node exploding. Slightly slower. Under ~€0.005/GB/month on B2.

To enable S3: in the panel, Admin → Settings → Backups, switch driver to S3, fill in endpoint / bucket / access key / secret. Then in Settings → Backups on each server, you can set automatic schedules (via the built-in Scheduler).

Set at least a weekly automatic backup on every production server. It takes 30 seconds and will save your hide.

19 // Honest pros and cons

20 // Pterodactyl vs Pelican vs AMP vs LinuxGSM

This is the comparison everyone is Googling. Here is the honest 2026 version:

21 // Troubleshooting — real problems, real fixes

Every error below I've hit personally or found at the top of the Pterodactyl Discourse. Ordered by how often they bite people.

22 // Security hardening

A few things to do after the install is working:

• Enable 2FA on your admin account. Panel → Account → Two Factor Authentication. Do this first.
• Disable admin registration — under Settings, only allow invite-based user creation for public panels.
• Set up fail2ban for SSH: apt install fail2ban. The default config bans brute-force attempts.
• Keep PHP, the panel and Wings updated. cd /var/www/pterodactyl && php artisan p:upgrade for the panel; re-download the Wings binary when a new release drops.
• Take off-site backups (S3 target, described in section 18). If a single VPS dies you don't want to lose everything.
• Restrict the MariaDB bind address to 127.0.0.1 in /etc/mysql/mariadb.conf.d/50-server.cnf — by default it's fine, but worth verifying.

23 // Keeping Pterodactyl updated

Run the upgrade command monthly or when a new release drops on GitHub:

cd /var/www/pterodactyl
php artisan p:upgrade

This downloads the latest tarball, extracts it over the existing install, runs migrations and clears caches. No manual steps needed.

For Wings, replace the binary and restart the service:

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")"
chmod u+x /usr/local/bin/wings
systemctl restart wings

24 // Next steps

• Add your first real game — Rust, Minecraft Paper, CS2, Valheim, ARK
• Compare alternatives — AMP, LinuxGSM, WindowsGSM
• Running Rust? See our Rust wipe guide with interactive force-wipe calendar
• Need managed hosting instead? Nitrado sets you up in 2 minutes — no Linux required