From 970f87c8d4bc7fd99dd986ffb0b489898193eb1e Mon Sep 17 00:00:00 2001
From: Florian <52180080+florianjs@users.noreply.github.com>
Date: Thu, 8 Jan 2026 11:41:09 +0100
Subject: [PATCH] Release v0.5.0 - Feature improvements and bug fixes

---
 app/components/admin/Categories.vue           | 127 ++++-
 app/components/admin/TorznabBlacklist.vue     | 190 +++++++
 app/components/admin/TorznabConfig.vue        | 167 +++++++
 app/components/admin/TorznabLogTable.vue      | 166 +++++++
 app/components/admin/TorznabLogs.vue          |  98 ++++
 app/components/admin/TorznabRateLimiting.vue  | 234 +++++++++
 app/components/admin/TorznabStats.vue         | 152 ++++++
 app/components/admin/TorznabUsers.vue         | 411 +++++++++++++++
 app/pages/admin.vue                           |   6 +
 app/pages/admin/torznab.vue                   |  73 +++
 doc/.vitepress/config.ts                      |   7 +
 doc/guide/roadmap.md                          |   1 +
 doc/integrations/torznab.md                   | 289 +++++++++++
 package.json                                  |   2 +-
 scripts/install.sh                            |  29 +-
 scripts/seed-categories.ts                    | 139 +++++-
 scripts/setup-local-prod.sh                   |  21 +
 server/api/admin/categories/[id].put.ts       |  20 +-
 server/api/admin/categories/index.post.ts     |   1 +
 server/api/admin/categories/seed.post.ts      | 137 +++++
 server/api/admin/debug/redis-all-peers.get.ts |   2 +-
 server/api/admin/debug/tracker-status.get.ts  |   2 +-
 server/api/admin/stats.get.ts                 |   2 +-
 server/api/admin/stats/history.get.ts         |  86 +++-
 server/api/admin/torznab/blacklist.get.ts     |  85 ++++
 server/api/admin/torznab/index.get.ts         |  49 ++
 server/api/admin/torznab/index.put.ts         |  68 +++
 server/api/admin/torznab/logs.get.ts          |  33 ++
 server/api/admin/torznab/stats.get.ts         |  30 ++
 server/api/admin/torznab/unblock.post.ts      |  66 +++
 server/api/admin/torznab/users.get.ts         |  62 +++
 .../admin/torznab/users/[id]/block.post.ts    |  73 +++
 .../admin/torznab/users/[id]/reset.post.ts    |  57 +++
 server/api/torznab/download.get.ts            | 183 +++++++
 server/api/torznab/index.get.ts               | 340 +++++++++++++
 server/api/torznab/utils/auth.ts              | 105 ++++
 server/api/torznab/utils/categories.ts        | 242 +++++++++
 server/api/torznab/utils/xml.ts               | 175 +++++++
 .../db/migrations/0010_torznab_categories.sql |   2 +
 server/db/schema.ts                           |   1 +
 server/plugins/stats-collector.ts             |  16 +-
 server/utils/auth.ts                          |   9 +
 server/utils/schemas.ts                       |  14 +-
 server/utils/torznabSettings.ts               | 146 ++++++
 server/utils/torznabStats.ts                  | 467 ++++++++++++++++++
 45 files changed, 4539 insertions(+), 46 deletions(-)
 create mode 100644 app/components/admin/TorznabBlacklist.vue
 create mode 100644 app/components/admin/TorznabConfig.vue
 create mode 100644 app/components/admin/TorznabLogTable.vue
 create mode 100644 app/components/admin/TorznabLogs.vue
 create mode 100644 app/components/admin/TorznabRateLimiting.vue
 create mode 100644 app/components/admin/TorznabStats.vue
 create mode 100644 app/components/admin/TorznabUsers.vue
 create mode 100644 app/pages/admin/torznab.vue
 create mode 100644 doc/integrations/torznab.md
 create mode 100644 server/api/admin/categories/seed.post.ts
 create mode 100644 server/api/admin/torznab/blacklist.get.ts
 create mode 100644 server/api/admin/torznab/index.get.ts
 create mode 100644 server/api/admin/torznab/index.put.ts
 create mode 100644 server/api/admin/torznab/logs.get.ts
 create mode 100644 server/api/admin/torznab/stats.get.ts
 create mode 100644 server/api/admin/torznab/unblock.post.ts
 create mode 100644 server/api/admin/torznab/users.get.ts
 create mode 100644 server/api/admin/torznab/users/[id]/block.post.ts
 create mode 100644 server/api/admin/torznab/users/[id]/reset.post.ts
 create mode 100644 server/api/torznab/download.get.ts
 create mode 100644 server/api/torznab/index.get.ts
 create mode 100644 server/api/torznab/utils/auth.ts
 create mode 100644 server/api/torznab/utils/categories.ts
 create mode 100644 server/api/torznab/utils/xml.ts
 create mode 100644 server/db/migrations/0010_torznab_categories.sql
 create mode 100644 server/utils/torznabSettings.ts
 create mode 100644 server/utils/torznabStats.ts

diff --git a/app/components/admin/Categories.vue b/app/components/admin/Categories.vue
index aee15e5..d4efa1b 100644
--- a/app/components/admin/Categories.vue
+++ b/app/components/admin/Categories.vue
@@ -37,6 +37,15 @@
           class="input flex-1 !py-2 text-xs font-bold uppercase tracking-wider"
           @keyup.enter="addCategory"
         />
+        <input
+          v-model.number="newCategoryNewznabId"
+          type="number"
+          placeholder="Newznab ID"
+          min="1000"
+          max="9999"
+          class="input w-28 !py-2 text-xs font-bold tracking-wider"
+          title="Newznab/Torznab category ID (e.g., 2040 for Movies/HD)"
+        />
         <button
           class="btn btn-primary !px-6 flex items-center gap-2 uppercase tracking-widest font-bold text-xs"
           :disabled="!newCategoryName.trim() || isAdding"
@@ -54,10 +63,23 @@
       >
         <Icon name="ph:tag-slash" class="text-3xl text-text-muted mb-2" />
         <p
-          class="text-[10px] font-bold text-text-muted uppercase tracking-widest"
+          class="text-[10px] font-bold text-text-muted uppercase tracking-widest mb-4"
         >
           No categories defined
         </p>
+        <button
+          class="btn btn-primary !px-4 !py-2 text-xs font-bold uppercase tracking-wider"
+          :disabled="isSeeding"
+          @click="seedCategories"
+        >
+          <Icon
+            v-if="isSeeding"
+            name="ph:circle-notch"
+            class="animate-spin mr-2"
+          />
+          <Icon v-else name="ph:plant" class="mr-2" />
+          Seed Torznab Categories
+        </button>
       </div>
       <div v-else class="space-y-3">
         <!-- Root Categories -->
@@ -93,20 +115,36 @@
               </div>
               <div class="flex-1">
                 <!-- Edit Mode -->
-                <div v-if="editingId === category.id" class="flex items-center gap-2">
+                <div
+                  v-if="editingId === category.id"
+                  class="flex items-center gap-2"
+                >
                   <input
                     v-model="editingName"
                     type="text"
-                    class="input !py-1 !px-2 text-xs font-bold uppercase tracking-wider w-48"
+                    class="input !py-1 !px-2 text-xs font-bold uppercase tracking-wider w-40"
                     @keyup.enter="saveEdit(category.id)"
                     @keyup.escape="cancelEdit"
                   />
+                  <input
+                    v-model.number="editingNewznabId"
+                    type="number"
+                    placeholder="NZ ID"
+                    min="1000"
+                    max="9999"
+                    class="input !py-1 !px-2 text-xs font-bold tracking-wider w-20"
+                    title="Newznab/Torznab category ID"
+                  />
                   <button
                     class="p-1 text-success hover:bg-success/10 rounded transition-colors"
                     :disabled="isSaving"
                     @click="saveEdit(category.id)"
                   >
-                    <Icon v-if="isSaving" name="ph:circle-notch" class="animate-spin" />
+                    <Icon
+                      v-if="isSaving"
+                      name="ph:circle-notch"
+                      class="animate-spin"
+                    />
                     <Icon v-else name="ph:check-bold" />
                   </button>
                   <button
@@ -122,6 +160,12 @@
                     class="text-xs font-bold text-text-primary uppercase tracking-wider"
                   >
                     {{ category.name }}
+                    <span
+                      v-if="category.newznabId"
+                      class="text-text-muted font-mono text-[10px] ml-2"
+                    >
+                      [{{ category.newznabId }}]
+                    </span>
                   </p>
                   <p class="text-[10px] font-mono text-text-muted">
                     {{ category.slug }}
@@ -135,7 +179,10 @@
                 </template>
               </div>
             </div>
-            <div v-if="editingId !== category.id" class="flex items-center gap-1 opacity-0 group-hover:opacity-100">
+            <div
+              v-if="editingId !== category.id"
+              class="flex items-center gap-1 opacity-0 group-hover:opacity-100"
+            >
               <button
                 class="p-2 text-text-muted hover:text-text-primary transition-colors rounded hover:bg-bg-tertiary"
                 @click="startEdit(category)"
@@ -172,20 +219,36 @@
                 </div>
                 <div class="flex-1">
                   <!-- Edit Mode for Subcategory -->
-                  <div v-if="editingId === subcategory.id" class="flex items-center gap-2">
+                  <div
+                    v-if="editingId === subcategory.id"
+                    class="flex items-center gap-2"
+                  >
                     <input
                       v-model="editingName"
                       type="text"
-                      class="input !py-1 !px-2 text-xs font-bold uppercase tracking-wider w-48"
+                      class="input !py-1 !px-2 text-xs font-bold uppercase tracking-wider w-40"
                       @keyup.enter="saveEdit(subcategory.id)"
                       @keyup.escape="cancelEdit"
                     />
+                    <input
+                      v-model.number="editingNewznabId"
+                      type="number"
+                      placeholder="NZ ID"
+                      min="1000"
+                      max="9999"
+                      class="input !py-1 !px-2 text-xs font-bold tracking-wider w-20"
+                      title="Newznab/Torznab category ID"
+                    />
                     <button
                       class="p-1 text-success hover:bg-success/10 rounded transition-colors"
                       :disabled="isSaving"
                       @click="saveEdit(subcategory.id)"
                     >
-                      <Icon v-if="isSaving" name="ph:circle-notch" class="animate-spin" />
+                      <Icon
+                        v-if="isSaving"
+                        name="ph:circle-notch"
+                        class="animate-spin"
+                      />
                       <Icon v-else name="ph:check-bold" />
                     </button>
                     <button
@@ -201,6 +264,12 @@
                       class="text-xs font-bold text-text-primary uppercase tracking-wider"
                     >
                       {{ subcategory.name }}
+                      <span
+                        v-if="subcategory.newznabId"
+                        class="text-text-muted font-mono text-[10px] ml-2"
+                      >
+                        [{{ subcategory.newznabId }}]
+                      </span>
                     </p>
                     <p class="text-[10px] font-mono text-text-muted">
                       {{ subcategory.slug }}
@@ -208,7 +277,10 @@
                   </template>
                 </div>
               </div>
-              <div v-if="editingId !== subcategory.id" class="flex items-center gap-1 opacity-0 group-hover:opacity-100">
+              <div
+                v-if="editingId !== subcategory.id"
+                class="flex items-center gap-1 opacity-0 group-hover:opacity-100"
+              >
                 <button
                   class="p-2 text-text-muted hover:text-text-primary transition-colors rounded hover:bg-bg-tertiary"
                   @click="startEdit(subcategory)"
@@ -236,6 +308,7 @@ interface Subcategory {
   name: string;
   slug: string;
   parentId: string | null;
+  newznabId: number | null;
   createdAt: string;
 }
 
@@ -244,6 +317,7 @@ interface Category {
   name: string;
   slug: string;
   parentId: string | null;
+  newznabId: number | null;
   createdAt: string;
   subcategories?: Subcategory[];
 }
@@ -252,11 +326,13 @@ const { data: categories, refresh } =
   await useFetch<Category[]>('/api/categories');
 
 const newCategoryName = ref('');
+const newCategoryNewznabId = ref<number | null>(null);
 const parentCategoryId = ref<string | null>(null);
 const isAdding = ref(false);
 const expandedCategories = ref(new Set<string>());
 const editingId = ref<string | null>(null);
 const editingName = ref('');
+const editingNewznabId = ref<number | null>(null);
 const isSaving = ref(false);
 
 function toggleCategory(id: string) {
@@ -270,11 +346,13 @@ function toggleCategory(id: string) {
 function startEdit(category: Category | Subcategory) {
   editingId.value = category.id;
   editingName.value = category.name;
+  editingNewznabId.value = category.newznabId;
 }
 
 function cancelEdit() {
   editingId.value = null;
   editingName.value = '';
+  editingNewznabId.value = null;
 }
 
 async function saveEdit(id: string) {
@@ -286,10 +364,12 @@ async function saveEdit(id: string) {
       method: 'PUT',
       body: {
         name: editingName.value.trim(),
+        newznabId: editingNewznabId.value,
       },
     });
     editingId.value = null;
     editingName.value = '';
+    editingNewznabId.value = null;
     await refresh();
   } catch (error: any) {
     alert(error.data?.message || 'Failed to update category');
@@ -308,9 +388,11 @@ async function addCategory() {
       body: {
         name: newCategoryName.value.trim(),
         parentId: parentCategoryId.value,
+        newznabId: newCategoryNewznabId.value,
       },
     });
     newCategoryName.value = '';
+    newCategoryNewznabId.value = null;
 
     // Expand parent if adding subcategory
     if (parentCategoryId.value) {
@@ -337,4 +419,31 @@ async function deleteCategory(id: string) {
     alert(error.data?.message || 'Failed to delete category');
   }
 }
+
+const isSeeding = ref(false);
+
+async function seedCategories() {
+  if (
+    !confirm(
+      'This will create recommended Torznab-compatible categories. Continue?'
+    )
+  )
+    return;
+
+  isSeeding.value = true;
+  try {
+    const result = await (globalThis as any).$fetch(
+      '/api/admin/categories/seed',
+      {
+        method: 'POST',
+      }
+    );
+    await refresh();
+    alert(`Created ${result.created} categories`);
+  } catch (error: any) {
+    alert(error.data?.message || 'Failed to seed categories');
+  } finally {
+    isSeeding.value = false;
+  }
+}
 </script>
diff --git a/app/components/admin/TorznabBlacklist.vue b/app/components/admin/TorznabBlacklist.vue
new file mode 100644
index 0000000..7ee3859
--- /dev/null
+++ b/app/components/admin/TorznabBlacklist.vue
@@ -0,0 +1,190 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center justify-between">
+        <div class="flex items-center gap-2">
+          <Icon name="ph:prohibit" class="text-text-muted" />
+          <h3
+            class="text-xs font-bold uppercase tracking-wider text-text-primary"
+          >
+            Blocked IPs & Users
+          </h3>
+        </div>
+        <button
+          @click="() => refresh()"
+          :disabled="loading"
+          class="p-1.5 bg-bg-tertiary border border-border rounded hover:border-white/20 transition-colors"
+          title="Refresh"
+        >
+          <Icon
+            name="ph:arrows-clockwise"
+            :class="['text-text-muted text-sm', loading && 'animate-spin']"
+          />
+        </button>
+      </div>
+    </div>
+    <div class="card-body">
+      <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        <!-- IP Blacklist -->
+        <div>
+          <h4
+            class="text-[10px] font-bold uppercase tracking-widest text-text-muted mb-3"
+          >
+            Rate Limited IPs
+          </h4>
+          <div v-if="loading" class="space-y-2">
+            <div
+              v-for="i in 3"
+              :key="i"
+              class="h-10 bg-bg-tertiary rounded animate-pulse"
+            ></div>
+          </div>
+          <div
+            v-else-if="data?.ipBlacklist.length === 0"
+            class="text-sm text-text-muted py-4 text-center bg-bg-tertiary rounded-lg"
+          >
+            No IPs currently blocked
+          </div>
+          <div v-else class="space-y-2">
+            <div
+              v-for="entry in data?.ipBlacklist"
+              :key="entry.ip"
+              class="flex items-center justify-between p-3 bg-bg-tertiary border border-border rounded-lg"
+            >
+              <div>
+                <code class="text-xs font-mono text-text-primary">{{
+                  entry.ip
+                }}</code>
+                <p class="text-[10px] text-text-muted mt-0.5">
+                  {{ entry.reason }}
+                </p>
+              </div>
+              <div class="text-right">
+                <span class="text-[10px] text-text-muted">Expires in</span>
+                <p class="text-xs font-mono text-yellow-400">
+                  {{ formatTimeRemaining(entry.expiresAt) }}
+                </p>
+              </div>
+            </div>
+          </div>
+        </div>
+
+        <!-- Blocked Users -->
+        <div>
+          <h4
+            class="text-[10px] font-bold uppercase tracking-widest text-text-muted mb-3"
+          >
+            Blocked API Users
+          </h4>
+          <div v-if="loading" class="space-y-2">
+            <div
+              v-for="i in 3"
+              :key="i"
+              class="h-10 bg-bg-tertiary rounded animate-pulse"
+            ></div>
+          </div>
+          <div
+            v-else-if="data?.blockedUsers.length === 0"
+            class="text-sm text-text-muted py-4 text-center bg-bg-tertiary rounded-lg"
+          >
+            No users currently blocked
+          </div>
+          <div v-else class="space-y-2">
+            <div
+              v-for="user in data?.blockedUsers"
+              :key="user.blockId"
+              class="flex items-center justify-between p-3 bg-bg-tertiary border border-border rounded-lg"
+            >
+              <div>
+                <code class="text-xs font-mono text-text-primary">{{
+                  user.passkey
+                }}</code>
+                <p class="text-[10px] text-text-muted mt-0.5">
+                  {{ user.reason }}
+                </p>
+              </div>
+              <div class="flex items-center gap-2">
+                <span class="text-[10px] text-text-muted">
+                  {{ formatRelativeTime(user.blockedAt) }}
+                </span>
+                <button
+                  @click="unblockUser(user.blockId)"
+                  :disabled="unblocking === user.blockId"
+                  class="px-2 py-1 bg-bg-secondary border border-border rounded text-[10px] hover:border-white/20 transition-colors disabled:opacity-50"
+                >
+                  {{
+                    unblocking === user.blockId ? 'Unblocking...' : 'Unblock'
+                  }}
+                </button>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface BlacklistEntry {
+  ip: string;
+  reason: string;
+  expiresAt: number;
+  violations: number;
+}
+
+interface BlockedUser {
+  blockId: string;
+  passkey: string;
+  reason: string;
+  blockedAt: number;
+}
+
+interface BlacklistData {
+  ipBlacklist: BlacklistEntry[];
+  blockedUsers: BlockedUser[];
+}
+
+const {
+  data,
+  pending: loading,
+  refresh,
+} = await useFetch<BlacklistData>('/api/admin/torznab/blacklist');
+
+const unblocking = ref<string | null>(null);
+
+async function unblockUser(blockId: string) {
+  unblocking.value = blockId;
+  try {
+    await fetch('/api/admin/torznab/unblock', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ blockId }),
+    });
+    await refresh();
+  } catch (error) {
+    console.error('Failed to unblock user:', error);
+  } finally {
+    unblocking.value = null;
+  }
+}
+
+function formatTimeRemaining(expiresAt: number): string {
+  const remaining = expiresAt - Date.now();
+  if (remaining < 0) return 'Expired';
+
+  const seconds = Math.floor(remaining / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+
+function formatRelativeTime(timestamp: number): string {
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+  if (seconds < 60) return 'Just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+</script>
diff --git a/app/components/admin/TorznabConfig.vue b/app/components/admin/TorznabConfig.vue
new file mode 100644
index 0000000..c1e0c32
--- /dev/null
+++ b/app/components/admin/TorznabConfig.vue
@@ -0,0 +1,167 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center justify-between">
+        <div class="flex items-center gap-2">
+          <Icon name="ph:gear" class="text-text-muted" />
+          <h3
+            class="text-xs font-bold uppercase tracking-wider text-text-primary"
+          >
+            API Configuration
+          </h3>
+        </div>
+        <div class="flex items-center gap-2">
+          <span
+            class="px-2 py-1 rounded text-[10px] font-bold uppercase"
+            :class="
+              config?.enabled
+                ? 'bg-success/20 text-success'
+                : 'bg-red-500/20 text-red-400'
+            "
+          >
+            {{ config?.enabled ? 'Enabled' : 'Disabled' }}
+          </span>
+        </div>
+      </div>
+    </div>
+    <div class="card-body space-y-6">
+      <!-- API Status Toggle -->
+      <SettingsGroup
+        label="Torznab API Status"
+        description="Enable or disable the Torznab API for all users. When disabled, *arr apps won't be able to connect."
+      >
+        <div class="flex items-center gap-3">
+          <button
+            @click="toggleEnabled"
+            :disabled="saving"
+            class="relative inline-flex h-6 w-11 items-center rounded-full transition-colors"
+            :class="
+              config?.enabled
+                ? 'bg-success'
+                : 'bg-bg-tertiary border border-border'
+            "
+          >
+            <span
+              class="inline-block h-4 w-4 transform rounded-full bg-white transition-transform"
+              :class="config?.enabled ? 'translate-x-6' : 'translate-x-1'"
+            />
+          </button>
+          <span class="text-sm text-text-muted">
+            {{
+              config?.enabled ? 'API is accepting requests' : 'API is disabled'
+            }}
+          </span>
+        </div>
+      </SettingsGroup>
+
+      <!-- Request Logging -->
+      <SettingsGroup
+        label="Request Logging"
+        description="Log all API requests for debugging and monitoring. Logs are stored for 7 days."
+      >
+        <div class="flex items-center gap-3">
+          <button
+            @click="toggleLogging"
+            :disabled="saving"
+            class="relative inline-flex h-6 w-11 items-center rounded-full transition-colors"
+            :class="
+              config?.enableLogging
+                ? 'bg-success'
+                : 'bg-bg-tertiary border border-border'
+            "
+          >
+            <span
+              class="inline-block h-4 w-4 transform rounded-full bg-white transition-transform"
+              :class="config?.enableLogging ? 'translate-x-6' : 'translate-x-1'"
+            />
+          </button>
+          <span class="text-sm text-text-muted">
+            {{ config?.enableLogging ? 'Logging enabled' : 'Logging disabled' }}
+          </span>
+        </div>
+      </SettingsGroup>
+
+      <!-- API URL Info -->
+      <SettingsGroup
+        label="API Endpoint"
+        description="The base URL for the Torznab API. Users add this in Prowlarr/Sonarr/Radarr."
+      >
+        <div class="flex items-center gap-2">
+          <input
+            :value="apiUrl"
+            readonly
+            class="flex-1 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm font-mono text-text-primary"
+          />
+          <button
+            @click="copyUrl"
+            class="p-2 bg-bg-tertiary border border-border rounded hover:border-white/20 transition-colors"
+            title="Copy URL"
+          >
+            <Icon
+              :name="copied ? 'ph:check' : 'ph:copy'"
+              class="text-text-muted"
+            />
+          </button>
+        </div>
+      </SettingsGroup>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface TorznabConfig {
+  enabled: boolean;
+  rateLimitSearch: number;
+  rateLimitDownload: number;
+  rateLimitWindow: number;
+  enableLogging: boolean;
+  allowedCategories: string[];
+}
+
+const props = defineProps<{
+  config?: TorznabConfig;
+  loading?: boolean;
+}>();
+
+const emit = defineEmits<{
+  update: [updates: Partial<TorznabConfig>];
+}>();
+
+const saving = ref(false);
+const copied = ref(false);
+
+const apiUrl = computed(() => {
+  if (import.meta.client) {
+    return `${window.location.origin}/api/torznab`;
+  }
+  return '/api/torznab';
+});
+
+async function toggleEnabled() {
+  saving.value = true;
+  try {
+    emit('update', { enabled: !props.config?.enabled });
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function toggleLogging() {
+  saving.value = true;
+  try {
+    emit('update', { enableLogging: !props.config?.enableLogging });
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function copyUrl() {
+  try {
+    await navigator.clipboard.writeText(apiUrl.value);
+    copied.value = true;
+    setTimeout(() => (copied.value = false), 2000);
+  } catch (error) {
+    console.error('Failed to copy URL:', error);
+  }
+}
+</script>
diff --git a/app/components/admin/TorznabLogTable.vue b/app/components/admin/TorznabLogTable.vue
new file mode 100644
index 0000000..c21ae03
--- /dev/null
+++ b/app/components/admin/TorznabLogTable.vue
@@ -0,0 +1,166 @@
+<template>
+  <div class="overflow-x-auto">
+    <table class="w-full">
+      <thead v-if="!compact">
+        <tr class="border-b border-border">
+          <th
+            class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            Time
+          </th>
+          <th
+            class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            User
+          </th>
+          <th
+            class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            Function
+          </th>
+          <th
+            class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            Query
+          </th>
+          <th
+            class="text-center text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            Results
+          </th>
+          <th
+            class="text-right text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+          >
+            Time
+          </th>
+        </tr>
+      </thead>
+      <tbody>
+        <tr
+          v-if="loading"
+          v-for="i in 5"
+          :key="i"
+          class="border-b border-border/50"
+        >
+          <td colspan="6" class="py-2 px-2">
+            <div class="h-4 bg-bg-tertiary rounded animate-pulse"></div>
+          </td>
+        </tr>
+        <tr
+          v-else
+          v-for="(log, index) in logs"
+          :key="index"
+          class="border-b border-border/50"
+          :class="log.error && 'bg-red-500/5'"
+        >
+          <td class="py-2 px-2">
+            <span class="text-xs text-text-muted font-mono">
+              {{ formatTime(log.timestamp) }}
+            </span>
+          </td>
+          <td class="py-2 px-2">
+            <code
+              class="text-[10px] font-mono text-text-muted bg-bg-tertiary px-1 py-0.5 rounded"
+            >
+              {{ log.passkey }}
+            </code>
+          </td>
+          <td class="py-2 px-2">
+            <span
+              class="px-1.5 py-0.5 rounded text-[10px] font-medium"
+              :class="getFunctionClass(log.function)"
+            >
+              {{ log.function }}
+            </span>
+          </td>
+          <td class="py-2 px-2 max-w-[200px]">
+            <span
+              class="text-xs text-text-primary truncate block"
+              :title="log.query"
+            >
+              {{ log.query || '—' }}
+            </span>
+          </td>
+          <td class="py-2 px-2 text-center">
+            <span
+              v-if="log.error"
+              class="text-xs text-red-400"
+              :title="log.error"
+            >
+              Error
+            </span>
+            <span v-else class="text-xs text-text-muted">
+              {{ log.resultCount }}
+            </span>
+          </td>
+          <td class="py-2 px-2 text-right">
+            <span
+              class="text-xs font-mono"
+              :class="getResponseTimeClass(log.responseTime)"
+            >
+              {{ log.responseTime }}ms
+            </span>
+          </td>
+        </tr>
+        <tr v-if="!loading && (!logs || logs.length === 0)">
+          <td colspan="6" class="py-8 text-center text-text-muted text-sm">
+            No logs available
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface LogEntry {
+  timestamp: number;
+  passkey: string;
+  function: string;
+  query?: string;
+  ip: string;
+  userAgent?: string;
+  responseTime: number;
+  resultCount: number;
+  error?: string;
+}
+
+defineProps<{
+  logs?: LogEntry[];
+  loading?: boolean;
+  compact?: boolean;
+}>();
+
+function formatTime(timestamp: number): string {
+  const date = new Date(timestamp);
+  return date.toLocaleTimeString('en-US', {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+  });
+}
+
+function getFunctionClass(func: string): string {
+  switch (func) {
+    case 'search':
+      return 'bg-blue-500/20 text-blue-400';
+    case 'tvsearch':
+      return 'bg-purple-500/20 text-purple-400';
+    case 'movie':
+      return 'bg-pink-500/20 text-pink-400';
+    case 'caps':
+      return 'bg-gray-500/20 text-gray-400';
+    case 'download':
+      return 'bg-green-500/20 text-green-400';
+    default:
+      return 'bg-gray-500/20 text-gray-400';
+  }
+}
+
+function getResponseTimeClass(time: number): string {
+  if (time < 100) return 'text-success';
+  if (time < 500) return 'text-yellow-400';
+  return 'text-red-400';
+}
+</script>
diff --git a/app/components/admin/TorznabLogs.vue b/app/components/admin/TorznabLogs.vue
new file mode 100644
index 0000000..c066506
--- /dev/null
+++ b/app/components/admin/TorznabLogs.vue
@@ -0,0 +1,98 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center justify-between">
+        <div class="flex items-center gap-2">
+          <Icon name="ph:list" class="text-text-muted" />
+          <h3
+            class="text-xs font-bold uppercase tracking-wider text-text-primary"
+          >
+            Recent Requests
+          </h3>
+        </div>
+        <div class="flex items-center gap-2">
+          <span class="text-[10px] text-text-muted">
+            {{ data?.total || 0 }} total requests
+          </span>
+          <button
+            @click="() => refresh()"
+            :disabled="loading"
+            class="p-1.5 bg-bg-tertiary border border-border rounded hover:border-white/20 transition-colors"
+            title="Refresh"
+          >
+            <Icon
+              name="ph:arrows-clockwise"
+              :class="['text-text-muted text-sm', loading && 'animate-spin']"
+            />
+          </button>
+        </div>
+      </div>
+    </div>
+    <div class="card-body">
+      <AdminTorznabLogTable :logs="data?.logs" :loading="loading" />
+
+      <!-- Pagination -->
+      <div
+        v-if="data?.total && data.total > limit"
+        class="flex items-center justify-between mt-4 pt-4 border-t border-border"
+      >
+        <span class="text-xs text-text-muted">
+          Showing {{ offset + 1 }} -
+          {{ Math.min(offset + limit, data.total) }} of {{ data.total }}
+        </span>
+        <div class="flex items-center gap-2">
+          <button
+            @click="prevPage"
+            :disabled="offset === 0"
+            class="px-3 py-1 bg-bg-tertiary border border-border rounded text-xs disabled:opacity-50 hover:border-white/20 transition-colors"
+          >
+            Previous
+          </button>
+          <button
+            @click="nextPage"
+            :disabled="offset + limit >= data.total"
+            class="px-3 py-1 bg-bg-tertiary border border-border rounded text-xs disabled:opacity-50 hover:border-white/20 transition-colors"
+          >
+            Next
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface LogEntry {
+  timestamp: number;
+  passkey: string;
+  function: string;
+  query?: string;
+  ip: string;
+  userAgent?: string;
+  responseTime: number;
+  resultCount: number;
+  error?: string;
+}
+
+const limit = 50;
+const offset = ref(0);
+
+const {
+  data,
+  pending: loading,
+  refresh,
+} = await useFetch<{
+  logs: LogEntry[];
+  total: number;
+}>('/api/admin/torznab/logs', {
+  query: computed(() => ({ limit, offset: offset.value })),
+});
+
+function prevPage() {
+  offset.value = Math.max(0, offset.value - limit);
+}
+
+function nextPage() {
+  offset.value += limit;
+}
+</script>
diff --git a/app/components/admin/TorznabRateLimiting.vue b/app/components/admin/TorznabRateLimiting.vue
new file mode 100644
index 0000000..984a289
--- /dev/null
+++ b/app/components/admin/TorznabRateLimiting.vue
@@ -0,0 +1,234 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center gap-2">
+        <Icon name="ph:gauge" class="text-text-muted" />
+        <h3
+          class="text-xs font-bold uppercase tracking-wider text-text-primary"
+        >
+          Rate Limiting
+        </h3>
+      </div>
+    </div>
+    <div class="card-body space-y-6">
+      <p class="text-xs text-text-muted">
+        Configure rate limits to prevent API abuse. These limits apply per user
+        (passkey) within the specified time window.
+      </p>
+
+      <!-- Time Window -->
+      <SettingsGroup
+        label="Time Window"
+        description="The duration (in seconds) for rate limit calculations."
+      >
+        <div class="flex items-center gap-3">
+          <input
+            v-model.number="localWindow"
+            type="number"
+            min="10"
+            max="3600"
+            class="w-24 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm text-text-primary focus:outline-none focus:border-white/20"
+          />
+          <span class="text-sm text-text-muted">seconds</span>
+          <div class="flex-1" />
+          <span class="text-[10px] text-text-muted font-mono">
+            = {{ formatDuration(localWindow) }}
+          </span>
+        </div>
+      </SettingsGroup>
+
+      <!-- Search Rate Limit -->
+      <SettingsGroup
+        label="Search Requests Limit"
+        description="Maximum search requests (search, tvsearch, movie) per window per user."
+      >
+        <div class="flex items-center gap-3">
+          <input
+            v-model.number="localSearchLimit"
+            type="number"
+            min="1"
+            max="1000"
+            class="w-24 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm text-text-primary focus:outline-none focus:border-white/20"
+          />
+          <span class="text-sm text-text-muted"
+            >requests / {{ formatDuration(localWindow) }}</span
+          >
+        </div>
+        <div class="mt-2">
+          <div class="h-1.5 bg-bg-tertiary rounded-full overflow-hidden">
+            <div
+              class="h-full bg-gradient-to-r from-success to-yellow-500"
+              :style="{
+                width: `${Math.min((localSearchLimit / 100) * 100, 100)}%`,
+              }"
+            />
+          </div>
+          <div class="flex justify-between mt-1 text-[10px] text-text-muted">
+            <span>Strict</span>
+            <span>Generous</span>
+          </div>
+        </div>
+      </SettingsGroup>
+
+      <!-- Download Rate Limit -->
+      <SettingsGroup
+        label="Download Requests Limit"
+        description="Maximum torrent file download requests per window per user."
+      >
+        <div class="flex items-center gap-3">
+          <input
+            v-model.number="localDownloadLimit"
+            type="number"
+            min="1"
+            max="500"
+            class="w-24 bg-bg-tertiary border border-border rounded px-3 py-2 text-sm text-text-primary focus:outline-none focus:border-white/20"
+          />
+          <span class="text-sm text-text-muted"
+            >requests / {{ formatDuration(localWindow) }}</span
+          >
+        </div>
+        <div class="mt-2">
+          <div class="h-1.5 bg-bg-tertiary rounded-full overflow-hidden">
+            <div
+              class="h-full bg-gradient-to-r from-success to-yellow-500"
+              :style="{
+                width: `${Math.min((localDownloadLimit / 50) * 100, 100)}%`,
+              }"
+            />
+          </div>
+          <div class="flex justify-between mt-1 text-[10px] text-text-muted">
+            <span>Strict</span>
+            <span>Generous</span>
+          </div>
+        </div>
+      </SettingsGroup>
+
+      <!-- Presets -->
+      <div class="border-t border-border pt-4">
+        <p
+          class="text-[10px] font-bold uppercase tracking-widest text-text-muted mb-3"
+        >
+          Quick Presets
+        </p>
+        <div class="flex flex-wrap gap-2">
+          <button
+            v-for="preset in presets"
+            :key="preset.name"
+            @click="applyPreset(preset)"
+            class="px-3 py-1.5 bg-bg-tertiary border border-border rounded text-xs hover:border-white/20 transition-colors"
+          >
+            {{ preset.name }}
+          </button>
+        </div>
+      </div>
+
+      <!-- Save Button -->
+      <div
+        class="flex items-center justify-between border-t border-border pt-4"
+      >
+        <p class="text-xs text-text-muted">
+          <Icon name="ph:info" class="inline mr-1" />
+          Changes take effect immediately for new requests.
+        </p>
+        <button
+          @click="saveChanges"
+          :disabled="!hasChanges || saving"
+          class="px-4 py-2 bg-text-primary text-bg-primary text-xs font-bold uppercase tracking-widest rounded hover:opacity-90 transition-opacity disabled:opacity-50 flex items-center gap-2"
+        >
+          <Icon v-if="saving" name="ph:circle-notch" class="animate-spin" />
+          {{ saving ? 'Saving...' : 'Save Changes' }}
+        </button>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface TorznabConfig {
+  enabled: boolean;
+  rateLimitSearch: number;
+  rateLimitDownload: number;
+  rateLimitWindow: number;
+  enableLogging: boolean;
+  allowedCategories: string[];
+}
+
+interface Preset {
+  name: string;
+  window: number;
+  search: number;
+  download: number;
+}
+
+const props = defineProps<{
+  config?: TorznabConfig;
+  loading?: boolean;
+}>();
+
+const emit = defineEmits<{
+  update: [updates: Partial<TorznabConfig>];
+}>();
+
+const saving = ref(false);
+
+// Local state for editing
+const localWindow = ref(props.config?.rateLimitWindow || 60);
+const localSearchLimit = ref(props.config?.rateLimitSearch || 30);
+const localDownloadLimit = ref(props.config?.rateLimitDownload || 20);
+
+// Sync with props
+watch(
+  () => props.config,
+  (newConfig) => {
+    if (newConfig) {
+      localWindow.value = newConfig.rateLimitWindow;
+      localSearchLimit.value = newConfig.rateLimitSearch;
+      localDownloadLimit.value = newConfig.rateLimitDownload;
+    }
+  },
+  { immediate: true }
+);
+
+const hasChanges = computed(() => {
+  if (!props.config) return false;
+  return (
+    localWindow.value !== props.config.rateLimitWindow ||
+    localSearchLimit.value !== props.config.rateLimitSearch ||
+    localDownloadLimit.value !== props.config.rateLimitDownload
+  );
+});
+
+const presets: Preset[] = [
+  { name: 'Strict', window: 60, search: 10, download: 5 },
+  { name: 'Default', window: 60, search: 30, download: 20 },
+  { name: 'Relaxed', window: 60, search: 60, download: 40 },
+  { name: 'Generous', window: 60, search: 100, download: 50 },
+];
+
+function applyPreset(preset: Preset) {
+  localWindow.value = preset.window;
+  localSearchLimit.value = preset.search;
+  localDownloadLimit.value = preset.download;
+}
+
+async function saveChanges() {
+  saving.value = true;
+  try {
+    emit('update', {
+      rateLimitWindow: localWindow.value,
+      rateLimitSearch: localSearchLimit.value,
+      rateLimitDownload: localDownloadLimit.value,
+    });
+  } finally {
+    setTimeout(() => {
+      saving.value = false;
+    }, 500);
+  }
+}
+
+function formatDuration(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+  return `${Math.floor(seconds / 3600)}h`;
+}
+</script>
diff --git a/app/components/admin/TorznabStats.vue b/app/components/admin/TorznabStats.vue
new file mode 100644
index 0000000..e37e2e4
--- /dev/null
+++ b/app/components/admin/TorznabStats.vue
@@ -0,0 +1,152 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center gap-2">
+        <Icon name="ph:chart-bar" class="text-text-muted" />
+        <h3
+          class="text-xs font-bold uppercase tracking-wider text-text-primary"
+        >
+          Torznab API Statistics
+        </h3>
+      </div>
+    </div>
+    <div class="card-body">
+      <!-- Loading State -->
+      <div v-if="loading" class="grid grid-cols-2 md:grid-cols-4 gap-4">
+        <div
+          v-for="i in 8"
+          :key="i"
+          class="bg-bg-tertiary rounded-lg p-4 animate-pulse"
+        >
+          <div class="h-3 bg-bg-secondary rounded w-20 mb-2"></div>
+          <div class="h-6 bg-bg-secondary rounded w-16"></div>
+        </div>
+      </div>
+
+      <!-- Stats Grid -->
+      <div v-else class="grid grid-cols-2 md:grid-cols-4 gap-4">
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Total Requests
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.totalRequests || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Last 24h
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.last24hRequests || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Unique Users
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.uniqueUsers || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Avg Response Time
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ (stats?.avgResponseTime || 0).toFixed(0)
+            }}<span class="text-sm text-text-muted">ms</span>
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Search Requests
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.searchRequests || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            TV Searches
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.tvSearchRequests || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Movie Searches
+          </p>
+          <p class="text-2xl font-bold text-text-primary">
+            {{ formatNumber(stats?.movieSearchRequests || 0) }}
+          </p>
+        </div>
+
+        <div class="bg-bg-tertiary border border-border rounded-lg p-4">
+          <p
+            class="text-[10px] font-medium uppercase tracking-widest text-text-muted mb-1"
+          >
+            Errors
+          </p>
+          <p
+            class="text-2xl font-bold"
+            :class="stats?.errorsCount ? 'text-red-400' : 'text-text-primary'"
+          >
+            {{ formatNumber(stats?.errorsCount || 0) }}
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface TorznabStats {
+  totalRequests: number;
+  searchRequests: number;
+  downloadRequests: number;
+  capsRequests: number;
+  tvSearchRequests: number;
+  movieSearchRequests: number;
+  errorsCount: number;
+  uniqueUsers: number;
+  avgResponseTime: number;
+  last24hRequests: number;
+}
+
+defineProps<{
+  stats?: TorznabStats;
+  loading?: boolean;
+}>();
+
+function formatNumber(num: number): string {
+  if (num >= 1000000) {
+    return (num / 1000000).toFixed(1) + 'M';
+  }
+  if (num >= 1000) {
+    return (num / 1000).toFixed(1) + 'K';
+  }
+  return num.toString();
+}
+</script>
diff --git a/app/components/admin/TorznabUsers.vue b/app/components/admin/TorznabUsers.vue
new file mode 100644
index 0000000..e3649d9
--- /dev/null
+++ b/app/components/admin/TorznabUsers.vue
@@ -0,0 +1,411 @@
+<template>
+  <div class="card">
+    <div class="card-header">
+      <div class="flex items-center justify-between">
+        <div class="flex items-center gap-2">
+          <Icon name="ph:users" class="text-text-muted" />
+          <h3
+            class="text-xs font-bold uppercase tracking-wider text-text-primary"
+          >
+            API Users
+          </h3>
+        </div>
+        <button
+          @click="() => refresh()"
+          :disabled="loading"
+          class="p-1.5 bg-bg-tertiary border border-border rounded hover:border-white/20 transition-colors"
+          title="Refresh"
+        >
+          <Icon
+            name="ph:arrows-clockwise"
+            :class="['text-text-muted text-sm', loading && 'animate-spin']"
+          />
+        </button>
+      </div>
+    </div>
+    <div class="card-body">
+      <!-- Search -->
+      <div class="flex items-center gap-3 mb-4">
+        <div class="relative flex-1">
+          <Icon
+            name="ph:magnifying-glass"
+            class="absolute left-3 top-1/2 -translate-y-1/2 text-text-muted text-sm"
+          />
+          <input
+            v-model="search"
+            type="text"
+            placeholder="Search users..."
+            class="w-full bg-bg-tertiary border border-border rounded pl-9 pr-3 py-2 text-sm text-text-primary placeholder:text-text-muted focus:outline-none focus:border-white/20"
+          />
+        </div>
+      </div>
+
+      <!-- Users Table -->
+      <div class="overflow-x-auto">
+        <table class="w-full">
+          <thead>
+            <tr class="border-b border-border">
+              <th
+                class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                User
+              </th>
+              <th
+                class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                Passkey
+              </th>
+              <th
+                class="text-center text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                Requests
+              </th>
+              <th
+                class="text-center text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                Rate Limits
+              </th>
+              <th
+                class="text-left text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                Last Request
+              </th>
+              <th
+                class="text-right text-[10px] font-bold uppercase tracking-widest text-text-muted py-2 px-2"
+              >
+                Actions
+              </th>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-if="loading"
+              v-for="i in 5"
+              :key="i"
+              class="border-b border-border/50"
+            >
+              <td colspan="6" class="py-3 px-2">
+                <div class="h-4 bg-bg-tertiary rounded animate-pulse"></div>
+              </td>
+            </tr>
+            <tr
+              v-else
+              v-for="user in filteredUsers"
+              :key="user.id"
+              class="border-b border-border/50 hover:bg-bg-tertiary/50 transition-colors"
+            >
+              <td class="py-3 px-2">
+                <NuxtLink
+                  :to="`/users/${user.username}`"
+                  class="text-sm font-medium text-text-primary hover:underline"
+                >
+                  {{ user.username }}
+                </NuxtLink>
+              </td>
+              <td class="py-3 px-2">
+                <code
+                  class="text-[11px] font-mono text-text-muted bg-bg-tertiary px-1.5 py-0.5 rounded"
+                >
+                  {{ user.passkeyMasked }}
+                </code>
+              </td>
+              <td class="py-3 px-2 text-center">
+                <span class="text-sm text-text-primary">
+                  {{ user.apiStats?.totalRequests || 0 }}
+                </span>
+              </td>
+              <td class="py-3 px-2 text-center">
+                <span
+                  v-if="(user.apiStats?.rateLimitHits || 0) > 0"
+                  class="px-1.5 py-0.5 rounded text-[10px] font-medium bg-yellow-500/20 text-yellow-400"
+                >
+                  {{ user.apiStats?.rateLimitHits }} hits
+                </span>
+                <span v-else class="text-xs text-text-muted">—</span>
+              </td>
+              <td class="py-3 px-2">
+                <span class="text-xs text-text-muted">
+                  {{
+                    user.apiStats?.lastRequest
+                      ? formatRelativeTime(user.apiStats.lastRequest)
+                      : 'Never'
+                  }}
+                </span>
+              </td>
+              <td class="py-3 px-2">
+                <div class="flex items-center justify-end gap-1">
+                  <button
+                    @click="showUserLogs(user)"
+                    class="p-1.5 text-text-muted hover:text-text-primary hover:bg-bg-tertiary rounded transition-colors"
+                    title="View logs"
+                  >
+                    <Icon name="ph:list" class="text-sm" />
+                  </button>
+                  <button
+                    @click="confirmResetPasskey(user)"
+                    class="p-1.5 text-text-muted hover:text-yellow-400 hover:bg-bg-tertiary rounded transition-colors"
+                    title="Reset passkey"
+                  >
+                    <Icon name="ph:key" class="text-sm" />
+                  </button>
+                  <button
+                    @click="confirmBlockUser(user)"
+                    class="p-1.5 text-text-muted hover:text-red-400 hover:bg-bg-tertiary rounded transition-colors"
+                    title="Block API access"
+                  >
+                    <Icon name="ph:prohibit" class="text-sm" />
+                  </button>
+                </div>
+              </td>
+            </tr>
+            <tr v-if="!loading && filteredUsers.length === 0">
+              <td colspan="6" class="py-8 text-center text-text-muted text-sm">
+                No users found
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <!-- Pagination -->
+      <div
+        v-if="data?.total && data.total > limit"
+        class="flex items-center justify-between mt-4 pt-4 border-t border-border"
+      >
+        <span class="text-xs text-text-muted">
+          Showing {{ offset + 1 }} -
+          {{ Math.min(offset + limit, data.total) }} of {{ data.total }}
+        </span>
+        <div class="flex items-center gap-2">
+          <button
+            @click="prevPage"
+            :disabled="offset === 0"
+            class="px-3 py-1 bg-bg-tertiary border border-border rounded text-xs disabled:opacity-50 hover:border-white/20 transition-colors"
+          >
+            Previous
+          </button>
+          <button
+            @click="nextPage"
+            :disabled="offset + limit >= data.total"
+            class="px-3 py-1 bg-bg-tertiary border border-border rounded text-xs disabled:opacity-50 hover:border-white/20 transition-colors"
+          >
+            Next
+          </button>
+        </div>
+      </div>
+    </div>
+
+    <!-- User Logs Modal -->
+    <Teleport to="body">
+      <div
+        v-if="selectedUser"
+        class="fixed inset-0 z-50 flex items-center justify-center p-4"
+      >
+        <div class="fixed inset-0 bg-black/80" @click="selectedUser = null" />
+        <div
+          class="relative bg-bg-primary border border-border rounded-lg w-full max-w-3xl max-h-[80vh] overflow-hidden"
+        >
+          <div
+            class="flex items-center justify-between p-4 border-b border-border"
+          >
+            <h3 class="text-sm font-bold text-text-primary">
+              API Logs - {{ selectedUser.username }}
+            </h3>
+            <button
+              @click="selectedUser = null"
+              class="text-text-muted hover:text-text-primary"
+            >
+              <Icon name="ph:x" />
+            </button>
+          </div>
+          <div class="p-4 overflow-y-auto max-h-[60vh]">
+            <AdminTorznabLogTable
+              :logs="userLogs"
+              :loading="loadingLogs"
+              compact
+            />
+          </div>
+        </div>
+      </div>
+    </Teleport>
+
+    <!-- Confirm Modal -->
+    <Teleport to="body">
+      <div
+        v-if="confirmAction"
+        class="fixed inset-0 z-50 flex items-center justify-center p-4"
+      >
+        <div class="fixed inset-0 bg-black/80" @click="confirmAction = null" />
+        <div
+          class="relative bg-bg-primary border border-border rounded-lg w-full max-w-md p-6"
+        >
+          <h3 class="text-lg font-bold text-text-primary mb-2">
+            {{ confirmAction.title }}
+          </h3>
+          <p class="text-sm text-text-muted mb-4">
+            {{ confirmAction.message }}
+          </p>
+          <div class="flex items-center justify-end gap-3">
+            <button
+              @click="confirmAction = null"
+              class="px-4 py-2 bg-bg-tertiary border border-border rounded text-sm hover:border-white/20 transition-colors"
+            >
+              Cancel
+            </button>
+            <button
+              @click="executeAction"
+              :disabled="actionLoading"
+              class="px-4 py-2 rounded text-sm font-medium flex items-center gap-2"
+              :class="
+                confirmAction.variant === 'danger'
+                  ? 'bg-red-500 text-white'
+                  : 'bg-yellow-500 text-black'
+              "
+            >
+              <Icon
+                v-if="actionLoading"
+                name="ph:circle-notch"
+                class="animate-spin"
+              />
+              {{ confirmAction.confirmText }}
+            </button>
+          </div>
+        </div>
+      </div>
+    </Teleport>
+  </div>
+</template>
+
+<script setup lang="ts">
+interface ApiStats {
+  totalRequests: number;
+  searchRequests: number;
+  downloadRequests: number;
+  lastRequest: number;
+  rateLimitHits: number;
+}
+
+interface TorznabUser {
+  id: string;
+  username: string;
+  passkeyMasked: string;
+  lastSeen: string;
+  createdAt: string;
+  apiStats: ApiStats | null;
+}
+
+interface ConfirmAction {
+  title: string;
+  message: string;
+  confirmText: string;
+  variant: 'danger' | 'warning';
+  action: () => Promise<void>;
+}
+
+const limit = 20;
+const offset = ref(0);
+const search = ref('');
+const selectedUser = ref<TorznabUser | null>(null);
+const userLogs = ref<any[]>([]);
+const loadingLogs = ref(false);
+const confirmAction = ref<ConfirmAction | null>(null);
+const actionLoading = ref(false);
+
+const {
+  data,
+  pending: loading,
+  refresh,
+} = await useFetch<{
+  users: TorznabUser[];
+  total: number;
+}>('/api/admin/torznab/users', {
+  query: computed(() => ({ limit, offset: offset.value })),
+});
+
+const filteredUsers = computed(() => {
+  if (!data.value?.users) return [];
+  if (!search.value) return data.value.users;
+
+  const query = search.value.toLowerCase();
+  return data.value.users.filter(
+    (user) =>
+      user.username.toLowerCase().includes(query) ||
+      user.passkeyMasked.toLowerCase().includes(query)
+  );
+});
+
+function prevPage() {
+  offset.value = Math.max(0, offset.value - limit);
+}
+
+function nextPage() {
+  offset.value += limit;
+}
+
+async function showUserLogs(user: TorznabUser) {
+  selectedUser.value = user;
+  loadingLogs.value = true;
+  try {
+    const response = await $fetch<{ logs: any[] }>('/api/admin/torznab/logs', {
+      query: { passkey: user.passkeyMasked.replace('...', '') },
+    });
+    userLogs.value = response.logs;
+  } catch (error) {
+    console.error('Failed to load user logs:', error);
+  } finally {
+    loadingLogs.value = false;
+  }
+}
+
+function confirmResetPasskey(user: TorznabUser) {
+  confirmAction.value = {
+    title: 'Reset Passkey',
+    message: `Are you sure you want to reset the passkey for ${user.username}? They will need to update their *arr apps with the new passkey.`,
+    confirmText: 'Reset Passkey',
+    variant: 'warning',
+    action: async () => {
+      await $fetch(`/api/admin/torznab/users/${user.id}/reset`, {
+        method: 'POST',
+      });
+      await refresh();
+    },
+  };
+}
+
+function confirmBlockUser(user: TorznabUser) {
+  confirmAction.value = {
+    title: 'Block API Access',
+    message: `Are you sure you want to block ${user.username} from using the Torznab API? They won't be able to search or download via *arr apps.`,
+    confirmText: 'Block User',
+    variant: 'danger',
+    action: async () => {
+      await $fetch(`/api/admin/torznab/users/${user.id}/block`, {
+        method: 'POST',
+        body: { block: true, reason: 'Blocked by admin' },
+      });
+      await refresh();
+    },
+  };
+}
+
+async function executeAction() {
+  if (!confirmAction.value) return;
+  actionLoading.value = true;
+  try {
+    await confirmAction.value.action();
+    confirmAction.value = null;
+  } catch (error) {
+    console.error('Action failed:', error);
+  } finally {
+    actionLoading.value = false;
+  }
+}
+
+function formatRelativeTime(timestamp: number): string {
+  const seconds = Math.floor((Date.now() - timestamp) / 1000);
+  if (seconds < 60) return 'Just now';
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+</script>
diff --git a/app/pages/admin.vue b/app/pages/admin.vue
index f75047a..af5bb4f 100644
--- a/app/pages/admin.vue
+++ b/app/pages/admin.vue
@@ -120,6 +120,12 @@ const menuItems = [
     icon: 'ph:envelope-simple',
     description: 'Manage invitation system',
   },
+  {
+    label: 'Torznab API',
+    path: '/admin/torznab',
+    icon: 'ph:plug',
+    description: 'Configure *arr integration and rate limiting',
+  },
   {
     label: 'Branding',
     path: '/admin/branding',
diff --git a/app/pages/admin/torznab.vue b/app/pages/admin/torznab.vue
new file mode 100644
index 0000000..a331d56
--- /dev/null
+++ b/app/pages/admin/torznab.vue
@@ -0,0 +1,73 @@
+<template>
+  <div class="space-y-6">
+    <!-- Stats Overview -->
+    <AdminTorznabStats :stats="data?.stats" :loading="pending" />
+
+    <!-- Configuration -->
+    <AdminTorznabConfig
+      :config="data?.config"
+      :loading="pending"
+      @update="handleConfigUpdate"
+    />
+
+    <!-- Rate Limiting -->
+    <AdminTorznabRateLimiting
+      :config="data?.config"
+      :loading="pending"
+      @update="handleConfigUpdate"
+    />
+
+    <!-- API Users -->
+    <AdminTorznabUsers />
+
+    <!-- Request Logs -->
+    <AdminTorznabLogs />
+
+    <!-- Blacklist -->
+    <AdminTorznabBlacklist />
+  </div>
+</template>
+
+<script setup lang="ts">
+interface TorznabConfig {
+  enabled: boolean;
+  rateLimitSearch: number;
+  rateLimitDownload: number;
+  rateLimitWindow: number;
+  enableLogging: boolean;
+  allowedCategories: string[];
+}
+
+interface TorznabStats {
+  totalRequests: number;
+  searchRequests: number;
+  downloadRequests: number;
+  capsRequests: number;
+  tvSearchRequests: number;
+  movieSearchRequests: number;
+  errorsCount: number;
+  uniqueUsers: number;
+  avgResponseTime: number;
+  last24hRequests: number;
+}
+
+interface TorznabData {
+  config: TorznabConfig;
+  stats: TorznabStats;
+}
+
+const { data, pending, refresh } =
+  await useFetch<TorznabData>('/api/admin/torznab');
+
+async function handleConfigUpdate(updates: Partial<TorznabConfig>) {
+  try {
+    await $fetch('/api/admin/torznab', {
+      method: 'PUT',
+      body: updates,
+    });
+    await refresh();
+  } catch (error) {
+    console.error('Failed to update Torznab config:', error);
+  }
+}
+</script>
diff --git a/doc/.vitepress/config.ts b/doc/.vitepress/config.ts
index d4c92e6..0f06274 100644
--- a/doc/.vitepress/config.ts
+++ b/doc/.vitepress/config.ts
@@ -35,6 +35,7 @@ export default defineConfig({
 
     nav: [
       { text: 'Guide', link: '/guide/getting-started' },
+      { text: 'Integrations', link: '/integrations/torznab' },
       { text: 'Reference', link: '/reference/api' },
       { text: 'Support', link: '/support/professional' },
     ],
@@ -67,6 +68,12 @@ export default defineConfig({
           ],
         },
       ],
+      '/integrations/': [
+        {
+          text: 'Integrations',
+          items: [{ text: 'Torznab API', link: '/integrations/torznab' }],
+        },
+      ],
       '/reference/': [
         {
           text: 'Reference',
diff --git a/doc/guide/roadmap.md b/doc/guide/roadmap.md
index 7e617a0..0d1293f 100644
--- a/doc/guide/roadmap.md
+++ b/doc/guide/roadmap.md
@@ -30,6 +30,7 @@ Trackarr is actively developed with a focus on performance, security, and usabil
 - [ ] **Freeleech System** — Global and per-torrent freeleech toggle
 - [ ] **User Classes** — Power User, VIP with granular permissions
 - [ ] **Notifications** — In-app alerts for replies, requests, etc.
+- [x] **Tornzb** — Torznab API for third-party clients
 
 ---
 
diff --git a/doc/integrations/torznab.md b/doc/integrations/torznab.md
new file mode 100644
index 0000000..9ce52d0
--- /dev/null
+++ b/doc/integrations/torznab.md
@@ -0,0 +1,289 @@
+# Torznab API
+
+Trackarr implements the Torznab API specification, enabling seamless integration with the \*arr ecosystem including **Prowlarr**, **Sonarr**, **Radarr**, and **Lidarr**.
+
+## Overview
+
+Torznab is an extension of the Newznab API tailored for torrent indexers. It provides a standardized interface that automation tools use to search and download torrents.
+
+### Features
+
+- 🔍 **Full-text search** with category filtering
+- 📺 **TV search** with season/episode parsing
+- 🎬 **Movie search** with IMDB support
+- 🔐 **Passkey authentication** for secure API access
+- 📦 **Personalized downloads** with announce URL injection
+
+## Setup with Prowlarr
+
+### Step 1: Get Your Passkey
+
+1. Log in to Trackarr
+2. Click your username in the top-right → **Passkey**
+3. Copy your **Passkey** (40-character hex string)
+
+### Step 2: Add Indexer in Prowlarr
+
+1. Open Prowlarr → **Indexers** → **Add Indexer**
+2. Select **Generic Torznab**
+3. Configure:
+
+| Field   | Value                                  |
+| ------- | -------------------------------------- |
+| Name    | `Trackarr`                             |
+| URL     | `https://your-tracker.com/api/torznab` |
+| API Key | Your passkey from Step 1               |
+
+4. Click **Test** to verify the connection
+5. Click **Save**
+
+### Step 3: Sync with \*arr Apps
+
+Prowlarr will automatically sync Trackarr as an indexer to your connected Sonarr, Radarr, and Lidarr instances.
+
+## API Endpoints
+
+All endpoints are accessed via a single base URL with function parameters:
+
+```
+GET /api/torznab?t={function}&apikey={passkey}&...
+```
+
+### Capabilities (`t=caps`)
+
+Returns XML describing indexer capabilities. No authentication required.
+
+```bash
+curl "https://your-tracker.com/api/torznab?t=caps"
+```
+
+**Response:** XML with supported search types and categories.
+
+### Search (`t=search`)
+
+General torrent search.
+
+```bash
+curl "https://your-tracker.com/api/torznab?t=search&apikey=YOUR_PASSKEY&q=ubuntu"
+```
+
+| Parameter | Type    | Required | Description                          |
+| --------- | ------- | -------- | ------------------------------------ |
+| `q`       | string  | No       | Search query                         |
+| `cat`     | string  | No       | Comma-separated Newznab category IDs |
+| `limit`   | integer | No       | Max results (default: 25, max: 100)  |
+| `offset`  | integer | No       | Result offset for pagination         |
+
+### TV Search (`t=tvsearch`)
+
+Search with TV-specific parameters.
+
+```bash
+curl "https://your-tracker.com/api/torznab?t=tvsearch&apikey=YOUR_PASSKEY&q=Breaking+Bad&season=1&ep=1"
+```
+
+| Parameter | Type   | Description    |
+| --------- | ------ | -------------- |
+| `season`  | string | Season number  |
+| `ep`      | string | Episode number |
+
+### Movie Search (`t=movie`)
+
+Search with movie-specific parameters.
+
+```bash
+curl "https://your-tracker.com/api/torznab?t=movie&apikey=YOUR_PASSKEY&imdbid=tt0111161"
+```
+
+| Parameter | Type   | Description                 |
+| --------- | ------ | --------------------------- |
+| `imdbid`  | string | IMDB ID (e.g., `tt1234567`) |
+
+### Download
+
+Download a torrent file with your passkey embedded.
+
+```bash
+curl -O "https://your-tracker.com/api/torznab/download?id=INFO_HASH&apikey=YOUR_PASSKEY"
+```
+
+## Category Mapping
+
+Trackarr categories are automatically mapped to Newznab standard IDs:
+
+| Newznab ID | Category    | Trackarr Slugs            |
+| ---------- | ----------- | ------------------------- |
+| 2000       | Movies      | `movies`                  |
+| 2040       | Movies/HD   | `movies-hd`               |
+| 2045       | Movies/UHD  | `movies-uhd`, `movies-4k` |
+| 5000       | TV          | `tv`                      |
+| 5040       | TV/HD       | `tv-hd`                   |
+| 5045       | TV/UHD      | `tv-uhd`, `tv-4k`         |
+| 5070       | TV/Anime    | `anime`, `tv-anime`       |
+| 3000       | Audio       | `audio`, `music`          |
+| 4050       | PC/Games    | `games`, `games-pc`       |
+| 7020       | Books/Ebook | `ebooks`, `books`         |
+
+### Quick Setup: Seed Torznab Categories
+
+For new installations, Trackarr provides a one-click solution to create Torznab-compatible categories:
+
+1. Go to **Admin Panel → Categories**
+2. If no categories exist, click **Seed Torznab Categories**
+3. This creates the following structure:
+
+| Category | Newznab ID | Subcategories                                                         |
+| -------- | ---------- | --------------------------------------------------------------------- |
+| Movies   | 2000       | HD (2040), UHD/4K (2045), SD (2030), Blu-Ray (2050)                   |
+| TV       | 5000       | HD (5040), UHD/4K (5045), SD (5030), Anime (5070), Documentary (5080) |
+| Audio    | 3000       | MP3 (3010), Lossless (3040)                                           |
+| Games    | 4050       | PC (4050), Console (1000), PlayStation (1180), Xbox (1040)            |
+| Software | 4000       | Windows (4020), Mac (4030)                                            |
+| Books    | 7000       | Ebooks (7020), Comics (7030), Magazines (7010)                        |
+| XXX      | 6000       | —                                                                     |
+| Other    | 8000       | —                                                                     |
+
+::: tip
+All seeded categories include proper Newznab IDs, ensuring immediate compatibility with Prowlarr, Sonarr, Radarr, and Lidarr without any additional configuration.
+:::
+
+::: warning
+The seed button only appears when no categories exist. To re-seed, delete all existing categories first.
+:::
+
+## Response Format
+
+Search results are returned as RSS 2.0 with Torznab namespace extensions:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:torznab="http://torznab.com/schemas/2015/feed">
+  <channel>
+    <title>Trackarr</title>
+    <item>
+      <title>Example.Movie.2024.1080p.BluRay</title>
+      <guid>abc123...</guid>
+      <pubDate>Wed, 08 Jan 2025 10:00:00 +0000</pubDate>
+      <size>4500000000</size>
+      <torznab:attr name="seeders" value="25"/>
+      <torznab:attr name="peers" value="5"/>
+      <enclosure url="https://..." type="application/x-bittorrent"/>
+    </item>
+  </channel>
+</rss>
+```
+
+## Error Handling
+
+Errors are returned as XML:
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<error code="100" description="Incorrect user credentials"/>
+```
+
+| Code | Description                |
+| ---- | -------------------------- |
+| 100  | Incorrect user credentials |
+| 101  | Account suspended          |
+| 200  | Missing parameter          |
+| 201  | Incorrect parameter        |
+| 300  | No such function           |
+
+## Security Notes
+
+- **HTTPS Only**: Always use HTTPS to protect your passkey
+- **Passkey = Identity**: Treat your passkey as a secret; anyone with it can download as you
+- **Rate Limits**: API is rate limited to prevent abuse (see below)
+
+## Rate Limits
+
+Torznab endpoints are protected by a configurable rate limiting system. Default limits:
+
+| Endpoint | Limit       | Window   |
+| -------- | ----------- | -------- |
+| Search   | 30 requests | 1 minute |
+| Download | 20 requests | 1 minute |
+
+Exceeding these limits will result in a `429 Too Many Requests` error. Repeated violations may result in temporary IP blacklisting with progressive penalties (5 min → 10 min → 20 min → up to 24h).
+
+::: tip Admin Configuration
+Rate limits can be configured from the **Admin Panel → Torznab API** page:
+
+- **Time Window**: Duration for rate limit calculations (10-3600 seconds)
+- **Search Limit**: Max search requests per window per user
+- **Download Limit**: Max download requests per window per user
+
+Admins can also:
+
+- Enable/disable the Torznab API entirely
+- Enable/disable request logging
+- View real-time API statistics and usage
+- Block specific users from API access
+- Reset user passkeys
+- View blocked IPs and users
+  :::
+
+## Admin Panel Features
+
+The Torznab API admin panel (`/admin/torznab`) provides comprehensive management:
+
+### API Statistics
+
+- Total requests, last 24h requests
+- Unique API users
+- Average response time
+- Breakdown by function type (search, tvsearch, movie, download)
+- Error count tracking
+
+### Configuration
+
+- Enable/disable API globally
+- Toggle request logging
+- Copy API endpoint URL
+
+### Rate Limiting
+
+- Adjustable time window (10s - 1h)
+- Configurable search/download limits per user
+- Quick presets (Strict, Default, Relaxed, Generous)
+
+### User Management
+
+- View all users with API access
+- See per-user request counts and rate limit violations
+- Reset user passkeys
+- Block users from API access
+- View per-user request logs
+
+### Request Logs
+
+- Real-time log of recent API requests
+- Function type, query, results, response time
+- Error tracking
+
+### Blacklist Management
+
+- View currently rate-limited IPs
+- View manually blocked users
+- Unblock users as needed
+
+## Troubleshooting
+
+### "Incorrect user credentials" error
+
+- Verify your passkey is correct (40 hex characters)
+- Check that your account is not banned
+- Ensure you're using the correct tracker URL
+
+### No results returned
+
+- Try a broader search query
+- Check that the category filter matches available content
+- Verify torrents exist in the requested categories
+
+### Connection timeout
+
+- Confirm the tracker URL is accessible
+- Check firewall rules allow outbound HTTPS
+- Try the capabilities endpoint first to test connectivity
diff --git a/package.json b/package.json
index d9983d9..d8f1714 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "trackarr",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "type": "module",
   "private": true,
   "scripts": {
diff --git a/scripts/install.sh b/scripts/install.sh
index 1b16f76..7fa2b92 100755
--- a/scripts/install.sh
+++ b/scripts/install.sh
@@ -546,8 +546,33 @@ run_migrations() {
     
     cd "$INSTALL_DIR"
     
-    # Wait for PostgreSQL to be ready
-    log_info "Waiting for database to be ready..."
+    # Wait for PostgreSQL to be ready (connect to default postgres DB first)
+    log_info "Waiting for database service to be ready..."
+    for i in {1..30}; do
+        if docker compose -f docker-compose.prod.yml exec -T postgres pg_isready -U "$DB_USER" -d "postgres" &> /dev/null; then
+            log_success "Database service is ready"
+            break
+        fi
+        sleep 2
+    done
+
+    # Check/Rename database
+    log_info "Verifying database name..."
+    if docker compose -f docker-compose.prod.yml exec -T postgres psql -U "$DB_USER" -d postgres -lqt | cut -d \| -f 1 | grep -qw "$DB_NAME"; then
+        log_success "Database '$DB_NAME' exists"
+    elif docker compose -f docker-compose.prod.yml exec -T postgres psql -U "$DB_USER" -d postgres -lqt | cut -d \| -f 1 | grep -qw "opentracker"; then
+        log_warn "Found legacy database 'opentracker'. Renaming to '$DB_NAME'..."
+        docker compose -f docker-compose.prod.yml exec -T postgres psql -U "$DB_USER" -d postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'opentracker';" > /dev/null 2>&1 || true
+        docker compose -f docker-compose.prod.yml exec -T postgres psql -U "$DB_USER" -d postgres -c "ALTER DATABASE opentracker RENAME TO \"$DB_NAME\";"
+        log_success "Database renamed successfully"
+    else
+        log_warn "Database '$DB_NAME' not found. Creating..."
+        docker compose -f docker-compose.prod.yml exec -T postgres psql -U "$DB_USER" -d postgres -c "CREATE DATABASE \"$DB_NAME\" OWNER \"$DB_USER\";"
+        log_success "Database created"
+    fi
+    
+    # Wait for target database to be ready
+    log_info "Waiting for $DB_NAME database to be ready..."
     for i in {1..30}; do
         if docker compose -f docker-compose.prod.yml exec -T postgres pg_isready -U "$DB_USER" -d "$DB_NAME" &> /dev/null; then
             log_success "Database is ready"
diff --git a/scripts/seed-categories.ts b/scripts/seed-categories.ts
index 6452135..1c5f8c4 100644
--- a/scripts/seed-categories.ts
+++ b/scripts/seed-categories.ts
@@ -1,34 +1,141 @@
 import { db, schema } from '../server/db';
 import { randomUUID } from 'crypto';
 
-const categories = [
-  { name: 'Movies', slug: 'movies' },
-  { name: 'TV Shows', slug: 'tv-shows' },
-  { name: 'Music', slug: 'music' },
-  { name: 'Games', slug: 'games' },
-  { name: 'Software', slug: 'software' },
-  { name: 'Other', slug: 'other' },
+// Torznab-compatible categories with proper Newznab IDs
+const SEED_CATEGORIES = [
+  // Movies
+  {
+    name: 'Movies',
+    slug: 'movies',
+    newznabId: 2000,
+    subcategories: [
+      { name: 'HD', slug: 'movies-hd', newznabId: 2040 },
+      { name: 'UHD/4K', slug: 'movies-uhd', newznabId: 2045 },
+      { name: 'SD', slug: 'movies-sd', newznabId: 2030 },
+      { name: 'Blu-Ray', slug: 'movies-bluray', newznabId: 2050 },
+    ],
+  },
+  // TV
+  {
+    name: 'TV',
+    slug: 'tv',
+    newznabId: 5000,
+    subcategories: [
+      { name: 'HD', slug: 'tv-hd', newznabId: 5040 },
+      { name: 'UHD/4K', slug: 'tv-uhd', newznabId: 5045 },
+      { name: 'SD', slug: 'tv-sd', newznabId: 5030 },
+      { name: 'Anime', slug: 'tv-anime', newznabId: 5070 },
+      { name: 'Documentary', slug: 'tv-documentary', newznabId: 5080 },
+    ],
+  },
+  // Audio
+  {
+    name: 'Audio',
+    slug: 'audio',
+    newznabId: 3000,
+    subcategories: [
+      { name: 'MP3', slug: 'audio-mp3', newznabId: 3010 },
+      { name: 'Lossless', slug: 'audio-lossless', newznabId: 3040 },
+    ],
+  },
+  // Games
+  {
+    name: 'Games',
+    slug: 'games',
+    newznabId: 4050,
+    subcategories: [
+      { name: 'PC', slug: 'games-pc', newznabId: 4050 },
+      { name: 'Console', slug: 'games-console', newznabId: 1000 },
+      { name: 'PlayStation', slug: 'games-playstation', newznabId: 1180 },
+      { name: 'Xbox', slug: 'games-xbox', newznabId: 1040 },
+    ],
+  },
+  // Software
+  {
+    name: 'Software',
+    slug: 'software',
+    newznabId: 4000,
+    subcategories: [
+      { name: 'Windows', slug: 'software-windows', newznabId: 4020 },
+      { name: 'Mac', slug: 'software-mac', newznabId: 4030 },
+    ],
+  },
+  // Books
+  {
+    name: 'Books',
+    slug: 'books',
+    newznabId: 7000,
+    subcategories: [
+      { name: 'Ebooks', slug: 'books-ebooks', newznabId: 7020 },
+      { name: 'Comics', slug: 'books-comics', newznabId: 7030 },
+      { name: 'Magazines', slug: 'books-magazines', newznabId: 7010 },
+    ],
+  },
+  // XXX
+  {
+    name: 'XXX',
+    slug: 'xxx',
+    newznabId: 6000,
+    subcategories: [],
+  },
+  // Other
+  {
+    name: 'Other',
+    slug: 'other',
+    newznabId: 8000,
+    subcategories: [],
+  },
 ];
 
 async function seed() {
-  console.log('Seeding categories...');
-  for (const cat of categories) {
-    try {
+  // Check if categories already exist
+  const existing = await db.query.categories.findFirst();
+  if (existing) {
+    console.log('✓ Categories already exist, skipping seed');
+    process.exit(0);
+  }
+
+  console.log('🌱 Seeding Torznab-compatible categories...');
+
+  let created = 0;
+
+  for (const cat of SEED_CATEGORIES) {
+    const parentId = randomUUID();
+
+    // Create parent category
+    await db
+      .insert(schema.categories)
+      .values({
+        id: parentId,
+        name: cat.name,
+        slug: cat.slug,
+        parentId: null,
+        newznabId: cat.newznabId,
+        createdAt: new Date(),
+      })
+      .onConflictDoNothing();
+    console.log(`  ✓ ${cat.name} [${cat.newznabId}]`);
+    created++;
+
+    // Create subcategories
+    for (const sub of cat.subcategories) {
       await db
         .insert(schema.categories)
         .values({
           id: randomUUID(),
-          name: cat.name,
-          slug: cat.slug,
+          name: sub.name,
+          slug: sub.slug,
+          parentId: parentId,
+          newznabId: sub.newznabId,
           createdAt: new Date(),
         })
         .onConflictDoNothing();
-      console.log(`Added category: ${cat.name}`);
-    } catch (e) {
-      console.error(`Failed to add category ${cat.name}:`, e);
+      console.log(`    ↳ ${sub.name} [${sub.newznabId}]`);
+      created++;
     }
   }
-  console.log('Done!');
+
+  console.log(`\n✅ Created ${created} Torznab-compatible categories`);
   process.exit(0);
 }
 
diff --git a/scripts/setup-local-prod.sh b/scripts/setup-local-prod.sh
index 35503cf..7e0f2e1 100755
--- a/scripts/setup-local-prod.sh
+++ b/scripts/setup-local-prod.sh
@@ -200,6 +200,27 @@ for i in {1..30}; do
     sleep 2
 done
 
+# =============================================================================
+# Database Setup / Migration
+# =============================================================================
+log_step "Verifying database..."
+
+# Check if 'trackarr' exists
+if docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T postgres psql -U tracker -d postgres -lqt | cut -d \| -f 1 | grep -qw "trackarr"; then
+    log_success "Database 'trackarr' exists"
+elif docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T postgres psql -U tracker -d postgres -lqt | cut -d \| -f 1 | grep -qw "opentracker"; then
+    log_warn "Found legacy database 'opentracker'. Renaming to 'trackarr'..."
+    # We need to terminate connections to the old db before renaming could potentially fail if app is retrying
+    # usage of pg_terminate_backend avoids "database is being accessed by other users"
+    docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T postgres psql -U tracker -d postgres -c "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'opentracker';" > /dev/null 2>&1 || true
+    docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T postgres psql -U tracker -d postgres -c "ALTER DATABASE opentracker RENAME TO trackarr;"
+    log_success "Database renamed successfully"
+else
+    log_warn "Database 'trackarr' not found. Creating..."
+    docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T postgres psql -U tracker -d postgres -c "CREATE DATABASE trackarr OWNER tracker;"
+    log_success "Database created"
+fi
+
 # Wait for Redis
 for i in {1..15}; do
     if docker compose -f docker-compose.local.yml --env-file "$ENV_FILE" exec -T redis redis-cli -a "$REDIS_PASSWORD" PING 2>/dev/null | grep -q PONG; then
diff --git a/server/api/admin/categories/[id].put.ts b/server/api/admin/categories/[id].put.ts
index f11bf54..aa3fefb 100644
--- a/server/api/admin/categories/[id].put.ts
+++ b/server/api/admin/categories/[id].put.ts
@@ -7,6 +7,7 @@ import { validateBody } from '../../../utils/schemas';
 
 const updateCategorySchema = z.object({
   name: z.string().min(1).max(50),
+  newznabId: z.coerce.number().int().min(1000).max(9999).nullable().optional(),
 });
 
 export default defineEventHandler(async (event) => {
@@ -59,12 +60,23 @@ export default defineEventHandler(async (event) => {
   }
 
   try {
+    const updateData: {
+      name: string;
+      slug: string;
+      newznabId?: number | null;
+    } = {
+      name,
+      slug,
+    };
+
+    // Only update newznabId if explicitly provided
+    if (body.newznabId !== undefined) {
+      updateData.newznabId = body.newznabId;
+    }
+
     const [category] = await db
       .update(schema.categories)
-      .set({
-        name,
-        slug,
-      })
+      .set(updateData)
       .where(eq(schema.categories.id, id))
       .returning();
 
diff --git a/server/api/admin/categories/index.post.ts b/server/api/admin/categories/index.post.ts
index 3ccb5a5..56d9c9f 100644
--- a/server/api/admin/categories/index.post.ts
+++ b/server/api/admin/categories/index.post.ts
@@ -52,6 +52,7 @@ export default defineEventHandler(async (event) => {
         name,
         slug,
         parentId,
+        newznabId: body.newznabId ?? null,
         createdAt: new Date(),
       })
       .returning();
diff --git a/server/api/admin/categories/seed.post.ts b/server/api/admin/categories/seed.post.ts
new file mode 100644
index 0000000..b1f2c1d
--- /dev/null
+++ b/server/api/admin/categories/seed.post.ts
@@ -0,0 +1,137 @@
+import { db, schema } from '../../../db';
+import { randomUUID } from 'crypto';
+import { requireAdminSession } from '../../../utils/adminAuth';
+import { rateLimit, RATE_LIMITS } from '../../../utils/rateLimit';
+
+// Recommended Torznab-compatible categories with proper Newznab IDs
+const SEED_CATEGORIES = [
+  // Movies
+  {
+    name: 'Movies',
+    slug: 'movies',
+    newznabId: 2000,
+    subcategories: [
+      { name: 'HD', slug: 'movies-hd', newznabId: 2040 },
+      { name: 'UHD/4K', slug: 'movies-uhd', newznabId: 2045 },
+      { name: 'SD', slug: 'movies-sd', newznabId: 2030 },
+      { name: 'Blu-Ray', slug: 'movies-bluray', newznabId: 2050 },
+    ],
+  },
+  // TV
+  {
+    name: 'TV',
+    slug: 'tv',
+    newznabId: 5000,
+    subcategories: [
+      { name: 'HD', slug: 'tv-hd', newznabId: 5040 },
+      { name: 'UHD/4K', slug: 'tv-uhd', newznabId: 5045 },
+      { name: 'SD', slug: 'tv-sd', newznabId: 5030 },
+      { name: 'Anime', slug: 'tv-anime', newznabId: 5070 },
+      { name: 'Documentary', slug: 'tv-documentary', newznabId: 5080 },
+    ],
+  },
+  // Audio
+  {
+    name: 'Audio',
+    slug: 'audio',
+    newznabId: 3000,
+    subcategories: [
+      { name: 'MP3', slug: 'audio-mp3', newznabId: 3010 },
+      { name: 'Lossless', slug: 'audio-lossless', newznabId: 3040 },
+    ],
+  },
+  // Games
+  {
+    name: 'Games',
+    slug: 'games',
+    newznabId: 4050,
+    subcategories: [
+      { name: 'PC', slug: 'games-pc', newznabId: 4050 },
+      { name: 'Console', slug: 'games-console', newznabId: 1000 },
+      { name: 'PlayStation', slug: 'games-playstation', newznabId: 1180 },
+      { name: 'Xbox', slug: 'games-xbox', newznabId: 1040 },
+    ],
+  },
+  // Software
+  {
+    name: 'Software',
+    slug: 'software',
+    newznabId: 4000,
+    subcategories: [
+      { name: 'Windows', slug: 'software-windows', newznabId: 4020 },
+      { name: 'Mac', slug: 'software-mac', newznabId: 4030 },
+    ],
+  },
+  // Books
+  {
+    name: 'Books',
+    slug: 'books',
+    newznabId: 7000,
+    subcategories: [
+      { name: 'Ebooks', slug: 'books-ebooks', newznabId: 7020 },
+      { name: 'Comics', slug: 'books-comics', newznabId: 7030 },
+      { name: 'Magazines', slug: 'books-magazines', newznabId: 7010 },
+    ],
+  },
+  // XXX (optional, can be removed if not needed)
+  {
+    name: 'XXX',
+    slug: 'xxx',
+    newznabId: 6000,
+    subcategories: [],
+  },
+  // Other
+  {
+    name: 'Other',
+    slug: 'other',
+    newznabId: 8000,
+    subcategories: [],
+  },
+];
+
+export default defineEventHandler(async (event) => {
+  rateLimit(event, RATE_LIMITS.admin);
+  await requireAdminSession(event);
+
+  // Check if categories already exist
+  const existingCategories = await db.query.categories.findMany();
+  if (existingCategories.length > 0) {
+    throw createError({
+      statusCode: 400,
+      message:
+        'Categories already exist. Delete all categories first to re-seed.',
+    });
+  }
+
+  let created = 0;
+
+  for (const cat of SEED_CATEGORIES) {
+    const parentId = randomUUID();
+
+    // Create parent category
+    await db.insert(schema.categories).values({
+      id: parentId,
+      name: cat.name,
+      slug: cat.slug,
+      parentId: null,
+      newznabId: cat.newznabId,
+      createdAt: new Date(),
+    });
+    created++;
+
+    // Create subcategories
+    for (const sub of cat.subcategories) {
+      await db.insert(schema.categories).values({
+        id: randomUUID(),
+        name: sub.name,
+        slug: sub.slug,
+        parentId: parentId,
+        newznabId: sub.newznabId,
+        createdAt: new Date(),
+      });
+      created++;
+    }
+  }
+
+  return { success: true, created };
+});
diff --git a/server/api/admin/debug/redis-all-peers.get.ts b/server/api/admin/debug/redis-all-peers.get.ts
index e7d0c37..4d39dd6 100644
--- a/server/api/admin/debug/redis-all-peers.get.ts
+++ b/server/api/admin/debug/redis-all-peers.get.ts
@@ -23,7 +23,7 @@ export default defineEventHandler(async (event) => {
       const [nextCursor, foundKeys] = await redis.scan(
         cursor,
         'MATCH',
-        'peers:*',
+        `${keyPrefix}peers:*`,
         'COUNT',
         100
       );
diff --git a/server/api/admin/debug/tracker-status.get.ts b/server/api/admin/debug/tracker-status.get.ts
index 3886401..21046b3 100644
--- a/server/api/admin/debug/tracker-status.get.ts
+++ b/server/api/admin/debug/tracker-status.get.ts
@@ -61,7 +61,7 @@ export default defineEventHandler(async (event) => {
       const [nextCursor, keys] = await redis.scan(
         cursor,
         'MATCH',
-        'peers:*',
+        `${keyPrefix}peers:*`,
         'COUNT',
         100
       );
diff --git a/server/api/admin/stats.get.ts b/server/api/admin/stats.get.ts
index 8e7328e..3f7c0f8 100644
--- a/server/api/admin/stats.get.ts
+++ b/server/api/admin/stats.get.ts
@@ -25,7 +25,7 @@ export default defineEventHandler(async (event) => {
       const [nextCursor, keys] = await redis.scan(
         cursor,
         'MATCH',
-        'peers:*',
+        `${keyPrefix}peers:*`,
         'COUNT',
         100
       );
diff --git a/server/api/admin/stats/history.get.ts b/server/api/admin/stats/history.get.ts
index bf1bd74..627dcd1 100644
--- a/server/api/admin/stats/history.get.ts
+++ b/server/api/admin/stats/history.get.ts
@@ -1,6 +1,7 @@
 import { db, schema } from '../../../db';
-import { desc, asc, gte } from 'drizzle-orm';
+import { desc, asc, gte, sql } from 'drizzle-orm';
 import { requireAdminSession } from '../../../utils/adminAuth';
+import { redis } from '../../../redis/client';
 
 export default defineEventHandler(async (event) => {
   await requireAdminSession(event);
@@ -11,11 +12,94 @@ export default defineEventHandler(async (event) => {
   const startDate = new Date();
   startDate.setDate(startDate.getDate() - days);
 
+  // 1. Get historical stats
   const history = await db
     .select()
     .from(schema.siteStats)
     .where(gte(schema.siteStats.createdAt, startDate))
     .orderBy(asc(schema.siteStats.createdAt));
 
+  // 2. keyPrefix (should match stats-collector)
+  const keyPrefix = process.env.REDIS_KEY_PREFIX || 'ot:';
+
+  // 3. Get CURRENT live stats to append as the latest data point
+  // This ensures the charts show real-time state even if collector hasn't run recently
+  try {
+    // Users
+    const usersCountResult = await db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(schema.users);
+    const usersCount = usersCountResult[0]?.count || 0;
+
+    // Torrents
+    const torrentsCountResult = await db
+      .select({ count: sql<number>`count(*)::int` })
+      .from(schema.torrents);
+    const torrentsCount = torrentsCountResult[0]?.count || 0;
+
+    // Redis Memory
+    const info = await redis.info('memory');
+    const memoryMatch = info.match(/used_memory:(\d+)/);
+    const redisMemoryUsage = memoryMatch ? parseInt(memoryMatch[1], 10) : 0;
+
+    // DB Size
+    const dbSizeResult = await db.execute(
+      sql`SELECT pg_database_size(current_database())::bigint`
+    );
+    const dbSize = Number(dbSizeResult[0]?.pg_database_size) || 0;
+
+    // Peers & Seeders (SCAN)
+    let peersCount = 0;
+    let seedersCount = 0;
+    let cursor = '0';
+    do {
+      const [nextCursor, keys] = await redis.scan(
+        cursor,
+        'MATCH',
+        `${keyPrefix}peers:*`,
+        'COUNT',
+        100
+      );
+      cursor = nextCursor;
+      for (const fullKey of keys) {
+        const key = fullKey.startsWith(keyPrefix)
+          ? fullKey.slice(keyPrefix.length)
+          : fullKey;
+        const peersData = await redis.hgetall(key);
+        for (const json of Object.values(peersData)) {
+          try {
+            const peer = JSON.parse(json as string);
+            peersCount++;
+            if (peer.isSeeder) seedersCount++;
+          } catch (e) {}
+        }
+      }
+    } while (cursor !== '0');
+
+    // Append 'live' data point
+    // Check if we should append: only if history is empty OR last point is older than 5 mins
+    const lastPoint = history[history.length - 1];
+    const now = Date.now();
+    const fiveMinutes = 5 * 60 * 1000;
+
+    if (
+      !lastPoint ||
+      now - new Date(lastPoint.createdAt).getTime() > fiveMinutes
+    ) {
+      history.push({
+        id: 'live',
+        usersCount,
+        torrentsCount,
+        peersCount,
+        seedersCount,
+        redisMemoryUsage,
+        dbSize,
+        createdAt: new Date(),
+      } as any);
+    }
+  } catch (err) {
+    console.error('[Stats History] Failed to fetch live stats:', err);
+  }
+
   return history;
 });
diff --git a/server/api/admin/torznab/blacklist.get.ts b/server/api/admin/torznab/blacklist.get.ts
new file mode 100644
index 0000000..df82bb2
--- /dev/null
+++ b/server/api/admin/torznab/blacklist.get.ts
@@ -0,0 +1,85 @@
+/**
+ * GET /api/admin/torznab/blacklist
+ * Get currently blacklisted IPs from rate limiting (admin only)
+ */
+
+import { createHash } from 'crypto';
+import { requireAdminSession } from '../../../utils/adminAuth';
+import { redis } from '../../../redis/client';
+
+const BLACKLIST_KEY = 'ddos:blacklist';
+const TORZNAB_BLOCK_KEY = 'torznab:blocked';
+
+interface BlacklistEntry {
+  ip: string;
+  reason: string;
+  expiresAt: number;
+  violations: number;
+}
+
+interface BlockedUser {
+  blockId: string;
+  passkey: string;
+  reason: string;
+  blockedAt: number;
+}
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  try {
+    // Get IP blacklist
+    const blacklistData = await redis.hgetall(BLACKLIST_KEY);
+    const ipBlacklist: BlacklistEntry[] = [];
+
+    for (const [ip, data] of Object.entries(blacklistData)) {
+      try {
+        const entry = JSON.parse(data);
+        if (entry.expiresAt > Date.now()) {
+          ipBlacklist.push({
+            ip: `${ip.substring(0, 8)}...`, // Mask IP for privacy
+            reason: entry.reason,
+            expiresAt: entry.expiresAt,
+            violations: entry.violations,
+          });
+        }
+      } catch {
+        // Skip invalid entries
+      }
+    }
+
+    // Get blocked Torznab users
+    const blockedData = await redis.hgetall(TORZNAB_BLOCK_KEY);
+    const blockedUsers: BlockedUser[] = [];
+
+    for (const [passkey, data] of Object.entries(blockedData)) {
+      try {
+        const entry = JSON.parse(data);
+        // Generate a short hash as blockId for secure unblock operations
+        const blockId = createHash('sha256')
+          .update(passkey)
+          .digest('hex')
+          .substring(0, 16);
+        blockedUsers.push({
+          blockId,
+          passkey: `${passkey.substring(0, 8)}...${passkey.substring(36)}`,
+          reason: entry.reason,
+          blockedAt: entry.blockedAt,
+        });
+      } catch {
+        // Skip invalid entries
+      }
+    }
+
+    return {
+      ipBlacklist: ipBlacklist.sort((a, b) => b.expiresAt - a.expiresAt),
+      blockedUsers: blockedUsers.sort((a, b) => b.blockedAt - a.blockedAt),
+    };
+  } catch (error) {
+    console.error('[Torznab] Failed to get blacklist:', error);
+    return {
+      ipBlacklist: [],
+      blockedUsers: [],
+    };
+  }
+});
diff --git a/server/api/admin/torznab/index.get.ts b/server/api/admin/torznab/index.get.ts
new file mode 100644
index 0000000..cc04e53
--- /dev/null
+++ b/server/api/admin/torznab/index.get.ts
@@ -0,0 +1,49 @@
+/**
+ * GET /api/admin/torznab
+ * Get Torznab API configuration and stats (admin only)
+ */
+
+import { requireAdminSession } from '../../../utils/adminAuth';
+import {
+  getTorznabEnabled,
+  getTorznabRateLimitSearch,
+  getTorznabRateLimitDownload,
+  getTorznabRateLimitWindow,
+  getTorznabEnableLogging,
+  getTorznabAllowedCategories,
+} from '../../../utils/torznabSettings';
+import { getTorznabStats } from '../../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const [
+    enabled,
+    rateLimitSearch,
+    rateLimitDownload,
+    rateLimitWindow,
+    enableLogging,
+    allowedCategories,
+    stats,
+  ] = await Promise.all([
+    getTorznabEnabled(),
+    getTorznabRateLimitSearch(),
+    getTorznabRateLimitDownload(),
+    getTorznabRateLimitWindow(),
+    getTorznabEnableLogging(),
+    getTorznabAllowedCategories(),
+    getTorznabStats(),
+  ]);
+
+  return {
+    config: {
+      enabled,
+      rateLimitSearch,
+      rateLimitDownload,
+      rateLimitWindow,
+      enableLogging,
+      allowedCategories,
+    },
+    stats,
+  };
+});
diff --git a/server/api/admin/torznab/index.put.ts b/server/api/admin/torznab/index.put.ts
new file mode 100644
index 0000000..7026736
--- /dev/null
+++ b/server/api/admin/torznab/index.put.ts
@@ -0,0 +1,68 @@
+/**
+ * PUT /api/admin/torznab
+ * Update Torznab API configuration (admin only)
+ */
+
+import { z } from 'zod';
+import { requireAdminSession } from '../../../utils/adminAuth';
+import {
+  setTorznabEnabled,
+  setTorznabRateLimitSearch,
+  setTorznabRateLimitDownload,
+  setTorznabRateLimitWindow,
+  setTorznabEnableLogging,
+  setTorznabAllowedCategories,
+} from '../../../utils/torznabSettings';
+
+const updateSchema = z.object({
+  enabled: z.boolean().optional(),
+  rateLimitSearch: z.number().min(1).max(1000).optional(),
+  rateLimitDownload: z.number().min(1).max(500).optional(),
+  rateLimitWindow: z.number().min(10).max(3600).optional(),
+  enableLogging: z.boolean().optional(),
+  allowedCategories: z.array(z.string()).optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const body = await readBody(event);
+  const parsed = updateSchema.safeParse(body);
+
+  if (!parsed.success) {
+    throw createError({
+      statusCode: 400,
+      message: 'Invalid request body',
+      data: parsed.error.issues,
+    });
+  }
+
+  const updates = parsed.data;
+
+  // Apply updates
+  if (updates.enabled !== undefined) {
+    await setTorznabEnabled(updates.enabled);
+  }
+
+  if (updates.rateLimitSearch !== undefined) {
+    await setTorznabRateLimitSearch(updates.rateLimitSearch);
+  }
+
+  if (updates.rateLimitDownload !== undefined) {
+    await setTorznabRateLimitDownload(updates.rateLimitDownload);
+  }
+
+  if (updates.rateLimitWindow !== undefined) {
+    await setTorznabRateLimitWindow(updates.rateLimitWindow);
+  }
+
+  if (updates.enableLogging !== undefined) {
+    await setTorznabEnableLogging(updates.enableLogging);
+  }
+
+  if (updates.allowedCategories !== undefined) {
+    await setTorznabAllowedCategories(updates.allowedCategories);
+  }
+
+  return { success: true };
+});
diff --git a/server/api/admin/torznab/logs.get.ts b/server/api/admin/torznab/logs.get.ts
new file mode 100644
index 0000000..b4cdcd9
--- /dev/null
+++ b/server/api/admin/torznab/logs.get.ts
@@ -0,0 +1,33 @@
+/**
+ * GET /api/admin/torznab/logs
+ * Get Torznab API request logs with pagination (admin only)
+ */
+
+import { requireAdminSession } from '../../../utils/adminAuth';
+import {
+  getTorznabRecentLogs,
+  getTorznabLogsByUser,
+} from '../../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const query = getQuery(event);
+  const limit = Math.min(parseInt(query.limit as string) || 50, 100);
+  const offset = parseInt(query.offset as string) || 0;
+  const passkey = query.passkey as string | undefined;
+
+  let result;
+  if (passkey) {
+    result = await getTorznabLogsByUser(passkey, limit, offset);
+  } else {
+    result = await getTorznabRecentLogs(limit, offset);
+  }
+
+  return {
+    logs: result.logs,
+    total: result.total,
+    limit,
+    offset,
+  };
+});
diff --git a/server/api/admin/torznab/stats.get.ts b/server/api/admin/torznab/stats.get.ts
new file mode 100644
index 0000000..37294a7
--- /dev/null
+++ b/server/api/admin/torznab/stats.get.ts
@@ -0,0 +1,30 @@
+/**
+ * GET /api/admin/torznab/stats
+ * Get detailed Torznab API statistics (admin only)
+ */
+
+import { requireAdminSession } from '../../../utils/adminAuth';
+import {
+  getTorznabStats,
+  getTorznabTopUsers,
+  getTorznabRequestsByHour,
+  getTorznabRateLimitHits,
+} from '../../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const [stats, topUsers, requestsByHour, rateLimitHits] = await Promise.all([
+    getTorznabStats(),
+    getTorznabTopUsers(10),
+    getTorznabRequestsByHour(24),
+    getTorznabRateLimitHits(),
+  ]);
+
+  return {
+    stats,
+    topUsers,
+    requestsByHour,
+    rateLimitHits,
+  };
+});
diff --git a/server/api/admin/torznab/unblock.post.ts b/server/api/admin/torznab/unblock.post.ts
new file mode 100644
index 0000000..6bd6cf0
--- /dev/null
+++ b/server/api/admin/torznab/unblock.post.ts
@@ -0,0 +1,66 @@
+/**
+ * POST /api/admin/torznab/unblock
+ * Unblock a user from Torznab API using their blockId (admin only)
+ */
+
+import { createHash } from 'crypto';
+import { requireAdminSession } from '../../../utils/adminAuth';
+import { redis } from '../../../redis/client';
+
+const TORZNAB_BLOCK_KEY = 'torznab:blocked';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const { blockId } = await readBody<{ blockId: string }>(event);
+
+  if (!blockId || typeof blockId !== 'string' || blockId.length !== 16) {
+    throw createError({
+      statusCode: 400,
+      message: 'Invalid blockId',
+    });
+  }
+
+  try {
+    // Get all blocked users and find the one matching the blockId
+    const blockedData = await redis.hgetall(TORZNAB_BLOCK_KEY);
+
+    let targetPasskey: string | null = null;
+
+    for (const passkey of Object.keys(blockedData)) {
+      const hash = createHash('sha256')
+        .update(passkey)
+        .digest('hex')
+        .substring(0, 16);
+      if (hash === blockId) {
+        targetPasskey = passkey;
+        break;
+      }
+    }
+
+    if (!targetPasskey) {
+      throw createError({
+        statusCode: 404,
+        message: 'Blocked user not found',
+      });
+    }
+
+    // Unblock the user
+    await redis.hdel(TORZNAB_BLOCK_KEY, targetPasskey);
+
+    return {
+      success: true,
+      message: 'User unblocked successfully',
+    };
+  } catch (error) {
+    if ((error as { statusCode?: number }).statusCode) {
+      throw error;
+    }
+
+    console.error('[Torznab] Failed to unblock user:', error);
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to unblock user',
+    });
+  }
+});
diff --git a/server/api/admin/torznab/users.get.ts b/server/api/admin/torznab/users.get.ts
new file mode 100644
index 0000000..4e0fbd7
--- /dev/null
+++ b/server/api/admin/torznab/users.get.ts
@@ -0,0 +1,62 @@
+/**
+ * GET /api/admin/torznab/users
+ * Get users with Torznab API access info (admin only)
+ */
+
+import { requireAdminSession } from '../../../utils/adminAuth';
+import { db, schema } from '../../../db';
+import { desc, eq, sql } from 'drizzle-orm';
+import { getTorznabUserStats } from '../../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const query = getQuery(event);
+  const limit = Math.min(parseInt(query.limit as string) || 50, 100);
+  const offset = parseInt(query.offset as string) || 0;
+
+  // Get users with their passkeys (masked) and API usage stats
+  const users = await db
+    .select({
+      id: schema.users.id,
+      username: schema.users.username,
+      passkey: schema.users.passkey,
+      isBanned: schema.users.isBanned,
+      lastSeen: schema.users.lastSeen,
+      createdAt: schema.users.createdAt,
+    })
+    .from(schema.users)
+    .where(eq(schema.users.isBanned, false))
+    .orderBy(desc(schema.users.lastSeen))
+    .limit(limit)
+    .offset(offset);
+
+  // Get API usage stats for each user
+  const usersWithStats = await Promise.all(
+    users.map(async (user) => {
+      const stats = await getTorznabUserStats(user.passkey);
+      return {
+        id: user.id,
+        username: user.username,
+        // Mask passkey for display (show first 8 + last 4 chars)
+        passkeyMasked: `${user.passkey.substring(0, 8)}...${user.passkey.substring(36)}`,
+        lastSeen: user.lastSeen,
+        createdAt: user.createdAt,
+        apiStats: stats,
+      };
+    })
+  );
+
+  // Get total count
+  const countResult = await db
+    .select({ count: sql<number>`count(*)::int` })
+    .from(schema.users)
+    .where(eq(schema.users.isBanned, false));
+
+  return {
+    users: usersWithStats,
+    total: countResult[0]?.count || 0,
+    limit,
+    offset,
+  };
+});
diff --git a/server/api/admin/torznab/users/[id]/block.post.ts b/server/api/admin/torznab/users/[id]/block.post.ts
new file mode 100644
index 0000000..54ef00a
--- /dev/null
+++ b/server/api/admin/torznab/users/[id]/block.post.ts
@@ -0,0 +1,73 @@
+/**
+ * POST /api/admin/torznab/users/:id/block
+ * Block a user from Torznab API access (admin only)
+ */
+
+import { requireAdminSession } from '../../../../../utils/adminAuth';
+import {
+  blockTorznabUser,
+  unblockTorznabUser,
+} from '../../../../../utils/torznabStats';
+import { db } from '../../../../../db';
+import * as schema from '../../../../../db/schema';
+import { eq } from 'drizzle-orm';
+import { z } from 'zod';
+
+const bodySchema = z.object({
+  block: z.boolean(),
+  reason: z.string().optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const userId = getRouterParam(event, 'id');
+
+  if (!userId) {
+    throw createError({
+      statusCode: 400,
+      message: 'User ID is required',
+    });
+  }
+
+  const body = await readBody(event);
+  const parsed = bodySchema.safeParse(body);
+
+  if (!parsed.success) {
+    throw createError({
+      statusCode: 400,
+      message: 'Invalid request body',
+    });
+  }
+
+  // Get user passkey
+  const users = await db
+    .select({ passkey: schema.users.passkey, username: schema.users.username })
+    .from(schema.users)
+    .where(eq(schema.users.id, userId))
+    .limit(1);
+
+  if (users.length === 0) {
+    throw createError({
+      statusCode: 404,
+      message: 'User not found',
+    });
+  }
+
+  const { passkey, username } = users[0];
+  const { block, reason } = parsed.data;
+
+  if (block) {
+    await blockTorznabUser(passkey, reason || 'Blocked by admin');
+  } else {
+    await unblockTorznabUser(passkey);
+  }
+
+  return {
+    success: true,
+    message: block
+      ? `Blocked Torznab access for ${username}`
+      : `Unblocked Torznab access for ${username}`,
+    blocked: block,
+  };
+});
diff --git a/server/api/admin/torznab/users/[id]/reset.post.ts b/server/api/admin/torznab/users/[id]/reset.post.ts
new file mode 100644
index 0000000..6eecd74
--- /dev/null
+++ b/server/api/admin/torznab/users/[id]/reset.post.ts
@@ -0,0 +1,57 @@
+/**
+ * POST /api/admin/torznab/users/:id/reset
+ * Reset a user's passkey (regenerate) (admin only)
+ */
+
+import { requireAdminSession } from '../../../../../utils/adminAuth';
+import { db, schema } from '../../../../../db';
+import { eq } from 'drizzle-orm';
+import { generatePasskey } from '../../../../../utils/auth';
+import { clearTorznabUserStats } from '../../../../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  await requireAdminSession(event);
+
+  const userId = getRouterParam(event, 'id');
+
+  if (!userId) {
+    throw createError({
+      statusCode: 400,
+      message: 'User ID is required',
+    });
+  }
+
+  // Get current user
+  const existingUsers = await db
+    .select({ passkey: schema.users.passkey, username: schema.users.username })
+    .from(schema.users)
+    .where(eq(schema.users.id, userId))
+    .limit(1);
+
+  if (existingUsers.length === 0) {
+    throw createError({
+      statusCode: 404,
+      message: 'User not found',
+    });
+  }
+
+  const oldPasskey = existingUsers[0].passkey;
+
+  // Generate new passkey
+  const newPasskey = generatePasskey();
+
+  // Update user
+  await db
+    .update(schema.users)
+    .set({ passkey: newPasskey })
+    .where(eq(schema.users.id, userId));
+
+  // Clear old stats
+  await clearTorznabUserStats(oldPasskey);
+
+  return {
+    success: true,
+    message: `Passkey reset for user ${existingUsers[0].username}`,
+    passkeyMasked: `${newPasskey.substring(0, 8)}...${newPasskey.substring(36)}`,
+  };
+});
diff --git a/server/api/torznab/download.get.ts b/server/api/torznab/download.get.ts
new file mode 100644
index 0000000..8e7d59e
--- /dev/null
+++ b/server/api/torznab/download.get.ts
@@ -0,0 +1,183 @@
+/**
+ * Torznab API - Download Endpoint
+ * GET /api/torznab/download?id={infoHash}&apikey={passkey}
+ *
+ * Downloads a torrent file with personalized announce URL
+ */
+
+import { db, schema } from '../../db';
+import { eq } from 'drizzle-orm';
+import bencode from 'bencode';
+import { authenticateTorznab } from './utils/auth';
+import { TORZNAB_ERRORS, buildErrorXml } from './utils/xml';
+import { rateLimit, getClientIP } from '../../utils/rateLimit';
+import {
+  getTorznabEnabled,
+  getTorznabRateLimitOptions,
+  getTorznabEnableLogging,
+} from '../../utils/torznabSettings';
+import {
+  logTorznabRequest,
+  isTorznabUserBlocked,
+  trackRateLimitHit,
+} from '../../utils/torznabStats';
+
+export default defineEventHandler(async (event) => {
+  const startTime = Date.now();
+
+  // Check if Torznab API is enabled
+  const enabled = await getTorznabEnabled();
+  if (!enabled) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 503,
+      message: 'Torznab API is currently disabled',
+      data: buildErrorXml({
+        code: 900,
+        description: 'Torznab API is currently disabled',
+      }),
+    });
+  }
+
+  // Authenticate via passkey
+  const user = await authenticateTorznab(event);
+
+  // Check if user is blocked from Torznab API
+  const blockStatus = await isTorznabUserBlocked(user.passkey);
+  if (blockStatus.blocked) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 403,
+      message: blockStatus.reason || 'Access denied',
+      data: buildErrorXml(TORZNAB_ERRORS.ACCOUNT_SUSPENDED),
+    });
+  }
+
+  // Apply dynamic rate limiting
+  const rateLimitOpts = await getTorznabRateLimitOptions('download');
+  try {
+    await rateLimit(event, rateLimitOpts);
+  } catch (error: any) {
+    if (error.statusCode === 429) {
+      await trackRateLimitHit(user.passkey);
+    }
+    throw error;
+  }
+
+  const config = useRuntimeConfig();
+
+  const query = getQuery(event);
+  const id = query.id as string | undefined;
+
+  if (!id) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 400,
+      message: 'Missing id parameter',
+      data: buildErrorXml(TORZNAB_ERRORS.MISSING_PARAMETER),
+    });
+  }
+
+  // Validate info hash format
+  if (!/^[a-fA-F0-9]{40}$/.test(id)) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 400,
+      message: 'Invalid info hash format',
+      data: buildErrorXml(TORZNAB_ERRORS.INCORRECT_PARAMETER),
+    });
+  }
+
+  const infoHash = id.toLowerCase();
+
+  // Get torrent from DB
+  const torrents = await db
+    .select({
+      name: schema.torrents.name,
+      torrentData: schema.torrents.torrentData,
+      isActive: schema.torrents.isActive,
+      isApproved: schema.torrents.isApproved,
+    })
+    .from(schema.torrents)
+    .where(eq(schema.torrents.infoHash, infoHash))
+    .limit(1);
+
+  const torrent = torrents[0];
+
+  if (!torrent || !torrent.torrentData) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 404,
+      message: 'Torrent not found',
+      data: buildErrorXml({ code: 300, description: 'Torrent not found' }),
+    });
+  }
+
+  // Check if torrent is active and approved
+  if (!torrent.isActive || !torrent.isApproved) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 403,
+      message: 'Torrent not available',
+      data: buildErrorXml(TORZNAB_ERRORS.INSUFFICIENT_PRIVILEGES),
+    });
+  }
+
+  // Inject passkey into torrent data
+  let decoded: any;
+  try {
+    decoded = bencode.decode(torrent.torrentData);
+  } catch (err) {
+    setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to decode torrent file',
+      data: buildErrorXml(TORZNAB_ERRORS.INTERNAL_ERROR),
+    });
+  }
+
+  // Personalize announce URL
+  const trackerUrl = new URL(config.public.trackerHttpUrl as string);
+  trackerUrl.searchParams.set('passkey', user.passkey);
+  const personalizedUrl = trackerUrl.toString();
+
+  decoded.announce = Buffer.from(personalizedUrl);
+
+  // Also update announce-list if it exists
+  if (decoded['announce-list']) {
+    decoded['announce-list'] = [[Buffer.from(personalizedUrl)]];
+  }
+
+  // Set private flag to 1
+  if (decoded.info) {
+    decoded.info.private = 1;
+  }
+
+  const personalizedData = bencode.encode(decoded);
+
+  // Sanitize filename
+  const filename = torrent.name.replace(/[^a-zA-Z0-9._-]/g, '_') + '.torrent';
+
+  // Log the download request
+  const loggingEnabled = await getTorznabEnableLogging();
+  if (loggingEnabled) {
+    const responseTime = Date.now() - startTime;
+    await logTorznabRequest({
+      timestamp: Date.now(),
+      passkey: user.passkey,
+      function: 'download',
+      query: infoHash,
+      ip: getClientIP(event),
+      userAgent: getHeader(event, 'user-agent'),
+      responseTime,
+      resultCount: 1,
+    });
+  }
+
+  // Set headers for download
+  setHeader(event, 'Content-Type', 'application/x-bittorrent');
+  setHeader(event, 'Content-Disposition', `attachment; filename="${filename}"`);
+  setHeader(event, 'Content-Length', personalizedData.length);
+
+  return personalizedData;
+});
diff --git a/server/api/torznab/index.get.ts b/server/api/torznab/index.get.ts
new file mode 100644
index 0000000..a2792cf
--- /dev/null
+++ b/server/api/torznab/index.get.ts
@@ -0,0 +1,340 @@
+/**
+ * Torznab API - Main Router
+ * GET /api/torznab?t={function}&apikey={passkey}&...
+ *
+ * Handles all Torznab functions:
+ * - caps: Capabilities
+ * - search: General search
+ * - tvsearch: TV-specific search
+ * - movie: Movie-specific search
+ */
+
+import type { H3Event } from 'h3';
+import { z } from 'zod';
+import { db, schema } from '../../db';
+import { getStats } from '../../redis/cache';
+import { desc, eq, ilike, and, inArray } from 'drizzle-orm';
+import { authenticateTorznab, sendTorznabError } from './utils/auth';
+import {
+  buildCapsXml,
+  buildSearchXml,
+  TORZNAB_ERRORS,
+  type TorznabItem,
+} from './utils/xml';
+import {
+  buildCategoryTree,
+  filterCategoriesByNewznab,
+  getNewznabCategoryId,
+} from './utils/categories';
+import { rateLimit, getClientIP } from '../../utils/rateLimit';
+import {
+  getTorznabEnabled,
+  getTorznabRateLimitOptions,
+  getTorznabEnableLogging,
+} from '../../utils/torznabSettings';
+import {
+  logTorznabRequest,
+  isTorznabUserBlocked,
+  trackRateLimitHit,
+} from '../../utils/torznabStats';
+
+// Query schema for Torznab requests
+const torznabQuerySchema = z.object({
+  t: z.string().default('search'),
+  apikey: z.string().optional(),
+  q: z.string().optional(),
+  cat: z.string().optional(), // Comma-separated category IDs
+  limit: z.coerce.number().min(1).max(100).default(25),
+  offset: z.coerce.number().min(0).default(0),
+  // TV search params
+  season: z.string().optional(),
+  ep: z.string().optional(),
+  tvdbid: z.string().optional(),
+  // Movie search params
+  imdbid: z.string().optional(),
+});
+
+export default defineEventHandler(async (event) => {
+  const startTime = Date.now();
+
+  // Check if Torznab API is enabled
+  const enabled = await getTorznabEnabled();
+  if (!enabled) {
+    return sendTorznabError(event, {
+      code: 900,
+      description: 'Torznab API is currently disabled',
+    });
+  }
+
+  // Parse query parameters
+  const rawQuery = getQuery(event);
+  const parseResult = torznabQuerySchema.safeParse(rawQuery);
+
+  if (!parseResult.success) {
+    return sendTorznabError(event, TORZNAB_ERRORS.INCORRECT_PARAMETER);
+  }
+
+  const query = parseResult.data;
+  const func = query.t.toLowerCase();
+
+  // Capabilities don't require authentication
+  if (func === 'caps') {
+    return handleCaps(event);
+  }
+
+  // All other functions require authentication
+  const user = await authenticateTorznab(event);
+
+  // Check if user is blocked from Torznab API
+  const blockStatus = await isTorznabUserBlocked(user.passkey);
+  if (blockStatus.blocked) {
+    return sendTorznabError(
+      event,
+      TORZNAB_ERRORS.ACCOUNT_SUSPENDED,
+      blockStatus.reason
+    );
+  }
+
+  // Apply dynamic rate limiting based on settings
+  const rateLimitOpts = await getTorznabRateLimitOptions('search');
+  try {
+    await rateLimit(event, rateLimitOpts);
+  } catch (error: any) {
+    if (error.statusCode === 429) {
+      await trackRateLimitHit(user.passkey);
+    }
+    throw error;
+  }
+
+  let result: string;
+  let resultCount = 0;
+  let errorMsg: string | undefined;
+
+  try {
+    switch (func) {
+      case 'search':
+        result = await handleSearch(event, query, user);
+        break;
+      case 'tvsearch':
+        result = await handleTvSearch(event, query, user);
+        break;
+      case 'movie':
+        result = await handleMovieSearch(event, query, user);
+        break;
+      default:
+        return sendTorznabError(
+          event,
+          TORZNAB_ERRORS.NO_SUCH_FUNCTION,
+          `Unknown function: ${func}`
+        );
+    }
+  } catch (error: any) {
+    errorMsg = error.message || 'Unknown error';
+    throw error;
+  } finally {
+    // Log the request if logging is enabled
+    const loggingEnabled = await getTorznabEnableLogging();
+    if (loggingEnabled) {
+      const responseTime = Date.now() - startTime;
+      await logTorznabRequest({
+        timestamp: Date.now(),
+        passkey: user.passkey,
+        function: func,
+        query: query.q,
+        ip: getClientIP(event),
+        userAgent: getHeader(event, 'user-agent'),
+        responseTime,
+        resultCount,
+        error: errorMsg,
+      });
+    }
+  }
+
+  return result;
+});
+
+/**
+ * Handle t=caps - Return capabilities
+ */
+async function handleCaps(event: H3Event) {
+  const categories = await buildCategoryTree();
+
+  const xml = buildCapsXml({
+    serverVersion: '1.0',
+    serverTitle: 'Trackarr',
+    maxLimit: 100,
+    defaultLimit: 25,
+    categories,
+  });
+
+  setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+  setHeader(event, 'Cache-Control', 'public, max-age=3600'); // Cache for 1 hour
+  return xml;
+}
+
+/**
+ * Handle t=search - General search
+ */
+async function handleSearch(
+  event: H3Event,
+  query: z.infer<typeof torznabQuerySchema>,
+  user: { passkey: string }
+) {
+  return performSearch(event, query, user);
+}
+
+/**
+ * Handle t=tvsearch - TV-specific search
+ * Supports season/episode parsing
+ */
+async function handleTvSearch(
+  event: H3Event,
+  query: z.infer<typeof torznabQuerySchema>,
+  user: { passkey: string }
+) {
+  // Build search query with season/episode
+  let searchQuery = query.q || '';
+
+  if (query.season) {
+    // Format: S01 or S1
+    const seasonNum = parseInt(query.season, 10);
+    if (!isNaN(seasonNum)) {
+      const seasonStr = `S${seasonNum.toString().padStart(2, '0')}`;
+      searchQuery += ` ${seasonStr}`;
+    }
+  }
+
+  if (query.ep) {
+    // Format: E01 or E1
+    const epNum = parseInt(query.ep, 10);
+    if (!isNaN(epNum)) {
+      const epStr = `E${epNum.toString().padStart(2, '0')}`;
+      searchQuery += epStr; // No space, directly after season
+    }
+  }
+
+  // Force TV categories if none specified
+  if (!query.cat) {
+    query.cat = '5000'; // TV main category
+  }
+
+  return performSearch(event, { ...query, q: searchQuery.trim() }, user);
+}
+
+/**
+ * Handle t=movie - Movie-specific search
+ * Supports IMDB ID
+ */
+async function handleMovieSearch(
+  event: H3Event,
+  query: z.infer<typeof torznabQuerySchema>,
+  user: { passkey: string }
+) {
+  let searchQuery = query.q || '';
+
+  // IMDB ID support - for now, just include it in search
+  // Full support would require IMDB field in torrents table
+  if (query.imdbid) {
+    // Clean IMDB ID format (tt1234567 -> 1234567)
+    const imdbNum = query.imdbid.replace(/^tt/i, '');
+    searchQuery += ` ${imdbNum}`;
+  }
+
+  // Force Movie categories if none specified
+  if (!query.cat) {
+    query.cat = '2000'; // Movies main category
+  }
+
+  return performSearch(event, { ...query, q: searchQuery.trim() }, user);
+}
+
+/**
+ * Perform the actual search and return Torznab XML
+ */
+async function performSearch(
+  event: H3Event,
+  query: z.infer<typeof torznabQuerySchema>,
+  user: { passkey: string }
+) {
+  const baseUrl = getRequestURL(event).origin;
+  const conditions = [];
+
+  // Only show active, approved torrents
+  conditions.push(eq(schema.torrents.isActive, true));
+  conditions.push(eq(schema.torrents.isApproved, true));
+
+  // Text search
+  if (query.q) {
+    const terms = query.q.split(/\s+/).filter((t) => t.length > 0);
+    if (terms.length > 0) {
+      conditions.push(
+        and(...terms.map((term) => ilike(schema.torrents.name, `%${term}%`)))
+      );
+    }
+  }
+
+  // Category filter
+  if (query.cat) {
+    const newznabIds = query.cat
+      .split(',')
+      .map((id) => parseInt(id.trim(), 10))
+      .filter((id) => !isNaN(id));
+
+    if (newznabIds.length > 0) {
+      const trackarrCatIds = await filterCategoriesByNewznab(newznabIds);
+      if (trackarrCatIds.length > 0) {
+        conditions.push(inArray(schema.torrents.categoryId, trackarrCatIds));
+      }
+    }
+  }
+
+  const whereClause = conditions.length > 0 ? and(...conditions) : undefined;
+
+  // Fetch torrents
+  const torrents = await db.query.torrents.findMany({
+    where: whereClause,
+    with: {
+      category: true,
+    },
+    orderBy: [desc(schema.torrents.createdAt)],
+    limit: query.limit,
+    offset: query.offset,
+  });
+
+  // Enrich with stats from Redis
+  const items: TorznabItem[] = await Promise.all(
+    torrents.map(async (torrent) => {
+      const stats = await getStats(torrent.infoHash);
+      const newznabCatId = getNewznabCategoryId(torrent.category);
+
+      return {
+        title: torrent.name,
+        guid: torrent.infoHash,
+        link: `${baseUrl}/torrents/${torrent.infoHash}`,
+        commentsUrl: `${baseUrl}/torrents/${torrent.infoHash}`,
+        pubDate: new Date(torrent.createdAt),
+        size: torrent.size,
+        description: torrent.description ?? undefined,
+        categoryName: torrent.category?.name,
+        categoryId: newznabCatId,
+        seeders: stats.seeders,
+        leechers: stats.leechers,
+        grabs: stats.completed,
+        downloadUrl: `${baseUrl}/api/torznab/download?id=${torrent.infoHash}&apikey=${user.passkey}`,
+        downloadVolumeFactor: 1, // Could be enhanced with freeleech support
+        uploadVolumeFactor: 1,
+      };
+    })
+  );
+
+  const xml = buildSearchXml({
+    title: 'Trackarr',
+    description: 'Trackarr Torznab Feed',
+    link: baseUrl,
+    selfUrl: `${baseUrl}/api/torznab`,
+    items,
+  });
+
+  setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+  return xml;
+}
diff --git a/server/api/torznab/utils/auth.ts b/server/api/torznab/utils/auth.ts
new file mode 100644
index 0000000..bf09f60
--- /dev/null
+++ b/server/api/torznab/utils/auth.ts
@@ -0,0 +1,105 @@
+/**
+ * Torznab Authentication Utilities
+ * Handles passkey-based authentication for Torznab API
+ */
+
+import { H3Event, createError } from 'h3';
+import { db, schema } from '../../../db';
+import { eq } from 'drizzle-orm';
+import { buildErrorXml, TORZNAB_ERRORS } from './xml';
+
+export interface TorznabUser {
+  id: string;
+  username: string;
+  passkey: string;
+  isBanned: boolean;
+  isAdmin: boolean;
+  isModerator: boolean;
+}
+
+/**
+ * Authenticate user via Torznab API key (passkey)
+ * Returns user if valid, throws error otherwise
+ */
+export async function authenticateTorznab(
+  event: H3Event
+): Promise<TorznabUser> {
+  const query = getQuery(event);
+  const apikey = query.apikey as string | undefined;
+
+  if (!apikey) {
+    throw createTorznabError(
+      event,
+      TORZNAB_ERRORS.MISSING_PARAMETER,
+      'Missing apikey parameter'
+    );
+  }
+
+  // Validate passkey format (40 hex chars)
+  if (!/^[a-f0-9]{40}$/i.test(apikey)) {
+    throw createTorznabError(event, TORZNAB_ERRORS.INCORRECT_CREDENTIALS);
+  }
+
+  // Look up user by passkey
+  const users = await db
+    .select({
+      id: schema.users.id,
+      username: schema.users.username,
+      passkey: schema.users.passkey,
+      isBanned: schema.users.isBanned,
+      isAdmin: schema.users.isAdmin,
+      isModerator: schema.users.isModerator,
+    })
+    .from(schema.users)
+    .where(eq(schema.users.passkey, apikey.toLowerCase()))
+    .limit(1);
+
+  const user = users[0];
+
+  if (!user) {
+    throw createTorznabError(event, TORZNAB_ERRORS.INCORRECT_CREDENTIALS);
+  }
+
+  if (user.isBanned) {
+    throw createTorznabError(event, TORZNAB_ERRORS.ACCOUNT_SUSPENDED);
+  }
+
+  return user;
+}
+
+/**
+ * Create a Torznab-compliant error response
+ */
+export function createTorznabError(
+  event: H3Event,
+  error: { code: number; description: string },
+  customMessage?: string
+): Error {
+  setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+
+  const httpStatus = error.code === 100 || error.code === 101 ? 401 : 400;
+
+  throw createError({
+    statusCode: httpStatus,
+    message: customMessage ?? error.description,
+    data: buildErrorXml({
+      code: error.code,
+      description: customMessage ?? error.description,
+    }),
+  });
+}
+
+/**
+ * Send XML error response
+ */
+export function sendTorznabError(
+  event: H3Event,
+  error: { code: number; description: string },
+  customMessage?: string
+): string {
+  setHeader(event, 'Content-Type', 'application/xml; charset=utf-8');
+  return buildErrorXml({
+    code: error.code,
+    description: customMessage ?? error.description,
+  });
+}
diff --git a/server/api/torznab/utils/categories.ts b/server/api/torznab/utils/categories.ts
new file mode 100644
index 0000000..53b5c33
--- /dev/null
+++ b/server/api/torznab/utils/categories.ts
@@ -0,0 +1,242 @@
+/**
+ * Torznab Category Mapping
+ * Maps Trackarr categories to Newznab standard category IDs
+ */
+
+import { db } from '../../../db';
+
+// Standard Newznab category hierarchy
+export const NEWZNAB_CATEGORIES = {
+  // Movies
+  MOVIES: 2000,
+  MOVIES_FOREIGN: 2010,
+  MOVIES_OTHER: 2020,
+  MOVIES_SD: 2030,
+  MOVIES_HD: 2040,
+  MOVIES_UHD: 2045,
+  MOVIES_BLURAY: 2050,
+  MOVIES_3D: 2060,
+  // TV
+  TV: 5000,
+  TV_WEBDL: 5010,
+  TV_FOREIGN: 5020,
+  TV_SD: 5030,
+  TV_HD: 5040,
+  TV_UHD: 5045,
+  TV_OTHER: 5050,
+  TV_SPORT: 5060,
+  TV_ANIME: 5070,
+  TV_DOCUMENTARY: 5080,
+  // Audio
+  AUDIO: 3000,
+  AUDIO_MP3: 3010,
+  AUDIO_VIDEO: 3020,
+  AUDIO_LOSSLESS: 3040,
+  // PC
+  PC: 4000,
+  PC_0DAY: 4010,
+  PC_ISO: 4020,
+  PC_MAC: 4030,
+  PC_MOBILE: 4040,
+  PC_GAMES: 4050,
+  // Console
+  CONSOLE: 1000,
+  CONSOLE_NDS: 1010,
+  CONSOLE_PSP: 1020,
+  CONSOLE_WII: 1030,
+  CONSOLE_XBOX: 1040,
+  CONSOLE_PS3: 1080,
+  CONSOLE_PS4: 1180,
+  // Books
+  BOOKS: 7000,
+  BOOKS_MAGAZINES: 7010,
+  BOOKS_EBOOK: 7020,
+  BOOKS_COMICS: 7030,
+  // Other
+  OTHER: 8000,
+  OTHER_MISC: 8010,
+} as const;
+
+// Default mapping based on common category names/slugs
+// This can be enhanced with database field later
+const DEFAULT_SLUG_MAPPINGS: Record<string, number> = {
+  // Movies
+  movies: NEWZNAB_CATEGORIES.MOVIES,
+  'movies-hd': NEWZNAB_CATEGORIES.MOVIES_HD,
+  'movies-uhd': NEWZNAB_CATEGORIES.MOVIES_UHD,
+  'movies-sd': NEWZNAB_CATEGORIES.MOVIES_SD,
+  'movies-4k': NEWZNAB_CATEGORIES.MOVIES_UHD,
+  'movies-bluray': NEWZNAB_CATEGORIES.MOVIES_BLURAY,
+  'movies-dvd': NEWZNAB_CATEGORIES.MOVIES_SD,
+  'movies-remux': NEWZNAB_CATEGORIES.MOVIES_BLURAY,
+  // TV
+  tv: NEWZNAB_CATEGORIES.TV,
+  'tv-hd': NEWZNAB_CATEGORIES.TV_HD,
+  'tv-uhd': NEWZNAB_CATEGORIES.TV_UHD,
+  'tv-sd': NEWZNAB_CATEGORIES.TV_SD,
+  'tv-4k': NEWZNAB_CATEGORIES.TV_UHD,
+  'tv-anime': NEWZNAB_CATEGORIES.TV_ANIME,
+  'tv-documentary': NEWZNAB_CATEGORIES.TV_DOCUMENTARY,
+  'tv-sport': NEWZNAB_CATEGORIES.TV_SPORT,
+  // Audio
+  audio: NEWZNAB_CATEGORIES.AUDIO,
+  music: NEWZNAB_CATEGORIES.AUDIO,
+  'music-mp3': NEWZNAB_CATEGORIES.AUDIO_MP3,
+  'music-flac': NEWZNAB_CATEGORIES.AUDIO_LOSSLESS,
+  'music-lossless': NEWZNAB_CATEGORIES.AUDIO_LOSSLESS,
+  // Games
+  games: NEWZNAB_CATEGORIES.PC_GAMES,
+  'games-pc': NEWZNAB_CATEGORIES.PC_GAMES,
+  'games-console': NEWZNAB_CATEGORIES.CONSOLE,
+  'games-ps4': NEWZNAB_CATEGORIES.CONSOLE_PS4,
+  'games-ps3': NEWZNAB_CATEGORIES.CONSOLE_PS3,
+  'games-xbox': NEWZNAB_CATEGORIES.CONSOLE_XBOX,
+  'games-switch': NEWZNAB_CATEGORIES.CONSOLE,
+  // Software
+  software: NEWZNAB_CATEGORIES.PC,
+  apps: NEWZNAB_CATEGORIES.PC_0DAY,
+  applications: NEWZNAB_CATEGORIES.PC_0DAY,
+  // Books
+  books: NEWZNAB_CATEGORIES.BOOKS,
+  ebooks: NEWZNAB_CATEGORIES.BOOKS_EBOOK,
+  comics: NEWZNAB_CATEGORIES.BOOKS_COMICS,
+  // Anime
+  anime: NEWZNAB_CATEGORIES.TV_ANIME,
+  // Other
+  other: NEWZNAB_CATEGORIES.OTHER,
+  misc: NEWZNAB_CATEGORIES.OTHER_MISC,
+};
+
+/**
+ * Get Newznab category ID for a Trackarr category
+ * Priority: 1) Database newznabId field, 2) Slug-based mapping, 3) Fallback to OTHER
+ */
+export function getNewznabCategoryId(
+  category: {
+    id: string;
+    slug: string;
+    parentId?: string | null;
+    newznabId?: number | null;
+  } | null
+): number {
+  if (!category) return NEWZNAB_CATEGORIES.OTHER;
+
+  // Priority 1: Use database-configured newznabId if set
+  if (category.newznabId) return category.newznabId;
+
+  // Priority 2: Check slug-based mapping
+  const mapped = DEFAULT_SLUG_MAPPINGS[category.slug.toLowerCase()];
+  if (mapped) return mapped;
+
+  // Fallback to OTHER
+  return NEWZNAB_CATEGORIES.OTHER;
+}
+
+/**
+ * Get all categories with their Newznab mappings
+ */
+export async function getCategoriesWithNewznabIds(): Promise<
+  Array<{
+    id: string;
+    name: string;
+    slug: string;
+    parentId: string | null;
+    newznabId: number;
+  }>
+> {
+  const categories = await db.query.categories.findMany({
+    orderBy: (cat, { asc }) => [asc(cat.name)],
+  });
+
+  return categories.map((cat) => ({
+    ...cat,
+    newznabId: getNewznabCategoryId(cat),
+  }));
+}
+
+/**
+ * Build Newznab category tree for capabilities response
+ */
+export async function buildCategoryTree() {
+  const categories = await getCategoriesWithNewznabIds();
+
+  // Group by parent categories (Newznab main categories)
+  const mainCats: Map<
+    number,
+    { name: string; subcats: Array<{ id: number; name: string }> }
+  > = new Map();
+
+  for (const cat of categories) {
+    const mainCatId = Math.floor(cat.newznabId / 1000) * 1000;
+
+    if (!mainCats.has(mainCatId)) {
+      mainCats.set(mainCatId, {
+        name: getMainCategoryName(mainCatId),
+        subcats: [],
+      });
+    }
+
+    // Add as subcat if it's not exactly the main category
+    if (cat.newznabId !== mainCatId) {
+      mainCats.get(mainCatId)!.subcats.push({
+        id: cat.newznabId,
+        name: cat.name,
+      });
+    }
+  }
+
+  return Array.from(mainCats.entries()).map(([id, data]) => ({
+    id,
+    name: data.name,
+    subcats: data.subcats.length > 0 ? data.subcats : undefined,
+  }));
+}
+
+function getMainCategoryName(catId: number): string {
+  switch (catId) {
+    case 1000:
+      return 'Console';
+    case 2000:
+      return 'Movies';
+    case 3000:
+      return 'Audio';
+    case 4000:
+      return 'PC';
+    case 5000:
+      return 'TV';
+    case 6000:
+      return 'XXX';
+    case 7000:
+      return 'Books';
+    case 8000:
+      return 'Other';
+    default:
+      return 'Other';
+  }
+}
+
+/**
+ * Filter Trackarr categories by Newznab category IDs
+ * Used for search filtering
+ */
+export async function filterCategoriesByNewznab(
+  newznabIds: number[]
+): Promise<string[]> {
+  if (newznabIds.length === 0) return [];
+
+  const categories = await getCategoriesWithNewznabIds();
+
+  // Match exact IDs or parent IDs (e.g., 2000 matches 2040, 2050, etc.)
+  return categories
+    .filter((cat) => {
+      for (const nId of newznabIds) {
+        // Exact match
+        if (cat.newznabId === nId) return true;
+        // Parent match (e.g., 2000 matches all 2xxx)
+        if (nId % 1000 === 0 && Math.floor(cat.newznabId / 1000) * 1000 === nId)
+          return true;
+      }
+      return false;
+    })
+    .map((cat) => cat.id);
+}
diff --git a/server/api/torznab/utils/xml.ts b/server/api/torznab/utils/xml.ts
new file mode 100644
index 0000000..bad7912
--- /dev/null
+++ b/server/api/torznab/utils/xml.ts
@@ -0,0 +1,175 @@
+/**
+ * Torznab XML Response Builders
+ * Utilities for building XML responses conforming to Torznab specification
+ */
+
+const escapeXml = (str: string): string =>
+  str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+
+// ============================================================================
+// Torznab Error Response
+// ============================================================================
+export interface TorznabError {
+  code: number;
+  description: string;
+}
+
+export function buildErrorXml(error: TorznabError): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<error code="${error.code}" description="${escapeXml(error.description)}"/>`;
+}
+
+// Error codes per Torznab spec
+export const TORZNAB_ERRORS = {
+  INCORRECT_CREDENTIALS: {
+    code: 100,
+    description: 'Incorrect user credentials',
+  },
+  ACCOUNT_SUSPENDED: { code: 101, description: 'Account suspended' },
+  INSUFFICIENT_PRIVILEGES: {
+    code: 102,
+    description: 'Insufficient privileges',
+  },
+  MISSING_PARAMETER: { code: 200, description: 'Missing parameter' },
+  INCORRECT_PARAMETER: { code: 201, description: 'Incorrect parameter' },
+  NO_SUCH_FUNCTION: { code: 300, description: 'No such function' },
+  INTERNAL_ERROR: { code: 500, description: 'Internal error' },
+  API_DISABLED: { code: 910, description: 'API disabled' },
+} as const;
+
+// ============================================================================
+// Capabilities Response
+// ============================================================================
+export interface TorznabCategory {
+  id: number;
+  name: string;
+  subcats?: TorznabCategory[];
+}
+
+export interface CapsConfig {
+  serverVersion: string;
+  serverTitle: string;
+  maxLimit: number;
+  defaultLimit: number;
+  categories: TorznabCategory[];
+}
+
+export function buildCapsXml(config: CapsConfig): string {
+  const buildSubcats = (subcats: TorznabCategory[] = []): string =>
+    subcats
+      .map((s) => `      <subcat id="${s.id}" name="${escapeXml(s.name)}"/>`)
+      .join('\n');
+
+  const buildCategories = (cats: TorznabCategory[]): string =>
+    cats
+      .map((c) => {
+        const subcatsXml = c.subcats?.length
+          ? `\n${buildSubcats(c.subcats)}\n    `
+          : '';
+        return `    <category id="${c.id}" name="${escapeXml(c.name)}">${subcatsXml}</category>`;
+      })
+      .join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<caps>
+  <server version="${escapeXml(config.serverVersion)}" title="${escapeXml(config.serverTitle)}"/>
+  <limits max="${config.maxLimit}" default="${config.defaultLimit}"/>
+  <registration available="no" open="no"/>
+
+  <searching>
+    <search available="yes" supportedParams="q"/>
+    <tv-search available="yes" supportedParams="q,season,ep"/>
+    <movie-search available="yes" supportedParams="q,imdbid"/>
+    <audio-search available="no"/>
+    <book-search available="no"/>
+  </searching>
+
+  <categories>
+${buildCategories(config.categories)}
+  </categories>
+</caps>`;
+}
+
+// ============================================================================
+// Search Response (RSS with Torznab extensions)
+// ============================================================================
+export interface TorznabItem {
+  title: string;
+  guid: string;
+  link: string;
+  commentsUrl: string;
+  pubDate: Date;
+  size: number;
+  description?: string;
+  categoryName?: string;
+  categoryId: number;
+  seeders: number;
+  leechers: number;
+  grabs: number;
+  downloadUrl: string;
+  downloadVolumeFactor?: number; // 0 = freeleech, 1 = normal
+  uploadVolumeFactor?: number; // 1 = normal, 2 = double upload
+  imdbId?: string;
+}
+
+export interface TorznabFeed {
+  title: string;
+  description: string;
+  link: string;
+  selfUrl: string;
+  items: TorznabItem[];
+}
+
+export function buildSearchXml(feed: TorznabFeed): string {
+  const items = feed.items
+    .map((item) => {
+      const attrs = [
+        `      <torznab:attr name="category" value="${item.categoryId}"/>`,
+        `      <torznab:attr name="size" value="${item.size}"/>`,
+        `      <torznab:attr name="seeders" value="${item.seeders}"/>`,
+        `      <torznab:attr name="peers" value="${item.leechers}"/>`,
+        `      <torznab:attr name="grabs" value="${item.grabs}"/>`,
+        `      <torznab:attr name="downloadvolumefactor" value="${item.downloadVolumeFactor ?? 1}"/>`,
+        `      <torznab:attr name="uploadvolumefactor" value="${item.uploadVolumeFactor ?? 1}"/>`,
+      ];
+
+      if (item.imdbId) {
+        attrs.push(
+          `      <torznab:attr name="imdbid" value="${escapeXml(item.imdbId)}"/>`
+        );
+      }
+
+      return `    <item>
+      <title>${escapeXml(item.title)}</title>
+      <guid>${escapeXml(item.guid)}</guid>
+      <link>${escapeXml(item.link)}</link>
+      <comments>${escapeXml(item.commentsUrl)}</comments>
+      <pubDate>${item.pubDate.toUTCString()}</pubDate>
+      <size>${item.size}</size>
+      <description><![CDATA[${item.description ?? ''}]]></description>
+      ${item.categoryName ? `<category>${escapeXml(item.categoryName)}</category>` : ''}
+${attrs.join('\n')}
+      <enclosure url="${escapeXml(item.downloadUrl)}" length="${item.size}" type="application/x-bittorrent"/>
+    </item>`;
+    })
+    .join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0"
+     xmlns:atom="http://www.w3.org/2005/Atom"
+     xmlns:torznab="http://torznab.com/schemas/2015/feed">
+  <channel>
+    <title>${escapeXml(feed.title)}</title>
+    <description>${escapeXml(feed.description)}</description>
+    <link>${escapeXml(feed.link)}</link>
+    <language>en-us</language>
+    <atom:link href="${escapeXml(feed.selfUrl)}" rel="self" type="application/rss+xml"/>
+${items}
+  </channel>
+</rss>`;
+}
diff --git a/server/db/migrations/0010_torznab_categories.sql b/server/db/migrations/0010_torznab_categories.sql
new file mode 100644
index 0000000..3e0be45
--- /dev/null
+++ b/server/db/migrations/0010_torznab_categories.sql
@@ -0,0 +1,2 @@
+-- Add newznabId column to categories table for Torznab API integration
+ALTER TABLE "categories" ADD COLUMN "newznab_id" integer;
diff --git a/server/db/schema.ts b/server/db/schema.ts
index 2ce2279..138a65a 100644
--- a/server/db/schema.ts
+++ b/server/db/schema.ts
@@ -77,6 +77,7 @@ export const categories = pgTable(
     name: text('name').notNull(),
     slug: text('slug').notNull().unique(),
     parentId: text('parent_id'),
+    newznabId: integer('newznab_id'), // Newznab/Torznab category ID for *arr integration
     createdAt: timestamp('created_at').defaultNow().notNull(),
   },
   (table) => [index('categories_parent_idx').on(table.parentId)]
diff --git a/server/plugins/stats-collector.ts b/server/plugins/stats-collector.ts
index 2e6dc4c..563b8da 100644
--- a/server/plugins/stats-collector.ts
+++ b/server/plugins/stats-collector.ts
@@ -4,10 +4,16 @@ import { redis } from '../redis/client';
 import { v4 as uuidv4 } from 'uuid';
 
 export default defineNitroPlugin((nitroApp) => {
-  // Run every hour
-  const INTERVAL = 60 * 60 * 1000;
+  // Run every hour by default, or use env var (in ms)
+  const INTERVAL = parseInt(
+    process.env.STATS_COLLECTION_INTERVAL || '3600000',
+    10
+  );
+
+  console.log(`[Stats Collector] Initialized with interval: ${INTERVAL}ms`);
 
   const collectStats = async () => {
+    console.log('[Stats Collector] Starting stats collection...');
     try {
       // 1. Users Count
       const usersCountResult = await db
@@ -32,7 +38,7 @@ export default defineNitroPlugin((nitroApp) => {
         const [nextCursor, keys] = await redis.scan(
           cursor,
           'MATCH',
-          'peers:*',
+          `${keyPrefix}peers:*`,
           'COUNT',
           100
         );
@@ -75,6 +81,10 @@ export default defineNitroPlugin((nitroApp) => {
         dbSize,
         createdAt: new Date(),
       });
+
+      console.log(
+        `[Stats Collector] Stats collected successfully. Peers: ${peersCount}, Seeders: ${seedersCount}`
+      );
     } catch (err) {
       console.error('[Stats Collector] Failed to collect stats:', err);
     }
diff --git a/server/utils/auth.ts b/server/utils/auth.ts
index 1f3021c..cb8146f 100644
--- a/server/utils/auth.ts
+++ b/server/utils/auth.ts
@@ -3,8 +3,17 @@
  * Protects admin routes with API key or session validation
  */
 
+import { randomBytes } from 'crypto';
+
 const ADMIN_API_KEY = process.env.ADMIN_API_KEY || '';
 
+/**
+ * Generate a random passkey (40 hex chars)
+ */
+export function generatePasskey(): string {
+  return randomBytes(20).toString('hex');
+}
+
 /**
  * Check if the request has valid admin authentication
  * Supports:
diff --git a/server/utils/schemas.ts b/server/utils/schemas.ts
index 5fdf349..7ea78b8 100644
--- a/server/utils/schemas.ts
+++ b/server/utils/schemas.ts
@@ -3,14 +3,13 @@
  * Centralized request validation schemas for all API endpoints
  */
 
-import { z } from 'zod';
+import { z } from 'zod/v4';
 
 // ============================================================================
 // Base Schemas
 // ============================================================================
 
 export const uuidSchema = z
-  .string()
   .uuid('Invalid UUID format')
   .transform((val) => val.toLowerCase());
 
@@ -76,14 +75,14 @@ export const registerSchema = z.object({
 // ============================================================================
 
 export const torrentUploadSchema = z.object({
-  categoryId: z.string().uuid('Invalid category ID').optional(),
+  categoryId: z.uuid('Invalid category ID').optional(),
   description: z.string().max(10000, 'Description too long').optional(),
 });
 
 export const torrentQuerySchema = z.object({
   page: z.coerce.number().int().positive().default(1),
   limit: z.coerce.number().int().positive().max(100).default(20),
-  categoryId: z.string().uuid().optional(),
+  categoryId: z.uuid().optional(),
   search: z.string().max(255).optional(),
   sortBy: z
     .enum(['uploaded', 'name', 'size', 'seeders', 'leechers'])
@@ -121,7 +120,8 @@ export const adminCategorySchema = z.object({
       'Slug can only contain lowercase letters, numbers, and hyphens'
     )
     .optional(),
-  parentId: z.string().uuid('Invalid parent category ID').nullable().optional(),
+  parentId: z.uuid('Invalid parent category ID').nullable().optional(),
+  newznabId: z.coerce.number().int().min(1000).max(9999).nullable().optional(),
   description: z.string().max(500).optional(),
   icon: z.string().max(50).optional(),
 });
@@ -185,12 +185,12 @@ export const forumCategorySchema = z.object({
 export const forumTopicSchema = z.object({
   title: z.string().min(1, 'Title is required').max(200),
   content: z.string().min(1, 'Content is required').max(50000),
-  categoryId: z.string().uuid('Invalid category ID'),
+  categoryId: z.uuid('Invalid category ID'),
 });
 
 export const forumPostSchema = z.object({
   content: z.string().min(1, 'Content is required').max(50000),
-  topicId: z.string().uuid('Invalid topic ID'),
+  topicId: z.uuid('Invalid topic ID'),
 });
 
 export const forumTopicUpdateSchema = z.object({
diff --git a/server/utils/torznabSettings.ts b/server/utils/torznabSettings.ts
new file mode 100644
index 0000000..a6a16b7
--- /dev/null
+++ b/server/utils/torznabSettings.ts
@@ -0,0 +1,146 @@
+/**
+ * Torznab API Settings Management
+ * Manages configuration for the Torznab API from admin panel
+ */
+
+import { getSetting, setSetting } from './settings';
+
+// Settings keys for Torznab
+export const TORZNAB_SETTINGS = {
+  ENABLED: 'torznab_enabled',
+  RATE_LIMIT_SEARCH: 'torznab_rate_limit_search',
+  RATE_LIMIT_DOWNLOAD: 'torznab_rate_limit_download',
+  RATE_LIMIT_WINDOW: 'torznab_rate_limit_window',
+  ENABLE_LOGGING: 'torznab_enable_logging',
+  ALLOWED_CATEGORIES: 'torznab_allowed_categories',
+} as const;
+
+// Default values
+const DEFAULTS = {
+  enabled: true,
+  rateLimitSearch: 30, // requests per window
+  rateLimitDownload: 20, // requests per window
+  rateLimitWindow: 60, // seconds
+  enableLogging: true,
+  allowedCategories: [] as string[], // empty = all allowed
+};
+
+/**
+ * Check if Torznab API is enabled
+ */
+export async function getTorznabEnabled(): Promise<boolean> {
+  const value = await getSetting(TORZNAB_SETTINGS.ENABLED);
+  return value !== 'false'; // Default to enabled
+}
+
+/**
+ * Set Torznab API enabled status
+ */
+export async function setTorznabEnabled(enabled: boolean): Promise<void> {
+  await setSetting(TORZNAB_SETTINGS.ENABLED, enabled ? 'true' : 'false');
+}
+
+/**
+ * Get search rate limit (requests per window)
+ */
+export async function getTorznabRateLimitSearch(): Promise<number> {
+  const value = await getSetting(TORZNAB_SETTINGS.RATE_LIMIT_SEARCH);
+  return value ? parseInt(value, 10) : DEFAULTS.rateLimitSearch;
+}
+
+/**
+ * Set search rate limit
+ */
+export async function setTorznabRateLimitSearch(limit: number): Promise<void> {
+  await setSetting(TORZNAB_SETTINGS.RATE_LIMIT_SEARCH, limit.toString());
+}
+
+/**
+ * Get download rate limit (requests per window)
+ */
+export async function getTorznabRateLimitDownload(): Promise<number> {
+  const value = await getSetting(TORZNAB_SETTINGS.RATE_LIMIT_DOWNLOAD);
+  return value ? parseInt(value, 10) : DEFAULTS.rateLimitDownload;
+}
+
+/**
+ * Set download rate limit
+ */
+export async function setTorznabRateLimitDownload(
+  limit: number
+): Promise<void> {
+  await setSetting(TORZNAB_SETTINGS.RATE_LIMIT_DOWNLOAD, limit.toString());
+}
+
+/**
+ * Get rate limit window (seconds)
+ */
+export async function getTorznabRateLimitWindow(): Promise<number> {
+  const value = await getSetting(TORZNAB_SETTINGS.RATE_LIMIT_WINDOW);
+  return value ? parseInt(value, 10) : DEFAULTS.rateLimitWindow;
+}
+
+/**
+ * Set rate limit window
+ */
+export async function setTorznabRateLimitWindow(window: number): Promise<void> {
+  await setSetting(TORZNAB_SETTINGS.RATE_LIMIT_WINDOW, window.toString());
+}
+
+/**
+ * Check if request logging is enabled
+ */
+export async function getTorznabEnableLogging(): Promise<boolean> {
+  const value = await getSetting(TORZNAB_SETTINGS.ENABLE_LOGGING);
+  return value !== 'false'; // Default to enabled
+}
+
+/**
+ * Set logging enabled status
+ */
+export async function setTorznabEnableLogging(enabled: boolean): Promise<void> {
+  await setSetting(TORZNAB_SETTINGS.ENABLE_LOGGING, enabled ? 'true' : 'false');
+}
+
+/**
+ * Get allowed categories (empty = all allowed)
+ */
+export async function getTorznabAllowedCategories(): Promise<string[]> {
+  const value = await getSetting(TORZNAB_SETTINGS.ALLOWED_CATEGORIES);
+  if (!value) return DEFAULTS.allowedCategories;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return DEFAULTS.allowedCategories;
+  }
+}
+
+/**
+ * Set allowed categories
+ */
+export async function setTorznabAllowedCategories(
+  categories: string[]
+): Promise<void> {
+  await setSetting(
+    TORZNAB_SETTINGS.ALLOWED_CATEGORIES,
+    JSON.stringify(categories)
+  );
+}
+
+/**
+ * Get dynamic rate limit options for Torznab endpoints
+ */
+export async function getTorznabRateLimitOptions(type: 'search' | 'download') {
+  const [window, searchLimit, downloadLimit] = await Promise.all([
+    getTorznabRateLimitWindow(),
+    getTorznabRateLimitSearch(),
+    getTorznabRateLimitDownload(),
+  ]);
+
+  return {
+    windowSec: window,
+    maxRequests: type === 'search' ? searchLimit : downloadLimit,
+    prefix: type === 'search' ? 'torznab:search' : 'torznab:dl',
+    progressive: true,
+  };
+}
diff --git a/server/utils/torznabStats.ts b/server/utils/torznabStats.ts
new file mode 100644
index 0000000..e57eb46
--- /dev/null
+++ b/server/utils/torznabStats.ts
@@ -0,0 +1,467 @@
+/**
+ * Torznab API Statistics and Logging
+ * Tracks API usage, logs requests, and manages user-specific stats
+ */
+
+import { redis } from '../redis/client';
+
+// Redis key prefixes
+const KEYS = {
+  STATS: 'torznab:stats',
+  LOGS: 'torznab:logs',
+  USER_STATS: 'torznab:user:stats',
+  USER_LOGS: 'torznab:user:logs',
+  BLOCKED: 'torznab:blocked',
+  HOURLY: 'torznab:hourly',
+  RATE_LIMIT_HITS: 'torznab:rate_limit_hits',
+};
+
+// Stats TTL (30 days)
+const STATS_TTL = 30 * 24 * 60 * 60;
+// Logs TTL (7 days)
+const LOGS_TTL = 7 * 24 * 60 * 60;
+
+interface TorznabLogEntry {
+  timestamp: number;
+  passkey: string;
+  function: string;
+  query?: string;
+  ip: string;
+  userAgent?: string;
+  responseTime: number;
+  resultCount: number;
+  error?: string;
+}
+
+interface TorznabUserStats {
+  totalRequests: number;
+  searchRequests: number;
+  downloadRequests: number;
+  lastRequest: number;
+  rateLimitHits: number;
+}
+
+interface TorznabStats {
+  totalRequests: number;
+  searchRequests: number;
+  downloadRequests: number;
+  capsRequests: number;
+  tvSearchRequests: number;
+  movieSearchRequests: number;
+  errorsCount: number;
+  uniqueUsers: number;
+  avgResponseTime: number;
+  last24hRequests: number;
+}
+
+// ============================================================================
+// Global Stats
+// ============================================================================
+
+/**
+ * Increment a stat counter
+ */
+async function incrementStat(field: string, amount = 1): Promise<void> {
+  try {
+    await redis.hincrby(KEYS.STATS, field, amount);
+    await redis.expire(KEYS.STATS, STATS_TTL);
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to increment stat:', error);
+  }
+}
+
+/**
+ * Get all Torznab stats
+ */
+export async function getTorznabStats(): Promise<TorznabStats> {
+  try {
+    const data = await redis.hgetall(KEYS.STATS);
+
+    // Get unique users count from user stats hash
+    const userKeys = await redis.hkeys(KEYS.USER_STATS);
+
+    // Get last 24h requests
+    const now = Date.now();
+    const oneDayAgo = now - 24 * 60 * 60 * 1000;
+    let last24hRequests = 0;
+
+    for (let i = 0; i < 24; i++) {
+      const hourKey = `${KEYS.HOURLY}:${Math.floor((now - i * 60 * 60 * 1000) / (60 * 60 * 1000))}`;
+      const count = await redis.get(hourKey);
+      if (count) {
+        last24hRequests += parseInt(count, 10);
+      }
+    }
+
+    return {
+      totalRequests: parseInt(data.totalRequests || '0', 10),
+      searchRequests: parseInt(data.searchRequests || '0', 10),
+      downloadRequests: parseInt(data.downloadRequests || '0', 10),
+      capsRequests: parseInt(data.capsRequests || '0', 10),
+      tvSearchRequests: parseInt(data.tvSearchRequests || '0', 10),
+      movieSearchRequests: parseInt(data.movieSearchRequests || '0', 10),
+      errorsCount: parseInt(data.errorsCount || '0', 10),
+      uniqueUsers: userKeys.length,
+      avgResponseTime: parseFloat(data.avgResponseTime || '0'),
+      last24hRequests,
+    };
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get stats:', error);
+    return {
+      totalRequests: 0,
+      searchRequests: 0,
+      downloadRequests: 0,
+      capsRequests: 0,
+      tvSearchRequests: 0,
+      movieSearchRequests: 0,
+      errorsCount: 0,
+      uniqueUsers: 0,
+      avgResponseTime: 0,
+      last24hRequests: 0,
+    };
+  }
+}
+
+/**
+ * Log a Torznab request
+ */
+export async function logTorznabRequest(entry: TorznabLogEntry): Promise<void> {
+  try {
+    const logEntry = JSON.stringify(entry);
+
+    // Add to global logs (capped at 1000 entries)
+    await redis.lpush(KEYS.LOGS, logEntry);
+    await redis.ltrim(KEYS.LOGS, 0, 999);
+    await redis.expire(KEYS.LOGS, LOGS_TTL);
+
+    // Add to user-specific logs
+    const userLogKey = `${KEYS.USER_LOGS}:${entry.passkey}`;
+    await redis.lpush(userLogKey, logEntry);
+    await redis.ltrim(userLogKey, 0, 99);
+    await redis.expire(userLogKey, LOGS_TTL);
+
+    // Update global stats
+    await incrementStat('totalRequests');
+
+    // Track by function type
+    switch (entry.function) {
+      case 'search':
+        await incrementStat('searchRequests');
+        break;
+      case 'tvsearch':
+        await incrementStat('tvSearchRequests');
+        break;
+      case 'movie':
+        await incrementStat('movieSearchRequests');
+        break;
+      case 'caps':
+        await incrementStat('capsRequests');
+        break;
+    }
+
+    if (entry.error) {
+      await incrementStat('errorsCount');
+    }
+
+    // Track hourly requests
+    const hourKey = `${KEYS.HOURLY}:${Math.floor(Date.now() / (60 * 60 * 1000))}`;
+    await redis.incr(hourKey);
+    await redis.expire(hourKey, 25 * 60 * 60); // Keep for 25 hours
+
+    // Update user stats
+    await updateUserStats(entry.passkey, entry.function);
+
+    // Update rolling average response time
+    const currentAvg = parseFloat(
+      (await redis.hget(KEYS.STATS, 'avgResponseTime')) || '0'
+    );
+    const total = parseInt(
+      (await redis.hget(KEYS.STATS, 'totalRequests')) || '1',
+      10
+    );
+    const newAvg = (currentAvg * (total - 1) + entry.responseTime) / total;
+    await redis.hset(KEYS.STATS, 'avgResponseTime', newAvg.toFixed(2));
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to log request:', error);
+  }
+}
+
+/**
+ * Get recent logs with pagination
+ */
+export async function getTorznabRecentLogs(
+  limit = 50,
+  offset = 0
+): Promise<{ logs: TorznabLogEntry[]; total: number }> {
+  try {
+    const total = await redis.llen(KEYS.LOGS);
+    const logs = await redis.lrange(KEYS.LOGS, offset, offset + limit - 1);
+    const parsedLogs = logs
+      .map((log) => {
+        try {
+          const entry = JSON.parse(log);
+          // Mask passkey in logs
+          entry.passkey = `${entry.passkey.substring(0, 8)}...`;
+          // Mask IP
+          entry.ip = entry.ip.split('.').slice(0, 2).join('.') + '.*.*';
+          return entry;
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean) as TorznabLogEntry[];
+    return { logs: parsedLogs, total };
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get logs:', error);
+    return { logs: [], total: 0 };
+  }
+}
+
+/**
+ * Get logs for a specific user with pagination
+ */
+export async function getTorznabLogsByUser(
+  passkey: string,
+  limit = 50,
+  offset = 0
+): Promise<{ logs: TorznabLogEntry[]; total: number }> {
+  try {
+    const key = `${KEYS.USER_LOGS}:${passkey}`;
+    const total = await redis.llen(key);
+    const logs = await redis.lrange(key, offset, offset + limit - 1);
+    const parsedLogs = logs
+      .map((log) => {
+        try {
+          const entry = JSON.parse(log);
+          entry.passkey = `${entry.passkey.substring(0, 8)}...`;
+          entry.ip = entry.ip.split('.').slice(0, 2).join('.') + '.*.*';
+          return entry;
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean) as TorznabLogEntry[];
+    return { logs: parsedLogs, total };
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get user logs:', error);
+    return { logs: [], total: 0 };
+  }
+}
+
+// ============================================================================
+// User Stats
+// ============================================================================
+
+/**
+ * Update user-specific stats
+ */
+async function updateUserStats(passkey: string, func: string): Promise<void> {
+  try {
+    const key = KEYS.USER_STATS;
+    const existing = await redis.hget(key, passkey);
+
+    let stats: TorznabUserStats = existing
+      ? JSON.parse(existing)
+      : {
+          totalRequests: 0,
+          searchRequests: 0,
+          downloadRequests: 0,
+          lastRequest: 0,
+          rateLimitHits: 0,
+        };
+
+    stats.totalRequests++;
+    stats.lastRequest = Date.now();
+
+    if (func === 'search' || func === 'tvsearch' || func === 'movie') {
+      stats.searchRequests++;
+    } else if (func === 'download') {
+      stats.downloadRequests++;
+    }
+
+    await redis.hset(key, passkey, JSON.stringify(stats));
+    await redis.expire(key, STATS_TTL);
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to update user stats:', error);
+  }
+}
+
+/**
+ * Get stats for a specific user
+ */
+export async function getTorznabUserStats(
+  passkey: string
+): Promise<TorznabUserStats | null> {
+  try {
+    const data = await redis.hget(KEYS.USER_STATS, passkey);
+    return data ? JSON.parse(data) : null;
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get user stats:', error);
+    return null;
+  }
+}
+
+/**
+ * Clear stats for a specific user (used when resetting passkey)
+ */
+export async function clearTorznabUserStats(passkey: string): Promise<void> {
+  try {
+    await redis.hdel(KEYS.USER_STATS, passkey);
+    await redis.del(`${KEYS.USER_LOGS}:${passkey}`);
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to clear user stats:', error);
+  }
+}
+
+/**
+ * Get top users by request count
+ */
+export async function getTorznabTopUsers(
+  limit = 10
+): Promise<Array<{ passkey: string; stats: TorznabUserStats }>> {
+  try {
+    const allStats = await redis.hgetall(KEYS.USER_STATS);
+    const users: Array<{ passkey: string; stats: TorznabUserStats }> = [];
+
+    for (const [passkey, data] of Object.entries(allStats)) {
+      try {
+        const stats = JSON.parse(data);
+        users.push({
+          passkey: `${passkey.substring(0, 8)}...${passkey.substring(36)}`,
+          stats,
+        });
+      } catch {
+        // Skip invalid entries
+      }
+    }
+
+    // Sort by total requests
+    return users
+      .sort((a, b) => b.stats.totalRequests - a.stats.totalRequests)
+      .slice(0, limit);
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get top users:', error);
+    return [];
+  }
+}
+
+/**
+ * Get requests by hour (last N hours)
+ */
+export async function getTorznabRequestsByHour(
+  hours = 24
+): Promise<Array<{ hour: number; count: number }>> {
+  try {
+    const now = Date.now();
+    const result: Array<{ hour: number; count: number }> = [];
+
+    for (let i = hours - 1; i >= 0; i--) {
+      const timestamp = now - i * 60 * 60 * 1000;
+      const hourKey = `${KEYS.HOURLY}:${Math.floor(timestamp / (60 * 60 * 1000))}`;
+      const count = await redis.get(hourKey);
+      result.push({
+        hour: Math.floor(timestamp / (60 * 60 * 1000)) * (60 * 60 * 1000),
+        count: count ? parseInt(count, 10) : 0,
+      });
+    }
+
+    return result;
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get hourly requests:', error);
+    return [];
+  }
+}
+
+/**
+ * Track rate limit hit
+ */
+export async function trackRateLimitHit(passkey: string): Promise<void> {
+  try {
+    // Update global count
+    await redis.hincrby(KEYS.RATE_LIMIT_HITS, 'total', 1);
+    await redis.expire(KEYS.RATE_LIMIT_HITS, STATS_TTL);
+
+    // Update user stats
+    const existing = await redis.hget(KEYS.USER_STATS, passkey);
+    if (existing) {
+      const stats = JSON.parse(existing);
+      stats.rateLimitHits = (stats.rateLimitHits || 0) + 1;
+      await redis.hset(KEYS.USER_STATS, passkey, JSON.stringify(stats));
+    }
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to track rate limit hit:', error);
+  }
+}
+
+/**
+ * Get rate limit hit stats
+ */
+export async function getTorznabRateLimitHits(): Promise<{
+  total: number;
+  byHour: Array<{ hour: number; count: number }>;
+}> {
+  try {
+    const data = await redis.hgetall(KEYS.RATE_LIMIT_HITS);
+    return {
+      total: parseInt(data.total || '0', 10),
+      byHour: [], // Could implement hourly tracking if needed
+    };
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to get rate limit hits:', error);
+    return { total: 0, byHour: [] };
+  }
+}
+
+// ============================================================================
+// User Blocking
+// ============================================================================
+
+/**
+ * Block a user from Torznab API
+ */
+export async function blockTorznabUser(
+  passkey: string,
+  reason: string
+): Promise<void> {
+  try {
+    await redis.hset(
+      KEYS.BLOCKED,
+      passkey,
+      JSON.stringify({
+        reason,
+        blockedAt: Date.now(),
+      })
+    );
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to block user:', error);
+  }
+}
+
+/**
+ * Unblock a user from Torznab API
+ */
+export async function unblockTorznabUser(passkey: string): Promise<void> {
+  try {
+    await redis.hdel(KEYS.BLOCKED, passkey);
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to unblock user:', error);
+  }
+}
+
+/**
+ * Check if a user is blocked
+ */
+export async function isTorznabUserBlocked(
+  passkey: string
+): Promise<{ blocked: boolean; reason?: string }> {
+  try {
+    const data = await redis.hget(KEYS.BLOCKED, passkey);
+    if (!data) return { blocked: false };
+
+    const entry = JSON.parse(data);
+    return { blocked: true, reason: entry.reason };
+  } catch (error) {
+    console.error('[Torznab Stats] Failed to check user block status:', error);
+    return { blocked: false };
+  }
+}