How to Run a FiveM Server Using Docker: Complete Setup Guide

# Server Identity
sv_hostname "My Docker FiveM Server"
sv_projectName "My Server"
sv_projectDesc "A containerized FiveM server"
sets sv_projectName "My Server"

# License and Authentication
sv_licenseKey "your-license-key-here"
sv_maxclients 32

# Network
endpoint_add_tcp "0.0.0.0:30120"
endpoint_add_udp "0.0.0.0:30120"

# Security
sv_scriptHookAllowed 0
set steam_webApiKey ""

# txAdmin
set txAdminPort 40120

# Resources
ensure mapmanager
ensure spawnmanager
ensure sessionmanager
ensure basic-gamemode
ensure hardcap
ensure chat
ensure monitor

Replace your-license-key-here with your actual Cfx.re license key. You can generate one at keymaster.fivem.net.

Starting the Server

Launch the server with a single command:

docker compose up -d

Monitor the startup process:

docker compose logs -f fivem

You should see the FiveM server initializing, loading resources, and eventually displaying the server startup message. txAdmin will be accessible at http://your-server-ip:40120 once the container is running.

To stop the server gracefully:

docker compose down

To restart after configuration changes:

docker compose restart fivem

txAdmin Setup Inside Docker

When you access http://your-server-ip:40120 for the first time, txAdmin walks you through the initial setup wizard:

1. Create your txAdmin admin account (separate from your Cfx.re account)
2. Link your Cfx.re account for license validation
3. Select the server data path — point it to /server-data
4. Choose your server template or point to your existing server.cfg

The txAdmin data directory (/txData) is mounted as a volume, so your admin accounts, player bans, scheduled restarts, and backups persist across container rebuilds.

Adding Resources and Scripts

Install scripts into your server-data/resources/ directory on the host machine. Changes are immediately visible inside the container because of the volume mount — no rebuild required.

# Example: Install a resource from GitHub
cd server-data/resources/
git clone https://github.com/example/my-resource.git

# Then add to server.cfg
echo 'ensure my-resource' >> ../server.cfg

Restart the server to load new resources:

docker compose restart fivem

For a curated collection of FiveM scripts and mods, browse our free mods library or the premium shop for production-ready resources with guaranteed compatibility.

Persistent Storage and Backups

Docker volumes ensure your data survives container restarts, updates, and rebuilds. The two critical directories are:

• ./server-data: Your server configuration, resources, and any file-based data
• ./txData: txAdmin configuration, player database, ban lists, and admin accounts

Automate backups with a simple cron job:

# Add to crontab (crontab -e)
0 4 * * * cd /path/to/fivem-server && tar -czf backups/backup-$(date +\%Y\%m\%d).tar.gz server-data/ txData/ --exclude='server-data/cache'

This creates a daily compressed backup at 4 AM, excluding the cache directory which can be regenerated. Rotate old backups to prevent disk fill:

# Keep last 14 days of backups
find /path/to/fivem-server/backups -name "backup-*.tar.gz" -mtime +14 -delete

Updating the FiveM Server

Updating a Dockerized FiveM server is clean and predictable. Your server data stays untouched — only the server artifacts change:

# Rebuild the image with latest artifacts
docker compose build --no-cache fivem

# Restart with the new image
docker compose up -d fivem

If something breaks after an update, rolling back is instant:

# Tag your current working image before updating
docker tag fivem-server:latest fivem-server:backup

# If the update causes issues, revert
docker tag fivem-server:backup fivem-server:latest
docker compose up -d fivem

This rollback capability alone makes Docker worth the setup effort. On a bare-metal server, reverting a bad update means manually restoring files and hoping you didn't miss anything.

Running Multiple Servers

One of Docker's strongest advantages for FiveM hosting is running multiple isolated server instances on a single host. Each server gets its own container, ports, and data:

services:
  fivem-main:
    build: .
    container_name: fivem-main
    restart: unless-stopped
    ports:
      - "30120:30120/tcp"
      - "30120:30120/udp"
      - "40120:40120/tcp"
    volumes:
      - ./servers/main/server-data:/server-data
      - ./servers/main/txData:/txData
    deploy:
      resources:
        limits:
          memory: 8G

  fivem-test:
    build: .
    container_name: fivem-test
    restart: unless-stopped
    ports:
      - "30121:30120/tcp"
      - "30121:30120/udp"
      - "40121:40120/tcp"
    volumes:
      - ./servers/test/server-data:/server-data
      - ./servers/test/txData:/txData
    deploy:
      resources:
        limits:
          memory: 4G

Start both servers:

docker compose up -d

Each server is completely isolated. You can test scripts on the test server without risking your production environment.

Database Integration

Most FiveM servers need a MySQL or MariaDB database for frameworks like ESX, QBCore, or QBox. Add it to your docker-compose.yml:

services:
  fivem:
    build: .
    container_name: fivem-server
    restart: unless-stopped
    depends_on:
      - db
    ports:
      - "30120:30120/tcp"
      - "30120:30120/udp"
      - "40120:40120/tcp"
    volumes:
      - ./server-data:/server-data
      - ./txData:/txData
    deploy:
      resources:
        limits:
          memory: 8G

  db:
    image: mariadb:11
    container_name: fivem-db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: "change-this-strong-password"
      MYSQL_DATABASE: "fivem"
      MYSQL_USER: "fivem"
      MYSQL_PASSWORD: "change-this-too"
    ports:
      - "3306:3306"
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

In your resource database configuration (e.g., oxmysql or mysql-async), use db as the hostname since Docker Compose creates an internal network where containers can reach each other by service name:

set mysql_connection_string "mysql://fivem:change-this-too@db:3306/fivem?charset=utf8mb4"

Production Hardening

Before exposing your Dockerized FiveM server to players, apply these production best practices:

Firewall Rules

Only expose the ports you actually need:

# Allow FiveM game traffic
sudo ufw allow 30120/tcp
sudo ufw allow 30120/udp

# Allow txAdmin (restrict to your IP if possible)
sudo ufw allow from YOUR_IP to any port 40120

# Block everything else
sudo ufw enable

Health Checks

Add a health check to your docker-compose.yml so Docker can detect and restart a stuck server:

services:
  fivem:
    # ... other config
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:30120/info.json"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

Resource Monitoring

Monitor your container's resource usage:

# Real-time stats
docker stats fivem-server

# Detailed inspection
docker inspect fivem-server --format='{{.State.Status}} - Memory: {{.HostConfig.Memory}}'

Set up alerts when memory or CPU usage exceeds thresholds to catch problems before players notice them.

Troubleshooting Common Issues

Container exits immediately after starting: Check the logs with docker compose logs fivem. Common causes: invalid license key, missing server.cfg, or port conflicts. Verify your license key is correct and no other process is using port 30120.

Cannot connect to the server: Ensure ports 30120/tcp and 30120/udp are open in your firewall and correctly mapped in docker-compose.yml. Test with docker compose port fivem 30120 to verify the mapping.

txAdmin not accessible: Verify port 40120 is exposed and not blocked by a firewall. Check that the TXADMIN_PORT environment variable matches the exposed port.

Resources not loading after adding them: Volume mounts sync automatically, but FiveM needs a restart to detect new resources. Run docker compose restart fivem and ensure the resource is listed in server.cfg with ensure.

Database connection refused: If using Docker Compose networking, use the service name (e.g., db) as the hostname, not localhost or 127.0.0.1. The database container must be running and healthy before FiveM starts — depends_on handles startup order.

For deeper debugging techniques, check our guide on how to debug your FiveM server.

Next Steps

With your FiveM server running in Docker, you have a solid foundation for scaling and maintaining your community. Here are the logical next steps:

• Optimize performance with our FiveM server optimization guide — profiling, script cleanup, and network tuning
• Set up txAdmin with Discord using our txAdmin Discord integration guide for remote server management
• Browse production-ready scripts in our free mods library or premium shop — all tested and maintained
• Scale your community with strategies from our complete server management guide

Docker transforms FiveM server management from manual sysadmin work into reproducible, version-controlled infrastructure. Every configuration change is tracked, every update is reversible, and every backup is predictable. That operational discipline is what separates servers that last from servers that burn out.