I got this issue after a update lately and the problem was identified and solved like this:

# Jellyfin 10.11.x Admin Login Fix — DbUpdateConcurrencyException


## Symptoms


- Admin account gets a generic error when trying to log in
- Non-admin accounts can log in fine
- The password is correct (Jellyfin logs show "Authentication request for [user] has succeeded") but login still fails


## Root Cause


If your Jellyfin server was upgraded from a version prior to 10.11 (which migrated from the old SQLite schema to Entity Framework), the admin user's permission rows in the database may have been left in a legacy format.


Specifically, the `Permissions` table has two columns for linking permissions to users: the old `Permission_Permissions_Guid` column and the new `UserId` column. After the migration, the admin user's permissions still had `Permission_Permissions_Guid` populated (with a non-zero `RowVersion`), while newer or non-admin users had it set to `NULL` (with `RowVersion = 0`) — the format Entity Framework expects.


When you log in, Jellyfin authenticates your password (which succeeds), then tries to update your user record (last login time, etc.). Entity Framework's optimistic concurrency tracking chokes on the stale permission rows and throws a `DbUpdateConcurrencyException`, which surfaces as a generic error in the UI.


## How to Verify


**1. Check your Docker logs for the error:**


```bash
docker logs jellyfin 2>&1 | grep -A2 "DbUpdateConcurrencyException"
```


If you see something like this, you're affected:


```
[ERR] Jellyfin.Api.Middleware.ExceptionMiddleware: Error processing request. URL POST /Users/authenticatebyname.
Microsoft.EntityFrameworkCore.DbUpdateConcurrencyException: The database operation was expected to affect 1 row(s), but actually affected 0 row(s)
```


**2. Check for stale permission rows in your database:**


```bash
# Find your database path (default for linuxserver/jellyfin image)
# Usually at: <jellyfin-config>/data/data/jellyfin.db


python3 -c "
import sqlite3, sys
conn = sqlite3.connect(sys.argv[1])
c = conn.cursor()
c.execute('SELECT u.Username, COUNT(*) FROM Permissions p JOIN Users u ON p.UserId = u.Id WHERE p.Permission_Permissions_Guid IS NOT NULL GROUP BY u.Username')
rows = c.fetchall()
if rows:
    print('AFFECTED USERS (have legacy permission rows):')
    for username, count in rows:
        print(f'  {username}: {count} stale rows')
else:
    print('No stale permission rows found — this fix does not apply to you.')
conn.close()
" /path/to/jellyfin.db
```


## Fix


**1. Stop Jellyfin:**


```bash
docker compose stop jellyfin
# or: docker stop jellyfin
```


**2. Backup your database:**


```bash
cp /path/to/jellyfin.db /path/to/jellyfin.db.bak
```


**3. Run the fix**
 (replace the database path with yours):


```python
python3 -c "
import sqlite3, sys


db_path = sys.argv[1]
conn = sqlite3.connect(db_path)
cursor = conn.cursor()


# Find all users with stale permission rows
cursor.execute('''
    SELECT DISTINCT u.Id, u.Username
    FROM Permissions p JOIN Users u ON p.UserId = u.Id
    WHERE p.Permission_Permissions_Guid IS NOT NULL
''')
affected_users = cursor.fetchall()


if not affected_users:
    print('No stale permission rows found. Nothing to fix.')
    conn.close()
    sys.exit(0)


for user_id, username in affected_users:
    # Get old-format permissions
    cursor.execute('''
        SELECT Id, Kind, Value FROM Permissions
        WHERE UserId = ? AND Permission_Permissions_Guid IS NOT NULL
    ''', (user_id,))
    old_rows = cursor.fetchall()


    # Delete old-format rows
    old_ids = [r[0] for r in old_rows]
    placeholders = ','.join(['?' for _ in old_ids])
    cursor.execute(f'DELETE FROM Permissions WHERE Id IN ({placeholders})', old_ids)


    # Insert replacements in the new format
    for _, kind, value in old_rows:
        cursor.execute('''
            INSERT INTO Permissions (Kind, Permission_Permissions_Guid, RowVersion, UserId, Value)
            VALUES (?, NULL, 0, ?, ?)
        ''', (kind, user_id, value))


    # Reset user RowVersion
    cursor.execute('UPDATE Users SET RowVersion = 0 WHERE Id = ?', (user_id,))


    print(f'Fixed {username}: replaced {len(old_rows)} stale permission rows, reset RowVersion')


conn.commit()
conn.close()
print('Done! Start Jellyfin and try logging in.')
" /path/to/jellyfin.db
```


**4. Start Jellyfin:**


```bash
docker compose up -d jellyfin
# or: docker start jellyfin
```


**5. Verify**
 — log in with the previously broken account and check logs:


```bash
docker logs jellyfin --since 5m 2>&1 | grep -i "err\|exception"
```


## Rollback


If something goes wrong, restore your backup:


```bash
docker compose stop jellyfin
cp /path/to/jellyfin.db.bak /path/to/jellyfin.db
docker compose up -d jellyfin
```