Tdarr: Automated Media Transcoding

Tdarr is an automated media library transcoding and health-checking application that helps you optimize your entire media collection. This comprehensive guide covers installation, configuration, hardware acceleration, and advanced workflows for processing thousands of media files.

What is Tdarr?

Tdarr is a distributed transcoding system designed to automate the conversion and optimization of media files in your library. It monitors your media directories, analyzes files against your rules, and automatically transcodes them to your desired formats and codecs.

Core Features

Automated Transcoding:

Monitor media libraries continuously
Transcode to efficient codecs (H.265/HEVC, AV1)
Hardware acceleration support (Intel QSV, NVIDIA NVENC, AMD AMF)
Distributed worker architecture
Queue management and prioritization

Health Checking:

Detect corrupted files
Find files missing audio tracks
Identify files with wrong codecs
Check bitrate and resolution
Validate container formats

Space Optimization:

Convert to more efficient codecs
Reduce file sizes by 40-70%
Maintain quality with proper encoding
Remove unwanted streams (audio/subtitle)
Normalize audio levels

Advanced Processing:

Custom plugin system
Conditional flows (if-then-else logic)
Multiple worker nodes
GPU transcoding support
Statistics and reporting

Why Use Tdarr?

Storage Savings:

H.264 to H.265: 40-50% size reduction
H.265 to AV1: Additional 20-30% savings
Remove unused audio/subtitle tracks
Convert 4K to 1080p for mobile devices

Standardization:

Unified codec across library
Consistent audio formats
Standardized containers (MP4/MKV)
Proper metadata handling

Compatibility:

Optimize for specific devices
Create copies for different platforms
Ensure direct play capability
Reduce server transcoding load

Automation:

Set rules once, forget about it
Process new content automatically
Health check on schedule
No manual intervention needed

Prerequisites

Before starting, ensure you have:

Docker and Docker Compose installed
Existing media library with video files
At least 8GB RAM (16GB+ recommended for 4K)
CPU with hardware encoding support or dedicated GPU
Sufficient disk space for transcoding (100GB+ temporary)
Understanding of video codecs and containers

Understanding Tdarr Architecture

Tdarr consists of several components:

Tdarr Server:

Web interface for management
Centralized database
Library scanning and scheduling
Statistics and reporting
Port 8265 (web UI), 8266 (server)

Tdarr Node:

Worker process for transcoding
Can run on same or different machines
Supports GPU passthrough
Configurable transcoding slots
Reports to server

Workflows: Tdarr uses plugin-based workflows:

Health Check Plugins: Validate files
Transcoding Plugins: Convert files
Post-Processing: Clean up after transcode

Directory Structure

Create organized directories for Tdarr:

# Create Tdarr directories
mkdir -p /opt/tdarr/{server,configs,logs}

# Create transcode cache (use fast SSD)
mkdir -p /mnt/cache/tdarr_transcode_cache

# Ensure media library accessible
# Assuming media at /media/{movies,tv}

# Set ownership
sudo chown -R $USER:$USER /opt/tdarr
sudo chown -R $USER:$USER /mnt/cache/tdarr_transcode_cache

Directory Explanation:

/opt/tdarr/server: Server database and configs
/opt/tdarr/configs: Node configurations
/opt/tdarr/logs: Application logs
/mnt/cache/tdarr_transcode_cache: Temporary transcode files (requires lots of space)
/media/*: Your existing media libraries

Docker Compose Configuration

Basic Setup

Create /opt/tdarr/docker-compose.yml:

version: '3.8'

services:
  tdarr:
    image: ghcr.io/haveagitgat/tdarr:latest
    container_name: tdarr
    restart: unless-stopped
    network_mode: bridge
    ports:
      - 8265:8265  # WebUI
      - 8266:8266  # Server port
    environment:
      - TZ=America/New_York
      - PUID=1000
      - PGID=1000
      - UMASK_SET=002
      - serverIP=0.0.0.0
      - serverPort=8266
      - webUIPort=8265
      - internalNode=true
      - nodeID=MainNode
    volumes:
      - /opt/tdarr/server:/app/server
      - /opt/tdarr/configs:/app/configs
      - /opt/tdarr/logs:/app/logs
      - /mnt/cache/tdarr_transcode_cache:/temp
      - /media:/media

Configuration Notes:

Replace PUID and PGID with your user ID (id -u and id -g)
internalNode=true runs worker inside same container
/temp should be on fast storage (SSD preferred)
/media grants access to your entire media library

Intel Quick Sync Configuration

Add device mapping for Intel hardware encoding:

version: '3.8'

services:
  tdarr:
    image: ghcr.io/haveagitgat/tdarr:latest
    container_name: tdarr
    restart: unless-stopped
    network_mode: bridge
    devices:
      - /dev/dri:/dev/dri
    group_add:
      - "109"  # render group ID
    ports:
      - 8265:8265
      - 8266:8266
    environment:
      - TZ=America/New_York
      - PUID=1000
      - PGID=1000
      - UMASK_SET=002
      - serverIP=0.0.0.0
      - serverPort=8266
      - webUIPort=8265
      - internalNode=true
      - nodeID=MainNode
      - ffmpegVersion=6
    volumes:
      - /opt/tdarr/server:/app/server
      - /opt/tdarr/configs:/app/configs
      - /opt/tdarr/logs:/app/logs
      - /mnt/cache/tdarr_transcode_cache:/temp
      - /media:/media

Verify render group:

getent group render
# Use the number in group_add

NVIDIA GPU Configuration

For NVIDIA hardware transcoding:

version: '3.8'

services:
  tdarr:
    image: ghcr.io/haveagitgat/tdarr:latest
    container_name: tdarr
    restart: unless-stopped
    runtime: nvidia
    network_mode: bridge
    ports:
      - 8265:8265
      - 8266:8266
    environment:
      - TZ=America/New_York
      - PUID=1000
      - PGID=1000
      - UMASK_SET=002
      - serverIP=0.0.0.0
      - serverPort=8266
      - webUIPort=8265
      - internalNode=true
      - nodeID=MainNode
      - ffmpegVersion=6
      - NVIDIA_DRIVER_CAPABILITIES=all
      - NVIDIA_VISIBLE_DEVICES=all
    volumes:
      - /opt/tdarr/server:/app/server
      - /opt/tdarr/configs:/app/configs
      - /opt/tdarr/logs:/app/logs
      - /mnt/cache/tdarr_transcode_cache:/temp
      - /media:/media

Prerequisites:

NVIDIA Container Toolkit installed
Compatible GPU (GTX 1650+, RTX series)
Recent drivers

Deployment

Verify Hardware Access

For Intel Quick Sync:

ls -la /dev/dri/
# Should show renderD128 and card0

# Check permissions
groups $USER
# Should include render and video groups

# Add if missing
sudo usermod -a -G video,render $USER

For NVIDIA:

# Test GPU access
nvidia-smi

# Test Docker runtime
docker run --rm --runtime=nvidia nvidia/cuda:12.0-base nvidia-smi

Start Tdarr

cd /opt/tdarr
docker-compose up -d

Monitor Startup

# Watch logs
docker logs -f tdarr

# Look for successful startup
# "Tdarr Node ready"
# "Tdarr Server listening on port 8266"

Access Web Interface

Open browser to:

http://YOUR-SERVER-IP:8265

Initial Configuration

First-Time Setup

Access Tdarr web UI
Navigate to Options tab

General Options:

Server IP: localhost
Server Port: 8266
Default working directory: /temp

Library Configuration

Add your media libraries for monitoring.

Navigate to Libraries Tab:

Add New Library:

Click + Library
Configure:
- Name: Movies
- Folder: /media/movies
- Folder watch scan: Enabled
- Scan on start: Enabled
- Scan interval: 3600 (1 hour)
- Recursive scan: Enabled
Click + Library again for TV shows:
- Name: TV Shows
- Folder: /media/tv
- Same settings as above

Library Options:

Source: Folder path in container
Output: Same as source (in-place transcoding)
Cache: /temp
Priority: 0 (higher = more important)

Node Configuration

Configure transcoding worker node.

Navigate to Nodes Tab:

Internal Node Settings:

Node ID: MainNode
Status: Should show “Connected”
Transcode capacity: Set based on hardware
- Intel QSV: 2-4 concurrent
- NVIDIA RTX 3060: 3-6 concurrent
- CPU only: 1-2 concurrent
Health check capacity: 2-4 workers

Hardware Acceleration: Verify FFmpeg can access GPU:

Nodes → MainNode → Logs
Look for hardware encoder detection

Creating Transcoding Workflows

Tdarr uses plugins to define transcoding rules.

Understanding Plugins

Plugin Types:

Community Plugins (recommended):

Pre-built by Tdarr community
Well-tested and maintained
Cover common use cases

Classic Plugins:

Original plugin system
Simple configuration
Less flexible than flows

Flows:

Advanced plugin system
Conditional logic
Multiple steps
Most powerful option

Basic Transcode Flow

Create a simple H.264 to H.265 transcoding workflow.

Navigate to Library → Movies → Transcode Options:

Add Plugin:

Click + in Plugins section
Search for community plugins
Select desired plugin

Recommended Starting Plugin:

Migz-Transcode Using Original Container
- Transcodes video to H.265
- Keeps original audio
- Maintains subtitles
- Uses same container format

Plugin Configuration:

Select plugin
Configure options:
- Video Encoder: hevc_qsv (Intel) or hevc_nvenc (NVIDIA) or libx265 (CPU)
- Bitrate mode: Variable (VBR)
- Quality: CRF 23-28 (lower = better quality, larger size)
- Preset: Medium (balance speed/quality)
- Audio: AAC, 192kbps
- Keep subtitles: Yes

Advanced H.265 Flow

Custom flow for maximum control:

Create New Flow:

Library → Transcode Options
Click Create Flow
Add steps:

Step 1: Check if already H.265:

Plugin: Check Video Codec
Condition: If codec NOT h265/hevc
Action: Continue to next step
Else: Skip transcoding

Step 2: Check file size:

Plugin: Check File Size
Condition: If size greater than 1GB
Action: Continue (don’t bother with small files)
Else: Skip

Step 3: Transcode to H.265:

Plugin: Transcode Video
Encoder: hevc_nvenc (or hevc_qsv)
CRF: 23
Preset: Medium
Max bitrate: 10Mbps (for 1080p)
Two-pass: Enabled for large files

Step 4: Validate output:

Plugin: Check Health
Verify no corruption
Compare file sizes
Ensure streams present

Hardware Acceleration Settings

Configure FFmpeg arguments for GPU encoding.

For Intel Quick Sync (QSV):

-c:v hevc_qsv -preset medium -global_quality 23 -look_ahead 1

For NVIDIA NVENC:

-c:v hevc_nvenc -preset p4 -cq:v 23 -rc vbr -b:v 0

For AMD AMF:

-c:v hevc_amf -quality quality -rc vbr_latency -qp_i 23 -qp_p 23

CPU (libx265):

-c:v libx265 -preset medium -crf 23 -x265-params log-level=error

Common Transcoding Scenarios

Scenario 1: H.264 to H.265 Conversion

Goal: Reduce storage by 40-50% while maintaining quality.

Plugin Configuration:

Input: Any H.264 files
Output: H.265/HEVC
Quality: CRF 22-25
Audio: Copy if AAC, else transcode to AAC
Subtitles: Copy all
Hardware acceleration: Enabled

Expected Results:

10GB H.264 file → 5-6GB H.265 file
Visual quality nearly identical
Compatible with modern devices
Processing time: 0.5-2x realtime (with GPU)

Scenario 2: 4K to 1080p for Mobile

Goal: Create 1080p copies for mobile streaming.

Plugin Configuration:

Input: Files with resolution greater than 1920x1080
Output: Scale to 1920x1080
Codec: H.265
Bitrate: 4-8 Mbps
Audio: Downmix to stereo AAC 128kbps
Separate folder: /media/mobile/

Flow:

Check resolution greater than 1080p
Scale to 1920x1080
Transcode with H.265
Move to mobile folder
Keep original in main library

Scenario 3: Remove Unwanted Audio Tracks

Goal: Keep only English audio, remove others.

Plugin Configuration:

Input: All files
Action: Check audio tracks
Keep: English audio only
Remove: All other language tracks
Processing: Fast (no transcoding)

Space Savings:

Movie with 5 audio tracks (each 500MB) → Remove 4 = 2GB saved
Especially effective on Blu-ray rips

Scenario 4: Normalize Audio Levels

Goal: Fix quiet or loud audio.

Plugin Configuration:

Input: All files
Action: Analyze audio loudness
Target: -14 LUFS (standard streaming level)
Method: EBU R128 normalization
Format: AAC or maintain original

Benefits:

Consistent volume across library
No more reaching for volume remote
Professional streaming quality

Scenario 5: Remove Intros/Outros

Goal: Automatically detect and remove intros.

Plugin Configuration (advanced):

Input: TV shows
Action: Detect black frames/silence
Remove: First 30-90 seconds (intro)
Keep: Main content
Validate: Check duration reasonable

Note: Use with caution, verify results.

Monitoring and Queue Management

Dashboard Overview

Navigate to Dashboard:

Shows real-time statistics:

Files being processed
Queue length
Worker utilization
Storage saved
Processing speed

Key Metrics:

Total files scanned
Files needing transcode
Space saved percentage
Average transcode time
Success/failure rate

Queue Management

Transcode Queue:

View pending files
Reorder by priority
Cancel items
Clear completed

Queue Operations:

Pause queue: Stop accepting new files
Skip item: Move to bottom of queue
Bump priority: Move specific file to front
Cancel item: Remove from queue

Worker Performance

Monitor Node Performance:

Nodes tab shows:

Current file processing
Progress percentage
ETA to completion
CPU/GPU utilization
Errors encountered

Optimize Worker Count:

Too few: Underutilized hardware
Too many: Reduced quality/speed per file
Optimal: CPU/GPU at 80-90% usage

Typical configurations:

Intel i5 + QSV: 3-4 workers
NVIDIA RTX 3060: 4-6 workers
AMD Ryzen 9 CPU-only: 2 workers

Advanced Configuration

Distributed Workers

Add additional nodes on other machines for faster processing.

On Second Machine:

Create docker-compose.yml:

version: '3.8'

services:
  tdarr-node:
    image: ghcr.io/haveagitgat/tdarr_node:latest
    container_name: tdarr-node
    restart: unless-stopped
    network_mode: bridge
    environment:
      - TZ=America/New_York
      - PUID=1000
      - PGID=1000
      - nodeID=Worker2
      - serverIP=MAIN-SERVER-IP
      - serverPort=8266
    volumes:
      - /opt/tdarr/configs:/app/configs
      - /opt/tdarr/logs:/app/logs
      - /mnt/cache/tdarr_transcode_cache:/temp
      - /media:/media

Benefits:

Distribute workload
Utilize multiple GPUs
Faster processing
Dedicated transcoding servers

Custom FFmpeg Commands

Create advanced FFmpeg commands for specific needs.

Example: HDR to SDR Tone Mapping:

-vf "zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=yuv420p" -c:v hevc_nvenc -preset p4 -cq:v 23

Example: Deinterlace and Upscale:

-vf "yadif=1,scale=1920:1080:flags=lanczos" -c:v hevc_qsv -preset medium -global_quality 23

Example: Add Hardcoded Subtitles:

-vf "subtitles=/media/movie.srt" -c:v hevc_nvenc -preset p4 -cq:v 23

Scheduling

Configure when Tdarr processes files.

Library Options → Scheduler:

Schedule Scans:

Scan frequency: Every 1 hour during off-peak
Deep scan: Weekly on Sunday 3 AM
Health check: Daily at 2 AM

Schedule Transcodes:

Active hours: 12 AM - 7 AM (low usage time)
Pause during: 6 PM - 11 PM (high usage)
Max concurrent: 4 during night, 1 during day

Benefits:

Reduce server load during peak usage
Utilize idle time
Prevent impacting streaming users

Notifications

Set up alerts for transcode completion and errors.

Options → Notifications:

Discord Webhook:

Webhook URL: https://discord.com/api/webhooks/YOUR-WEBHOOK
Events:
- Transcode completed
- Error encountered
- Queue empty
- Storage threshold reached

Email Notifications:

SMTP server configuration
Alert on failures
Daily summary report

Webhook Integration: Custom webhooks for Home Assistant, n8n, etc.

Optimization Best Practices

Quality vs. Size Balance

CRF Values Guide:

For H.265 encoding:

CRF 18-22: Near-transparent quality, larger files
CRF 23-25: Excellent quality, good compression (recommended)
CRF 26-28: Good quality, maximum compression
CRF 29+: Noticeable quality loss

Rule of thumb:

Archival content: CRF 20-22
General library: CRF 23-25
Space-constrained: CRF 26-28

Preset Selection

Encoding Presets (NVENC example):

p1 (fastest): Lowest quality, 3x realtime
p4 (medium): Balanced quality/speed, 1.5x realtime
p7 (slowest): Best quality, 0.8x realtime

Recommended:

Quick conversions: p1-p3
General use: p4
Archival/important: p6-p7

Storage Optimization

Transcode Cache Size:

Minimum: 100GB
Recommended: 200-500GB
Large library (4K): 1TB+

Why large cache?

Files staged before transcoding
Original kept until verified
Multiple concurrent transcodes
Prevents repeated downloads

Cleanup Strategy:

Auto-delete on success: Enabled
Keep originals: 24 hours after success
Manual cleanup: Weekly

Performance Tuning

For Maximum Speed:

Use GPU encoding (10-20x faster)
Increase worker count
Use fast presets
Skip health checks initially
Process in batches

For Maximum Quality:

Use two-pass encoding
Slow/slower presets
Lower CRF values
Enable all filters
Validate all outputs

Balanced Approach (recommended):

GPU encoding with medium preset
CRF 23-25
Single-pass VBR
2-4 concurrent workers
Health check after transcode

Troubleshooting

Common Issues

Issue: Transcodes Failing

Diagnostics:

# Check logs
docker logs tdarr

# Check FFmpeg errors
cat /opt/tdarr/logs/node_MainNode.txt

# Test FFmpeg manually
docker exec tdarr ffmpeg -version

Solutions:

Verify hardware access (GPU)
Check file permissions
Ensure sufficient disk space in /temp
Update FFmpeg version
Simplify plugin configuration

Issue: Slow Transcoding

Diagnostics:

# Check CPU/GPU usage
top
# or
nvidia-smi

# Check I/O wait
iostat -x 1

Solutions:

Enable hardware acceleration
Move cache to SSD
Reduce concurrent workers
Use faster encoding preset
Check network speed (if remote storage)

Issue: Output Files Corrupted

Diagnostics:

Review transcode logs
Check source file health
Verify FFmpeg command
Test with different encoder

Solutions:

Run health check on source
Update FFmpeg
Change encoding parameters
Use two-pass encoding
Reduce worker count (less contention)

Issue: Hardware Acceleration Not Working

Diagnostics:

# For Intel
docker exec tdarr vainfo

# For NVIDIA
docker exec tdarr nvidia-smi

# Check FFmpeg encoders
docker exec tdarr ffmpeg -encoders | grep hevc

Solutions:

Verify device mapping in docker-compose.yml
Check group permissions
Update GPU drivers on host
Restart container
Use correct encoder name (hevc_qsv, hevc_nvenc, etc.)

Issue: Running Out of Disk Space

Solutions:

# Check cache usage
du -sh /mnt/cache/tdarr_transcode_cache

# Manual cleanup
docker exec tdarr find /temp -type f -mtime +1 -delete

# Configure auto-cleanup
# In Tdarr: Options → Cache Management

Settings:

Auto-delete successful: Enabled
Keep originals: 12-24 hours
Max cache size: 500GB

Issue: Specific File Won’t Transcode

Debugging:

Check file with mediainfo:

docker exec tdarr mediainfo /media/movies/problematic_file.mkv

Test manual transcode:

docker exec tdarr ffmpeg -i /media/movies/file.mkv -c:v hevc_nvenc -preset p4 -cq:v 23 /temp/test_output.mkv

Review specific error in logs
Try different encoder or plugin
Re-download source if corrupted

Integration with Media Servers

Plex Integration

Workflow:

Tdarr transcodes files in-place
Plex detects file change
Metadata preserved
Playback uses new file

Best Practices:

Schedule during Plex off-hours
Use “Analyze after transcode” plugin
Keep original filename/folder structure
Enable “Update library” in Tdarr
Monitor Plex database for corruption

Notification Setup:

Tdarr webhook → Trigger Plex library scan
Verify metadata after batch processing

Jellyfin Integration

Similar to Plex integration.

Configuration:

Preserve file structure
Transcode in-place
Trigger library scan via API
Monitor for playback issues

Jellyfin API Call (after transcode):

curl -X POST "http://jellyfin:8096/Library/Refresh?api_key=YOUR_API_KEY"

Arr Stack Integration

Integrate with Sonarr/Radarr for automatic processing.

Workflow:

Sonarr/Radarr download content
Import to library
Tdarr detects new file
Transcode automatically
Notify media server

Configuration:

Tdarr watches same folders as *arr apps
Process newly imported files first (priority)
Notify user when ready

Statistics and Reporting

Built-in Statistics

Navigate to Statistics Tab:

Library Statistics:

Total files processed
Space saved (GB and %)
Average file size reduction
Processing time stats
Success/failure rates

Codec Distribution:

Before: % H.264 vs. H.265 vs. others
After: Target codec percentage
Remaining files to process

Worker Performance:

Files per day per worker
Average transcode time
Hardware utilization
Error rates per node

Export Reports

Generate Reports:

Statistics → Export
Select date range
Choose format (CSV, JSON)
Download

Report Data:

File paths processed
Original vs. new file size
Processing duration
Codec changes
Errors encountered

Use Cases:

Track space savings over time
Identify problematic files
Plan hardware upgrades
Audit library optimization

Backup and Recovery

Configuration Backup

Backup Tdarr Configuration:

# Stop Tdarr
docker-compose down

# Backup database and configs
tar -czf tdarr-backup-$(date +%Y%m%d).tar.gz /opt/tdarr/server /opt/tdarr/configs

# Restart
docker-compose up -d

Automated Backup Script:

#!/bin/bash
BACKUP_DIR="/backups/tdarr"
DATE=$(date +%Y%m%d_%H%M%S)

mkdir -p $BACKUP_DIR
cd /opt/tdarr
docker-compose down
tar -czf $BACKUP_DIR/tdarr-$DATE.tar.gz server configs
docker-compose up -d

# Keep only last 7 backups
ls -t $BACKUP_DIR/tdarr-*.tar.gz | tail -n +8 | xargs -r rm

Schedule with Cron:

0 3 * * 0 /opt/scripts/backup-tdarr.sh

Disaster Recovery

Restore from Backup:

# Stop containers
docker-compose down

# Restore backup
tar -xzf tdarr-backup-20251217.tar.gz -C /opt/tdarr/

# Restart
docker-compose up -d

Important Files:

/opt/tdarr/server/Tdarr.db: Main database
/opt/tdarr/configs/: Node configurations
/opt/tdarr/server/Tdarr_DB_Backups/: Automatic backups

Security Best Practices

Access Control

Authentication:

Navigate to Options → Security
Enable authentication
Set strong password
Restrict to local network only

Firewall Rules:

# Allow only local network
sudo ufw allow from 192.168.1.0/24 to any port 8265
sudo ufw allow from 192.168.1.0/24 to any port 8266

# Or use reverse proxy with SSL
sudo ufw allow 443/tcp

Reverse Proxy Setup

Nginx Configuration:

server {
    listen 443 ssl http2;
    server_name tdarr.yourdomain.com;

    ssl_certificate /etc/ssl/certs/cert.pem;
    ssl_certificate_key /etc/ssl/private/key.pem;

    location / {
        proxy_pass http://localhost:8265;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket support
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

File Permissions

Ensure Proper Permissions:

# Set ownership
sudo chown -R 1000:1000 /opt/tdarr
sudo chown -R 1000:1000 /mnt/cache/tdarr_transcode_cache

# Set permissions
sudo chmod -R 755 /opt/tdarr
sudo chmod -R 755 /mnt/cache/tdarr_transcode_cache

Conclusion

You now have a production-ready Tdarr transcoding system capable of automatically optimizing your entire media library. Tdarr will continuously monitor, analyze, and transcode your files according to your specifications, saving storage space and improving compatibility.

Key Takeaways

Tdarr automates the tedious process of media transcoding
Hardware acceleration provides 10-20x speed improvements
Plugin system enables complex conditional workflows
Distributed workers allow scaling across multiple machines
In-place transcoding preserves library organization
Storage savings of 40-70% are common with H.265

Next Steps

After basic setup:

Start small: Transcode 10-20 test files first
Verify quality: Compare originals to transcoded files
Optimize settings: Adjust CRF and presets based on results
Create backup: Before processing entire library
Monitor closely: Watch first 24 hours of processing
Scale gradually: Add more workers as confidence grows

Advanced Topics

Once comfortable with basics:

Multiple quality tiers: 4K, 1080p, 720p, mobile versions
Audio normalization: Consistent volume across library
Automatic upgrades: Transcode old files when better codecs available
Scene detection: Remove intros, credits, commercials
Custom plugins: Write JavaScript for unique needs
Multi-node cluster: Distributed processing across homelab

Resources

Official Documentation:

Tdarr Docs: docs.tdarr.io
GitHub: github.com/HaveAGitGat/Tdarr
Community Plugins: github.com/HaveAGitGat/Tdarr_Plugins

Community Resources:

r/Tdarr: Reddit community
Discord: Tdarr Discord server
Forums: Tdarr community forums

Related Guides:

FFmpeg encoding guide
Hardware acceleration setup
Plex/Jellyfin optimization
Storage management for homelabs

Final Tips

Before Processing Entire Library:

Create backup of database
Test on sample files first
Verify media server still reads files
Check playback on all devices
Monitor disk space closely
Have rollback plan ready

Space Savings Examples (H.264 to H.265 @ CRF 23):

1080p movie (10GB) → 5-6GB (40-50% saving)
4K movie (50GB) → 25-30GB (40-50% saving)
TV episode (2GB) → 1-1.2GB (40-50% saving)
Entire 10TB library → 5-6TB (saving 4-5TB)

Quality Recommendations:

Test files: CRF 20-28, compare visually
Most content: CRF 23-25 provides excellent quality
Animation/cartoons: CRF 26-28 (compress better)
High-action content: CRF 22-24 (needs higher quality)
Archival copies: CRF 18-20 (near-lossless)

Enjoy your optimized, space-efficient media library!