diff --git a/frontend/src/components/config/MetadataConfigSection.tsx b/frontend/src/components/config/MetadataConfigSection.tsx
index 1b638bbd7..996a324e5 100644
--- a/frontend/src/components/config/MetadataConfigSection.tsx
+++ b/frontend/src/components/config/MetadataConfigSection.tsx
@@ -315,30 +315,6 @@ export function MetadataConfigSection({
 								</span>
 							</div>
 						</label>
-
-						<label className="label cursor-pointer items-start justify-start gap-4">
-							<input
-								type="checkbox"
-								className="checkbox checkbox-error checkbox-sm mt-1 shrink-0"
-								checked={formData.delete_completed_nzb ?? false}
-								disabled={isReadOnly}
-								onChange={(e) => handleCheckboxChange("delete_completed_nzb", e.target.checked)}
-							/>
-							<div className="min-w-0 flex-1">
-								<div className="flex items-center gap-2">
-									<span className="whitespace-normal break-words font-bold text-xs">
-										Aggressive Cleanup
-									</span>
-									<div className="badge badge-error badge-xs shrink-0 font-black text-[8px] uppercase">
-										Dangerous
-									</div>
-								</div>
-								<span className="mt-1 block whitespace-normal break-words text-base-content/50 text-xs leading-relaxed">
-									Delete original NZB immediately after metadata generation. Cannot re-scan without
-									re-upload.
-								</span>
-							</div>
-						</label>
 					</div>
 				</div>
 
diff --git a/frontend/src/components/config/WorkersConfigSection.tsx b/frontend/src/components/config/WorkersConfigSection.tsx
index 981639ad1..14c82b7ba 100644
--- a/frontend/src/components/config/WorkersConfigSection.tsx
+++ b/frontend/src/components/config/WorkersConfigSection.tsx
@@ -282,6 +282,33 @@ export function ImportConfigSection({
 								</span>
 							</div>
 						</label>
+
+						<div className="divider text-base-content/70" />
+
+						<label className="label cursor-pointer items-start justify-start gap-4">
+							<input
+								type="checkbox"
+								className="checkbox checkbox-error checkbox-sm mt-1 shrink-0"
+								checked={formData.delete_completed_nzb ?? false}
+								disabled={isReadOnly}
+								onChange={(e) => handleInputChange("delete_completed_nzb", e.target.checked)}
+							/>
+							<div className="min-w-0 flex-1">
+								<div className="flex items-center gap-2">
+									<span className="whitespace-normal break-words font-bold text-xs">
+										Delete NZB After Import
+									</span>
+									<div className="badge badge-error badge-xs shrink-0 font-black text-[8px] uppercase">
+										Dangerous
+									</div>
+								</div>
+								<span className="mt-1 block whitespace-normal break-words text-base-content/50 text-xs leading-relaxed">
+									Delete the original NZB file from disk once the import completes successfully. The
+									queue entry is retained, but downloading the NZB from the queue will no longer be
+									possible.
+								</span>
+							</div>
+						</label>
 					</div>
 				</div>
 
diff --git a/frontend/src/pages/QueuePage.tsx b/frontend/src/pages/QueuePage.tsx
index 989b11467..ce23cf45e 100644
--- a/frontend/src/pages/QueuePage.tsx
+++ b/frontend/src/pages/QueuePage.tsx
@@ -34,6 +34,7 @@ import { Pagination } from "../components/ui/Pagination";
 import { PathDisplay } from "../components/ui/PathDisplay";
 import { StatusBadge } from "../components/ui/StatusBadge";
 import { useConfirm } from "../contexts/ModalContext";
+import { useToast } from "../contexts/ToastContext";
 import {
 	useAddTestQueueItem,
 	useBulkCancelQueueItems,
@@ -130,6 +131,7 @@ export function QueuePage() {
 	const addTestQueueItem = useAddTestQueueItem();
 	const regenerateSymlinks = useRegenerateSymlinks();
 	const { confirmDelete, confirmAction } = useConfirm();
+	const { showToast } = useToast();
 
 	const handleDelete = useCallback(
 		async (id: number) => {
@@ -166,10 +168,36 @@ export function QueuePage() {
 		[confirmAction, cancelItem],
 	);
 
-	const handleDownload = async (id: number) => {
+	const handleDownload = async (id: number, status?: string) => {
 		try {
 			const response = await fetch(`/api/queue/${id}/download`);
-			if (!response.ok) throw new Error("Failed to download NZB file");
+			if (!response.ok) {
+				let title = "Download Failed";
+				let message = `Server returned ${response.status} ${response.statusText}`;
+				try {
+					const body = (await response.json()) as {
+						error?: { message?: string; details?: string };
+					};
+					if (body?.error?.message) {
+						title = body.error.message;
+						message = body.error.details || "";
+					}
+				} catch {
+					// Non-JSON error body — fall back to status text.
+				}
+				// For completed items, a missing file almost always means the server
+				// cleaned it up post-import (delete_completed_nzb). Soften the toast.
+				if (response.status === 404 && status === "completed") {
+					showToast({
+						type: "info",
+						title: "NZB file already removed",
+						message: "This NZB was cleaned up after successful import.",
+					});
+					return;
+				}
+				showToast({ type: "error", title, message });
+				return;
+			}
 			const contentDisposition = response.headers.get("Content-Disposition");
 			const filenameMatch = contentDisposition?.match(/filename[^;=\n]*=["']?([^"'\n]*)["']?/);
 			const filename = filenameMatch?.[1] || `queue-${id}.nzb`;
@@ -184,6 +212,11 @@ export function QueuePage() {
 			document.body.removeChild(a);
 		} catch (error) {
 			console.error("Failed to download NZB:", error);
+			showToast({
+				type: "error",
+				title: "Download Failed",
+				message: error instanceof Error ? error.message : "Network error",
+			});
 		}
 	};
 
@@ -944,7 +977,7 @@ export function QueuePage() {
 																			<li>
 																				<button
 																					type="button"
-																					onClick={() => handleDownload(item.id)}
+																					onClick={() => handleDownload(item.id, item.status)}
 																				>
 																					<Download className="h-4 w-4" />
 																					Download NZB
diff --git a/frontend/src/types/config.ts b/frontend/src/types/config.ts
index cd54610f4..dd12de4e6 100644
--- a/frontend/src/types/config.ts
+++ b/frontend/src/types/config.ts
@@ -228,6 +228,7 @@ export interface ImportConfig {
 	rename_to_nzb_name?: boolean;
 	filter_sample_files?: boolean;
 	failed_item_retention_hours?: number | null;
+	delete_completed_nzb?: boolean;
 }
 
 // Log configuration
diff --git a/internal/api/queue_handlers.go b/internal/api/queue_handlers.go
index 8c9562fab..7301329d1 100644
--- a/internal/api/queue_handlers.go
+++ b/internal/api/queue_handlers.go
@@ -1,7 +1,6 @@
 package api
 
 import (
-	"compress/gzip"
 	"fmt"
 	"html"
 	"io"
@@ -19,9 +18,25 @@ import (
 	"github.com/javi11/altmount/internal/database"
 	internalerrors "github.com/javi11/altmount/internal/errors"
 	"github.com/javi11/altmount/internal/importer/utils/nzbtrim"
+	"github.com/javi11/altmount/internal/nzbfile"
 	"github.com/javi11/altmount/internal/nzblnk"
 )
 
+// removeQueueNzbFiles deletes the on-disk NZB files for every non-empty path.
+// Missing files are ignored; other errors are logged so the caller can still
+// report the DB deletion as successful.
+func (s *Server) removeQueueNzbFiles(c *fiber.Ctx, paths []string) {
+	for _, p := range paths {
+		if p == "" {
+			continue
+		}
+		if err := os.Remove(p); err != nil && !os.IsNotExist(err) {
+			slog.WarnContext(c.Context(), "Failed to delete NZB file after queue removal",
+				"path", p, "error", err)
+		}
+	}
+}
+
 // transformQueueError transforms specific errors to user-friendly messages
 func transformQueueError(err *string) string {
 	if err == nil {
@@ -232,6 +247,8 @@ func (s *Server) handleDeleteQueue(c *fiber.Ctx) error {
 		return RespondInternalError(c, "Failed to delete queue item", err.Error())
 	}
 
+	s.removeQueueNzbFiles(c, []string{item.NzbPath})
+
 	if s.progressBroadcaster != nil {
 		s.progressBroadcaster.BroadcastQueueChanged()
 	}
@@ -439,12 +456,13 @@ func (s *Server) handleGetQueueHistoricalStats(c *fiber.Ctx) error {
 //	@Security		ApiKeyAuth
 //	@Router			/queue/completed [delete]
 func (s *Server) handleClearCompletedQueue(c *fiber.Ctx) error {
-	// Clear completed items
-	count, err := s.queueRepo.ClearCompletedQueueItems(c.Context())
+	paths, count, err := s.queueRepo.ClearCompletedQueueItems(c.Context())
 	if err != nil {
 		return RespondInternalError(c, "Failed to clear completed queue items", err.Error())
 	}
 
+	s.removeQueueNzbFiles(c, paths)
+
 	if s.progressBroadcaster != nil {
 		s.progressBroadcaster.BroadcastQueueChanged()
 	}
@@ -464,12 +482,13 @@ func (s *Server) handleClearCompletedQueue(c *fiber.Ctx) error {
 //	@Security		ApiKeyAuth
 //	@Router			/queue/failed [delete]
 func (s *Server) handleClearFailedQueue(c *fiber.Ctx) error {
-	// Clear failed items
-	count, err := s.queueRepo.ClearFailedQueueItems(c.Context())
+	paths, count, err := s.queueRepo.ClearFailedQueueItems(c.Context())
 	if err != nil {
 		return RespondInternalError(c, "Failed to clear failed queue items", err.Error())
 	}
 
+	s.removeQueueNzbFiles(c, paths)
+
 	if s.progressBroadcaster != nil {
 		s.progressBroadcaster.BroadcastQueueChanged()
 	}
@@ -489,12 +508,13 @@ func (s *Server) handleClearFailedQueue(c *fiber.Ctx) error {
 //	@Security		ApiKeyAuth
 //	@Router			/queue/pending [delete]
 func (s *Server) handleClearPendingQueue(c *fiber.Ctx) error {
-	// Clear pending items
-	count, err := s.queueRepo.ClearPendingQueueItems(c.Context())
+	paths, count, err := s.queueRepo.ClearPendingQueueItems(c.Context())
 	if err != nil {
 		return RespondInternalError(c, "Failed to clear pending queue items", err.Error())
 	}
 
+	s.removeQueueNzbFiles(c, paths)
+
 	if s.progressBroadcaster != nil {
 		s.progressBroadcaster.BroadcastQueueChanged()
 	}
@@ -542,6 +562,8 @@ func (s *Server) handleDeleteQueueBulk(c *fiber.Ctx) error {
 		return RespondInternalError(c, "Failed to delete queue items", err.Error())
 	}
 
+	s.removeQueueNzbFiles(c, result.DeletedPaths)
+
 	if s.progressBroadcaster != nil {
 		s.progressBroadcaster.BroadcastQueueChanged()
 	}
@@ -1330,39 +1352,26 @@ func (s *Server) handleDownloadNZB(c *fiber.Ctx) error {
 		return RespondNotFound(c, "Queue item", "")
 	}
 
-	// Check if NZB file exists
-	if _, err := os.Stat(item.NzbPath); os.IsNotExist(err) {
+	resolved, err := nzbfile.ResolveOnDisk(item.NzbPath)
+	if err != nil {
 		return RespondNotFound(c, "NZB file", "The NZB file no longer exists on disk")
 	}
 
-	// Strip .gz suffix from the download filename so clients receive a plain .nzb
-	filename := filepath.Base(item.NzbPath)
-	if strings.HasSuffix(strings.ToLower(filename), ".nzb.gz") {
-		filename = strings.TrimSuffix(filename, ".gz")
-	}
 	c.Set("Content-Type", "application/x-nzb")
-	c.Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", filename))
+	c.Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", nzbfile.PlainFilename(resolved)))
 
-	// For gzip-compressed NZBs, decompress on-the-fly before sending
-	if strings.HasSuffix(strings.ToLower(item.NzbPath), ".nzb.gz") {
-		f, err := os.Open(item.NzbPath)
+	if nzbfile.IsGzipped(resolved) {
+		rc, err := nzbfile.Open(resolved)
 		if err != nil {
 			return RespondInternalError(c, "Failed to open NZB file", err.Error())
 		}
-		defer f.Close()
+		defer rc.Close()
 
-		gr, err := gzip.NewReader(f)
-		if err != nil {
-			return RespondInternalError(c, "Failed to decompress NZB file", err.Error())
-		}
-		defer gr.Close()
-
-		data, err := io.ReadAll(gr)
-		if err != nil {
+		if _, err := io.Copy(c.Response().BodyWriter(), rc); err != nil {
 			return RespondInternalError(c, "Failed to read NZB content", err.Error())
 		}
-		return c.Send(data)
+		return nil
 	}
 
-	return c.SendFile(item.NzbPath)
+	return c.SendFile(resolved)
 }
diff --git a/internal/api/system_handlers.go b/internal/api/system_handlers.go
index d5674573b..4b660d705 100644
--- a/internal/api/system_handlers.go
+++ b/internal/api/system_handlers.go
@@ -180,7 +180,8 @@ func (s *Server) handleSystemCleanup(c *fiber.Ctx) error {
 
 	// Clean up queue items
 	if !req.DryRun {
-		queueItemsRemoved, err = s.queueRepo.ClearCompletedQueueItems(c.Context())
+		var paths []string
+		paths, queueItemsRemoved, err = s.queueRepo.ClearCompletedQueueItems(c.Context())
 		if err != nil {
 			return c.Status(500).JSON(fiber.Map{
 				"success": false,
@@ -188,6 +189,7 @@ func (s *Server) handleSystemCleanup(c *fiber.Ctx) error {
 				"details": err.Error(),
 			})
 		}
+		s.removeQueueNzbFiles(c, paths)
 	} else {
 		// For dry run, we could count what would be removed
 		// For now, we'll just return 0
@@ -335,11 +337,17 @@ func (s *Server) handleResetSystemStats(c *fiber.Ctx) error {
 
 		// Optional: Clear completed/failed queue items too if requested
 		if resetQueue {
-			if _, err := s.queueRepo.ClearCompletedQueueItems(ctx); err != nil {
+			completedPaths, _, err := s.queueRepo.ClearCompletedQueueItems(ctx)
+			if err != nil {
 				slog.ErrorContext(ctx, "Failed to clear completed queue items during reset", "error", err)
+			} else {
+				s.removeQueueNzbFiles(c, completedPaths)
 			}
-			if _, err := s.queueRepo.ClearFailedQueueItems(ctx); err != nil {
+			failedPaths, _, err := s.queueRepo.ClearFailedQueueItems(ctx)
+			if err != nil {
 				slog.ErrorContext(ctx, "Failed to clear failed queue items during reset", "error", err)
+			} else {
+				s.removeQueueNzbFiles(c, failedPaths)
 			}
 		}
 	}
diff --git a/internal/config/manager.go b/internal/config/manager.go
index dc5a14db0..cf4fe5180 100644
--- a/internal/config/manager.go
+++ b/internal/config/manager.go
@@ -275,6 +275,21 @@ type ImportConfig struct {
 	RenameToNzbName                *bool          `yaml:"rename_to_nzb_name" mapstructure:"rename_to_nzb_name" json:"rename_to_nzb_name,omitempty"`
 	FilterSampleFiles              *bool          `yaml:"filter_sample_files" mapstructure:"filter_sample_files" json:"filter_sample_files,omitempty"`
 	FailedItemRetentionHours       *int           `yaml:"failed_item_retention_hours" mapstructure:"failed_item_retention_hours" json:"failed_item_retention_hours,omitempty"`
+	DeleteCompletedNzb             *bool          `yaml:"delete_completed_nzb" mapstructure:"delete_completed_nzb" json:"delete_completed_nzb,omitempty"`
+}
+
+// ShouldDeleteCompletedNzb returns whether the NZB file should be removed from
+// disk after a successful import. Reads from ImportConfig first, falling back
+// to the legacy MetadataConfig field for back-compatibility with older config
+// files (the setting was moved from metadata.* to import.*).
+func (c *Config) ShouldDeleteCompletedNzb() bool {
+	if c.Import.DeleteCompletedNzb != nil {
+		return *c.Import.DeleteCompletedNzb
+	}
+	if c.Metadata.DeleteCompletedNzb != nil {
+		return *c.Metadata.DeleteCompletedNzb
+	}
+	return false
 }
 
 // LogConfig represents logging configuration with rotation support
diff --git a/internal/database/models.go b/internal/database/models.go
index e9dfa9a86..782ebee16 100644
--- a/internal/database/models.go
+++ b/internal/database/models.go
@@ -55,6 +55,9 @@ type BulkOperationResult struct {
 	DeletedCount    int
 	ProcessingCount int
 	FailedIDs       []int64
+	// DeletedPaths holds the nzb_path values for rows that were actually removed,
+	// so callers can clean up the corresponding files on disk.
+	DeletedPaths []string
 }
 
 // QueueStats represents statistics about the import queue
diff --git a/internal/database/queue_repository.go b/internal/database/queue_repository.go
index f845e0bf9..7d33a21a2 100644
--- a/internal/database/queue_repository.go
+++ b/internal/database/queue_repository.go
@@ -42,10 +42,11 @@ func (r *QueueRepository) RemoveFromQueueBulk(ctx context.Context, ids []int64)
 
 	err := r.withQueueTransaction(ctx, func(txRepo *QueueRepository) error {
 		for _, id := range ids {
-			// Check status first - we can't delete processing items
+			// Check status + path in a single query - we can't delete processing items
 			var status QueueStatus
-			checkQuery := `SELECT status FROM import_queue WHERE id = ?`
-			err := txRepo.db.QueryRowContext(ctx, checkQuery, id).Scan(&status)
+			var nzbPath string
+			checkQuery := `SELECT status, nzb_path FROM import_queue WHERE id = ?`
+			err := txRepo.db.QueryRowContext(ctx, checkQuery, id).Scan(&status, &nzbPath)
 			if err != nil {
 				if err == sql.ErrNoRows {
 					continue // Already gone, ignore
@@ -66,6 +67,9 @@ func (r *QueueRepository) RemoveFromQueueBulk(ctx context.Context, ids []int64)
 				return fmt.Errorf("failed to delete item %d: %w", id, err)
 			}
 			result.DeletedCount++
+			if nzbPath != "" {
+				result.DeletedPaths = append(result.DeletedPaths, nzbPath)
+			}
 		}
 		return nil
 	})
diff --git a/internal/database/repository.go b/internal/database/repository.go
index 7193b40e5..cc719d621 100644
--- a/internal/database/repository.go
+++ b/internal/database/repository.go
@@ -866,64 +866,69 @@ func (r *Repository) CountActiveQueueItems(ctx context.Context, search string, c
 	return count, nil
 }
 
-// ClearCompletedQueueItems removes completed and failed items from the queue
-func (r *Repository) ClearCompletedQueueItems(ctx context.Context) (int, error) {
-	query := `
-		DELETE FROM import_queue 
-		WHERE status IN ('completed')
-	`
-
-	result, err := r.db.ExecContext(ctx, query)
+// clearQueueItemsByStatus removes queue rows matching the given statuses and
+// returns the nzb_path values of every deleted row so the caller can clean up
+// files on disk.
+func (r *Repository) clearQueueItemsByStatus(ctx context.Context, statuses ...QueueStatus) ([]string, int, error) {
+	if len(statuses) == 0 {
+		return nil, 0, nil
+	}
+	placeholders := strings.Repeat("?,", len(statuses))
+	placeholders = placeholders[:len(placeholders)-1]
+	args := make([]any, 0, len(statuses))
+	for _, s := range statuses {
+		args = append(args, s)
+	}
+
+	paths := []string{}
+	selectQuery := fmt.Sprintf(`SELECT nzb_path FROM import_queue WHERE status IN (%s)`, placeholders)
+	rows, err := r.db.QueryContext(ctx, selectQuery, args...)
 	if err != nil {
-		return 0, fmt.Errorf("failed to clear completed queue items: %w", err)
+		return nil, 0, fmt.Errorf("failed to list queue paths: %w", err)
 	}
-
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return 0, fmt.Errorf("failed to get rows affected: %w", err)
+	for rows.Next() {
+		var p string
+		if err := rows.Scan(&p); err != nil {
+			rows.Close()
+			return nil, 0, fmt.Errorf("failed to scan queue path: %w", err)
+		}
+		if p != "" {
+			paths = append(paths, p)
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, 0, err
 	}
 
-	return int(rowsAffected), nil
-}
-
-// ClearFailedQueueItems removes failed items from the queue
-func (r *Repository) ClearFailedQueueItems(ctx context.Context) (int, error) {
-	query := `
-		DELETE FROM import_queue
-		WHERE status = 'failed'
-	`
-
-	result, err := r.db.ExecContext(ctx, query)
+	deleteQuery := fmt.Sprintf(`DELETE FROM import_queue WHERE status IN (%s)`, placeholders)
+	result, err := r.db.ExecContext(ctx, deleteQuery, args...)
 	if err != nil {
-		return 0, fmt.Errorf("failed to clear failed queue items: %w", err)
+		return nil, 0, fmt.Errorf("failed to clear queue items: %w", err)
 	}
-
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		return 0, fmt.Errorf("failed to get rows affected: %w", err)
+		return nil, 0, fmt.Errorf("failed to get rows affected: %w", err)
 	}
-
-	return int(rowsAffected), nil
+	return paths, int(rowsAffected), nil
 }
 
-// ClearPendingQueueItems removes pending items from the queue
-func (r *Repository) ClearPendingQueueItems(ctx context.Context) (int, error) {
-	query := `
-		DELETE FROM import_queue
-		WHERE status = 'pending'
-	`
-
-	result, err := r.db.ExecContext(ctx, query)
-	if err != nil {
-		return 0, fmt.Errorf("failed to clear pending queue items: %w", err)
-	}
+// ClearCompletedQueueItems removes completed items from the queue and returns
+// the paths of deleted rows.
+func (r *Repository) ClearCompletedQueueItems(ctx context.Context) ([]string, int, error) {
+	return r.clearQueueItemsByStatus(ctx, QueueStatusCompleted)
+}
 
-	rowsAffected, err := result.RowsAffected()
-	if err != nil {
-		return 0, fmt.Errorf("failed to get rows affected: %w", err)
-	}
+// ClearFailedQueueItems removes failed items from the queue and returns the
+// paths of deleted rows.
+func (r *Repository) ClearFailedQueueItems(ctx context.Context) ([]string, int, error) {
+	return r.clearQueueItemsByStatus(ctx, QueueStatusFailed)
+}
 
-	return int(rowsAffected), nil
+// ClearPendingQueueItems removes pending items from the queue and returns the
+// paths of deleted rows.
+func (r *Repository) ClearPendingQueueItems(ctx context.Context) ([]string, int, error) {
+	return r.clearQueueItemsByStatus(ctx, QueueStatusPending)
 }
 
 // IsFileInQueue checks if a file is already in the queue (pending or processing)
diff --git a/internal/importer/migration.go b/internal/importer/migration.go
index 4ab188073..34073b262 100644
--- a/internal/importer/migration.go
+++ b/internal/importer/migration.go
@@ -7,6 +7,8 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/javi11/altmount/internal/nzbfile"
 )
 
 const migrationSentinelFile = ".migration_nzb_compressed_v1"
@@ -33,7 +35,7 @@ func migrateNzbsToGz(ctx context.Context, nzbDir, sentinelPath string, updater f
 		}
 
 		gzPath := path + ".gz"
-		if compErr := compressNzbToGz(path, gzPath); compErr != nil {
+		if compErr := nzbfile.Compress(path, gzPath); compErr != nil {
 			slog.WarnContext(ctx, "NZB migration: failed to compress file",
 				"path", path, "error", compErr)
 			return nil
diff --git a/internal/importer/migration_test.go b/internal/importer/migration_test.go
index 2422879b0..675b2527f 100644
--- a/internal/importer/migration_test.go
+++ b/internal/importer/migration_test.go
@@ -7,10 +7,15 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/javi11/altmount/internal/nzbfile"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+const testNzbContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE nzb PUBLIC "-//newzBin//DTD NZB 1.1//EN" "http://www.newzbin.com/DTD/nzb/nzb-1.1.dtd">
+<nzb xmlns="http://www.newzbin.com/DTD/2003/nzb"></nzb>`
+
 func TestNzbCompressionMigration(t *testing.T) {
 	dir := t.TempDir()
 	nzbPath := filepath.Join(dir, "movie.nzb")
@@ -27,7 +32,7 @@ func TestNzbCompressionMigration(t *testing.T) {
 
 	// Compressed version should exist and be readable
 	gzPath := filepath.Join(dir, "movie.nzb.gz")
-	rc, err := openNzbFile(gzPath)
+	rc, err := nzbfile.Open(gzPath)
 	require.NoError(t, err)
 	data, err := io.ReadAll(rc)
 	rc.Close()
@@ -62,7 +67,7 @@ func TestNzbCompressionMigration_AlreadyGzFiles(t *testing.T) {
 	srcNzb := filepath.Join(dir, "src.nzb")
 	gzPath := filepath.Join(dir, "existing.nzb.gz")
 	require.NoError(t, os.WriteFile(srcNzb, []byte(testNzbContent), 0644))
-	require.NoError(t, compressNzbToGz(srcNzb, gzPath))
+	require.NoError(t, nzbfile.Compress(srcNzb, gzPath))
 	require.NoError(t, os.Remove(srcNzb))
 
 	err := migrateNzbsToGz(context.Background(), dir, sentinelPath, nil)
diff --git a/internal/importer/nzb_file.go b/internal/importer/nzb_file.go
deleted file mode 100644
index 588bc3967..000000000
--- a/internal/importer/nzb_file.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package importer
-
-import (
-	"compress/gzip"
-	"io"
-	"os"
-	"strings"
-)
-
-const nzbGzExtension = ".nzb.gz"
-
-// openNzbFile opens an NZB file for reading, transparently decompressing .nzb.gz files.
-// The caller is responsible for closing the returned ReadCloser.
-func openNzbFile(path string) (io.ReadCloser, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-
-	if !strings.HasSuffix(strings.ToLower(path), nzbGzExtension) {
-		return f, nil
-	}
-
-	gr, err := gzip.NewReader(f)
-	if err != nil {
-		f.Close()
-		return nil, err
-	}
-
-	return &gzipReadCloser{file: f, reader: gr}, nil
-}
-
-// gzipReadCloser wraps a gzip.Reader and its underlying file so both are closed together.
-type gzipReadCloser struct {
-	file   *os.File
-	reader *gzip.Reader
-}
-
-func (g *gzipReadCloser) Read(p []byte) (int, error) {
-	return g.reader.Read(p)
-}
-
-func (g *gzipReadCloser) Close() error {
-	rerr := g.reader.Close()
-	ferr := g.file.Close()
-	if rerr != nil {
-		return rerr
-	}
-	return ferr
-}
-
-// compressNzbToGz reads the NZB at srcPath and writes a gzip-compressed copy to dstPath.
-func compressNzbToGz(srcPath, dstPath string) error {
-	src, err := os.Open(srcPath)
-	if err != nil {
-		return err
-	}
-	defer src.Close()
-
-	dst, err := os.Create(dstPath)
-	if err != nil {
-		return err
-	}
-	defer dst.Close()
-
-	gw, err := gzip.NewWriterLevel(dst, gzip.BestSpeed)
-	if err != nil {
-		_ = os.Remove(dstPath)
-		return err
-	}
-
-	if _, err := io.Copy(gw, src); err != nil {
-		_ = gw.Close()
-		_ = os.Remove(dstPath)
-		return err
-	}
-
-	if err := gw.Close(); err != nil {
-		_ = os.Remove(dstPath)
-		return err
-	}
-
-	return dst.Close()
-}
diff --git a/internal/importer/nzb_file_test.go b/internal/importer/nzb_file_test.go
deleted file mode 100644
index 19de09a87..000000000
--- a/internal/importer/nzb_file_test.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package importer
-
-import (
-	"compress/gzip"
-	"io"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-const testNzbContent = `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE nzb PUBLIC "-//newzBin//DTD NZB 1.1//EN" "http://www.newzbin.com/DTD/nzb/nzb-1.1.dtd">
-<nzb xmlns="http://www.newzbin.com/DTD/2003/nzb"></nzb>`
-
-func TestOpenNzbFile_PlainNzb(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.nzb")
-	require.NoError(t, os.WriteFile(path, []byte(testNzbContent), 0644))
-
-	rc, err := openNzbFile(path)
-	require.NoError(t, err)
-	defer rc.Close()
-
-	data, err := io.ReadAll(rc)
-	require.NoError(t, err)
-	assert.Equal(t, testNzbContent, string(data))
-}
-
-func TestOpenNzbFile_GzippedNzb(t *testing.T) {
-	dir := t.TempDir()
-	path := filepath.Join(dir, "test.nzb.gz")
-
-	f, err := os.Create(path)
-	require.NoError(t, err)
-	gw := gzip.NewWriter(f)
-	_, err = gw.Write([]byte(testNzbContent))
-	require.NoError(t, err)
-	require.NoError(t, gw.Close())
-	require.NoError(t, f.Close())
-
-	rc, err := openNzbFile(path)
-	require.NoError(t, err)
-	defer rc.Close()
-
-	data, err := io.ReadAll(rc)
-	require.NoError(t, err)
-	assert.Equal(t, testNzbContent, string(data))
-}
-
-func TestOpenNzbFile_NotFound(t *testing.T) {
-	_, err := openNzbFile("/nonexistent/path/test.nzb")
-	assert.Error(t, err)
-}
-
-func TestCompressNzbToGz(t *testing.T) {
-	dir := t.TempDir()
-	srcPath := filepath.Join(dir, "source.nzb")
-	require.NoError(t, os.WriteFile(srcPath, []byte(testNzbContent), 0644))
-
-	dstPath := filepath.Join(dir, "dest.nzb.gz")
-	require.NoError(t, compressNzbToGz(srcPath, dstPath))
-
-	rc, err := openNzbFile(dstPath)
-	require.NoError(t, err)
-	defer rc.Close()
-
-	data, err := io.ReadAll(rc)
-	require.NoError(t, err)
-	assert.Equal(t, testNzbContent, string(data))
-
-	dstInfo, err := os.Stat(dstPath)
-	require.NoError(t, err)
-	assert.NotZero(t, dstInfo.Size())
-}
diff --git a/internal/importer/processor.go b/internal/importer/processor.go
index bf101da96..86aec5885 100644
--- a/internal/importer/processor.go
+++ b/internal/importer/processor.go
@@ -22,6 +22,7 @@ import (
 	"github.com/javi11/altmount/internal/importer/singlefile"
 	"github.com/javi11/altmount/internal/importer/utils/nzbtrim"
 	"github.com/javi11/altmount/internal/metadata"
+	"github.com/javi11/altmount/internal/nzbfile"
 	"github.com/javi11/altmount/internal/pool"
 	"github.com/javi11/altmount/internal/progress"
 )
@@ -180,10 +181,8 @@ func (proc *Processor) ProcessNzbFile(ctx context.Context, filePath, relativePat
 		allowedExtensions = *allowedExtensionsOverride
 	}
 
-	// Update progress: starting
 	proc.updateProgressWithStage(queueID, 0, "Parsing NZB")
-	// Step 1: Open and parse the file (handles .nzb and .nzb.gz transparently)
-	file, err := openNzbFile(filePath)
+	file, err := nzbfile.Open(filePath)
 	if err != nil {
 		return "", nil, NewNonRetryableError("failed to open file", err)
 	}
diff --git a/internal/importer/service.go b/internal/importer/service.go
index 63020f417..4db0f9c62 100644
--- a/internal/importer/service.go
+++ b/internal/importer/service.go
@@ -26,6 +26,7 @@ import (
 	"github.com/javi11/altmount/internal/importer/scanner"
 	"github.com/javi11/altmount/internal/importer/utils/nzbtrim"
 	"github.com/javi11/altmount/internal/metadata"
+	"github.com/javi11/altmount/internal/nzbfile"
 	"github.com/javi11/altmount/internal/pool"
 	"github.com/javi11/altmount/internal/progress"
 	"github.com/javi11/altmount/internal/sabnzbd"
@@ -672,17 +673,23 @@ func (s *Service) AddToQueue(ctx context.Context, filePath string, relativePath
 		CreatedAt:    time.Now(),
 	}
 
-	// Ensure NZB is in a persistent location immediately to prevent data loss if /tmp is cleaned on restart
-	if err := s.ensurePersistentNzb(ctx, item); err != nil {
-		s.log.ErrorContext(ctx, "Failed to ensure persistent NZB during queue addition", "file", filePath, "error", err)
-		return nil, fmt.Errorf("failed to make NZB persistent: %w", err)
-	}
-
+	// Insert the DB row first so item.ID is available for the persistent filename
+	// (which uses the queue ID as a uniqueness suffix). If persisting the NZB to
+	// disk fails afterwards, roll back the row so the queue doesn't leak an orphan.
 	if err := s.database.Repository.AddToQueue(ctx, item); err != nil {
 		s.log.ErrorContext(ctx, "Failed to add file to queue", "file", item.NzbPath, "error", err)
 		return nil, err
 	}
 
+	if err := s.ensurePersistentNzb(ctx, item); err != nil {
+		s.log.ErrorContext(ctx, "Failed to ensure persistent NZB during queue addition", "file", filePath, "error", err)
+		if rmErr := s.database.Repository.RemoveFromQueue(ctx, item.ID); rmErr != nil {
+			s.log.WarnContext(ctx, "Failed to roll back queue row after persistence failure",
+				"queue_id", item.ID, "error", rmErr)
+		}
+		return nil, fmt.Errorf("failed to make NZB persistent: %w", err)
+	}
+
 	if s.broadcaster != nil {
 		s.broadcaster.BroadcastQueueChanged()
 	}
@@ -870,28 +877,13 @@ func (s *Service) ensurePersistentNzb(ctx context.Context, item *database.Import
 		return nil
 	}
 
-	// Generate new filename with sanitized name, always stored compressed
-	filename := filepath.Base(item.NzbPath)
-	newFilename := sanitizeFilename(filename)
-	if !strings.HasSuffix(strings.ToLower(newFilename), nzbGzExtension) {
-		newFilename = nzbtrim.TrimNzbExtension(newFilename) + nzbGzExtension
-	}
-	newPath := filepath.Join(nzbDir, newFilename)
-
-	// If a file with the same name already exists, append a numeric counter suffix
-	// (e.g. movie.nzb → movie_1.nzb) to avoid silently overwriting a different item.
-	if _, err := os.Stat(newPath); err == nil {
-		ext := filepath.Ext(newFilename)
-		base := strings.TrimSuffix(newFilename, ext)
-		for i := 1; ; i++ {
-			candidate := filepath.Join(nzbDir, fmt.Sprintf("%s_%d%s", base, i, ext))
-			if _, statErr := os.Stat(candidate); os.IsNotExist(statErr) {
-				newPath = candidate
-				break
-			}
-		}
-		s.log.DebugContext(ctx, "NZB name collision, using alternate path", "path", newPath)
+	// Persistent filename uses the queue ID as a suffix to guarantee uniqueness
+	// across concurrent imports without filesystem collision checks.
+	if item.ID == 0 {
+		return fmt.Errorf("cannot persist NZB without queue ID (row must be inserted first)")
 	}
+	base := nzbtrim.TrimNzbExtension(sanitizeFilename(filepath.Base(item.NzbPath)))
+	newPath := filepath.Join(nzbDir, fmt.Sprintf("%s_%d%s", base, item.ID, nzbfile.GzExtension))
 
 	s.log.DebugContext(ctx, "Moving and compressing NZB to persistent storage", "old_path", item.NzbPath, "new_path", newPath)
 
@@ -901,7 +893,7 @@ func (s *Service) ensurePersistentNzb(ctx context.Context, item *database.Import
 	err := os.Rename(item.NzbPath, tmpPath)
 	if err == nil {
 		// Same filesystem: compress the tmp file to the final .nzb.gz path
-		if compErr := compressNzbToGz(tmpPath, newPath); compErr != nil {
+		if compErr := nzbfile.Compress(tmpPath, newPath); compErr != nil {
 			_ = os.Rename(tmpPath, item.NzbPath) // attempt to restore on failure
 			return fmt.Errorf("failed to compress NZB: %w", compErr)
 		}
@@ -909,7 +901,7 @@ func (s *Service) ensurePersistentNzb(ctx context.Context, item *database.Import
 	} else {
 		// Cross-device: compress directly from source to destination
 		s.log.DebugContext(ctx, "Rename failed, compressing directly from source", "error", err, "src", item.NzbPath, "dst", newPath)
-		if compErr := compressNzbToGz(item.NzbPath, newPath); compErr != nil {
+		if compErr := nzbfile.Compress(item.NzbPath, newPath); compErr != nil {
 			return fmt.Errorf("failed to compress NZB: %w", compErr)
 		}
 		if err := os.Remove(item.NzbPath); err != nil {
@@ -1025,11 +1017,14 @@ func (s *Service) handleProcessingSuccess(ctx context.Context, item *database.Im
 
 	s.log.InfoContext(ctx, "Successfully processed queue item", "queue_id", item.ID, "file", item.NzbPath)
 
-	// Handle cleanup of completed NZB if configured
+	// Handle cleanup of completed NZB if configured. The path is kept in the DB
+	// so the UI can still display the original filename; download requests will
+	// 404 and the frontend surfaces an "already removed" message for completed
+	// items.
 	cfg := s.configGetter()
-	if cfg.Metadata.DeleteCompletedNzb != nil && *cfg.Metadata.DeleteCompletedNzb {
+	if cfg.ShouldDeleteCompletedNzb() {
 		s.log.InfoContext(ctx, "Deleting completed NZB (per config)", "file", item.NzbPath)
-		if err := os.Remove(item.NzbPath); err != nil {
+		if err := os.Remove(item.NzbPath); err != nil && !os.IsNotExist(err) {
 			s.log.WarnContext(ctx, "Failed to delete completed NZB", "file", item.NzbPath, "error", err)
 		}
 	}
@@ -1288,7 +1283,7 @@ func (s *Service) CalculateFileSizeOnly(filePath string) (int64, error) {
 		return s.calculateStrmFileSize(file)
 	}
 
-	file, err := openNzbFile(filePath)
+	file, err := nzbfile.Open(filePath)
 	if err != nil {
 		return 0, NewNonRetryableError("failed to open file for size calculation", err)
 	}
@@ -1393,18 +1388,10 @@ func (s *Service) RegenerateMetadata(ctx context.Context, mountRelativePath stri
 		}
 
 		filename := d.Name()
-		lname := strings.ToLower(filename)
-		if !strings.HasSuffix(lname, ".nzb") && !strings.HasSuffix(lname, nzbGzExtension) {
+		if !nzbtrim.HasNzbExtension(filename) {
 			return nil
 		}
-		// Strip .nzb.gz or .nzb to get the bare name for matching
-		var cleanName string
-		switch {
-		case strings.HasSuffix(lname, nzbGzExtension):
-			cleanName = filename[:len(filename)-len(nzbGzExtension)]
-		default:
-			cleanName = strings.TrimSuffix(filename, ".nzb")
-		}
+		cleanName := nzbtrim.TrimNzbExtension(filename)
 		if _, after, ok := strings.Cut(cleanName, "_"); ok {
 			// Check both with and without queue ID prefix
 			if after == releaseName || cleanName == releaseName {
diff --git a/internal/nzbfile/nzbfile.go b/internal/nzbfile/nzbfile.go
new file mode 100644
index 000000000..3cd2c2554
--- /dev/null
+++ b/internal/nzbfile/nzbfile.go
@@ -0,0 +1,123 @@
+// Package nzbfile centralizes on-disk NZB I/O, hiding gzip compression so
+// callers always deal with plain XML regardless of how the file is stored.
+package nzbfile
+
+import (
+	"compress/gzip"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// GzExtension is the persistent storage extension for gzip-compressed NZB files.
+const GzExtension = ".nzb.gz"
+
+// IsGzipped reports whether path points to a gzip-compressed NZB by suffix.
+func IsGzipped(path string) bool {
+	return strings.HasSuffix(strings.ToLower(path), GzExtension)
+}
+
+// PlainFilename returns the base filename with any .gz suffix stripped, so
+// downstream consumers (download clients, external SABnzbd) see a plain .nzb.
+// The case of the original name is preserved.
+func PlainFilename(path string) string {
+	name := filepath.Base(path)
+	if strings.HasSuffix(strings.ToLower(name), GzExtension) {
+		return name[:len(name)-len(".gz")]
+	}
+	return name
+}
+
+// Open opens an NZB file for reading, transparently decompressing .nzb.gz
+// files so callers always receive plain XML. The caller must Close the result.
+func Open(path string) (io.ReadCloser, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+
+	if !IsGzipped(path) {
+		return f, nil
+	}
+
+	gr, err := gzip.NewReader(f)
+	if err != nil {
+		f.Close()
+		return nil, err
+	}
+	return &gzipReadCloser{file: f, reader: gr}, nil
+}
+
+// Compress reads the NZB at srcPath and writes a gzip-compressed copy to dstPath.
+func Compress(srcPath, dstPath string) error {
+	src, err := os.Open(srcPath)
+	if err != nil {
+		return err
+	}
+	defer src.Close()
+
+	dst, err := os.Create(dstPath)
+	if err != nil {
+		return err
+	}
+	defer dst.Close()
+
+	gw, err := gzip.NewWriterLevel(dst, gzip.BestCompression)
+	if err != nil {
+		_ = os.Remove(dstPath)
+		return err
+	}
+
+	if _, err := io.Copy(gw, src); err != nil {
+		_ = gw.Close()
+		_ = os.Remove(dstPath)
+		return err
+	}
+
+	if err := gw.Close(); err != nil {
+		_ = os.Remove(dstPath)
+		return err
+	}
+	return dst.Close()
+}
+
+// ResolveOnDisk returns an existing path for an NZB, tolerating drift between
+// the stored extension and what's actually on disk (e.g. legacy rows pointing
+// at .nzb while the file was later gzipped, or vice versa). Returns the input
+// path unchanged if it exists, the .gz-toggled variant if that exists, or
+// (path, os.ErrNotExist) otherwise.
+func ResolveOnDisk(path string) (string, error) {
+	if _, err := os.Stat(path); err == nil {
+		return path, nil
+	} else if !os.IsNotExist(err) {
+		return path, err
+	}
+
+	var alt string
+	if IsGzipped(path) {
+		alt = strings.TrimSuffix(path, filepath.Ext(path))
+	} else {
+		alt = path + ".gz"
+	}
+	if _, err := os.Stat(alt); err == nil {
+		return alt, nil
+	}
+	return path, os.ErrNotExist
+}
+
+type gzipReadCloser struct {
+	file   *os.File
+	reader *gzip.Reader
+}
+
+func (g *gzipReadCloser) Read(p []byte) (int, error) { return g.reader.Read(p) }
+
+func (g *gzipReadCloser) Close() error {
+	rerr := g.reader.Close()
+	ferr := g.file.Close()
+	if rerr != nil {
+		return rerr
+	}
+	return ferr
+}
diff --git a/internal/nzbfile/nzbfile_test.go b/internal/nzbfile/nzbfile_test.go
new file mode 100644
index 000000000..ed781f3c4
--- /dev/null
+++ b/internal/nzbfile/nzbfile_test.go
@@ -0,0 +1,94 @@
+package nzbfile
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestIsGzippedAndPlainFilename(t *testing.T) {
+	cases := []struct {
+		in      string
+		gzipped bool
+		plainFn string
+	}{
+		{"movie.nzb", false, "movie.nzb"},
+		{"movie.nzb.gz", true, "movie.nzb"},
+		{"MOVIE.NZB.GZ", true, "MOVIE.NZB"},
+		{"/a/b/movie.nzb.gz", true, "movie.nzb"},
+	}
+	for _, c := range cases {
+		if got := IsGzipped(c.in); got != c.gzipped {
+			t.Errorf("IsGzipped(%q)=%v want %v", c.in, got, c.gzipped)
+		}
+		if got := PlainFilename(c.in); got != c.plainFn {
+			t.Errorf("PlainFilename(%q)=%q want %q", c.in, got, c.plainFn)
+		}
+	}
+}
+
+func TestOpenAndCompressRoundtrip(t *testing.T) {
+	dir := t.TempDir()
+	plain := filepath.Join(dir, "a.nzb")
+	gz := filepath.Join(dir, "a.nzb.gz")
+	content := []byte("<nzb>hello</nzb>")
+
+	if err := os.WriteFile(plain, content, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if err := Compress(plain, gz); err != nil {
+		t.Fatalf("Compress: %v", err)
+	}
+
+	rc, err := Open(gz)
+	if err != nil {
+		t.Fatalf("Open gz: %v", err)
+	}
+	defer rc.Close()
+	got, err := io.ReadAll(rc)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != string(content) {
+		t.Fatalf("roundtrip mismatch: %q want %q", got, content)
+	}
+
+	rc2, err := Open(plain)
+	if err != nil {
+		t.Fatalf("Open plain: %v", err)
+	}
+	defer rc2.Close()
+	got2, _ := io.ReadAll(rc2)
+	if string(got2) != string(content) {
+		t.Fatalf("plain read mismatch: %q", got2)
+	}
+}
+
+func TestResolveOnDisk(t *testing.T) {
+	dir := t.TempDir()
+	plain := filepath.Join(dir, "only-plain.nzb")
+	gz := filepath.Join(dir, "only-gz.nzb.gz")
+	os.WriteFile(plain, []byte("x"), 0o644)
+	os.WriteFile(gz, []byte("x"), 0o644)
+
+	// Stored path matches disk.
+	if got, err := ResolveOnDisk(plain); err != nil || got != plain {
+		t.Errorf("plain exact: got=%q err=%v", got, err)
+	}
+
+	// Stored as .nzb, on disk as .nzb.gz.
+	if got, err := ResolveOnDisk(filepath.Join(dir, "only-gz.nzb")); err != nil || got != gz {
+		t.Errorf("drift .nzb→.nzb.gz: got=%q err=%v", got, err)
+	}
+
+	// Stored as .nzb.gz, on disk as .nzb.
+	if got, err := ResolveOnDisk(filepath.Join(dir, "only-plain.nzb.gz")); err != nil || got != plain {
+		t.Errorf("drift .nzb.gz→.nzb: got=%q err=%v", got, err)
+	}
+
+	// Neither exists.
+	if _, err := ResolveOnDisk(filepath.Join(dir, "missing.nzb")); !os.IsNotExist(err) {
+		t.Errorf("missing: err=%v", err)
+	}
+}
diff --git a/internal/sabnzbd/client.go b/internal/sabnzbd/client.go
index 00197a423..3c1d46dc4 100644
--- a/internal/sabnzbd/client.go
+++ b/internal/sabnzbd/client.go
@@ -10,10 +10,10 @@ import (
 	"net/http"
 	"net/url"
 	"os"
-	"path/filepath"
 	"time"
 
 	"github.com/javi11/altmount/internal/httpclient"
+	"github.com/javi11/altmount/internal/nzbfile"
 )
 
 // SABnzbdClient handles communication with external SABnzbd instances
@@ -72,25 +72,24 @@ func (c *SABnzbdClient) SendNZBFile(ctx context.Context, host, apiKey, nzbPath s
 		return "", fmt.Errorf("NZB path is a directory, not a file")
 	}
 
-	// Open the NZB file
-	file, err := os.Open(nzbPath)
+	// Open the NZB, transparently decompressing .nzb.gz so external SABnzbd
+	// receives plain XML regardless of on-disk storage format.
+	rc, err := nzbfile.Open(nzbPath)
 	if err != nil {
 		return "", fmt.Errorf("failed to open NZB file: %w", err)
 	}
-	defer file.Close()
+	defer rc.Close()
 
 	// Create multipart form data
 	body := &bytes.Buffer{}
 	writer := multipart.NewWriter(body)
 
-	// Add the file
-	filename := filepath.Base(nzbPath)
-	part, err := writer.CreateFormFile("nzbfile", filename)
+	part, err := writer.CreateFormFile("nzbfile", nzbfile.PlainFilename(nzbPath))
 	if err != nil {
 		return "", fmt.Errorf("failed to create form file: %w", err)
 	}
 
-	if _, err := io.Copy(part, file); err != nil {
+	if _, err := io.Copy(part, rc); err != nil {
 		return "", fmt.Errorf("failed to copy file data: %w", err)
 	}