Pterodactyl: Self-Hosted Game Server Management Done Right

If you have ever managed game servers by hand — SSHing in to restart a crashed Minecraft instance at 2 AM, manually editing config files over SFTP, or trying to remember which screen session is running your Valheim world — you know the pain. It works for one server. It falls apart at two. By three, you are begging for a panel.

Photo by ThisisEngineering on Unsplash

Pterodactyl Panel is the open-source answer to commercial game server management platforms. It gives you a polished web interface for creating, managing, and monitoring game servers, all running in isolated Docker containers on one or more machines. Your players get a self-service portal for restarting their servers and managing files. You get centralized control without the recurring licensing fees of commercial panels.

The project has been around since 2015, is actively maintained, and runs thousands of game server hosting businesses worldwide. It is not the simplest option to set up — the split architecture between the Panel and Wings daemon takes some effort — but the payoff is a professional-grade management layer that scales from a handful of personal servers to hundreds of client instances.

Pterodactyl vs AMP vs Crafty Controller vs PufferPanel

Choosing a game server panel depends on what you need: simple personal use, a commercial hosting operation, or something in between.

When to choose Pterodactyl

You want a professional, scalable game server panel and you are comfortable with a more involved setup. Pterodactyl is the right choice when:

• You are running a game hosting business or community with multiple users
• You need Docker isolation between servers (security and stability)
• You want multi-node support to spread servers across machines
• You need granular user permissions — letting players manage their own servers without giving them root
• You want a mature ecosystem with hundreds of community-contributed eggs for different games
• You care about having a complete REST API for automation

When to choose AMP

You want a polished, commercial product and are willing to pay for it. AMP (Application Management Panel) is worth the license fee when:

• You run a hosting business and want dedicated commercial support
• You need Windows server support (Pterodactyl is Linux-only)
• You prefer a batteries-included product over assembling open-source components
• You want the easiest multi-game panel experience with minimal setup
• Budget for licensing is not a concern ($10 for personal use, $40-150 for commercial)

When to choose Crafty Controller

You only need Minecraft servers and want something running in five minutes. Crafty is the path of least resistance when:

• You exclusively host Minecraft (Java and Bedrock)
• You want the simplest possible setup — pip install and go
• You do not need Docker isolation or multi-node
• You are running a small personal or friend-group setup
• You want a quick solution without architecting infrastructure

When to choose PufferPanel

You want something simpler than Pterodactyl but still multi-game and open source. PufferPanel makes sense when:

• You want a lightweight panel for a small number of servers
• You prefer a Go binary over a PHP application stack
• You need basic multi-node without Pterodactyl's complexity
• You want to get running quickly with minimal dependencies
• You do not need the depth of Pterodactyl's permission system or egg ecosystem

How Pterodactyl Works

Pterodactyl has a split architecture that is important to understand before you install it:

Panel — The web application. Built with Laravel (PHP) and a MySQL/MariaDB database. This is where users log in, create servers, manage files, and view console output. The Panel does not run any game servers itself. It is purely the management and API layer.

Wings — The server daemon. Written in Go, Wings runs on each machine that actually hosts game servers. It receives instructions from the Panel, creates Docker containers, manages server processes, handles file operations, and streams console output back to the Panel via WebSocket.

This split means you can have one Panel controlling Wings daemons across multiple physical or virtual machines. It also means the setup is more involved than a single-binary solution — you need to install and configure both components, and they need to communicate over HTTPS.

Installation via Docker Compose

The Panel itself runs well in Docker. Wings, however, needs to run directly on the host because it manages Docker containers — running Docker-in-Docker for game servers adds unnecessary complexity and performance overhead. The recommended setup is Panel in Docker, Wings installed natively.

Panel Setup

Create a directory for the panel and the following docker-compose.yml:

# docker-compose.yml — Pterodactyl Panel
services:
  panel:
    image: ghcr.io/pterodactyl/panel:latest
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - panel_var:/app/var/
      - panel_nginx:/etc/nginx/http.d/
      - panel_certs:/etc/letsencrypt/
      - panel_logs:/app/storage/logs
    environment:
      # App settings
      APP_URL: "https://panel.example.com"
      APP_TIMEZONE: "America/Los_Angeles"
      APP_SERVICE_AUTHOR: "[email protected]"
      APP_ENV: "production"
      # Database
      DB_HOST: "database"
      DB_PORT: "3306"
      DB_DATABASE: "panel"
      DB_USERNAME: "pterodactyl"
      DB_PASSWORD: "CHANGE_ME_DB_PASSWORD"
      # Redis / Cache
      CACHE_DRIVER: "redis"
      SESSION_DRIVER: "redis"
      QUEUE_DRIVER: "redis"
      REDIS_HOST: "cache"
      # Mail (adjust for your SMTP provider)
      MAIL_DRIVER: "smtp"
      MAIL_HOST: "smtp.example.com"
      MAIL_PORT: "587"
      MAIL_USERNAME: "[email protected]"
      MAIL_PASSWORD: "CHANGE_ME_MAIL_PASSWORD"
      MAIL_FROM: "[email protected]"
      MAIL_FROM_NAME: "Pterodactyl Panel"
      MAIL_ENCRYPTION: "tls"
    depends_on:
      database:
        condition: service_healthy
      cache:
        condition: service_started

  database:
    image: mariadb:10.11
    restart: unless-stopped
    volumes:
      - panel_db:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: "CHANGE_ME_ROOT_PASSWORD"
      MYSQL_DATABASE: "panel"
      MYSQL_USER: "pterodactyl"
      MYSQL_PASSWORD: "CHANGE_ME_DB_PASSWORD"
    healthcheck:
      test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
      interval: 10s
      timeout: 5s
      retries: 5

  cache:
    image: redis:7-alpine
    restart: unless-stopped
    volumes:
      - panel_cache:/data

volumes:
  panel_var:
  panel_nginx:
  panel_certs:
  panel_logs:
  panel_db:
  panel_cache:

Start the stack and create your first admin user:

# Start the panel
docker compose up -d

# Wait for the database to initialize, then create admin user
docker compose exec panel php artisan p:user:make

# Follow the prompts — set as administrator

The p:user:make command will ask for an email, username, and password. Make sure to set the user as an administrator.

Wings Installation

Wings runs directly on the host machine (not in Docker). Install it on each node that will run game servers:

# Install Docker if not already present
curl -fsSL https://get.docker.com | bash

# Create the Wings directory structure
sudo mkdir -p /etc/pterodactyl
sudo mkdir -p /var/lib/pterodactyl/{volumes,backups}

# Download the Wings binary
sudo curl -Lo /usr/local/bin/wings \
  "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_amd64"
sudo chmod +x /usr/local/bin/wings

Before starting Wings, you need to configure it from the Panel:

1. Log into your Panel as administrator
2. Go to Admin → Nodes → Create New
3. Fill in the node details (name, FQDN, memory, disk, etc.)
4. After creating the node, go to the Configuration tab
5. Copy the generated config.yml and save it to /etc/pterodactyl/config.yml on the Wings machine

Then create a systemd service for Wings:

# /etc/systemd/system/wings.service
[Unit]
Description=Pterodactyl Wings Daemon
After=docker.service
Requires=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

sudo systemctl enable --now wings

Once Wings is running and connected to the Panel, you will see the node status turn green in the admin area.

Core Features

Web Panel

The Panel provides a clean, responsive interface for both administrators and regular users. Administrators get access to node management, server creation, user management, and system settings. Regular users see only their assigned servers, with the ability to:

• Start, stop, and restart their server
• View real-time console output and send commands
• Manage files through a browser-based file manager
• View resource usage (CPU, RAM, disk)
• Create and restore backups
• Manage scheduled tasks

The interface is genuinely well-designed. It does not feel like an open-source afterthought — it is a polished product that you can hand to non-technical users without embarrassment.

Docker Isolation

Every game server runs in its own Docker container. This is not optional, and that is a good thing. Isolation means:

• A crashed or compromised server cannot affect other servers on the same node
• Resource limits (CPU, RAM, disk, network) are enforced at the container level
• Each server gets its own filesystem, so mods and plugins cannot conflict
• You can run different game versions or even different games on the same machine without dependency conflicts

Pterodactyl uses purpose-built Docker images called "yolks" — minimal base images optimized for game servers (Java, Node.js, Source engine, etc.).

Server Eggs

Eggs are Pterodactyl's templating system for game servers. An egg defines everything needed to install and run a specific game:

• The Docker image to use
• Installation scripts (downloading server files, accepting EULAs)
• Startup command and configurable variables
• Configuration file parsing rules
• Stop command (for graceful shutdown)

The community maintains eggs for over 100 games and applications:

• Minecraft: Vanilla, Paper, Purpur, Forge, Fabric, Spigot, BungeeCord, Velocity, Bedrock
• Survival/Sandbox: Valheim, Terraria, Rust, ARK: Survival Evolved, 7 Days to Die, Satisfactory
• FPS: Counter-Strike 2, Team Fortress 2, Garry's Mod, Left 4 Dead 2
• Other: Factorio, Don't Starve Together, Palworld, Project Zomboid, Stardew Valley

You can browse and import community eggs from the Pterodactyl Eggs repository on GitHub.

Built-in SFTP

Each server gets its own SFTP endpoint for file management. Users connect with their Panel credentials, and they can only access files for servers they have permission to manage. This means players can upload mods, edit configs, and download backups without needing SSH access to the host machine.

The SFTP server is built into Wings, so there is no separate FTP daemon to configure or secure.

Task Scheduling

The built-in scheduler lets users create cron-style tasks for their servers. Common uses:

• Restart the server every 6 hours for performance
• Send a warning message to players 5 minutes before a scheduled restart
• Create automated backups on a daily schedule
• Run custom commands at specific times (day/night cycles, events)

Tasks can be chained with delays between them, so you can create sequences like "warn players → wait 5 minutes → save world → restart."

Advanced Configuration

Custom Eggs

When a game you need is not in the community repository, you can create your own egg. An egg is a JSON file that defines:

{
  "name": "My Custom Game",
  "description": "A custom egg for My Game Server",
  "docker_images": {
    "ghcr.io/pterodactyl/yolks:java_21": "Java 21"
  },
  "startup": "java -Xms128M -Xmx{{SERVER_MEMORY}}M -jar server.jar",
  "config": {
    "startup": {
      "done": "Server started on port"
    },
    "stop": "stop"
  },
  "scripts": {
    "installation": {
      "script": "#!/bin/bash\ncurl -Lo server.jar https://example.com/server.jar",
      "container": "ghcr.io/pterodactyl/installers:alpine",
      "entrypoint": "bash"
    }
  },
  "variables": [
    {
      "name": "Server Port",
      "env_variable": "SERVER_PORT",
      "default_value": "25565",
      "user_viewable": true,
      "user_editable": false
    }
  ]
}

The key parts of an egg are the startup detection string (so Wings knows when the server is ready), the stop command (for graceful shutdowns), the installation script, and the configurable variables. Import custom eggs through the admin panel under Nests → Import Egg.

Resource Limits

Pterodactyl gives you granular control over resources per server:

• CPU: Percentage-based limits (100% = one full core, 200% = two cores)
• RAM: Hard memory limit in MB — the container is killed if it exceeds this
• Disk: Storage quota in MB — the server cannot write beyond this limit
• Network: Allocate specific IP:port combinations per server
• IO: Block IO weight for disk performance prioritization
• Swap: Control whether the server can use swap memory
• Backup limit: Maximum number of backups a user can create

These limits are enforced by Docker, so they are real constraints, not suggestions. A runaway Minecraft server with a memory leak will be killed when it hits its limit rather than taking down every other server on the machine.

Multi-Node Setup with Wings

Scaling beyond a single machine is where Pterodactyl's architecture shines. Each node runs its own Wings daemon, and the central Panel orchestrates all of them:

1. Set up a new machine with Docker and Wings installed
2. Add the node in the Panel admin area with the machine's FQDN, available memory, and disk
3. Configure allocations — the IP:port combinations available on that node
4. Deploy the config to /etc/pterodactyl/config.yml on the new node
5. Start Wings and verify connectivity

From there, you can create servers on any node. The Panel handles routing console connections, SFTP traffic, and API requests to the correct Wings instance. Users do not need to know or care which physical machine their server runs on.

For hosting businesses, this means you can add capacity by plugging in new machines and registering them as nodes. For home users, you might run one node on a beefy desktop and another on a dedicated server, distributing your game servers based on resource needs.

Resource Requirements

Panel (Web Application)

The Panel is lightweight. A $5/month VPS can comfortably run it. You do not need to co-locate the Panel with your game server nodes — it can run on a completely separate machine.

Wings (Game Server Node)

Wings itself uses minimal resources (50-100 MB RAM). The real resource consumers are the game servers. Budget your node hardware based on what games you plan to host and how many concurrent servers you expect.

As a rule of thumb, a machine with 32 GB of RAM and an 8-core CPU can comfortably run 8-12 Minecraft servers or 3-4 Rust servers, depending on player counts and mod loads.

Honest Limitations

Pterodactyl is excellent software, but it is not without trade-offs. You should know what you are getting into.

Setup complexity is real. You need a web server, PHP, MariaDB, Redis, and the Panel application configured correctly. Then you need Wings installed separately on each node with its own configuration. Compared to Crafty (download and run) or PufferPanel (single Go binary), the initial setup is a project in itself. Budget an afternoon for your first installation, not an hour.

PHP dependency. The Panel runs on Laravel, which means you are managing a PHP application stack. If you are not familiar with PHP deployments, Composer, or Artisan commands, the learning curve is steeper. The Docker installation mitigates this significantly, but debugging issues still requires some familiarity with the ecosystem.

Panel and Wings must communicate over HTTPS. Both components need valid SSL certificates. If you are running on a local network without a domain, you will need to set up self-signed certificates or use a tunnel solution like Cloudflare Tunnel. This is an extra step that simpler panels do not require.

No built-in game server updating. Pterodactyl installs game servers via egg scripts, but updating a game server (new Minecraft version, new Rust wipe) is usually a manual process or requires reinstalling the server. Some eggs handle updates better than others, but there is no universal "update" button.

The Pelican fork. The original Pterodactyl maintainer stepped back from active development in 2024, and a community fork called Pelican has emerged as the successor. As of early 2026, both projects are active, but if you are starting fresh, it is worth evaluating Pelican alongside Pterodactyl. Pelican aims for the same architecture with modernized internals and a renewed development pace. The egg format is compatible between the two.

Database backups are your responsibility. While Pterodactyl can back up individual game server files, the Panel's own database (your user accounts, server configurations, node settings) is not automatically backed up. Set up MariaDB backups separately — losing that database means reconfiguring everything from scratch.

Practical Tips for Operators

Start with the Docker-based Panel install. The manual installation instructions involve setting up Nginx, PHP-FPM, Composer, and Artisan migrations by hand. The Docker Compose approach gets you running faster and is easier to maintain long-term.

Use a separate machine (or VPS) for the Panel. The Panel is lightweight and does not need to be on the same machine as your game servers. Putting it on a $5 VPS gives you reliable access to management even if a game server node goes down. It also keeps the Panel's web traffic separate from game server network traffic.

Pre-allocate ports thoughtfully. Pterodactyl requires you to create port allocations before creating servers. Plan your allocation ranges in advance. A common pattern is to reserve a range like 25565-25600 for Minecraft, 2456-2470 for Valheim, and so on. This makes it easier to manage firewall rules and understand what is running where.

Set up Wings as a systemd service from day one. The systemd unit ensures Wings starts on boot and restarts automatically if it crashes. Game servers are supposed to be always-on — do not rely on a screen session or manual start.

Use the API for automation. Pterodactyl's REST API is comprehensive and well-documented. If you are running a hosting business, use it to automate server provisioning, billing integration, and monitoring. WHMCS and Blesta both have Pterodactyl modules for automated game server hosting.

Monitor your nodes independently. Pterodactyl shows basic resource usage, but it is not a monitoring solution. Run something like Netdata or Prometheus on your nodes to get real alerting on disk space, memory pressure, and CPU load. A full disk on a Wings node will silently corrupt game server data.

Test your backups. Pterodactyl's backup system works well, but test restoring from a backup before you need to do it in an emergency. Also back up your MariaDB database regularly — that is the single point of failure for your entire setup.

Keep eggs updated. Community eggs get updated when games release new versions or when bugs are found. Periodically check the eggs repository for updates to the games you host, and import the updated versions.

Resources

• Pterodactyl documentation
• Pterodactyl GitHub
• Wings GitHub
• Community eggs repository
• Pelican fork — community-driven successor project
• Pterodactyl Discord — active community support
• API documentation — comprehensive third-party API reference