Skip to content

Plex Media Server (Core Service)

Plex organizes and streams media from local folders or mounted remote content. DUMB manages its process and persistent data; you choose the Plex account, library paths, sharing policy, and transcoding settings.

At a glance

Use the same curated library folder in your collector and media server. A running server is only the first check.

flowchart TD
    A["Open Plex and finish sign-in"] --> B
    B["Choose the curated library folder"] --> C
    C["Check the mount before scanning"] --> D
    D["Scan a small library"] --> E
    E["Play and seek through one item"]

How to Start

  1. Select Plex during DUMB onboarding. For a fresh server on the release backend, provide its short-lived claim token immediately before startup.
  2. Open the Plex service card. On DUMB Config, use Start if stopped, then select Embedded UI. Sign in to Plex and confirm your intended account owns this server.
  3. In the Plex setup wizard or server library settings, create a library for each media type. Browse to the curated folder used by your workflow, using the path inside DUMB. For an Arr workflow, compare it with the saved Sonarr/Radarr root folder.
  4. Keep automatic trash removal disabled while validating a remote mount. Confirm that mount is available, then scan the new library.
  5. Open one imported item and test playback and seeking. If it does not appear, compare the saved library path with your workflow's folder; if playback fails, check the provider connection and Plex's stream status.
  6. Set up sharing, remote access or hardware transcoding after local playback works. Account authorization, library access and playback are separate checks.

A Plex claim token authorizes a server claim. A Plex API token lets configured integrations call that server; neither token grants a Plex Pass subscription or its features.

Utilize the onboarding process

You can reopen onboarding from Settings → Launch Onboarding. Review account authorization and selected library paths rather than recreating an existing server.

Manually

Technical details: manual Plex startup

For manual configuration, review the plex settings below. A fresh instance needs a valid plex_claim immediately before startup. Start Plex from its DUMB service page. A deliberately published native port also allows http://<host>:32400/web access.

Setup checklist and remaining work

Review account/claim authorization separately from libraries. The checklist can create or reuse explicitly selected libraries when authorized, preserving existing libraries and paths. Sharing, remote access, host GPU mapping and real playback remain deliberate decisions/checks.

Requires the backend setup-arrangement capability. See Setup checklist and automation for retained tasks, coverage and safe retries.

Service Relationships

Classification Role
Core Service Media Server / Playback Host
Depends On
Optional None
Exposes UI Yes (Web UI on port 32400)

Technical details: configuration reference

Configuration in dumb_config.json

{
"plex": {
  "enabled": false,
  "process_name": "Plex Media Server",
  "suppress_logging": false,
  "log_level": "INFO",
  "port": 32400,
  "auto_update": false,
  "auto_update_interval": 24,
  "auto_update_start_time": "04:00",
  "pinned_version": "",
  "config_dir": "/plex",
  "config_file": "/plex/Plex Media Server/Preferences.xml",
  "log_file": "/plex/Plex Media Server/Logs/Plex Media Server.log",
  "plex_claim": "",
  "friendly_name": "DUMB",
  "dbrepair": {
    "enabled": false,
    "run_before_start": false,
    "interval_minutes": 10080,
    "idle_check_minutes": 5,
    "backoff_multiplier": 2.0,
    "max_backoff_minutes": 60,
    "max_wait_minutes": 0,
    "install_dir": "/data/dbrepair",
    "executable": "DBRepair.sh",
    "sqlite_path": "/usr/lib/plexmediaserver/Plex SQLite",
    "databases_path": "/plex/Plex Media Server/Plug-in Support/Databases",
    "required_args": [],
    "script_args": [
      "auto"
    ],
    "log_file": "/log/plex_dbrepair.log",
    "db_path": "/plex/Plex Media Server/Plug-in Support/Databases/com.plexapp.plugins.library.db",
    "work_dir": "",
    "command": [],
    "env": {}
  },
  "command": [],
  "env": {}
}
}

Key configuration fields

  • enabled: Toggle Plex Media Server on or off.
  • plex_claim: Plex claim token for initial server registration.
  • friendly_name: The name that appears in the Plex Web App and on local clients.
  • config_dir: Directory containing Plex server data (including preferences).
  • port: Default access port (32400).
  • pinned_version: Pin Plex to a specific version when using manual builds.
  • dbrepair: Optional DBRepair configuration for scheduled Plex database maintenance.

DUMB does not yet support port assignment for Plex Media Server


Setup & Behavior

Media Library Protection

The Plex service page includes Library Protection. Review the configured mount scope and policy. When enabled, DUMB uses its existing Plex token to check sessions, inhibit scans before rclone/InfiniDysk/Decypharr/Zurg/AltMount/CLI Debrid maintenance, and restore Plex after the dependency stabilizes. The same panel exposes live Plex library preferences, including Empty trash automatically after every scan; keep that option off for remote or virtual libraries.

See Media Library Protection for the override choices, recommended Plex settings, recovery journal, and limitations.

Optional Plex Cloud Status

The Plex service page includes a capability-gated Plex Status panel on current DUMB/dmbdb versions. It can enable a cached metric sourced from Plex's official status page, choose a 60-3600 second polling interval, refresh the sample, and show affected components, incidents, or scheduled maintenance without leaving dmbdb.

This option is disabled by default and lives under dumb.metrics.plex_status; it is not a Plex process setting. DUMB makes the public request without a Plex token or local server data. Treat it as cloud-service context only: the local Plex process can be healthy during a Plex cloud incident, and Plex can report all systems operational while a local DUMB, network, remote-access, or playback problem remains.

See Metrics Collection for configuration and failure behavior.

Requirements

Plex must have access to:

  • Media directories (local or rclone-mounted).
  • Transcoding cache (if transcoding is enabled).
  • Valid claim token for first-time setup (if not already configured).

Migrating an Existing Plex Server into DUMB

If you're migrating an existing Plex Media Server into the DUMB container, the process involves preserving your current Plex data directory and ensuring it is placed correctly within the DUMB ecosystem.


Preserve the existing server

Back up the complete Plex application data and stop the source server before copying it. Keep the original data until the copied server's ownership, library paths and playback have been checked. Moving application data requires access to the Docker host; the procedure below is for that operator.

Geek details: copy an existing server, adjust paths and verify permissions

Step 1: Locate your existing Plex data directory

Plex keeps its state in a folder named Plex Media Server. That folder contains:

  • Preferences.xml
  • Plug-in Support/Databases/ (library DB)
  • Metadata/, Media/, Cache/, Logs/, and more

Common locations:

Environment Typical Plex data path
Linux (native) /var/lib/plexmediaserver/Library/Application Support/Plex Media Server
Linux (snap) ~/snap/plexmediaserver/common/Library/Application Support/Plex Media Server
Docker Your mapped volume (example: /path/to/plex → /config)

What you need to copy

Copy the entire Plex Media Server folder, not just Preferences.xml.


Step 2: Copy the Plex data into DUMB

Whether your current Plex server is running as a Docker container or directly on the host machine, locate its configuration directory. This directory typically contains:

  • Plex Media Server/Preferences.xml
  • Plex Media Server/Plug-in Support/Databases/...
  • Plex Media Server/Logs/...

Stop Plex before copying

Stop the existing Plex server before copying data to avoid a partial or corrupted database copy.

Copy this entire Plex configuration directory to the DUMB host's Plex directory:

# Replace /path/to/existing/plex with the path from your host or old container
rsync -a "/path/to/existing/plex/Plex Media Server" "/path/to/DUMB/data/plex/"

The result should be:

DUMB/data/plex/Plex Media Server/Preferences.xml
DUMB/data/plex/Plex Media Server/Plug-in Support/Databases/...

The internal path must remain /plex/Plex Media Server/Preferences.xml inside the container, unless you follow Step 3 below.


Step 3: Point DUMB to the copied config

This is only required if changing the default location (shown below) for Plex configs inside the container

Update the dumb_config.json to ensure the config_dir is /plex, which is the internal path mounted inside the container.

{
  "plex": {
    "enabled": true,
    "config_dir": "/plex",
    "config_file": "/plex/Plex Media Server/Preferences.xml"
  }
}

Step 4: Verify permissions

Plex must be able to read and write the copied files. If you see permission errors, adjust ownership to match the user defined in your Docker compose.

Match PUID/PGID ownership

The Plex data directory should be owned by the same UID/GID used in the container (PUID/PGID).
Example:

# Replace 1000:1000 with your container PUID:PGID and adjust the path
sudo chown -R 1000:1000 /path/to/DUMB/data/plex
sudo chmod -R u+rwX,g+rwX /path/to/DUMB/data/plex

If your container uses a different PUID/PGID (for example, 568:568 on some NAS setups), use that instead.


Step 5: Add media content

If you have existing media content from your previous Plex setup:

  1. Mount to a custom path (e.g., /mnt/local):

    Custom Path

    Using /mnt/local or any other custom path allows you to preserve legacy media folder structures separately from DUMB's collection system..

    You can also consolidate or symlink these into /mnt/debrid if needed.

    Example Docker Compose snippet:

    volumes:
      - /path/to/old/media/movies:/mnt/local/movies
      - /path/to/old/media/shows:/mnt/local/shows
    
  2. Update Plex library folders in the Plex Web UI to match the new internal container paths (e.g., /mnt/local/movies).


Step 6: Restart and verify

Once configuration and mounts are complete:

  1. Start the DUMB container.
  2. Access Plex via http://<host>:32400/web.
  3. Verify:
    • Your old libraries and settings are intact
    • Media paths resolve correctly
    • Server is claimed and signed in to Plex.tv

Optional: reclaim or reconfigure

If you're reusing an old server and want to reset it:

  • Delete Preferences.xml to force a new setup
  • Provide a new plex_claim token in dumb_config.json

This allows you to re-register the server cleanly if needed.


Summary Table

Migration Source Steps
Plex Docker Container Copy container's volume contents to DUMB/data/plex
Plex on Host Copy /var/lib/plexmediaserver or equivalent to DUMB/data/plex
Plex Media Bind mount original media directories to /mnt/debrid in DUMB

Once complete, your DUMB-based Plex server should fully replicate your prior setup while gaining the integration benefits of the DUMB ecosystem.


Claim authorization during setup

With the arrangement checklist, start Plex first and use its retained account task when a fresh claim is needed. Claim tokens are short-lived; submit one when the server is ready, then retry that account task without reinstalling the arrangement. An already claimed Plex server keeps its account.

The checklist tracks account authorization, library configuration and verified connection checks separately. A successful account claim does not verify playback, sharing or remote access. See Setup Checklist and Automation.


Hardware Transcoding

Hardware-accelerated streaming enables Plex to use the GPU or specialized hardware encoders to offload and speed up transcoding operations, significantly improving performance and lowering CPU usage.

Plex Pass Required

Hardware-accelerated transcoding is a premium feature and requires an active Plex Pass subscription. Learn more

Geek details: prepare Docker GPU access and a writable transcode directory

Docker Setup for Hardware Transcoding

To enable hardware transcoding in a Docker container, pass through the GPU device and provide Plex with a writable transcode directory:

volumes:
  - ./data/plex/transcode:/transcode

devices:
  - /dev/dri:/dev/dri

Create the host directory before starting DUMB and make sure it is writable by the configured PUID:PGID:

mkdir -p ./data/plex/transcode
sudo chown -R 1000:1000 ./data/plex/transcode

Adjust 1000:1000 to match your container PUID and PGID. Without a writable /transcode mount, Plex can log Error creating directory "/transcode": Permission denied and fall back to software transcoding or fail to transcode.

The device mapping grants the container access to the host system's Direct Rendering Infrastructure (DRI), which is required for GPU access (e.g., Intel Quick Sync, NVIDIA NVENC).

Intel Quick Sync Users

Additional permissions may be needed:

group_add:
  - "992"  # Typically 'render' group
  - "993"  # Some systems require both 'render' and 'video'

You can confirm the group IDs for your system by running:

getent group video
getent group render

Make sure the Plex container runs with appropriate PUID and PGID values that also have access to /dev/dri.

Enabling in Plex Settings

Once the container is running and hardware access is configured:

  1. Go to the Plex Web UI: http://<host>:32400/web
  2. Navigate to: Settings > Transcoder
  3. Enable the checkbox: Use hardware acceleration when available
  4. (Optional) Enable Use hardware-accelerated video encoding for encoding tasks.

Confirming Hardware Transcoding is Active

When a video is playing:

  1. Click the three dots next to the playback and choose Stats for Nerds
  2. Look for entries like hw or h264_qsv or nvenc which indicate hardware acceleration.
  3. Alternatively, open the Server Dashboard during playback and check the stream status for an (hw) label next to the transcoding type.

Geek details: inspect GPU use from the container shell

Monitoring GPU Usage from Inside the Container

You can supplement Plex's built-in tools (like "Stats for Nerds") with real-time GPU monitoring inside the DUMB container.


Intel iGPU Monitoring

Intel GPUs (e.g., Quick Sync) can be monitored using intel-gpu-tools:

# Enter the container
docker exec -it DUMB bash

# Install the tools (Debian/Ubuntu based images)
apt update && apt install -y intel-gpu-tools

# Launch real-time GPU monitor
intel_gpu_top

This provides a live view of the GPU's video encode/decode engines. Look for activity under:

  • Video or Video/0 for decoding
  • VideoEnhance or Blitter for scaling and filtering

Use q to exit intel_gpu_top


NVIDIA GPU Monitoring

For NVIDIA GPUs with NVENC/NVDEC support, use the nvidia-smi tool:

# Enter the container
docker exec -it DUMB bash

# If not already installed, install NVIDIA tools
apt update && apt install -y nvidia-smi

# Monitor GPU usage
nvidia-smi

Look for the Plex process listed under the Processes section. When active transcoding is occurring, you should see:

  • Increased GPU-Util percentage
  • Encoder usage
  • Memory allocation from Plex or Plex Transcoder

If nvidia-smi is not recognized, ensure the container is running with the --gpus all flag and NVIDIA Docker runtime is enabled on the host.


Troubleshooting GPU Access & Hardware Transcoding

  • Confirm the container has access to /dev/dri or sometimes /dev/nvidia*
  • Confirm Plex Pass is active and the account used in Plex is signed in and authorized
  • Validate Plex transcoder settings are enabled for hardware use
  • Check that Plex is actually transcoding (not Direct Playing)
  • Ensure your hardware supports it (Intel iGPU, NVIDIA GPU with driver support, etc.)
  • Review container logs and Plex logs for errors related to transcoding

Integration with Other Services

Plex is designed to serve content collected and maintained by core DUMB services including Riven, CLI Debrid, and Decypharr. These services fetch, organize, and optionally symlink media content into the mounted directory used by Plex.

By default, media content is made available inside the container at /mnt/debrid through rclone mounts.

  • Core services populate /mnt/debrid with downloaded or upgraded content.
  • Plex scans this location to index and serve the media.

If you want to serve media from the host system, bind mount your local media directory into the container and add it as a library path in Plex.


Access

Open the service from DUMB's Embedded UI tab when available. The native URLs below require the corresponding Docker host port to be published; use the port saved in your running configuration.

  • URL: http://<host>:32400/web
  • Credentials: Managed through Plex.tv account

Mount and Path Planning

Ensure your media storage is accessible to Plex via the correct container path.

  • Default internal mount: /mnt/debrid
  • Add bind mounts: for local media stored on the host machine not managed by DUMB.

Tips and Troubleshooting

  • If the container fails to start due to permissions, ensure Plex has proper access to its config_dir and media directories.
  • Use PUID and PGID to match host user permissions.
  • Logs can be viewed directly from the DUMB Frontend.
  • You can also start, stop, restart Plex, and modify the dumb_config.json or Plex Preferences.xml from the DUMB Frontend interface.

Resources