Immich vs PhotoPrism: Which Self-Hosted Photo Library Wins in 2026?

The Problem

Google Photos raised prices again. Or capped your storage. Or both.

You’re looking for a self-hosted alternative, but you’re stuck between Immich and PhotoPrism. They look like they do the same thing. They don’t.

I was in the exact same spot 4 months ago. 50,000 photos sitting on Google Photos, that nagging “what if” feeling, and two solutions that seem identical on paper.

I installed both. I migrated parts of my library to each. I lived with them for 3 months straight.

Here’s what I learned — and why I ended up keeping both.

TL;DR (for the impatient)

Pick Immich if:

• You want a Google Photos clone (same UX, same feel)
• The mobile app matters (auto-upload, notifications)
• You want facial recognition and semantic search
• You’re okay with occasional breaking changes

Pick PhotoPrism if:

• You already have an organized library (folders, tags)
• Stability is your biggest concern (mature project, 2018)
• You want more control over organization
• You’re on a low-power server (2GB RAM)

My pick: Immich for daily use. But I kept PhotoPrism as a backup archive. More on that later.

Quick Intro to Both

Immich

Launched: 2022 (the newcomer) Philosophy: “Google Photos killer” — UX first, everything else second Stack: Node.js + PostgreSQL + Redis Mobile app: Native (iOS/Android), very active development State: Rapid development, occasional breaking changes

Immich is the loud newcomer. The team isn’t subtle about their goal: replace Google Photos. The mobile app is excellent, features ship fast, and the community is hyperactive.

The catch: This project moves FAST. Features change, configs can break between major versions. If you want “set and forget,” look elsewhere.

PhotoPrism

Launched: 2018 (the veteran) Philosophy: “Photo management for everyone” — organization and control Stack: Go + TensorFlow + MariaDB/SQLite Mobile app: PWA (installable web app), less polished State: Stable, mature, no breaking changes

PhotoPrism is the old sage. Eight years of development, a Go codebase that sips resources, and a “library management” approach rather than a “photo app” one.

The catch: The mobile experience is a PWA. It works, but it’s not as smooth as a native app. And the UX leans “pro tool” more than “consumer app.”

Round 1: Installation & Setup

Immich

Difficulty: Medium (Docker Compose required) Time: 30-45 minutes Resources: 2GB RAM minimum, 4 cores recommended

Immich needs a full Docker stack with 4 services:

version: '3.8'
services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:latest
    container_name: immich_server
    volumes:
      - /srv/immich/photos:/usr/src/app/upload
    environment:
      - DB_HOSTNAME=immich_postgres
      - REDIS_HOSTNAME=immich_redis
    depends_on:
      - immich_postgres
      - immich_redis

  immich_postgres:
    image: tensorchord/pgvecto-rs:pg14-v0.2.0
    environment:
      - POSTGRES_PASSWORD=immich
      - POSTGRES_USER=immich
      - POSTGRES_DB=immich
    volumes:
      - /srv/immich/pgdata:/var/lib/postgresql/data

  immich_redis:
    image: redis:6.2-alpine

  immich-machine-learning:
    image: ghcr.io/immich-app/immich-machine-learning:latest
    volumes:
      - /srv/immich/model-cache:/cache

Install notes:

1. pgvecto-rs: That’s a custom PostgreSQL build with vector extensions for ML search. Don’t use a standard PostgreSQL — it won’t work.
2. ML service: Handles facial recognition and embedding. Optional but recommended. Budget 1GB extra RAM.
3. Separate volumes: Keep /upload (photos) separate from /pgdata (DB). A DB crash shouldn’t touch your images.

Run docker-compose up -d, wait 2 minutes for DB init, then open http://your-ip:2283.

PhotoPrism

Difficulty: Easy (single container) Time: 15-20 minutes Resources: 1GB RAM minimum, 2 cores

PhotoPrism runs as a single container:

version: '3.8'
services:
  photoprism:
    image: photoprism/photoprism:latest
    container_name: photoprism
    volumes:
      - /srv/photoprism/photos:/photoprism/originals
      - /srv/photoprism/storage:/photoprism/storage
    environment:
      - PHOTOPRISM_UPLOAD_NSFW=false
      - PHOTOPRISM_ADMIN_PASSWORD=your-secure-password
      - PHOTOPRISM_SITE_URL=http://photoprism.yourdomain.com
    ports:
      - "2342:2342"

Install notes:

1. Two volumes: /originals (your photos) and /storage (cache, thumbnails, config). Don’t mix them.
2. No external DB: PhotoPrism uses SQLite by default. Switch to MariaDB if you have 100k+ photos.
3. NSFW filter: On by default. Disable it if you want everything indexed (beach vacations, etc.).

Run docker-compose up -d, wait 1 minute, open http://your-ip:2342.

Verdict: PhotoPrism wins. Simpler setup, fewer services, less config. For beginners, PhotoPrism is way more accessible.

Round 2: Import & Organization

Immich

Import methods:

1. Web upload: Drag-and-drop in the browser
2. Mobile app: Auto-upload in background (like Google Photos)
3. CLI: immich-cli upload /path/to/photos
4. API: For custom scripts

Organization: Immich uses a “smart albums” model: timeline view by default, manual albums, auto-generated albums (by location, event), shared albums with other users, and archived items hidden from the timeline.

The cool part: The mobile app auto-uploads in the background. Take a photo, and it’s on your server within minutes (if on WiFi). Just like Google Photos — but it’s your server.

PhotoPrism

Import methods:

1. Original folders: PhotoPrism scans a directory and indexes without moving files
2. Web upload: Via the browser interface
3. Import folder: A dedicated folder where you drop files, PhotoPrism processes and organizes them
4. Sync: Can sync with external folders (rsync, Dropbox, etc.)

Organization: PhotoPrism takes a more traditional approach: keeps your existing folder structure, manual albums, AI-generated labels (objects, scenes, locations), custom tags, and optional facial recognition.

The cool part: PhotoPrism DOESN’T MOVE your photos by default. It indexes from their current location. If you already have an organized library (/photos/2024/08-Italy-Vacation/), it respects that.

Verdict: Depends on your situation.

• Starting from scratch → Immich (simple upload, mobile auto-upload)
• Already have an organized library → PhotoPrism (indexes in place)

Round 3: Facial Recognition & Search

Immich

Facial recognition:

• Accuracy: ~90-95% (after training)
• Training: Automatic, runs in background
• Manual correction: Yes, assign and correct faces
• Privacy: Everything is local, no cloud

How it works:

1. Immich scans all photos
2. Detects faces (via ML model)
3. Clusters similar faces
4. You assign names to clusters
5. The AI learns and improves

My experience: On 50k photos, it found ~200 unique faces. I assigned the 20 main people in 30 minutes. After that, 95% of new photos are auto-tagged correctly.

Smart search: Immich uses CLIP (embedding model) for semantic search:

"beach sunset" → finds beach photos at sunset
"dog in snow" → finds dog + snow photos
"birthday cake" → finds birthday pics with cake

Accuracy: ~85%. Sometimes it struggles with complex queries.

PhotoPrism

Facial recognition:

• Accuracy: ~85-90% (slightly below Immich)
• Training: Manual (you must run “optimize” after upload)
• Manual correction: Yes, but the UI feels dated
• Privacy: Everything is local

How it works: PhotoPrism uses TensorFlow for face detection. Less automatic than Immich: upload photos, run “Index” + “Optimize” in the admin panel, then assign names manually. No continuous learning.

My experience: Similar detection to Immich, but worse clustering. I had to manually merge duplicate clusters (“Jane #1” and “Jane #2”).

Smart search: PhotoPrism searches by labels (objects, scenes, locations):

"beach" → finds photos labeled "beach"
"dog" → finds photos with a dog

Limitation: No semantic search. You need exact labels. “Coucher de soleil” won’t find photos labeled “sunset.”

Verdict: Immich wins. Better facial recognition accuracy, semantic search (CLIP), and continuous learning. PhotoPrism does the job but it’s less smooth.

Round 4: Mobile App & UX

Immich

Mobile app:

• Native: iOS and Android (real apps, not a PWA)
• Auto-upload: Yes, background, configurable (WiFi-only or cellular)
• UI: Google Photos clone (timeline, albums, sharing)
• Offline: Yes, local cache of viewed photos
• Performance: Very smooth, even with 50k+ photos

My experience: Immich’s app is honestly impressive. It does EXACTLY what Google Photos does: infinite scrollable timeline, album creation from selected photos, shared albums with comments, “Memories” (this day N years ago), and voice search.

Auto-upload works flawlessly. Take a photo, it’s synced within 30 seconds on WiFi.

One bug I hit: The app occasionally crashes on very long scrolls (>10k visible photos). Restart fixes it. The devs are on it.

PhotoPrism

Mobile app:

• PWA: Installable web app (not on app stores)
• Auto-upload: No (not native — needs a third-party tool)
• UI: Mobile-adapted but still web-based
• Offline: Limited (browser cache)
• Performance: Decent, but less smooth than Immich

My experience: The PhotoPrism PWA works. You can install it on your homescreen, and it looks like an app. But: no auto-upload, less smooth scrolling (web loading), no notifications (shares, new uploads), and very limited offline.

For browsing your library on mobile, it’s fine. For replacing Google Photos, it’s not enough.

Workaround: Some people use Syncthing + PhotoPrism. Syncthing syncs photos to the server, PhotoPrism indexes. But that’s an advanced setup.

Verdict: Immich wins (and it’s not close). The native app is in a different league. If you want to replace Google Photos with the same mobile UX, Immich is the only choice.

Round 5: Performance & Resources

Immich

Resources (50k photos):

• RAM: 2-3GB (server + ML)
• CPU: 4 cores recommended (ML is hungry)
• Storage: Photos + 20% (thumbnails + cache)
• DB size: ~5GB PostgreSQL for 50k photos

Performance:

• Initial index: ~2 hours for 50k photos (with ML)
• Search: <500ms (well-optimized indexes)
• Thumbnail gen: Fast (GPU helps but optional)

Gotchas:

1. ML service alone eats 1-2GB RAM. If you have less than 4GB total, disable it.
2. pgvecto-rs PostgreSQL is heavier than standard PostgreSQL.
3. Upgrades can be slow (DB migrations on large libraries).

PhotoPrism

Resources (50k photos):

• RAM: 1-2GB
• CPU: 2 cores are enough
• Storage: Photos + 30% (thumbnails + storage)
• DB size: ~2GB SQLite for 50k photos

Performance:

• Initial index: ~3 hours for 50k photos
• Search: <1s (well-indexed SQLite)
• Thumbnail gen: Decent (Go is fast)

Gotchas:

1. SQLite gets slow past 100k photos. Switch to MariaDB.
2. TensorFlow loads into RAM even when idle.
3. First load after index can be slow (cache rebuild).

Verdict: PhotoPrism wins on resources. Less RAM, fewer Docker services, easier to host on a small server. Immich is heavier but the ML features justify it.

Round 6: Advanced Features

Both do:

• ✅ Chronological timeline
• ✅ Manual albums
• ✅ Sharing (public links or with users)
• ✅ Search by date/location/camera
• ✅ Photo export
• ✅ Slideshow mode
• ✅ Favorites / Archive

Immich-only:

• ✅ Mobile auto-upload (background)
• ✅ Semantic search (“beach sunset” — it just works)
• ✅ Memories (“this day N years ago”)
• ✅ Shared albums with comments
• ✅ Links for external users (password-protected)
• ✅ Full API (scripts, integrations)
• ✅ Official CLI (upload/download from command line)

PhotoPrism-only:

• ✅ In-place indexing (keeps your folder structure)
• ✅ Sidecar XMP (metadata travels with your files)
• ✅ Auto-labels (objects, scenes, locations)
• ✅ Panoramic / RAW support (excellent RAW handling)
• ✅ Built-in editor (crop, rotate, basic adjustments)
• ✅ Map view (OpenStreetMap integration)
• ✅ Batch export (by album, date, or tag)

Verdict: Immich (by a hair). More “consumer” features (auto-upload, memories, search). PhotoPrism has more “pro” features (RAW, XMP, editor). Depends on your use case.

My Final Verdict

Pick Immich if:

• ✅ You want a 1:1 Google Photos replacement
• ✅ The mobile app is critical (auto-upload, notifications)
• ✅ You want facial recognition and smart search
• ✅ You’re okay following updates (occasional breaking changes)
• ✅ You have 4GB+ RAM on your server

Your profile: “I want the same UX as Google Photos but on my own hardware, and I’m fine with a fast-moving project.”

Pick PhotoPrism if:

• ✅ You already have an organized library (folders, tags)
• ✅ Stability comes first (no breaking changes, ever)
• ✅ You shoot in RAW and need solid support
• ✅ You prefer manual control over organization
• ✅ You’re on limited resources (2GB RAM server)

Your profile: “I’m a hobbyist photographer with 10 years of organized photos. I want a stable tool that respects my structure.”

What I actually did

I’m running both. Here’s why:

1. Immich is my daily driver — the mobile app is non-negotiable. I take 10-20 photos a week, and auto-upload in the background is a must.

2. Semantic search changed how I find photos — “find me the cat on the couch” actually works. PhotoPrism can’t do that.

3. My girlfriend uses Immich without asking me for help — that’s the real test. The UX is intuitive enough for non-tech people.

But: once a month, I export new photos from Immich and index them in PhotoPrism. Double backup, double organization. The two projects complement each other better than you’d think.

Things I Wish I Knew Before Starting

1. Immich eats RAM

The ML service runs constantly and takes 1-2GB. On my 8GB NUC, that was 25% of RAM just for Immich.

Solution: I disabled the ML service and switched to “lite” mode. Fewer facial features, but much lighter.

2. PhotoPrism doesn’t handle Live Photos well

iPhone Live Photos are poorly supported. The still gets indexed, the video part gets ignored.

Workaround: Convert Live Photos to JPEG + MOV before import. I wrote a simple Python script for this.

3. Backups are YOUR responsibility

Neither tool does automatic cloud backup. You need to script it.

My setup: Cron + rclone to Backblaze B2 (~$5/month for 500GB).

4. Migration between them is painful

No cross-export/import tool exists.

Method: Export from one → copy files → import to the other → re-tag manually. 3 hours of work.

5. Facial recognition takes time

On 50k photos, training takes 6-8 hours. The server struggles during that time.

Tip: Run training at night, not during production use.

What’s Next?

Both projects are excellent. You really can’t go wrong.

My advice: Test both for a week. Import 500 photos on each, use them daily. The one that makes you say “this feels right” — that’s your pick.

For me: Immich is my primary. PhotoPrism is my cold archive. Both run on the same NUC with separate docker-compose files.

Next on my list:

• Script the cross-backup (Immich → PhotoPrism weekly)
• Test Immich + Home Assistant integration (show photos on dashboard)
• Wait for the official Immich desktop app (in development)

Got questions about your specific setup? The Immich Discord is incredibly responsive. So is PhotoPrism’s. Drop in and ask — both communities are genuinely helpful.

Useful links:

• Immich GitHub — Docs and roadmap
• PhotoPrism GitHub — Official docs
• Immich Discord — Active community
• PhotoPrism Discord — Tech support
• r/selfhosted — Community experiences

Tested on NUC Intel i5-8259U / 16GB RAM / Ubuntu 22.04, 3 months with 50,000+ photos.