Digarr

Digarr

Docker app from Selfhosters

Overview

AI-powered music discovery engine for self-hosted music stacks. Connects to Lidarr, Last.fm, ListenBrainz, Spotify, and more to find new artists you will actually like. Supports auto-playlists, subscription feeds, mood-based discovery, and genre browsing. Ships with a built-in embedded database -- no separate PostgreSQL container needed. Data is stored in the mapped data folder (/mnt/user/appdata/digarr/data), which must be writable by the container user (uid 1000). To use an external PostgreSQL instead, set the (advanced) Database URL variable.

Digarr

Digarr

CI License: MIT Bun TypeScript Docker Tests Release

Self-hosted music discovery for your library. Digarr finds artists and albums from your listening history or a mood. Review the suggestions, listen to previews, then send what you like to Lidarr, slskd, or a playlist. Bring your own AI provider or local model. Lidarr is optional.

[!NOTE] v2.0.0 is out. This release fixes discovery, album approval, saved playlist exports, and recovery, and binds SSO accounts to exact issuer/subject pairs. Existing installations must follow the v2.0.0 upgrade procedure before updating. See the changelog for release details.

Dashboard

This dashboard capture predates v1.19.0; see current behavior and screenshots.

More screenshots | Quick start | Configuration | Documentation

What you can do

  • Find artists and albums. Connect a listening source, scan, and review scored suggestions. Release Radar finds new releases; Library Gap-Fill finds missing albums. Mood and artist searches work without a listening history.
  • Review before adding. Preview, approve, reject, or permanently block suggestions. Individual and bulk album approval monitor and search only the recommended album in Lidarr. Automatic album approval also uses only the recommended release; its monitoring setting applies to artist recommendations.
  • Keep discovery running. Schedule scans and subscriptions, or generate playlists from your connected libraries and catalog searches for Spotify and supported media servers. Saved playlists refresh their bound remote playlists; explicit recovery handles uncertain creation and changed destinations. Audition playlists use pending artists without approving them. You can also export M3U/XSPF files. Media-server exports use music already in that server's library.
  • Share an instance. Each user has their own queue, connections, and preferences; admins assign targets to each user. Local accounts and OIDC/SSO are supported, with 15 languages and light and dark themes.

Digarr calls your connected services. It doesn't include a downloader or a full music player.

AI suggestions and MusicBrainz matches can be wrong, so check the artist and release before approving. Playlist generation reports local results; it doesn't verify remote playback. Media-server exports require an exact artist/title match after case and whitespace normalization. Unmatched tracks are skipped, and omissions are reported in Job History. See known limitations.

Connections at a glance

Use Services
Scan taste-profile sources ListenBrainz, Last.fm, Spotify, Plex, Jellyfin, Emby, Subsonic, Discogs
Deezer feeds Flow, favorites, followed artists, and playlists (own app required)
Library sync Lidarr, Plex, Jellyfin, Emby, Subsonic
Approval and acquisition Lidarr, slskd
Playlist export Spotify, Navidrome, Jellyfin, Emby, Plex
Search Spotify, Deezer, MusicBrainz; Bandcamp and TIDAL (both experimental)
AI recommendations Anthropic, OpenAI, Gemini, Ollama, OpenAI-compatible endpoints
Notifications Webhooks, ntfy, Telegram, Apprise

A connection's capabilities differ by service. Release Radar requires ListenBrainz, Spotify, or Last.fm. Spotify Saved Albums and Followed Artists, Deezer Flow, and Subsonic Starred have focused discovery modes.

Privacy and credentials

Your database runs on your server. Connected services still receive requests: hosted AI providers receive discovery prompts, metadata services receive lookups, and embedded previews contact their providers. A local AI model keeps AI requests local, but does not make all of Digarr offline.

Set and retain DIGARR_ENCRYPTION_KEY before saving service credentials. Without it, sensitive database fields are stored unencrypted. Back up the key separately from the database; losing it means re-entering encrypted credentials. Application exports preserve persistent state; a native consistent database backup is still required for exact schema rollback. Required automatic-backup failures stop migrations. See the key rotation guide before changing an existing key.

Quick start

You need Docker and access to an AI provider or local model. Digarr includes an embedded PostgreSQL database (PGlite), so this runs as one container:

mkdir digarr && cd digarr &&
(set -C; umask 077 && key=$(openssl rand -hex 32) && printf 'DIGARR_ENCRYPTION_KEY=%s\n' "$key" > digarr.env) &&
docker run -d --name digarr --restart unless-stopped -p 127.0.0.1:3000:3000 \
  --env-file ./digarr.env \
  -e ALLOWED_ORIGIN=http://localhost:3000 \
  -e DIGARR_ALLOW_INSECURE_COOKIES=true \
  -v digarr-data:/app/data -v digarr-backups:/app/backups \
  docker.io/iuliandita/digarr:latest

This local-only HTTP example needs OpenSSL and saves the key in protected digarr.env. Retain that file for container recreation and recovery. The cookie override avoids browser-dependent Secure-cookie handling on localhost. For other devices, configure an HTTPS public origin; deliberate HTTP exposes session cookies to interception.

Open http://localhost:3000 and complete setup. Create the first account or sign in before the wizard. Passwords need 12 characters. The first account becomes admin; further local self-registration is closed by default. OIDC can still create accounts, so restrict access at your identity provider.

For unattended first boot, set both DIGARR_INITIAL_USERNAME and DIGARR_INITIAL_PASSWORD before starting. The configured admin must be created before HTTP opens; partial credentials or a password shorter than 12 characters stop startup. Leave both unset for manual registration. These settings never reset an existing account. Restrict access until you verify the intended admin. See first-boot access.

Use :latest for the newest release, a minor tag like :2.0 for patch updates, or a specific patch like :2.0.0 to pin a release. Only the newest release receives security fixes. See image channels.

For Compose, backend selection, and updates, follow the Docker guide. Keep one app instance per database, verify its backend at /health, and back up before upgrading.

Your first recommendations

  1. Sign in, then choose Lidarr, Emby, or discovery-only in the setup wizard and configure your AI provider. Requested settings, connections, and targets save together; a failed save leaves setup retryable.
  2. Connect a listening source in Settings. Add library sources and targets when needed.
  3. Run a scan from Dashboard or Discover.
  4. Preview, approve, or reject suggestions. Adjust genre priorities in Settings > Recommendations if needed. Personal saves work for non-admins and global metadata controls are admin-only. Use Release Radar or Library Gap-Fill for albums. The net-new album toggle defaults to off and persists when saved.

CSV and playlist imports process the listed artists into recommendations through separate subscription runs. Spotify's Import Liked Songs does the same for saved tracks. Imports do not become inputs to a normal scan. Spotify playlist imports honor the saved artist cap across pages; see limits and playlist access.

A scan can complete with a failed source. Admins can check Job History for partial results; other users can refresh Discover. Services without similar-artist lookup still contribute their supported listening and library data. See the pipeline guide for the details.

Configuration

Use Settings for connections, scoring, schedules, preferences, and language. Authentication covers origins, cookies, SSO, and proxies. Operations covers Plex listeners, slskd imports, Data Hygiene, playlists, notifications, and local AI.

Service apps

Spotify needs your own OAuth app, a Premium app owner, and up to five allowlisted Development Mode users. Search needs a connected account. Local HTTP uses 127.0.0.1, with the same ALLOWED_ORIGIN and browser address. Follow Spotify setup before changing the quick-start origin.

TIDAL is experimental: authorization, refresh, and favorite-artist retrieval have not been tested with a live account. Catalog search needs admin-registered credentials; each user connects their own account for Favorite Artists. Follow TIDAL setup. The feedback checklist explains what to report safely.

Backup and restore

Application JSON exports preserve persistent application state and reject unsafe partial restores before writes. Required automatic-backup failures stop migrations. Retain the matching encryption key separately, and use a native consistent database backup for exact schema rollback. Read backup boundaries and recovery before upgrading or restoring, including the explicit native-backup procedure for older schemas. Operations covers application exports and version-specific upgrade notes.

Selecting a backup in Settings > Administration opens a replacement confirmation before any upload. An encryption-key mismatch requires a separate Restore Anyway confirmation; retain the original key whenever possible.

Deployment

Method Path Notes
Docker Compose deploy/docker/ Recommended. Choose single-container PGlite or the bundled PostgreSQL stack. Also on Docker Hub.
Helm chart deploy/helm/digarr/ Kubernetes. Embedded PGlite, bundled PostgreSQL, or your own database. Keep one app replica.
Raw k8s manifests deploy/k8s/ Reference manifests for advanced setups.
Unraid docs/guides/unraid.md In the Community Applications store (search "Digarr"); bundled template (deploy/unraid/digarr.xml) as manual fallback. Embedded PGlite by default; external PostgreSQL optional.
Synology NAS docs/guides/synology.md DSM 7.1+ (Docker/Container Manager). SSH or GUI.
Docker Desktop docs/guides/docker-desktop.md macOS and Windows (WSL 2 or PowerShell).

Check image signatures and SBOM coverage before running a release.

Documentation

Contributing

Bug reports, translations, documentation fixes, and code contributions are welcome. See CONTRIBUTING.md for development setup and checks. Report security problems through the private reporting process.

Most code and tests are AI-generated, with a human setting direction and reviewing changes.

License

MIT. See LICENSE.

Made by Iulian Dita. Other projects.

Requirements


    No separate database required -- uses a built-in embedded database by
    default. The data folder (/mnt/user/appdata/digarr/data) must be
    writable by the container user (uid 1000). Optionally point Database URL
    at an external PostgreSQL instance.

Download Statistics

44,759
Total Downloads
14,934
This Month
11,518
Avg / Month

Total Downloads Over Time

Loading chart...

Related apps

Explore more like this

Explore all

Details

Repository
docker.io/iuliandita/digarr:latest
Last Updated2026-09-16
First Seen2026-06-29

Runtime arguments

Web UI
http://[IP]:[PORT:3000]
Network
bridge
Shell
sh
Privileged
false

Template configuration

Web UI PortPorttcp

Port for the web interface

Target
3000
Default
3000
Value
3000
DataPathrw

Persistent storage for the built-in embedded database. Must be writable by the container user (uid 1000).

Target
/app/data
Default
/mnt/user/appdata/digarr/data
Value
/mnt/user/appdata/digarr/data
Data PathVariable

Container path for the built-in embedded database (matches the Data folder mapping)

Target
DB_PATH
Default
/app/data
Value
/app/data
Database URLVariable

Leave empty to use the built-in database. Set only to use an external PostgreSQL, e.g. postgresql://user:pass@host:5432/digarr

Target
DATABASE_URL
Initial UsernameVariable

Auto-create this admin user on first boot

Target
DIGARR_INITIAL_USERNAME
Initial PasswordVariable

Password for the initial admin user (min 8 chars)

Target
DIGARR_INITIAL_PASSWORD
AI ProviderVariable

AI provider: anthropic, openai, gemini, ollama, openai-compatible (or configure in UI)

Target
AI_PROVIDER
AI ModelVariable

Model name, e.g. gpt-4o-mini, claude-sonnet-4-5-20250514

Target
AI_MODEL
AI API KeyVariable

API key for the AI provider

Target
AI_API_KEY
AI Base URLVariable

Base URL for openai-compatible or ollama (e.g. http://ollama:11434)

Target
AI_BASE_URL
Lidarr URLVariable

Lidarr instance URL, e.g. http://lidarr:8686 (optional -- discovery works without Lidarr)

Target
LIDARR_URL
Lidarr API KeyVariable

Lidarr API key (Settings > General in Lidarr)

Target
LIDARR_API_KEY
ListenBrainz UsernameVariable

ListenBrainz username for taste analysis

Target
LISTENBRAINZ_USERNAME
ListenBrainz TokenVariable

ListenBrainz user token

Target
LISTENBRAINZ_TOKEN
Last.fm UsernameVariable

Last.fm username for taste analysis

Target
LASTFM_USERNAME
Last.fm API KeyVariable

Last.fm API key

Target
LASTFM_API_KEY
Allowed OriginVariable

CORS allowed origin, e.g. https://digarr.example.com (required for reverse proxy)

Target
ALLOWED_ORIGIN
Encryption KeyVariable

32+ char key for encrypting API keys, tokens, and connection passwords (blank stores those fields unencrypted)

Target
DIGARR_ENCRYPTION_KEY
Disable RegistrationVariable

Set to false to allow new user registration

Target
DIGARR_DISABLE_REGISTRATION
Default
true|false
Skip TLS VerifyVariable

Skip TLS certificate verification for Lidarr/Jellyfin connections

Target
SKIP_TLS_VERIFY
Default
false|true
Webhook URLVariable

Discord HTTPS webhook or public HTTPS endpoint that accepts Digarr JSON

Target
WEBHOOK_URL