diff --git a/StabilityMatrix.Avalonia/DesignData/DesignData.cs b/StabilityMatrix.Avalonia/DesignData/DesignData.cs
index 9bbbeceb..41569dcf 100644
--- a/StabilityMatrix.Avalonia/DesignData/DesignData.cs
+++ b/StabilityMatrix.Avalonia/DesignData/DesignData.cs
@@ -481,6 +481,9 @@ public static void Initialize()
     public static HuggingFacePageViewModel HuggingFacePageViewModel =>
         Services.GetRequiredService<HuggingFacePageViewModel>();
 
+    public static DirectUrlImportViewModel DirectUrlImportViewModel =>
+        Services.GetRequiredService<DirectUrlImportViewModel>();
+
     public static NewOneClickInstallViewModel NewOneClickInstallViewModel =>
         Services.GetRequiredService<NewOneClickInstallViewModel>();
 
diff --git a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
index af726ddd..da6a6f3c 100644
--- a/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
+++ b/StabilityMatrix.Avalonia/Languages/Resources.Designer.cs
@@ -4146,5 +4146,437 @@ public static string Watermark_EnterPackageName {
                 return ResourceManager.GetString("Watermark_EnterPackageName", resourceCulture);
             }
         }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Action_SkipThisPage {
+            get {
+                return ResourceManager.GetString("Action_SkipThisPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_CustomEllipsis {
+            get {
+                return ResourceManager.GetString("Label_CustomEllipsis", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_DirectUrl {
+            get {
+                return ResourceManager.GetString("Label_DirectUrl", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_DirectUrlImport {
+            get {
+                return ResourceManager.GetString("Label_DirectUrlImport", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_ImportFailed {
+            get {
+                return ResourceManager.GetString("Label_ImportFailed", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_ImportsStarted {
+            get {
+                return ResourceManager.GetString("Label_ImportsStarted", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_InvalidUrl {
+            get {
+                return ResourceManager.GetString("Label_InvalidUrl", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_ModelFileNameForDirectUrls {
+            get {
+                return ResourceManager.GetString("Label_ModelFileNameForDirectUrls", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_ModelHasNoFiles {
+            get {
+                return ResourceManager.GetString("Label_ModelHasNoFiles", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_NoFileNameProvided {
+            get {
+                return ResourceManager.GetString("Label_NoFileNameProvided", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_NoModelsSelected {
+            get {
+                return ResourceManager.GetString("Label_NoModelsSelected", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_NoUrlsProvided {
+            get {
+                return ResourceManager.GetString("Label_NoUrlsProvided", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_SelectCivitAiModelsFromCurrentPage {
+            get {
+                return ResourceManager.GetString("Label_SelectCivitAiModelsFromCurrentPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_SelectDownloadFolder {
+            get {
+                return ResourceManager.GetString("Label_SelectDownloadFolder", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_SomeImportsFailed {
+            get {
+                return ResourceManager.GetString("Label_SomeImportsFailed", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_Tips {
+            get {
+                return ResourceManager.GetString("Label_Tips", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Label_UnknownBase {
+            get {
+                return ResourceManager.GetString("Label_UnknownBase", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_CivitAiModelsAvailableFrom {
+            get {
+                return ResourceManager.GetString("Text_CivitAiModelsAvailableFrom", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_CivitAiPage {
+            get {
+                return ResourceManager.GetString("Text_CivitAiPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_CustomFolderSet {
+            get {
+                return ResourceManager.GetString("Text_CustomFolderSet", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DirectUrlImportTipCivitAiModelPage {
+            get {
+                return ResourceManager.GetString("Text_DirectUrlImportTipCivitAiModelPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DirectUrlImportTipCivitAiPage {
+            get {
+                return ResourceManager.GetString("Text_DirectUrlImportTipCivitAiPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DirectUrlImportTipDirectUrls {
+            get {
+                return ResourceManager.GetString("Text_DirectUrlImportTipDirectUrls", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DirectUrlImportTipSaveLocation {
+            get {
+                return ResourceManager.GetString("Text_DirectUrlImportTipSaveLocation", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DirectUrlInputUrlsOnePerLine {
+            get {
+                return ResourceManager.GetString("Text_DirectUrlInputUrlsOnePerLine", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_DownloadingFromDirectUrls {
+            get {
+                return ResourceManager.GetString("Text_DownloadingFromDirectUrls", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_InvalidUrlFormat {
+            get {
+                return ResourceManager.GetString("Text_InvalidUrlFormat", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_LoadingCivitAiModels {
+            get {
+                return ResourceManager.GetString("Text_LoadingCivitAiModels", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_ModelHasNoDownloadableFiles {
+            get {
+                return ResourceManager.GetString("Text_ModelHasNoDownloadableFiles", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_ModelsFormat {
+            get {
+                return ResourceManager.GetString("Text_ModelsFormat", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_NoDownloadableModelVersionsFoundOnThisPageMovingToNext {
+            get {
+                return ResourceManager.GetString("Text_NoDownloadableModelVersionsFoundOnThisPageMovingToNext", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_NoModelsFoundOnThisPageMovingToNext {
+            get {
+                return ResourceManager.GetString("Text_NoModelsFoundOnThisPageMovingToNext", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PageFormat {
+            get {
+                return ResourceManager.GetString("Text_PageFormat", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_ParsingUrls {
+            get {
+                return ResourceManager.GetString("Text_ParsingUrls", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleaseEnterAFileNameForFallbackDirectDownloads {
+            get {
+                return ResourceManager.GetString("Text_PleaseEnterAFileNameForFallbackDirectDownloads", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleaseEnterAtLeastOneModelFromThisPage {
+            get {
+                return ResourceManager.GetString("Text_PleaseEnterAtLeastOneModelFromThisPage", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleaseEnterAtLeastOneUrl {
+            get {
+                return ResourceManager.GetString("Text_PleaseEnterAtLeastOneUrl", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleaseEnterAtLeastOneValidUrl {
+            get {
+                return ResourceManager.GetString("Text_PleaseEnterAtLeastOneValidUrl", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleasePickAFolderForTheCustomLocation {
+            get {
+                return ResourceManager.GetString("Text_PleasePickAFolderForTheCustomLocation", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PleaseSelectADownloadLocation {
+            get {
+                return ResourceManager.GetString("Text_PleaseSelectADownloadLocation", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_PlatformDoesNotSupportFolderPicking {
+            get {
+                return ResourceManager.GetString("Text_PlatformDoesNotSupportFolderPicking", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_SearchFormat {
+            get {
+                return ResourceManager.GetString("Text_SearchFormat", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_StartedModels {
+            get {
+                return ResourceManager.GetString("Text_StartedModels", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_StartedModelsSkippedModels {
+            get {
+                return ResourceManager.GetString("Text_StartedModelsSkippedModels", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_TagFormat {
+            get {
+                return ResourceManager.GetString("Text_TagFormat", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_UrlImportModelFileNameWatermark {
+            get {
+                return ResourceManager.GetString("Text_UrlImportModelFileNameWatermark", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_UrlImportUrlsWatermark {
+            get {
+                return ResourceManager.GetString("Text_UrlImportUrlsWatermark", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string.
+        /// </summary>
+        public static string Text_UserFormat {
+            get {
+                return ResourceManager.GetString("Text_UserFormat", resourceCulture);
+            }
+        }
     }
 }
diff --git a/StabilityMatrix.Avalonia/Languages/Resources.resx b/StabilityMatrix.Avalonia/Languages/Resources.resx
index 42d057cf..47fdaa11 100644
--- a/StabilityMatrix.Avalonia/Languages/Resources.resx
+++ b/StabilityMatrix.Avalonia/Languages/Resources.resx
@@ -1509,4 +1509,149 @@ We prioritize your privacy ([Gen AI Terms](&lt;https://lykos.ai/gen-ai-terms&gt;
   <data name="Label_Filter" xml:space="preserve">
     <value>Filter</value>
   </data>
+  <data name="Action_SkipThisPage" xml:space="preserve">
+    <value>Skip this page</value>
+  </data>
+  <data name="Label_CustomEllipsis" xml:space="preserve">
+    <value>Custom...</value>
+  </data>
+  <data name="Label_DirectUrl" xml:space="preserve">
+    <value>Direct URL</value>
+  </data>
+  <data name="Label_DirectUrlImport" xml:space="preserve">
+    <value>Direct URL Import</value>
+  </data>
+  <data name="Label_ImportFailed" xml:space="preserve">
+    <value>Import failed</value>
+  </data>
+  <data name="Label_ImportsStarted" xml:space="preserve">
+    <value>Imports started</value>
+  </data>
+  <data name="Label_InvalidUrl" xml:space="preserve">
+    <value>Invalid URL</value>
+  </data>
+  <data name="Label_ModelFileNameForDirectUrls" xml:space="preserve">
+    <value>Model File Name (for direct URLs):</value>
+  </data>
+  <data name="Label_ModelHasNoFiles" xml:space="preserve">
+    <value>Model has no files</value>
+  </data>
+  <data name="Label_NoFileNameProvided" xml:space="preserve">
+    <value>No file name provided</value>
+  </data>
+  <data name="Label_NoModelsSelected" xml:space="preserve">
+    <value>No models selected</value>
+  </data>
+  <data name="Label_NoUrlsProvided" xml:space="preserve">
+    <value>No URLs provided</value>
+  </data>
+  <data name="Label_SelectCivitAiModelsFromCurrentPage" xml:space="preserve">
+    <value>Select CivitAI models from current page</value>
+  </data>
+  <data name="Label_SelectDownloadFolder" xml:space="preserve">
+    <value>Select Download Folder</value>
+  </data>
+  <data name="Label_SomeImportsFailed" xml:space="preserve">
+    <value>Some imports failed</value>
+  </data>
+  <data name="Label_Tips" xml:space="preserve">
+    <value>Tips:</value>
+  </data>
+  <data name="Label_UnknownBase" xml:space="preserve">
+    <value>Unknown Base</value>
+  </data>
+  <data name="Text_CivitAiModelsAvailableFrom" xml:space="preserve">
+    <value>{0} model(s) available from {1}</value>
+  </data>
+  <data name="Text_CivitAiPage" xml:space="preserve">
+    <value>CivitAI page</value>
+  </data>
+  <data name="Text_CustomFolderSet" xml:space="preserve">
+    <value>Custom folder set: {0}</value>
+  </data>
+  <data name="Text_DirectUrlImportTipCivitAiModelPage" xml:space="preserve">
+    <value>• If your CivitAI URL is a model page (https://civitai.com/models/12345), the page's available models are shown for selection.</value>
+  </data>
+  <data name="Text_DirectUrlImportTipCivitAiPage" xml:space="preserve">
+    <value>• If you add CivitAI page URLs (for example https://civitai.com/models?query=... ), you'll be asked to pick models page-by-page.</value>
+  </data>
+  <data name="Text_DirectUrlImportTipDirectUrls" xml:space="preserve">
+    <value>• Use direct URLs only when you want a single fallback file name for download.</value>
+  </data>
+  <data name="Text_DirectUrlImportTipSaveLocation" xml:space="preserve">
+    <value>• The download will be saved to the selected model folder.</value>
+  </data>
+  <data name="Text_DirectUrlInputUrlsOnePerLine" xml:space="preserve">
+    <value>Input URLs (one per line):</value>
+  </data>
+  <data name="Text_DownloadingFromDirectUrls" xml:space="preserve">
+    <value>Downloading from {0} direct URL(s)...</value>
+  </data>
+  <data name="Text_InvalidUrlFormat" xml:space="preserve">
+    <value>Invalid URL: {0}</value>
+  </data>
+  <data name="Text_LoadingCivitAiModels" xml:space="preserve">
+    <value>Loading CivitAI models...</value>
+  </data>
+  <data name="Text_ModelHasNoDownloadableFiles" xml:space="preserve">
+    <value>{0} ({1}) has no downloadable files.</value>
+  </data>
+  <data name="Text_ModelsFormat" xml:space="preserve">
+    <value>Models: {0}</value>
+  </data>
+  <data name="Text_NoDownloadableModelVersionsFoundOnThisPageMovingToNext" xml:space="preserve">
+    <value>No downloadable model versions found on this page. Moving to the next page...</value>
+  </data>
+  <data name="Text_NoModelsFoundOnThisPageMovingToNext" xml:space="preserve">
+    <value>No models found on this page. Moving to the next page...</value>
+  </data>
+  <data name="Text_PageFormat" xml:space="preserve">
+    <value>{0} (Page {1})</value>
+  </data>
+  <data name="Text_ParsingUrls" xml:space="preserve">
+    <value>Parsing URLs...</value>
+  </data>
+  <data name="Text_PleaseEnterAFileNameForFallbackDirectDownloads" xml:space="preserve">
+    <value>Please enter a file name for fallback direct downloads.</value>
+  </data>
+  <data name="Text_PleaseEnterAtLeastOneModelFromThisPage" xml:space="preserve">
+    <value>Please select at least one model from this page.</value>
+  </data>
+  <data name="Text_PleaseEnterAtLeastOneUrl" xml:space="preserve">
+    <value>Please enter at least one URL.</value>
+  </data>
+  <data name="Text_PleaseEnterAtLeastOneValidUrl" xml:space="preserve">
+    <value>Please enter at least one valid URL.</value>
+  </data>
+  <data name="Text_PleasePickAFolderForTheCustomLocation" xml:space="preserve">
+    <value>Please pick a folder for the custom location.</value>
+  </data>
+  <data name="Text_PleaseSelectADownloadLocation" xml:space="preserve">
+    <value>Please select a download location.</value>
+  </data>
+  <data name="Text_PlatformDoesNotSupportFolderPicking" xml:space="preserve">
+    <value>The platform does not support folder picking.</value>
+  </data>
+  <data name="Text_SearchFormat" xml:space="preserve">
+    <value>Search: {0}</value>
+  </data>
+  <data name="Text_StartedModels" xml:space="preserve">
+    <value>Started {0} model(s).</value>
+  </data>
+  <data name="Text_StartedModelsSkippedModels" xml:space="preserve">
+    <value>Started {0} model(s), skipped {1} model(s).</value>
+  </data>
+  <data name="Text_TagFormat" xml:space="preserve">
+    <value>Tag: #{0}</value>
+  </data>
+  <data name="Text_UrlImportModelFileNameWatermark" xml:space="preserve">
+    <value>model.safetensors</value>
+  </data>
+  <data name="Text_UrlImportUrlsWatermark" xml:space="preserve">
+    <value>https://example.com/model.safetensors
+https://civitai.com/models?query=anime</value>
+  </data>
+  <data name="Text_UserFormat" xml:space="preserve">
+    <value>User: @{0}</value>
+  </data>
 </root>
diff --git a/StabilityMatrix.Avalonia/Services/ModelImportService.cs b/StabilityMatrix.Avalonia/Services/ModelImportService.cs
index 7d36c2b9..149d0ac9 100644
--- a/StabilityMatrix.Avalonia/Services/ModelImportService.cs
+++ b/StabilityMatrix.Avalonia/Services/ModelImportService.cs
@@ -319,10 +319,19 @@ await notificationService.TryAsync(
             cleanupFilePaths.Add(previewImageDownloadPath);
         }
 
-        // Create tracked download
-        // todo: support multiple uris
-        var modelUri = modelUris.First();
-        var download = trackedDownloadService.NewDownload(modelUri, downloadPath);
+        // Create tracked download with first URL, storing others as fallbacks
+        // If download fails, the TrackedDownloadService will attempt to use fallback URLs
+        var uriList = modelUris.ToList();
+        var primaryUri = uriList.First();
+        var fallbackUris = uriList.Skip(1).ToList();
+        
+        var download = trackedDownloadService.NewDownload(primaryUri, downloadPath);
+        
+        // Store fallback URLs for retry attempts
+        if (fallbackUris.Count > 0)
+        {
+            download.FallbackUris = fallbackUris;
+        }
 
         // Add hash info
         // download.ExpectedHashSha256 = modelFile.Hashes.SHA256;
diff --git a/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/DirectUrlImportViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/DirectUrlImportViewModel.cs
new file mode 100644
index 00000000..5b10df59
--- /dev/null
+++ b/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowser/DirectUrlImportViewModel.cs
@@ -0,0 +1,895 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Web;
+using Avalonia.Controls.Notifications;
+using Avalonia.Platform.Storage;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Injectio.Attributes;
+using StabilityMatrix.Avalonia;
+using StabilityMatrix.Avalonia.Languages;
+using StabilityMatrix.Avalonia.Services;
+using StabilityMatrix.Avalonia.ViewModels.Base;
+using StabilityMatrix.Core.Api;
+using StabilityMatrix.Core.Attributes;
+using StabilityMatrix.Core.Extensions;
+using StabilityMatrix.Core.Models;
+using StabilityMatrix.Core.Models.Api;
+using StabilityMatrix.Core.Models.FileInterfaces;
+using StabilityMatrix.Core.Services;
+
+namespace StabilityMatrix.Avalonia.ViewModels.CheckpointBrowser;
+
+[View(typeof(Views.DirectUrlImportPage))]
+[RegisterSingleton<DirectUrlImportViewModel>]
+public partial class DirectUrlImportViewModel : TabViewModelBase
+{
+    private static string CustomLocationLabel => Resources.Label_CustomEllipsis;
+    private const string CivitAiHost = "civitai.com";
+    private const string WwwCivitAiHost = "www.civitai.com";
+    private const int DefaultCivitPageLimit = 30;
+    private static readonly string[] UrlLineSeparators = ["\r\n", "\r", "\n"];
+
+    private readonly IModelImportService modelImportService;
+    private readonly CivitCompatApiManager civitApi;
+    private readonly ISettingsManager settingsManager;
+    private readonly INotificationService notificationService;
+
+    private readonly Queue<CivitAiImportContext> civitAiImportQueue = new();
+    private CivitAiImportContext? activeCivitAiContext;
+
+    [ObservableProperty]
+    private string urlsInput = string.Empty;
+
+    [ObservableProperty]
+    private string modelFileName = string.Empty;
+
+    [ObservableProperty]
+    private string selectedDownloadLocation = string.Empty;
+
+    [ObservableProperty]
+    private List<string> availableDownloadLocations = new();
+
+    [ObservableProperty]
+    private string customDownloadLocation = string.Empty;
+
+    [ObservableProperty]
+    private bool isImporting;
+
+    [ObservableProperty]
+    private string importStatus = string.Empty;
+
+    [ObservableProperty]
+    private bool isCivitAiSelectionMode;
+
+    [ObservableProperty]
+    private string civitAiCurrentPageLabel = string.Empty;
+
+    [ObservableProperty]
+    private string civitAiCurrentPageUrl = string.Empty;
+
+    [ObservableProperty]
+    private ObservableCollection<CivitModelSelectionItem> civitAiCurrentPageModels = new();
+
+    [ObservableProperty]
+    private bool hasMoreCivitAiPages;
+
+    [ObservableProperty]
+    private string civitAiSelectionStatus = string.Empty;
+
+    private string lastValidDownloadLocation = string.Empty;
+
+    public override string Header => Resources.Label_DirectUrl;
+
+    public DirectUrlImportViewModel(
+        IModelImportService modelImportService,
+        CivitCompatApiManager civitApi,
+        ISettingsManager settingsManager,
+        INotificationService notificationService
+    )
+    {
+        this.modelImportService = modelImportService;
+        this.civitApi = civitApi;
+        this.settingsManager = settingsManager;
+        this.notificationService = notificationService;
+    }
+
+    public override void OnLoaded()
+    {
+        LoadAvailableDownloadLocations();
+        if (AvailableDownloadLocations.Count > 0 && string.IsNullOrWhiteSpace(SelectedDownloadLocation))
+        {
+            SelectedDownloadLocation = AvailableDownloadLocations[0];
+            if (!IsCustomLocation(SelectedDownloadLocation))
+            {
+                lastValidDownloadLocation = SelectedDownloadLocation;
+            }
+        }
+    }
+
+    private static bool IsCustomLocation(string value)
+    {
+        return string.Equals(value, CustomLocationLabel, StringComparison.OrdinalIgnoreCase);
+    }
+
+    partial void OnSelectedDownloadLocationChanged(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return;
+        }
+
+        if (IsCustomLocation(value))
+        {
+            if (string.IsNullOrWhiteSpace(CustomDownloadLocation))
+            {
+                SelectCustomFolderCommand.Execute(null);
+            }
+
+            return;
+        }
+
+        lastValidDownloadLocation = value;
+    }
+
+    private void LoadAvailableDownloadLocations()
+    {
+        var locations = Enum
+            .GetValues<SharedFolderType>()
+            .Where(folderType => folderType != SharedFolderType.Unknown)
+            .Select(folderType => $"Models/{folderType.GetStringValue()}")
+            .ToList();
+        locations.Add(CustomLocationLabel);
+        AvailableDownloadLocations = locations;
+    }
+
+    [RelayCommand]
+    private async Task Import()
+    {
+        if (string.IsNullOrWhiteSpace(UrlsInput))
+        {
+            ShowNotification(
+                Resources.Label_NoUrlsProvided,
+                Resources.Text_PleaseEnterAtLeastOneUrl,
+                NotificationType.Warning
+            );
+            return;
+        }
+
+        var downloadFolder = GetValidatedDownloadFolder();
+        if (downloadFolder is null)
+        {
+            return;
+        }
+
+        try
+        {
+            IsImporting = true;
+            ImportStatus = Resources.Text_ParsingUrls;
+
+            var parsedUrls = ParseUrls(UrlsInput);
+            if (parsedUrls.Count == 0)
+            {
+                ShowNotification(
+                    Resources.Label_InvalidUrl,
+                    Resources.Text_PleaseEnterAtLeastOneValidUrl,
+                    NotificationType.Warning
+                );
+                return;
+            }
+
+            var directUrls = new List<Uri>();
+            var civitAiContexts = new List<CivitAiImportContext>();
+
+            foreach (var parsedUrl in parsedUrls)
+            {
+                if (TryCreateCivitAiImportContext(parsedUrl, out var civitAiContext))
+                {
+                    civitAiContexts.Add(civitAiContext);
+                }
+                else
+                {
+                    directUrls.Add(parsedUrl);
+                }
+            }
+
+            if (directUrls.Count > 0 && string.IsNullOrWhiteSpace(ModelFileName))
+            {
+                ShowNotification(
+                    Resources.Label_NoFileNameProvided,
+                    Resources.Text_PleaseEnterAFileNameForFallbackDirectDownloads,
+                    NotificationType.Warning
+                );
+                return;
+            }
+
+            if (directUrls.Count > 0)
+            {
+                ImportStatus = string.Format(
+                    Resources.Text_DownloadingFromDirectUrls,
+                    directUrls.Count
+                );
+                await modelImportService.DoCustomImport(directUrls, ModelFileName, downloadFolder);
+
+                var downloadMessage = string.Format(
+                    Resources.Label_DownloadWillBeSavedToLocation,
+                    ModelFileName,
+                    downloadFolder
+                );
+                ImportStatus = downloadMessage;
+                ShowNotification(
+                    Resources.Label_DownloadStarted,
+                    downloadMessage,
+                    NotificationType.Success
+                );
+            }
+
+            if (civitAiContexts.Count > 0)
+            {
+                StartCivitAiSelectionFlow(civitAiContexts);
+                ImportStatus = Resources.Text_LoadingCivitAiModels;
+                await LoadCurrentCivitAiPageAsync();
+                return;
+            }
+
+            UrlsInput = string.Empty;
+            ModelFileName = string.Empty;
+            ImportStatus = string.Empty;
+        }
+        catch (UriFormatException ex)
+        {
+            ShowNotification(Resources.Label_InvalidUrl, ex.Message, NotificationType.Error);
+        }
+        catch (Exception ex)
+        {
+            ShowNotification(Resources.Label_ImportFailed, ex.Message, NotificationType.Error);
+        }
+        finally
+        {
+            if (!IsCivitAiSelectionMode)
+            {
+                IsImporting = false;
+            }
+        }
+    }
+
+    private static List<Uri> ParseUrls(string rawInput)
+    {
+        var urls = new List<Uri>();
+
+        foreach (
+            var line in rawInput.Split(
+                UrlLineSeparators,
+                StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries
+            )
+        )
+        {
+            if (!Uri.TryCreate(line, UriKind.Absolute, out var parsed))
+            {
+                throw new UriFormatException(string.Format(Resources.Text_InvalidUrlFormat, line));
+            }
+
+            urls.Add(parsed);
+        }
+
+        return urls;
+    }
+
+    private static string[] ParseListValues(string? rawValue)
+    {
+        if (string.IsNullOrWhiteSpace(rawValue))
+        {
+            return [];
+        }
+
+        return rawValue.Split([
+            ',',
+            ';'
+        ], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+    }
+
+    private static int? ParseQueryInt(string? rawValue)
+    {
+        return int.TryParse(rawValue, out var value) ? value : null;
+    }
+
+    private static TEnum? TryParseEnum<TEnum>(string? value)
+        where TEnum : struct, Enum
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+
+        return Enum.TryParse(value, true, out TEnum parsed)
+            ? parsed
+            : null;
+    }
+
+    private DirectoryPath ResolveDownloadFolder()
+    {
+        if (IsCustomLocation(SelectedDownloadLocation))
+        {
+            return new DirectoryPath(CustomDownloadLocation);
+        }
+
+        var folderName = SelectedDownloadLocation.Split('/').Last();
+        return new DirectoryPath(settingsManager.ModelsDirectory, folderName);
+    }
+
+    private static bool IsCivitAiHost(Uri uri)
+    {
+        return uri.Host.Equals(CivitAiHost, StringComparison.OrdinalIgnoreCase)
+            || uri.Host.Equals(WwwCivitAiHost, StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool IsCivitAiModelsUrl(Uri uri)
+    {
+        return uri.AbsolutePath.StartsWith("/models", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private static bool TryCreateCivitAiImportContext(Uri uri, out CivitAiImportContext? context)
+    {
+        context = null;
+
+        if (!IsCivitAiHost(uri) || !IsCivitAiModelsUrl(uri))
+        {
+            return false;
+        }
+
+        var request = new CivitModelsRequest { Limit = DefaultCivitPageLimit, Nsfw = "true" };
+        var query = HttpUtility.ParseQueryString(uri.Query);
+
+        var pathParts = uri.AbsolutePath.Split('/', StringSplitOptions.RemoveEmptyEntries);
+        if (pathParts.Length > 1 && int.TryParse(pathParts[1], out var modelId))
+        {
+            request.CommaSeparatedModelIds = modelId.ToString();
+            context = new CivitAiImportContext
+            {
+                Request = request,
+                SourceLabel = $"https://{CivitAiHost}/models/{modelId}",
+            };
+
+            return true;
+        }
+
+        var queryValue = query["query"];
+        var tagValue = query["tag"];
+        var usernameValue = query["username"];
+        var idsValue = query["ids"];
+        var modelIdValue = query["modelId"];
+        var sortValue = query["sort"];
+        var periodValue = query["period"];
+        var cursorValue = query["cursor"];
+        var pageValue = query["page"];
+        var limitValue = query["limit"];
+        var typesValue = query["types"];
+        var baseModelsValue = query["baseModels"];
+
+        if (!string.IsNullOrWhiteSpace(queryValue))
+        {
+            request.Query = queryValue;
+        }
+
+        if (!string.IsNullOrWhiteSpace(tagValue))
+        {
+            request.Tag = tagValue;
+        }
+
+        if (!string.IsNullOrWhiteSpace(usernameValue))
+        {
+            request.Username = usernameValue;
+        }
+
+        if (!string.IsNullOrWhiteSpace(idsValue))
+        {
+            request.CommaSeparatedModelIds = idsValue;
+        }
+
+        if (!string.IsNullOrWhiteSpace(modelIdValue))
+        {
+            request.CommaSeparatedModelIds = modelIdValue;
+        }
+
+        var sort = TryParseEnum<CivitSortMode>(sortValue);
+        if (sort is not null)
+        {
+            request.Sort = sort;
+        }
+
+        var period = TryParseEnum<CivitPeriod>(periodValue);
+        if (period is not null)
+        {
+            request.Period = period;
+        }
+
+        if (!string.IsNullOrWhiteSpace(cursorValue))
+        {
+            request.Cursor = cursorValue;
+        }
+
+        var page = ParseQueryInt(pageValue);
+        if (page is not null)
+        {
+            request.Page = page;
+        }
+
+        var limit = ParseQueryInt(limitValue);
+        if (limit is > 0)
+        {
+            request.Limit = Math.Min(limit.Value, 200);
+        }
+
+        var typeStrings = ParseListValues(typesValue);
+        if (typeStrings.Length > 0)
+        {
+            var types = new List<CivitModelType>();
+            foreach (var type in typeStrings)
+            {
+                var parsedType = TryParseEnum<CivitModelType>(type);
+                if (parsedType is not null)
+                {
+                    types.Add(parsedType.Value);
+                }
+            }
+
+            request.Types = types.Count > 0 ? [.. types] : null;
+        }
+
+        var baseModels = ParseListValues(baseModelsValue);
+        request.BaseModels = baseModels.Length > 0 ? baseModels : null;
+
+        context = new CivitAiImportContext
+        {
+            Request = request,
+            SourceLabel = uri.ToString(),
+        };
+
+        return true;
+    }
+
+    private void StartCivitAiSelectionFlow(IReadOnlyList<CivitAiImportContext> civitAiContexts)
+    {
+        civitAiImportQueue.Clear();
+
+        foreach (var context in civitAiContexts)
+        {
+            civitAiImportQueue.Enqueue(context);
+        }
+
+        if (!civitAiImportQueue.TryDequeue(out var firstContext))
+        {
+            return;
+        }
+
+        activeCivitAiContext = firstContext;
+        IsCivitAiSelectionMode = true;
+        CivitAiSelectionStatus = string.Empty;
+        CivitAiCurrentPageUrl = firstContext.SourceLabel;
+    }
+
+    [RelayCommand]
+    private async Task ImportSelectedCivitAiModels()
+    {
+        var selected = CivitAiCurrentPageModels.Where(x => x.IsSelected).ToList();
+        if (selected.Count == 0)
+        {
+            ShowNotification(
+                Resources.Label_NoModelsSelected,
+                Resources.Text_PleaseEnterAtLeastOneModelFromThisPage,
+                NotificationType.Warning
+            );
+            return;
+        }
+
+        var downloadFolder = GetValidatedDownloadFolder();
+        if (downloadFolder is null)
+        {
+            return;
+        }
+
+        IsImporting = true;
+
+        try
+        {
+            var started = 0;
+            var failed = 0;
+
+            foreach (var item in selected)
+            {
+                if (await TryImportCivitModel(item.Model, item.ModelVersion, downloadFolder))
+                {
+                    started++;
+                }
+                else
+                {
+                    failed++;
+                }
+            }
+
+            if (failed > 0)
+            {
+                ShowNotification(
+                    Resources.Label_SomeImportsFailed,
+                    string.Format(Resources.Text_StartedModelsSkippedModels, started, failed),
+                    NotificationType.Warning
+                );
+            }
+            else
+            {
+                ShowNotification(
+                    Resources.Label_ImportsStarted,
+                    string.Format(Resources.Text_StartedModels, started),
+                    NotificationType.Success
+                );
+            }
+
+            await MoveToNextCivitAiPageAsync();
+        }
+        finally
+        {
+            IsImporting = false;
+        }
+    }
+
+    [RelayCommand]
+    private async Task SkipCurrentCivitAiPage()
+    {
+        if (IsImporting)
+        {
+            return;
+        }
+
+        await MoveToNextCivitAiPageAsync();
+    }
+
+    [RelayCommand]
+    private void CancelCivitAiSelection()
+    {
+        ResetCivitAiSelectionFlow();
+        IsImporting = false;
+        ImportStatus = string.Empty;
+    }
+
+    [RelayCommand]
+    private async Task ContinueNextCivitAiPage()
+    {
+        await MoveToNextCivitAiPageAsync();
+    }
+
+    private async Task MoveToNextCivitAiPageAsync()
+    {
+        if (!TryAdvanceToNextCivitAiPage())
+        {
+            CompleteCivitAiSelectionFlow();
+            return;
+        }
+
+        await LoadCurrentCivitAiPageAsync();
+    }
+
+    private async Task LoadCurrentCivitAiPageAsync()
+    {
+        if (activeCivitAiContext is null)
+        {
+            ResetCivitAiSelectionFlow();
+            return;
+        }
+
+        IsImporting = true;
+
+        try
+        {
+            while (activeCivitAiContext is not null)
+            {
+                var request = activeCivitAiContext.Request.Clone();
+                if (!string.IsNullOrWhiteSpace(activeCivitAiContext.CurrentCursor))
+                {
+                    request.Cursor = activeCivitAiContext.CurrentCursor;
+                }
+
+                var response = await civitApi.GetModels(request);
+                var pageModels = CreateSelectionItems(response.Items);
+
+                if (pageModels.Count == 0)
+                {
+                    CivitAiSelectionStatus = response.Items is { Count: > 0 }
+                        ? Resources.Text_NoDownloadableModelVersionsFoundOnThisPageMovingToNext
+                        : Resources.Text_NoModelsFoundOnThisPageMovingToNext;
+
+                    if (!TryAdvanceToNextCivitAiPage())
+                    {
+                        CompleteCivitAiSelectionFlow();
+                        return;
+                    }
+
+                    continue;
+                }
+
+                SetCurrentCivitAiPage(response, pageModels);
+                return;
+            }
+
+            CompleteCivitAiSelectionFlow();
+        }
+        finally
+        {
+            IsImporting = false;
+        }
+    }
+
+    private async Task<bool> TryImportCivitModel(
+        CivitModel model,
+        CivitModelVersion modelVersion,
+        DirectoryPath downloadFolder
+    )
+    {
+        var modelFile =
+            modelVersion.Files?.FirstOrDefault(file => file.Type == CivitFileType.Model)
+            ?? modelVersion.Files?.FirstOrDefault();
+
+        if (modelFile is null)
+        {
+            ShowNotification(
+                Resources.Label_ModelHasNoFiles,
+                string.Format(
+                    Resources.Text_ModelHasNoDownloadableFiles,
+                    model.Name,
+                    modelVersion.Name
+                ),
+                NotificationType.Warning
+            );
+            return false;
+        }
+
+        await modelImportService.DoImport(
+            model,
+            downloadFolder,
+            selectedVersion: modelVersion,
+            selectedFile: modelFile
+        );
+
+        return true;
+    }
+
+    private void ResetCivitAiSelectionFlow()
+    {
+        IsCivitAiSelectionMode = false;
+        CivitAiCurrentPageModels.Clear();
+        CivitAiCurrentPageLabel = string.Empty;
+        CivitAiCurrentPageUrl = string.Empty;
+        CivitAiSelectionStatus = string.Empty;
+        HasMoreCivitAiPages = false;
+        activeCivitAiContext = null;
+        civitAiImportQueue.Clear();
+        ImportStatus = string.Empty;
+    }
+
+    private sealed class CivitAiImportContext
+    {
+        public required CivitModelsRequest Request { get; init; }
+        public required string SourceLabel { get; init; }
+        public string? CurrentCursor { get; set; }
+        public string? NextCursor { get; set; }
+        public int? NextPage { get; set; }
+    }
+
+    public sealed partial class CivitModelSelectionItem : ObservableObject
+    {
+        [ObservableProperty]
+        private bool isSelected;
+
+        public required CivitModel Model { get; init; }
+        public required CivitModelVersion ModelVersion { get; init; }
+
+        public string DisplayName => $"{Model.Name} - {ModelVersion.Name}";
+
+        public string Details =>
+            $"{Model.Type} • {ModelVersion.BaseModel ?? Resources.Label_UnknownBase} • {Model.Creator?.Username}";
+    }
+
+    [RelayCommand]
+    private async Task SelectCustomFolder()
+    {
+        if (!App.StorageProvider.CanPickFolder)
+        {
+            ShowNotification(
+                Resources.Label_SelectDownloadFolder,
+                Resources.Text_PlatformDoesNotSupportFolderPicking,
+                NotificationType.Warning
+            );
+            return;
+        }
+
+        var files = await App.StorageProvider.OpenFolderPickerAsync(
+            new FolderPickerOpenOptions
+            {
+                Title = Resources.Label_SelectDownloadFolder,
+                AllowMultiple = false,
+            }
+        );
+
+        if (files.FirstOrDefault()?.TryGetLocalPath() is { } path)
+        {
+            CustomDownloadLocation = path;
+            SelectedDownloadLocation = CustomLocationLabel;
+            ImportStatus = string.Format(Resources.Text_CustomFolderSet, path);
+            return;
+        }
+
+        SelectedDownloadLocation = GetLastValidDownloadLocation();
+    }
+
+    private string GetLastValidDownloadLocation()
+    {
+        if (!string.IsNullOrWhiteSpace(lastValidDownloadLocation))
+        {
+            return lastValidDownloadLocation;
+        }
+
+        return AvailableDownloadLocations.FirstOrDefault(loc => !IsCustomLocation(loc)) ?? string.Empty;
+    }
+
+    private DirectoryPath? GetValidatedDownloadFolder()
+    {
+        if (string.IsNullOrWhiteSpace(SelectedDownloadLocation))
+        {
+            ShowNotification(
+                Resources.Label_SelectDownloadLocation,
+                Resources.Text_PleaseSelectADownloadLocation,
+                NotificationType.Warning
+            );
+            return null;
+        }
+
+        if (IsCustomLocation(SelectedDownloadLocation) && string.IsNullOrWhiteSpace(CustomDownloadLocation))
+        {
+            ShowNotification(
+                Resources.Label_SelectDownloadLocation,
+                Resources.Text_PleasePickAFolderForTheCustomLocation,
+                NotificationType.Warning
+            );
+            return null;
+        }
+
+        return ResolveDownloadFolder();
+    }
+
+    private bool TryAdvanceToNextCivitAiPage()
+    {
+        if (activeCivitAiContext is null)
+        {
+            return false;
+        }
+
+        if (!string.IsNullOrWhiteSpace(activeCivitAiContext.NextCursor))
+        {
+            activeCivitAiContext.CurrentCursor = activeCivitAiContext.NextCursor;
+            activeCivitAiContext.NextCursor = null;
+            return true;
+        }
+
+        if (activeCivitAiContext.NextPage is > 0)
+        {
+            activeCivitAiContext.CurrentCursor = null;
+            activeCivitAiContext.Request.Page = activeCivitAiContext.NextPage;
+            activeCivitAiContext.Request.Cursor = null;
+            activeCivitAiContext.NextPage = null;
+            return true;
+        }
+
+        if (!civitAiImportQueue.TryDequeue(out var nextContext))
+        {
+            return false;
+        }
+
+        activeCivitAiContext = nextContext;
+        CivitAiCurrentPageUrl = nextContext.SourceLabel;
+        return true;
+    }
+
+    private static List<CivitModelSelectionItem> CreateSelectionItems(IReadOnlyList<CivitModel>? models)
+    {
+        var items = new List<CivitModelSelectionItem>();
+        if (models is not { Count: > 0 })
+        {
+            return items;
+        }
+
+        foreach (var model in models.DistinctBy(x => x.Id))
+        {
+            if (model.ModelVersions is not { Count: > 0 })
+            {
+                continue;
+            }
+
+            foreach (var version in model.ModelVersions.DistinctBy(x => x.Id))
+            {
+                if (version.Files is not { Count: > 0 })
+                {
+                    continue;
+                }
+
+                items.Add(
+                    new CivitModelSelectionItem
+                    {
+                        Model = model,
+                        ModelVersion = version,
+                    }
+                );
+            }
+        }
+
+        return items;
+    }
+
+    private void SetCurrentCivitAiPage(
+        CivitModelsResponse response,
+        IReadOnlyCollection<CivitModelSelectionItem> pageModels
+    )
+    {
+        CivitAiCurrentPageModels.Clear();
+        foreach (var item in pageModels)
+        {
+            CivitAiCurrentPageModels.Add(item);
+        }
+
+        activeCivitAiContext!.NextCursor = response.Metadata?.NextCursor;
+        activeCivitAiContext.NextPage = ParseQueryInt(response.Metadata?.NextPage);
+        HasMoreCivitAiPages =
+            !string.IsNullOrWhiteSpace(activeCivitAiContext.NextCursor)
+            || activeCivitAiContext.NextPage is > 0;
+        CivitAiCurrentPageLabel = FormatCivitAiPageLabel(activeCivitAiContext);
+        CivitAiSelectionStatus = string.Format(
+            Resources.Text_CivitAiModelsAvailableFrom,
+            CivitAiCurrentPageModels.Count,
+            CivitAiCurrentPageUrl
+        );
+    }
+
+    private static string FormatCivitAiPageLabel(CivitAiImportContext context)
+    {
+        var pageLabelSource = Resources.Text_CivitAiPage;
+        if (!string.IsNullOrWhiteSpace(context.Request.Query))
+        {
+            pageLabelSource = string.Format(Resources.Text_SearchFormat, context.Request.Query);
+        }
+        else if (!string.IsNullOrWhiteSpace(context.Request.Tag))
+        {
+            pageLabelSource = string.Format(Resources.Text_TagFormat, context.Request.Tag);
+        }
+        else if (!string.IsNullOrWhiteSpace(context.Request.Username))
+        {
+            pageLabelSource = string.Format(Resources.Text_UserFormat, context.Request.Username);
+        }
+        else if (!string.IsNullOrWhiteSpace(context.Request.CommaSeparatedModelIds))
+        {
+            pageLabelSource = string.Format(
+                Resources.Text_ModelsFormat,
+                context.Request.CommaSeparatedModelIds
+            );
+        }
+
+        if (context.Request.Page is > 0)
+        {
+            pageLabelSource = string.Format(Resources.Text_PageFormat, pageLabelSource, context.Request.Page);
+        }
+
+        return pageLabelSource;
+    }
+
+    private void CompleteCivitAiSelectionFlow()
+    {
+        ResetCivitAiSelectionFlow();
+        UrlsInput = string.Empty;
+        ModelFileName = string.Empty;
+    }
+
+    private void ShowNotification(string title, string message, NotificationType notificationType)
+    {
+        notificationService.Show(new Notification(title, message, notificationType));
+    }
+}
diff --git a/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowserViewModel.cs b/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowserViewModel.cs
index 589f4d25..04680433 100644
--- a/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowserViewModel.cs
+++ b/StabilityMatrix.Avalonia/ViewModels/CheckpointBrowserViewModel.cs
@@ -33,12 +33,18 @@ public partial class CheckpointBrowserViewModel : PageViewModelBase
     public CheckpointBrowserViewModel(
         CivitAiBrowserViewModel civitAiBrowserViewModel,
         HuggingFacePageViewModel huggingFaceViewModel,
-        OpenModelDbBrowserViewModel openModelDbBrowserViewModel
+        OpenModelDbBrowserViewModel openModelDbBrowserViewModel,
+        DirectUrlImportViewModel directUrlImportViewModel
     )
     {
         Pages = new List<TabItem>(
             new List<TabViewModelBase>(
-                [civitAiBrowserViewModel, huggingFaceViewModel, openModelDbBrowserViewModel]
+                [
+                    civitAiBrowserViewModel,
+                    huggingFaceViewModel,
+                    openModelDbBrowserViewModel,
+                    directUrlImportViewModel
+                ]
             ).Select(vm => new TabItem { Header = vm.Header, Content = vm })
         );
         SelectedPage = Pages.FirstOrDefault();
diff --git a/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml b/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml
new file mode 100644
index 00000000..74df8bc9
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml
@@ -0,0 +1,206 @@
+<controls:UserControlBase
+    x:Class="StabilityMatrix.Avalonia.Views.DirectUrlImportPage"
+    xmlns="https://github.com/avaloniaui"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:checkpointBrowser="clr-namespace:StabilityMatrix.Avalonia.ViewModels.CheckpointBrowser"
+    xmlns:controls="clr-namespace:StabilityMatrix.Avalonia.Controls"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:lang="clr-namespace:StabilityMatrix.Avalonia.Languages"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:mocks="clr-namespace:StabilityMatrix.Avalonia.DesignData"
+    d:DataContext="{x:Static mocks:DesignData.DirectUrlImportViewModel}"
+    d:DesignHeight="700"
+    d:DesignWidth="800"
+    x:CompileBindings="True"
+    x:DataType="checkpointBrowser:DirectUrlImportViewModel"
+    mc:Ignorable="d">
+    <ScrollViewer>
+        <StackPanel Margin="24" Spacing="16" VerticalAlignment="Top">
+            <TextBlock
+                FontSize="18"
+                FontWeight="SemiBold"
+                Text="{x:Static lang:Resources.Label_DirectUrlImport}" />
+
+            <StackPanel Spacing="8">
+                <TextBlock
+                    FontWeight="Medium"
+                    Text="{x:Static lang:Resources.Text_DirectUrlInputUrlsOnePerLine}" />
+
+                <TextBox
+                    AcceptsReturn="True"
+                    Height="150"
+                    IsEnabled="{Binding !IsImporting}"
+                    Watermark="{x:Static lang:Resources.Text_UrlImportUrlsWatermark}"
+                    Text="{Binding UrlsInput, Mode=TwoWay}"
+                    TextWrapping="Wrap"
+                    VerticalAlignment="Top" />
+            </StackPanel>
+
+            <StackPanel Spacing="8">
+                <TextBlock
+                    FontWeight="Medium"
+                    Text="{x:Static lang:Resources.Label_ModelFileNameForDirectUrls}" />
+
+                <TextBox
+                    IsEnabled="{Binding !IsImporting}"
+                    Watermark="{x:Static lang:Resources.Text_UrlImportModelFileNameWatermark}"
+                    Text="{Binding ModelFileName, Mode=TwoWay}" />
+            </StackPanel>
+
+            <StackPanel Spacing="8">
+                <TextBlock
+                    FontWeight="Medium"
+                    Text="{x:Static lang:Resources.Label_SelectDownloadLocation}" />
+
+                <StackPanel Spacing="8" Orientation="Horizontal">
+                    <ComboBox
+                        HorizontalAlignment="Stretch"
+                        IsEnabled="{Binding !IsImporting}"
+                        ItemsSource="{Binding AvailableDownloadLocations}"
+                        SelectedItem="{Binding SelectedDownloadLocation}"
+                        Width="300" />
+
+                    <Button
+                        Classes="transparent-full"
+                        Command="{Binding SelectCustomFolderCommand}"
+                        Content="{x:Static lang:Resources.Action_SelectDirectory}" />
+                </StackPanel>
+
+                <TextBlock
+                    FontSize="11"
+                    Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                    IsVisible="{Binding !!CustomDownloadLocation}"
+                    Text="{Binding CustomDownloadLocation}" />
+            </StackPanel>
+
+            <StackPanel Spacing="8">
+                <TextBlock
+                    FontSize="12"
+                    Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                    IsVisible="{Binding !!ImportStatus}"
+                    Text="{Binding ImportStatus}" />
+            </StackPanel>
+
+            <StackPanel Spacing="8" Orientation="Horizontal" IsVisible="{Binding !IsCivitAiSelectionMode}">
+                <Button
+                    Classes="accent"
+                    Command="{Binding ImportCommand}"
+                    IsEnabled="{Binding !IsImporting}"
+                    Content="{x:Static lang:Resources.Action_Download}" />
+            </StackPanel>
+
+            <Border
+                Background="{DynamicResource ColorNeutralBackground3}"
+                BorderBrush="{DynamicResource ColorNeutralStroke2}"
+                BorderThickness="1"
+                CornerRadius="6"
+                IsVisible="{Binding IsCivitAiSelectionMode}"
+                Padding="12">
+                <StackPanel Spacing="8">
+                    <TextBlock
+                        FontSize="14"
+                        FontWeight="SemiBold"
+                        Text="{x:Static lang:Resources.Label_SelectCivitAiModelsFromCurrentPage}" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                        Text="{Binding CivitAiCurrentPageLabel}" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                        Text="{Binding CivitAiCurrentPageUrl}" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                        IsVisible="{Binding !!CivitAiSelectionStatus}"
+                        Text="{Binding CivitAiSelectionStatus}" />
+
+                    <ListBox
+                        ItemsSource="{Binding CivitAiCurrentPageModels}"
+                        MaxHeight="280">
+                        <ListBox.ItemTemplate>
+                            <DataTemplate>
+                                <CheckBox
+                                    IsChecked="{Binding IsSelected}"
+                                    VerticalContentAlignment="Center"
+                                    HorizontalContentAlignment="Stretch">
+                                    <StackPanel Spacing="2">
+                                        <TextBlock Text="{Binding DisplayName}" TextWrapping="NoWrap" />
+                                        <TextBlock
+                                            FontSize="11"
+                                            Foreground="{DynamicResource TextFillColorTertiaryBrush}"
+                                            Text="{Binding Details}" TextWrapping="NoWrap" />
+                                    </StackPanel>
+                                </CheckBox>
+                            </DataTemplate>
+                        </ListBox.ItemTemplate>
+                    </ListBox>
+
+                    <StackPanel Spacing="8" Orientation="Horizontal">
+                        <Button
+                            Classes="accent"
+                            Command="{Binding ImportSelectedCivitAiModelsCommand}"
+                            IsEnabled="{Binding !IsImporting}"
+                            Content="{x:Static lang:Resources.Action_Import}" />
+
+                        <Button
+                            Command="{Binding SkipCurrentCivitAiPageCommand}"
+                            IsEnabled="{Binding !IsImporting}"
+                            Content="{x:Static lang:Resources.Action_SkipThisPage}" />
+
+                        <Button
+                            Command="{Binding ContinueNextCivitAiPageCommand}"
+                            IsEnabled="{Binding !IsImporting}"
+                            IsVisible="{Binding HasMoreCivitAiPages}"
+                            Content="{x:Static lang:Resources.Label_NextPage}" />
+
+                        <Button
+                            Command="{Binding CancelCivitAiSelectionCommand}"
+                            Content="{x:Static lang:Resources.Action_Cancel}" />
+                    </StackPanel>
+                </StackPanel>
+            </Border>
+
+            <Border
+                Padding="12"
+                Background="{DynamicResource ColorNeutralBackground3}"
+                BorderBrush="{DynamicResource ColorNeutralStroke2}"
+                BorderThickness="1"
+                CornerRadius="4">
+                <StackPanel Spacing="8">
+                    <TextBlock
+                        FontSize="11"
+                        FontWeight="SemiBold"
+                        Text="{x:Static lang:Resources.Label_Tips}" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                        Text="{x:Static lang:Resources.Text_DirectUrlImportTipCivitAiPage}"
+                        TextWrapping="Wrap" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                        Text="{x:Static lang:Resources.Text_DirectUrlImportTipDirectUrls}"
+                        TextWrapping="Wrap" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                        Text="{x:Static lang:Resources.Text_DirectUrlImportTipCivitAiModelPage}"
+                        TextWrapping="Wrap" />
+
+                    <TextBlock
+                        FontSize="11"
+                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
+                        Text="{x:Static lang:Resources.Text_DirectUrlImportTipSaveLocation}"
+                        TextWrapping="Wrap" />
+                </StackPanel>
+            </Border>
+        </StackPanel>
+    </ScrollViewer>
+</controls:UserControlBase>
diff --git a/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml.cs b/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml.cs
new file mode 100644
index 00000000..a21025f0
--- /dev/null
+++ b/StabilityMatrix.Avalonia/Views/DirectUrlImportPage.axaml.cs
@@ -0,0 +1,13 @@
+using Injectio.Attributes;
+using StabilityMatrix.Avalonia.Controls;
+
+namespace StabilityMatrix.Avalonia.Views;
+
+[RegisterTransient<DirectUrlImportPage>]
+public partial class DirectUrlImportPage : UserControlBase
+{
+    public DirectUrlImportPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/StabilityMatrix.Core/Models/Api/CivitModelsRequest.cs b/StabilityMatrix.Core/Models/Api/CivitModelsRequest.cs
index 613fa879..afefbcb9 100644
--- a/StabilityMatrix.Core/Models/Api/CivitModelsRequest.cs
+++ b/StabilityMatrix.Core/Models/Api/CivitModelsRequest.cs
@@ -124,6 +124,14 @@ public class CivitModelsRequest
     [AliasAs("cursor")]
     public string? Cursor { get; set; }
 
+    public CivitModelsRequest Clone()
+    {
+        var clone = (CivitModelsRequest)MemberwiseClone();
+        clone.Types = Types is null ? null : (CivitModelType[])Types.Clone();
+        clone.BaseModels = BaseModels is null ? null : (string[])BaseModels.Clone();
+        return clone;
+    }
+
     public override string ToString()
     {
         return $"Page: {Page}, "
diff --git a/StabilityMatrix.Core/Models/TrackedDownload.cs b/StabilityMatrix.Core/Models/TrackedDownload.cs
index c7a31e3b..d63b8f7e 100644
--- a/StabilityMatrix.Core/Models/TrackedDownload.cs
+++ b/StabilityMatrix.Core/Models/TrackedDownload.cs
@@ -38,6 +38,20 @@ public class TrackedDownload
 
     public Uri? RedirectedUrl { get; init; }
 
+    /// <summary>
+    /// Optional list of fallback URLs to try if the primary download fails
+    /// </summary>
+    public List<Uri>? FallbackUris { get; set; }
+
+    /// <summary>
+    /// Gets the current URL to use for download (either SourceUrl or a fallback URL)
+    /// </summary>
+    [JsonIgnore]
+    public Uri CurrentDownloadUrl =>
+        currentUrlIndex > 0 && FallbackUris is { Count: > 0 } && currentUrlIndex - 1 < FallbackUris.Count
+            ? FallbackUris[currentUrlIndex - 1]
+            : SourceUrl;
+
     public required DirectoryPath DownloadDirectory { get; init; }
 
     public required string FileName { get; init; }
@@ -78,6 +92,7 @@ public class TrackedDownload
     public Exception? Exception { get; private set; }
 
     private int attempts;
+    private int currentUrlIndex;
 
     #region Events
     public event EventHandler<ProgressReport>? ProgressUpdate;
@@ -127,7 +142,7 @@ private async Task StartDownloadTask(long resumeFromByte, CancellationToken canc
 
         await downloadService!
             .ResumeDownloadToFileAsync(
-                SourceUrl.ToString(),
+                CurrentDownloadUrl.ToString(),
                 DownloadDirectory.JoinFile(TempFileName),
                 resumeFromByte,
                 progress,
@@ -316,6 +331,18 @@ private void DoCleanup()
         }
     }
 
+    private void DoCleanupTempFile()
+    {
+        try
+        {
+            DownloadDirectory.JoinFile(TempFileName).Delete();
+        }
+        catch (IOException)
+        {
+            Logger.Warn("Failed to delete temp file {TempFile}", TempFileName);
+        }
+    }
+
     /// <summary>
     /// Invoked by the task's completion callback
     /// </summary>
@@ -365,6 +392,31 @@ private void OnDownloadTaskCompleted(Task task)
                 return;
             }
 
+            // If we have fallback URLs, try the next one
+            if (FallbackUris is { Count: > 0 } && currentUrlIndex < FallbackUris.Count)
+            {
+                attempts = 0;
+                var nextUrl = FallbackUris[currentUrlIndex];
+                currentUrlIndex++;
+
+                Logger.Warn(
+                    "Download {Download} failed, trying fallback URL {Url} ({Index}/{Total})",
+                    FileName,
+                    nextUrl,
+                    currentUrlIndex + 1,
+                    FallbackUris.Count + 1
+                );
+
+                // Start each fallback URL as a fresh download instead of resuming from
+                // a partial file created by the previous URL.
+                DoCleanupTempFile();
+
+                OnProgressStateChanging(ProgressState.Inactive);
+                ProgressState = ProgressState.Inactive;
+                Start();
+                return;
+            }
+
             Logger.Warn(Exception, "Download {Download} failed", FileName);
 
             OnProgressStateChanging(ProgressState.Failed);
diff --git a/StabilityMatrix.Tests/Core/CivitModelsRequestTests.cs b/StabilityMatrix.Tests/Core/CivitModelsRequestTests.cs
new file mode 100644
index 00000000..118de2af
--- /dev/null
+++ b/StabilityMatrix.Tests/Core/CivitModelsRequestTests.cs
@@ -0,0 +1,70 @@
+using StabilityMatrix.Core.Models.Api;
+
+namespace StabilityMatrix.Tests.Core;
+
+[TestClass]
+public class CivitModelsRequestTests
+{
+    [TestMethod]
+    public void Clone_ShouldCopyValues_AndCloneArrays()
+    {
+        var request = new CivitModelsRequest
+        {
+            Limit = 25,
+            Page = 2,
+            Query = "portrait",
+            Tag = "anime",
+            Username = "artist",
+            Types = [CivitModelType.Checkpoint, CivitModelType.VAE],
+            Sort = CivitSortMode.HighestRated,
+            Period = CivitPeriod.AllTime,
+            Rating = 5,
+            Favorites = true,
+            Hidden = false,
+            PrimaryFileOnly = true,
+            AllowDerivatives = true,
+            AllowDifferentLicenses = false,
+            AllowCommercialUse = CivitCommercialUse.Image,
+            Nsfw = "true",
+            BaseModels = ["SD 1.5", "SDXL 1.0"],
+            CommaSeparatedModelIds = "123,456",
+            Cursor = "cursor-1",
+        };
+
+        var clone = request.Clone();
+
+        Assert.AreNotSame(request, clone);
+        Assert.AreEqual(request.Limit, clone.Limit);
+        Assert.AreEqual(request.Page, clone.Page);
+        Assert.AreEqual(request.Query, clone.Query);
+        Assert.AreEqual(request.Tag, clone.Tag);
+        Assert.AreEqual(request.Username, clone.Username);
+        Assert.AreEqual(request.Sort, clone.Sort);
+        Assert.AreEqual(request.Period, clone.Period);
+        Assert.AreEqual(request.Rating, clone.Rating);
+        Assert.AreEqual(request.Favorites, clone.Favorites);
+        Assert.AreEqual(request.Hidden, clone.Hidden);
+        Assert.AreEqual(request.PrimaryFileOnly, clone.PrimaryFileOnly);
+        Assert.AreEqual(request.AllowDerivatives, clone.AllowDerivatives);
+        Assert.AreEqual(request.AllowDifferentLicenses, clone.AllowDifferentLicenses);
+        Assert.AreEqual(request.AllowCommercialUse, clone.AllowCommercialUse);
+        Assert.AreEqual(request.Nsfw, clone.Nsfw);
+        Assert.AreEqual(request.CommaSeparatedModelIds, clone.CommaSeparatedModelIds);
+        Assert.AreEqual(request.Cursor, clone.Cursor);
+        CollectionAssert.AreEqual(request.Types, clone.Types);
+        CollectionAssert.AreEqual(request.BaseModels, clone.BaseModels);
+        Assert.AreNotSame(request.Types, clone.Types);
+        Assert.AreNotSame(request.BaseModels, clone.BaseModels);
+
+        Assert.IsNotNull(clone.Types);
+        Assert.IsNotNull(clone.BaseModels);
+        Assert.IsNotNull(request.Types);
+        Assert.IsNotNull(request.BaseModels);
+
+        clone.Types[0] = CivitModelType.LORA;
+        clone.BaseModels[0] = "Changed";
+
+        Assert.AreEqual(CivitModelType.Checkpoint, request.Types[0]);
+        Assert.AreEqual("SD 1.5", request.BaseModels[0]);
+    }
+}
diff --git a/global.json b/global.json
index f4fd3857..6d77f621 100644
--- a/global.json
+++ b/global.json
@@ -4,4 +4,4 @@
     "rollForward": "latestMajor",
     "allowPrerelease": true
   }
-}
\ No newline at end of file
+}