> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/pterodactyl/wings/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Start Guide

> Get Wings up and running in minutes with this step-by-step guide

## Prerequisites

Before installing Wings, ensure your system meets the following requirements:

<AccordionGroup>
  <Accordion title="Operating System">
    Wings runs on Linux-based operating systems. Supported distributions include:

    * Ubuntu 20.04+ (recommended)
    * Debian 11+
    * CentOS 8+ / Rocky Linux / AlmaLinux
    * Fedora 35+
  </Accordion>

  <Accordion title="Docker Installation">
    Wings requires Docker to be installed and running:

    * Docker Engine 20.10 or newer
    * Docker must be running and accessible by the Wings process
    * The user running Wings needs permission to interact with Docker
  </Accordion>

  <Accordion title="Panel Setup">
    You need a running Pterodactyl Panel instance:

    * Panel version compatible with Wings
    * A node created in the Panel admin area
    * API credentials from the Panel for this node
  </Accordion>
</AccordionGroup>

<Warning>
  Wings should be installed on a **separate server** from your Pterodactyl Panel for security and performance reasons. Installing both on the same server is not recommended for production use.
</Warning>

## Installation Steps

<Steps>
  <Step title="Install Docker">
    If Docker is not already installed, install it using the official Docker installation script:

    <CodeGroup>
      ```bash Ubuntu/Debian theme={null}
      curl -fsSL https://get.docker.com | sh
      systemctl enable --now docker
      ```

      ```bash CentOS/RHEL/Rocky theme={null}
      curl -fsSL https://get.docker.com | sh
      systemctl enable --now docker
      ```
    </CodeGroup>

    Verify Docker is running:

    ```bash theme={null}
    docker --version
    docker ps
    ```

    <Note>
      The Docker installation script automatically handles repository setup and package installation for most distributions.
    </Note>
  </Step>

  <Step title="Create Required Directories">
    Wings uses specific directories for configuration and data storage. Create them with appropriate permissions:

    ```bash theme={null}
    # Create configuration directory
    mkdir -p /etc/pterodactyl

    # Create data directories
    mkdir -p /var/lib/pterodactyl/volumes
    mkdir -p /var/lib/pterodactyl/backups
    mkdir -p /var/lib/pterodactyl/archives

    # Create log directory
    mkdir -p /var/log/pterodactyl
    ```

    <Tip>
      These are the default directories. You can customize them in the Wings configuration file if needed.
    </Tip>
  </Step>

  <Step title="Download Wings Binary">
    Download the latest Wings binary from the official GitHub releases:

    ```bash theme={null}
    # Download the latest release
    curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_amd64"

    # Make it executable
    chmod +x /usr/local/bin/wings
    ```

    For ARM64 systems, use:

    ```bash theme={null}
    curl -L -o /usr/local/bin/wings "https://github.com/pterodactyl/wings/releases/latest/download/wings_linux_arm64"
    chmod +x /usr/local/bin/wings
    ```

    Verify the installation:

    ```bash theme={null}
    wings version
    ```

    You should see output similar to:

    ```
    wings v1.12.1
    Copyright © 2018 - 2026 Dane Everitt & Contributors
    ```
  </Step>

  <Step title="Configure Wings via Panel">
    Wings provides an automatic configuration command that fetches settings from your Panel:

    <Note>
      Before running this command, create a node in your Pterodactyl Panel admin area and obtain the auto-configuration command from the node's configuration tab.
    </Note>

    The command looks like this:

    ```bash theme={null}
    wings configure --panel-url https://panel.example.com \
      --token YOUR_API_TOKEN \
      --node NODE_ID
    ```

    **Parameters explained:**

    * `--panel-url` (`-p`): Your Panel's URL (must be accessible from Wings)
    * `--token` (`-t`): API token from the Panel
    * `--node` (`-n`): The numeric ID of the node

    This command will:

    1. Connect to your Panel via the API
    2. Fetch the node configuration
    3. Write the configuration to `/etc/pterodactyl/config.yml`

    <CodeGroup>
      ```bash Interactive Mode theme={null}
      # Run without arguments for interactive prompts
      wings configure
      # You'll be prompted for Panel URL, Token, and Node ID
      ```

      ```bash Command Line theme={null}
      # Provide all arguments directly
      wings configure \
        --panel-url https://panel.example.com \
        --token ptlc_abc123xyz789 \
        --node 1
      ```

      ```bash With Custom Config Path theme={null}
      # Specify a custom configuration file location
      wings configure \
        --config-path /custom/path/config.yml \
        --panel-url https://panel.example.com \
        --token ptlc_abc123xyz789 \
        --node 1
      ```
    </CodeGroup>

    <Warning>
      If you need to reconfigure an existing Wings installation, use the `--override` flag to overwrite the existing configuration file.
    </Warning>
  </Step>

  <Step title="Start Wings in Debug Mode (Optional)">
    Before setting up Wings as a service, test that it works correctly:

    ```bash theme={null}
    # Start Wings in debug mode
    wings --debug
    ```

    You should see output similar to:

    ```
                      ____
    __ Pterodactyl _____/___/_______ _______ ______
    \_____\    \/\/    /   /       /  __   /   ___/
    \___\          /   /   /   /  /_/  /___   /
         \___/\___/___/___/___/___    /______/
                             /_______/ v1.12.1

    Copyright © 2018 - 2026 Dane Everitt & Contributors
    ```

    Wings will:

    * Load the configuration from `/etc/pterodactyl/config.yml`
    * Configure the Docker environment
    * Start the HTTP API server (default port 8080)
    * Start the SFTP server (default port 2022)
    * Load and initialize any existing servers

    <Tip>
      Watch the logs to ensure there are no errors. Press `Ctrl+C` to stop Wings when you're ready to continue.
    </Tip>
  </Step>

  <Step title="Create Systemd Service">
    Create a systemd service file to manage Wings:

    Create `/etc/systemd/system/wings.service`:

    ```ini theme={null}
    [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
    ```

    Enable and start the service:

    ```bash theme={null}
    # Reload systemd to recognize the new service
    systemctl daemon-reload

    # Enable Wings to start on boot
    systemctl enable wings

    # Start Wings
    systemctl start wings
    ```

    <Note>
      Wings runs as root by default because it needs to interact with Docker and manage file permissions. The actual game servers run as the `pterodactyl` user inside containers.
    </Note>
  </Step>

  <Step title="Verify Wings is Running">
    Check that Wings is running correctly:

    ```bash theme={null}
    # Check service status
    systemctl status wings
    ```

    You should see:

    ```
    ● wings.service - Pterodactyl Wings Daemon
       Loaded: loaded (/etc/systemd/system/wings.service; enabled)
       Active: active (running) since ...
    ```

    View live logs:

    ```bash theme={null}
    # Follow Wings logs in real-time
    journalctl -u wings -f
    ```

    Check that Wings is listening on the correct ports:

    ```bash theme={null}
    # Check API port (default 8080)
    ss -tlnp | grep 8080

    # Check SFTP port (default 2022)
    ss -tlnp | grep 2022
    ```
  </Step>
</Steps>

## Configure Firewall

Ensure your firewall allows traffic on the required ports:

<CodeGroup>
  ```bash UFW (Ubuntu/Debian) theme={null}
  # Allow Wings API (from Panel)
  ufw allow 8080/tcp

  # Allow SFTP
  ufw allow 2022/tcp

  # Allow game server ports (example range)
  ufw allow 25565:25665/tcp
  ufw allow 25565:25665/udp
  ```

  ```bash FirewallD (CentOS/RHEL) theme={null}
  # Allow Wings API
  firewall-cmd --permanent --add-port=8080/tcp

  # Allow SFTP
  firewall-cmd --permanent --add-port=2022/tcp

  # Allow game server ports
  firewall-cmd --permanent --add-port=25565-25665/tcp
  firewall-cmd --permanent --add-port=25565-25665/udp

  # Reload firewall
  firewall-cmd --reload
  ```

  ```bash iptables theme={null}
  # Allow Wings API
  iptables -A INPUT -p tcp --dport 8080 -j ACCEPT

  # Allow SFTP
  iptables -A INPUT -p tcp --dport 2022 -j ACCEPT

  # Save rules (Ubuntu/Debian)
  netfilter-persistent save
  ```
</CodeGroup>

<Warning>
  The Wings API port (8080) should **only** be accessible from your Pterodactyl Panel server, not from the public internet. Configure your firewall accordingly.
</Warning>

## Create Your First Server

With Wings running, you can now create servers from your Pterodactyl Panel:

<Steps>
  <Step title="Verify Node Connection">
    In the Panel admin area, navigate to **Nodes** and check that your node shows as online with a green indicator.
  </Step>

  <Step title="Create a Server">
    Go to **Servers** → **Create New Server** in the Panel and:

    * Select your Wings node
    * Choose an egg (game/application type)
    * Allocate resources (CPU, memory, disk)
    * Assign network allocations (IP and ports)
  </Step>

  <Step title="Install the Server">
    The Panel will send installation instructions to Wings. Wings will:

    * Create a Docker container for the server
    * Run the installation script defined in the egg
    * Download game files as needed
    * Configure the server environment

    Monitor the installation in real-time via the server console in the Panel.
  </Step>

  <Step title="Start the Server">
    Once installation completes, start the server from the Panel. Wings will:

    * Start the Docker container
    * Execute the startup command
    * Begin streaming console output
    * Report resource usage back to the Panel
  </Step>
</Steps>

## Common Commands

Useful Wings commands for system administration:

<CodeGroup>
  ```bash Service Management theme={null}
  # Start Wings
  systemctl start wings

  # Stop Wings
  systemctl stop wings

  # Restart Wings
  systemctl restart wings

  # View status
  systemctl status wings

  # Enable autostart
  systemctl enable wings

  # Disable autostart
  systemctl disable wings
  ```

  ```bash Log Management theme={null}
  # View recent logs
  journalctl -u wings

  # Follow logs in real-time
  journalctl -u wings -f

  # View logs since last boot
  journalctl -u wings -b

  # View logs from last hour
  journalctl -u wings --since "1 hour ago"
  ```

  ```bash Wings Commands theme={null}
  # Check version
  wings version

  # Run in foreground (debug)
  wings --debug

  # Reconfigure from Panel
  wings configure --override

  # Run diagnostics
  wings diagnostics

  # Use custom config file
  wings --config /custom/path/config.yml
  ```
</CodeGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion title="Wings won't start">
    Common causes:

    * Docker is not running: `systemctl status docker`
    * Configuration file is missing or invalid: Check `/etc/pterodactyl/config.yml`
    * Port already in use: Check with `ss -tlnp | grep 8080`
    * Permission issues: Ensure Wings has access to required directories

    Check logs for specific errors:

    ```bash theme={null}
    journalctl -u wings -n 50
    ```
  </Accordion>

  <Accordion title="Node shows offline in Panel">
    Verify:

    * Wings service is running: `systemctl status wings`
    * API port (8080) is accessible from Panel server
    * Panel URL in config matches your actual Panel URL
    * Authentication token is correct in `/etc/pterodactyl/config.yml`
    * Firewall rules allow Panel → Wings communication
  </Accordion>

  <Accordion title="Servers won't start">
    Check:

    * Docker containers: `docker ps -a`
    * Server logs in Panel console
    * Wings logs: `journalctl -u wings -f`
    * Available system resources (memory, disk)
    * Docker network configuration: `docker network ls`

    Manually inspect container:

    ```bash theme={null}
    docker logs <container-name>
    docker inspect <container-name>
    ```
  </Accordion>

  <Accordion title="SFTP connection fails">
    Verify:

    * SFTP server is running on port 2022: `ss -tlnp | grep 2022`
    * Firewall allows port 2022
    * Using correct credentials (Panel username and password)
    * Server is not suspended
    * SFTP is not disabled in config: Check `read_only` setting

    Test SFTP connection:

    ```bash theme={null}
    sftp -P 2022 username@your-wings-server
    ```
  </Accordion>
</AccordionGroup>

## Next Steps

Now that Wings is running, explore these topics:

<CardGroup cols={2}>
  <Card title="Configuration" icon="gear" href="/configuration/config-file">
    Customize Wings behavior and settings
  </Card>

  <Card title="SSL/TLS Setup" icon="lock" href="/configuration/ssl-tls">
    Enable HTTPS with Let's Encrypt
  </Card>

  <Card title="Performance Tuning" icon="gauge-high" href="/troubleshooting/performance">
    Optimize Wings for your workload
  </Card>

  <Card title="Backup Operations" icon="floppy-disk" href="/operations/backups">
    Configure automated backups
  </Card>
</CardGroup>

## Additional Resources

<Note>
  For more detailed information, consult the following resources:

  * [Official Wings Documentation](https://pterodactyl.io/wings/1.0/installing.html)
  * [Community Guides](https://pterodactyl.io/community/about.html)
  * [GitHub Issues](https://github.com/pterodactyl/panel/issues)
  * [Discord Support](https://discord.gg/pterodactyl)
</Note>