diff --git a/src/AStar.Dev.Infrastructure.FilesDb/Data/FilesContext.cs b/src/AStar.Dev.Infrastructure.FilesDb/Data/FilesContext.cs
index 5f2460b..a9f1eb1 100644
--- a/src/AStar.Dev.Infrastructure.FilesDb/Data/FilesContext.cs
+++ b/src/AStar.Dev.Infrastructure.FilesDb/Data/FilesContext.cs
@@ -1,4 +1,4 @@
-using AStar.Dev.Infrastructure.FilesDb.Models;
+using AStar.Dev.Infrastructure.FilesDb.Models;
 using Microsoft.EntityFrameworkCore;
 
 namespace AStar.Dev.Infrastructure.FilesDb.Data;
@@ -76,7 +76,11 @@ public FilesContext()
     public DbSet<DownloadedFileClassification> DownloadedFileClassifications { get; set; } = null!;
 
     /// <inheritdoc />
-    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) => _ = optionsBuilder.UseSqlite("Data Source=/home/jbarden/Documents/Scrapper/files.db");
+    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+    {
+        if(!optionsBuilder.IsConfigured)
+            _ = optionsBuilder.UseSqlite("Data Source=/home/jbarden/Documents/Scrapper/files.db");
+    }
 
     /// <summary>
     ///     The overridden OnModelCreating method
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/App.axaml.cs b/src/AStar.Dev.Wallpaper.Scrapper/App.axaml.cs
index 38f07d3..d2a9da1 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/App.axaml.cs
+++ b/src/AStar.Dev.Wallpaper.Scrapper/App.axaml.cs
@@ -88,6 +88,7 @@ public override void OnFrameworkInitializationCompleted()
             .AddTransient<SearchResultsPageFunctional>()
             .AddTransient<IImportExportService, ImportExportService>()
             .AddTransient<IFileSystem, RealFileSystem>()
+            .AddTransient<ScrapeConfigurationService>()
             .AddTransient<Func<ScrapeConfigurationView>>(sp => () => sp.GetRequiredService<ScrapeConfigurationView>())
             .AddTransient<MainWindow>();
 
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/ApplicationMetadata.cs b/src/AStar.Dev.Wallpaper.Scrapper/ApplicationMetadata.cs
index 2bb1b1f..6b6c148 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/ApplicationMetadata.cs
+++ b/src/AStar.Dev.Wallpaper.Scrapper/ApplicationMetadata.cs
@@ -8,9 +8,12 @@ public static class ApplicationMetadata
 {
     public const string Name = "AStar.Dev.Wallpaper.Scrapper";
     public const string Version = "1.0.0";
+    public const string Redacted = "REDACTED";
 
     public static string ApplicationFolder => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)!.CombinePath("..", "..", "..");
 
     public static string FileClassificationsExportFilePath => SpecialDirectories.MyDocuments.CombinePath("Scrapper", "FileClassifications.json");
+
+    public static string ScrapeConfigurationExportFilePath => SpecialDirectories.MyDocuments.CombinePath("Scrapper", "ScrapeConfiguration.json");
     public static string ScrapedTagsExportFilePath         => SpecialDirectories.MyDocuments.CombinePath("Scrapper", "ScrapedTags.json");
 }
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ConnectionStringsDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ConnectionStringsDto.cs
new file mode 100644
index 0000000..83c41e3
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ConnectionStringsDto.cs
@@ -0,0 +1,6 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record ConnectionStringsDto
+{
+    public string Sqlite { get; init; } = string.Empty;
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDto.cs
new file mode 100644
index 0000000..6c3e8a3
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDto.cs
@@ -0,0 +1,9 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record ScrapeConfigurationDto
+{
+    public ConnectionStringsDto ConnectionStrings { get; init; } = new();
+    public UserConfigurationDto UserConfiguration { get; init; } = new();
+    public SearchConfigurationDto SearchConfiguration { get; init; } = new();
+    public ScrapeDirectoriesDto ScrapeDirectories { get; init; } = new();
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDtoExtensions.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDtoExtensions.cs
new file mode 100644
index 0000000..a6fe900
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeConfigurationDtoExtensions.cs
@@ -0,0 +1,109 @@
+using ScrapeConfigurationEntityDomain = AStar.Dev.Infrastructure.FilesDb.Models.ScrapeConfigurationEntity;
+using SearchCategoriesDomain = AStar.Dev.Infrastructure.FilesDb.Models.SearchCategories;
+using ConnectionStringsDomain = AStar.Dev.Infrastructure.FilesDb.Models.ConnectionStrings;
+using UserConfigurationDomain = AStar.Dev.Infrastructure.FilesDb.Models.UserConfiguration;
+using SearchConfigurationDomain = AStar.Dev.Infrastructure.FilesDb.Models.SearchConfiguration;
+using ScrapeDirectoriesDomain = AStar.Dev.Infrastructure.FilesDb.Models.ScrapeDirectories;
+
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public static class ScrapeConfigurationDtoExtensions
+{
+    public static ScrapeConfigurationDto ToDto(this ScrapeConfigurationEntityDomain entity) => new()
+    {
+        ConnectionStrings = new ConnectionStringsDto { Sqlite = entity.ConnectionStrings.Sqlite },
+        UserConfiguration = new UserConfigurationDto
+        {
+            LoginEmailAddress = entity.UserConfiguration.LoginEmailAddress,
+            Username          = entity.UserConfiguration.Username,
+            Password          = ApplicationMetadata.Redacted,
+            SessionCookie     = ApplicationMetadata.Redacted
+        },
+        SearchConfiguration = new SearchConfigurationDto
+        {
+            BaseUrl                         = entity.SearchConfiguration.BaseUrl,
+            ApiKey                          = ApplicationMetadata.Redacted,
+            SearchCategories                = [.. entity.SearchConfiguration.SearchCategories.Select(c => new SearchCategoryDto
+            {
+                Id                  = c.Id,
+                Name                = c.Name,
+                LastKnownImageCount = c.LastKnownImageCount,
+                LastPageVisited     = c.LastPageVisited,
+                TotalPages          = c.TotalPages,
+                IncludeInSearch     = c.IncludeInSearch
+            })],
+            SearchString                    = entity.SearchConfiguration.SearchString,
+            TopWallpapers                   = entity.SearchConfiguration.TopWallpapers,
+            SearchStringPrefix              = entity.SearchConfiguration.SearchStringPrefix,
+            SearchStringSuffix              = entity.SearchConfiguration.SearchStringSuffix,
+            Subscriptions                   = entity.SearchConfiguration.Subscriptions,
+            ImagePauseInSeconds             = entity.SearchConfiguration.ImagePauseInSeconds,
+            StartingPageNumber              = entity.SearchConfiguration.StartingPageNumber,
+            TotalPages                      = entity.SearchConfiguration.TotalPages,
+            SubscriptionsStartingPageNumber = entity.SearchConfiguration.SubscriptionsStartingPageNumber,
+            SubscriptionsTotalPages         = entity.SearchConfiguration.SubscriptionsTotalPages,
+            TopWallpapersTotalPages         = entity.SearchConfiguration.TopWallpapersTotalPages,
+            TopWallpapersStartingPageNumber = entity.SearchConfiguration.TopWallpapersStartingPageNumber,
+            LoginUrl                        = entity.SearchConfiguration.LoginUrl,
+            UseHeadless                     = entity.SearchConfiguration.UseHeadless,
+            SlowMotionDelay                 = entity.SearchConfiguration.SlowMotionDelay
+        },
+        ScrapeDirectories = new ScrapeDirectoriesDto
+        {
+            RootDirectory       = entity.ScrapeDirectories.RootDirectory,
+            BaseSaveDirectory   = entity.ScrapeDirectories.BaseSaveDirectory,
+            BaseDirectory       = entity.ScrapeDirectories.BaseDirectory,
+            BaseDirectoryFamous = entity.ScrapeDirectories.BaseDirectoryFamous,
+            SubDirectoryName    = entity.ScrapeDirectories.SubDirectoryName
+        }
+    };
+
+    public static ScrapeConfigurationEntityDomain ToDomain(this ScrapeConfigurationDto dto) => new()
+    {
+        ConnectionStrings = new ConnectionStringsDomain { Sqlite = dto.ConnectionStrings.Sqlite },
+        UserConfiguration = new UserConfigurationDomain
+        {
+            LoginEmailAddress = dto.UserConfiguration.LoginEmailAddress,
+            Username          = dto.UserConfiguration.Username,
+            Password          = dto.UserConfiguration.Password,
+            SessionCookie     = dto.UserConfiguration.SessionCookie
+        },
+        SearchConfiguration = new SearchConfigurationDomain
+        {
+            BaseUrl                         = dto.SearchConfiguration.BaseUrl,
+            ApiKey                          = dto.SearchConfiguration.ApiKey,
+            SearchCategories                = [.. dto.SearchConfiguration.SearchCategories.Select(c => new SearchCategoriesDomain
+            {
+                Id                  = c.Id,
+                Name                = c.Name,
+                LastKnownImageCount = c.LastKnownImageCount,
+                LastPageVisited     = c.LastPageVisited,
+                TotalPages          = c.TotalPages,
+                IncludeInSearch     = c.IncludeInSearch
+            })],
+            SearchString                    = dto.SearchConfiguration.SearchString,
+            TopWallpapers                   = dto.SearchConfiguration.TopWallpapers,
+            SearchStringPrefix              = dto.SearchConfiguration.SearchStringPrefix,
+            SearchStringSuffix              = dto.SearchConfiguration.SearchStringSuffix,
+            Subscriptions                   = dto.SearchConfiguration.Subscriptions,
+            ImagePauseInSeconds             = dto.SearchConfiguration.ImagePauseInSeconds,
+            StartingPageNumber              = dto.SearchConfiguration.StartingPageNumber,
+            TotalPages                      = dto.SearchConfiguration.TotalPages,
+            SubscriptionsStartingPageNumber = dto.SearchConfiguration.SubscriptionsStartingPageNumber,
+            SubscriptionsTotalPages         = dto.SearchConfiguration.SubscriptionsTotalPages,
+            TopWallpapersTotalPages         = dto.SearchConfiguration.TopWallpapersTotalPages,
+            TopWallpapersStartingPageNumber = dto.SearchConfiguration.TopWallpapersStartingPageNumber,
+            LoginUrl                        = dto.SearchConfiguration.LoginUrl,
+            UseHeadless                     = dto.SearchConfiguration.UseHeadless,
+            SlowMotionDelay                 = dto.SearchConfiguration.SlowMotionDelay
+        },
+        ScrapeDirectories = new ScrapeDirectoriesDomain
+        {
+            RootDirectory       = dto.ScrapeDirectories.RootDirectory,
+            BaseSaveDirectory   = dto.ScrapeDirectories.BaseSaveDirectory,
+            BaseDirectory       = dto.ScrapeDirectories.BaseDirectory,
+            BaseDirectoryFamous = dto.ScrapeDirectories.BaseDirectoryFamous,
+            SubDirectoryName    = dto.ScrapeDirectories.SubDirectoryName
+        }
+    };
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeDirectoriesDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeDirectoriesDto.cs
new file mode 100644
index 0000000..bcadf9a
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/ScrapeDirectoriesDto.cs
@@ -0,0 +1,10 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record ScrapeDirectoriesDto
+{
+    public string RootDirectory { get; init; } = string.Empty;
+    public string BaseSaveDirectory { get; init; } = string.Empty;
+    public string BaseDirectory { get; init; } = string.Empty;
+    public string BaseDirectoryFamous { get; init; } = string.Empty;
+    public string SubDirectoryName { get; init; } = string.Empty;
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchCategoryDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchCategoryDto.cs
new file mode 100644
index 0000000..adbd5c0
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchCategoryDto.cs
@@ -0,0 +1,11 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record SearchCategoryDto
+{
+    public string Id { get; init; } = string.Empty;
+    public string Name { get; init; } = string.Empty;
+    public int LastKnownImageCount { get; init; }
+    public int LastPageVisited { get; init; }
+    public int TotalPages { get; init; }
+    public bool IncludeInSearch { get; init; } = true;
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchConfigurationDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchConfigurationDto.cs
new file mode 100644
index 0000000..221d797
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/SearchConfigurationDto.cs
@@ -0,0 +1,23 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record SearchConfigurationDto
+{
+    public string BaseUrl { get; init; } = string.Empty;
+    public string ApiKey { get; init; } = string.Empty;
+    public List<SearchCategoryDto> SearchCategories { get; init; } = [];
+    public string SearchString { get; init; } = string.Empty;
+    public string TopWallpapers { get; init; } = string.Empty;
+    public string SearchStringPrefix { get; init; } = string.Empty;
+    public string SearchStringSuffix { get; init; } = string.Empty;
+    public string Subscriptions { get; init; } = string.Empty;
+    public int ImagePauseInSeconds { get; init; }
+    public int StartingPageNumber { get; init; }
+    public int TotalPages { get; init; }
+    public int SubscriptionsStartingPageNumber { get; init; }
+    public int SubscriptionsTotalPages { get; init; }
+    public int TopWallpapersTotalPages { get; init; }
+    public int TopWallpapersStartingPageNumber { get; init; }
+    public string LoginUrl { get; init; } = string.Empty;
+    public bool UseHeadless { get; init; }
+    public float? SlowMotionDelay { get; init; }
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/DTOs/UserConfigurationDto.cs b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/UserConfigurationDto.cs
new file mode 100644
index 0000000..635c72f
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/DTOs/UserConfigurationDto.cs
@@ -0,0 +1,9 @@
+namespace AStar.Dev.Wallpaper.Scrapper.DTOs;
+
+public sealed record UserConfigurationDto
+{
+    public string LoginEmailAddress { get; init; } = string.Empty;
+    public string Username { get; init; } = string.Empty;
+    public string Password { get; init; } = string.Empty;
+    public string SessionCookie { get; init; } = string.Empty;
+}
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml b/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml
index 87f1dd2..b0022fb 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml
+++ b/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml
@@ -10,6 +10,8 @@
             <Button x:Name="ScrapeSiteNewButton" Content="Scrape Site New" Click="OnScrapeSiteFunctionalClicked" />
             <Button x:Name="ExportButton" Content="Export Classifications" Click="OnExportClicked" />
             <Button x:Name="ImportButton" Content="Import Classifications" Click="OnImportClicked" />
+            <Button x:Name="ExportScrapeConfigButton" Content="Export Config" Click="OnExportScrapeConfigClicked" />
+            <Button x:Name="ImportScrapeConfigButton" Content="Import Config" Click="OnImportScrapeConfigClicked" />
             <Button x:Name="ExportTagsButton" Content="Export Tags" Click="OnExportTagsClicked" />
             <Button x:Name="ImportTagsButton" Content="Import Tags" Click="OnImportTagsClicked" />
             <Button x:Name="CancelButton" Content="Cancel" Click="OnCancelClicked" IsEnabled="False" />
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml.cs b/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml.cs
index df4ee70..29f1705 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml.cs
+++ b/src/AStar.Dev.Wallpaper.Scrapper/MainWindow.axaml.cs
@@ -36,10 +36,11 @@ public partial class MainWindow : Window, IDisposable
     private readonly SearchWorkflowFunctional imagePageServiceFunctional;
     private readonly SearchWorkflowFunctional searchWorkflowFunctional;
     private readonly IFileSystem fileSystem;
+    private readonly ScrapeConfigurationService scrapeConfigurationService;
     private CancellationTokenSource? cts;
     private readonly Logger scrapeLogger;
 
-    public MainWindow(Func<ScrapeConfigurationView> scrapeConfigViewFactory, SearchWorkflowFunctional imagePageServiceFunctional, IFileSystem fileSystem, IPlaywrightService playwrightService, ScrapeConfiguration scrapeConfiguration, SearchWorkflowFunctional searchWorkflowFunctional, Logger logger, IScrapedTagRepository scrapedTagRepository, IFileDetailRepository fileDetailRepository, FileClassificationService fileClassificationService, IScrapedTagService scrapedTagService, ConfigurationSaver configurationSaver, TagsToIgnoreCompletely tagsToIgnoreCompletely, TagsTextToIgnore tagsTextToIgnore, IImportExportService importExportService)
+    public MainWindow(Func<ScrapeConfigurationView> scrapeConfigViewFactory, SearchWorkflowFunctional imagePageServiceFunctional, IFileSystem fileSystem, IPlaywrightService playwrightService, ScrapeConfiguration scrapeConfiguration, SearchWorkflowFunctional searchWorkflowFunctional, Logger logger, IScrapedTagRepository scrapedTagRepository, IFileDetailRepository fileDetailRepository, FileClassificationService fileClassificationService, IScrapedTagService scrapedTagService, ConfigurationSaver configurationSaver, TagsToIgnoreCompletely tagsToIgnoreCompletely, TagsTextToIgnore tagsTextToIgnore, IImportExportService importExportService, ScrapeConfigurationService scrapeConfigurationService)
     {
         this.scrapeConfigViewFactory = scrapeConfigViewFactory;
         this.scrapeConfiguration = scrapeConfiguration;
@@ -56,6 +57,7 @@ public MainWindow(Func<ScrapeConfigurationView> scrapeConfigViewFactory, SearchW
         this.imagePageServiceFunctional = imagePageServiceFunctional;
         this.searchWorkflowFunctional = searchWorkflowFunctional;
         this.fileSystem = fileSystem;
+        this.scrapeConfigurationService = scrapeConfigurationService;
         this.scrapeLogger = GetScrapeLoggerForDisplaySync();
         InitializeComponent();
         Closed += (_, _) => cts?.Dispose();
@@ -114,6 +116,39 @@ private async void OnImportClicked(object? sender, RoutedEventArgs e)
             .TapAsync(_ => scrapeLogger.Information("Import completed..."))
             .EnsureAsync(() => ResetUI());
 
+    private async void OnExportScrapeConfigClicked(object? sender, RoutedEventArgs e)
+        => _ = await ResetCancellationTokenSource()
+            .Match<CancellationToken, Exception, Result<CancellationToken, string>>(
+                onSuccess: DisableControlsAndClearStatus,
+                onFailure: ex =>
+                {
+                    scrapeLogger.Error(ex, "Failed to reset cancellation token source");
+                    UpdateStatus($"Error: {ex.Message}");
+                    return ex.Message;
+                }
+            )
+            .Tap(_ => scrapeLogger.Information("Exporting scrape configuration..."))
+            .MapAsync(_ => scrapeConfigurationService.ExportScrapeConfigurationAsync(cts!.Token))
+            .Tap(importExportService.ExportScrapeConfigurationToFile)
+            .TapAsync(_ => scrapeLogger.Information("Scrape configuration export completed..."))
+            .EnsureAsync(() => ResetUI());
+
+    private async void OnImportScrapeConfigClicked(object? sender, RoutedEventArgs e)
+        => _ = await ResetCancellationTokenSource()
+            .Match<CancellationToken, Exception, Result<CancellationToken, string>>(
+                onSuccess: DisableControlsAndClearStatus,
+                onFailure: ex =>
+                {
+                    scrapeLogger.Error(ex, "Failed to reset cancellation token source");
+                    return ex.Message;
+                }
+            )
+            .Tap(_ => scrapeLogger.Information("Importing scrape configuration..."))
+            .Bind(_ => importExportService.ImportScrapeConfigurationFromFile())
+            .MapAsync(entity => scrapeConfigurationService.ImportScrapeConfigurationAsync(entity, cts!.Token))
+            .TapAsync(_ => scrapeLogger.Information("Scrape configuration import completed..."))
+            .EnsureAsync(() => ResetUI());
+
     private async void OnExportTagsClicked(object? sender, RoutedEventArgs e)
         => _ = await ResetCancellationTokenSource()
             .Match<CancellationToken, Exception, Result<CancellationToken, string>>(
@@ -160,6 +195,8 @@ private Result<CancellationToken, string> DisableControlsAndClearStatus(Cancella
         ScrapeSiteNewButton.IsEnabled = false;
         ExportButton.IsEnabled = false;
         ImportButton.IsEnabled = false;
+        ExportScrapeConfigButton.IsEnabled = false;
+        ImportScrapeConfigButton.IsEnabled = false;
         ExportTagsButton.IsEnabled = false;
         ImportTagsButton.IsEnabled = false;
         CancelButton.IsEnabled = true;
@@ -182,6 +219,8 @@ private void ResetUI()
                 ScrapeSiteNewButton.IsEnabled = true;
                 ExportButton.IsEnabled = true;
                 ImportButton.IsEnabled = true;
+                ExportScrapeConfigButton.IsEnabled = true;
+                ImportScrapeConfigButton.IsEnabled = true;
                 ExportTagsButton.IsEnabled = true;
                 ImportTagsButton.IsEnabled = true;
                 CancelButton.IsEnabled = false;
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/Services/IImportExportService.cs b/src/AStar.Dev.Wallpaper.Scrapper/Services/IImportExportService.cs
index ca1a5b2..6b839b0 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/Services/IImportExportService.cs
+++ b/src/AStar.Dev.Wallpaper.Scrapper/Services/IImportExportService.cs
@@ -1,4 +1,5 @@
 using AStar.Dev.FunctionalParadigm;
+using AStar.Dev.Infrastructure.FilesDb.Models;
 using FileClassificationDomain = AStar.Dev.Infrastructure.FilesDb.Models.FileClassification;
 using ScrapedTagDomain = AStar.Dev.Infrastructure.FilesDb.Models.ScrapedTag;
 
@@ -8,6 +9,8 @@ public interface IImportExportService
 {
     void ExportFileClassificationsToFile(List<FileClassificationDomain> classifications);
     Result<List<FileClassificationDomain>, string> ImportFileClassificationsFromFile();
+    void ExportScrapeConfigurationToFile(ScrapeConfigurationEntity entity);
+    Result<ScrapeConfigurationEntity, string> ImportScrapeConfigurationFromFile();
 
     void ExportScrapedTagsToFile(List<ScrapedTagDomain> tags);
     Result<List<ScrapedTagDomain>, string> ImportScrapedTagsFromFile();
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/Services/ImportExportService.cs b/src/AStar.Dev.Wallpaper.Scrapper/Services/ImportExportService.cs
index dc07139..417db2c 100644
--- a/src/AStar.Dev.Wallpaper.Scrapper/Services/ImportExportService.cs
+++ b/src/AStar.Dev.Wallpaper.Scrapper/Services/ImportExportService.cs
@@ -1,4 +1,5 @@
 using AStar.Dev.FunctionalParadigm;
+using AStar.Dev.Infrastructure.FilesDb.Models;
 using AStar.Dev.Utilities;
 using AStar.Dev.Wallpaper.Scrapper.DTOs;
 using Serilog;
@@ -49,6 +50,21 @@ public Result<List<FileClassificationDomain>, string> ImportFileClassificationsF
         return classifications.ToDomain();
     }
 
+    public void ExportScrapeConfigurationToFile(ScrapeConfigurationEntity entity)
+    {
+        try
+        {
+            var json = entity.ToDto().ToJson();
+            fileSystem.File.WriteAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath, json);
+            logger.Information("Scrape configuration exported to {FilePath}", ApplicationMetadata.ScrapeConfigurationExportFilePath);
+        }
+        catch(Exception ex)
+        {
+            logger.Error(ex, "Failed to export scrape configuration to file: {FilePath}", ApplicationMetadata.ScrapeConfigurationExportFilePath);
+            throw;
+        }
+    }
+
     public void ExportScrapedTagsToFile(List<ScrapedTagDomain> tags)
     {
         try
@@ -64,6 +80,28 @@ public void ExportScrapedTagsToFile(List<ScrapedTagDomain> tags)
         }
     }
 
+    public Result<ScrapeConfigurationEntity, string> ImportScrapeConfigurationFromFile()
+    {
+        if(!fileSystem.File.Exists(ApplicationMetadata.ScrapeConfigurationExportFilePath))
+        {
+            logger.Error("File not found: {FilePath}", ApplicationMetadata.ScrapeConfigurationExportFilePath);
+
+            return $"Error: File not found - {ApplicationMetadata.ScrapeConfigurationExportFilePath}";
+        }
+
+        var json = fileSystem.File.ReadAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath);
+        var dto = json.FromJson<ScrapeConfigurationDto>(AStar.Dev.Utilities.Constants.WebDeserialisationSettings);
+
+        if(dto is null)
+        {
+            logger.Error("Failed to deserialize scrape configuration from file: {FilePath}", ApplicationMetadata.ScrapeConfigurationExportFilePath);
+
+            return $"Error: Failed to deserialize scrape configuration from file - {ApplicationMetadata.ScrapeConfigurationExportFilePath}";
+        }
+
+        return dto.ToDomain();
+    }
+
     public Result<List<ScrapedTagDomain>, string> ImportScrapedTagsFromFile()
     {
         if(!fileSystem.File.Exists(ApplicationMetadata.ScrapedTagsExportFilePath))
diff --git a/src/AStar.Dev.Wallpaper.Scrapper/Services/ScrapeConfigurationService.cs b/src/AStar.Dev.Wallpaper.Scrapper/Services/ScrapeConfigurationService.cs
new file mode 100644
index 0000000..ac468d2
--- /dev/null
+++ b/src/AStar.Dev.Wallpaper.Scrapper/Services/ScrapeConfigurationService.cs
@@ -0,0 +1,107 @@
+using AStar.Dev.FunctionalParadigm;
+using AStar.Dev.Infrastructure.FilesDb.Data;
+using AStar.Dev.Infrastructure.FilesDb.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace AStar.Dev.Wallpaper.Scrapper.Services;
+
+public sealed class ScrapeConfigurationService(IDbContextFactory<FilesContext> contextFactory)
+{
+    public async Task<ScrapeConfigurationEntity> ExportScrapeConfigurationAsync(CancellationToken token)
+    {
+        await using var context = await contextFactory.CreateDbContextAsync(token).ConfigureAwait(false);
+
+        return await context.ScrapeConfiguration
+            .Include(e => e.ConnectionStrings)
+            .Include(e => e.UserConfiguration)
+            .Include(e => e.SearchConfiguration).ThenInclude(s => s.SearchCategories)
+            .Include(e => e.ScrapeDirectories)
+            .FirstAsync(token)
+            .ConfigureAwait(false);
+    }
+
+    public async Task<Unit> ImportScrapeConfigurationAsync(ScrapeConfigurationEntity incoming, CancellationToken token)
+    {
+        await using var context = await contextFactory.CreateDbContextAsync(token).ConfigureAwait(false);
+
+        var existing = await context.ScrapeConfiguration
+            .Include(e => e.ConnectionStrings)
+            .Include(e => e.UserConfiguration)
+            .Include(e => e.SearchConfiguration).ThenInclude(s => s.SearchCategories)
+            .Include(e => e.ScrapeDirectories)
+            .FirstAsync(token)
+            .ConfigureAwait(false);
+
+        existing.ConnectionStrings.Sqlite = incoming.ConnectionStrings.Sqlite;
+
+        existing.UserConfiguration.LoginEmailAddress = incoming.UserConfiguration.LoginEmailAddress;
+        existing.UserConfiguration.Username          = incoming.UserConfiguration.Username;
+
+        if(incoming.UserConfiguration.Password != ApplicationMetadata.Redacted)
+            existing.UserConfiguration.Password = incoming.UserConfiguration.Password;
+
+        if(incoming.UserConfiguration.SessionCookie != ApplicationMetadata.Redacted)
+            existing.UserConfiguration.SessionCookie = incoming.UserConfiguration.SessionCookie;
+
+        existing.SearchConfiguration.BaseUrl             = incoming.SearchConfiguration.BaseUrl;
+        existing.SearchConfiguration.SearchString        = incoming.SearchConfiguration.SearchString;
+        existing.SearchConfiguration.TopWallpapers       = incoming.SearchConfiguration.TopWallpapers;
+        existing.SearchConfiguration.SearchStringPrefix  = incoming.SearchConfiguration.SearchStringPrefix;
+        existing.SearchConfiguration.SearchStringSuffix  = incoming.SearchConfiguration.SearchStringSuffix;
+        existing.SearchConfiguration.Subscriptions       = incoming.SearchConfiguration.Subscriptions;
+        existing.SearchConfiguration.ImagePauseInSeconds = incoming.SearchConfiguration.ImagePauseInSeconds;
+        existing.SearchConfiguration.StartingPageNumber  = incoming.SearchConfiguration.StartingPageNumber;
+        existing.SearchConfiguration.TotalPages          = incoming.SearchConfiguration.TotalPages;
+        existing.SearchConfiguration.SubscriptionsStartingPageNumber = incoming.SearchConfiguration.SubscriptionsStartingPageNumber;
+        existing.SearchConfiguration.SubscriptionsTotalPages         = incoming.SearchConfiguration.SubscriptionsTotalPages;
+        existing.SearchConfiguration.TopWallpapersTotalPages         = incoming.SearchConfiguration.TopWallpapersTotalPages;
+        existing.SearchConfiguration.TopWallpapersStartingPageNumber = incoming.SearchConfiguration.TopWallpapersStartingPageNumber;
+        existing.SearchConfiguration.LoginUrl            = incoming.SearchConfiguration.LoginUrl;
+        existing.SearchConfiguration.UseHeadless         = incoming.SearchConfiguration.UseHeadless;
+        existing.SearchConfiguration.SlowMotionDelay     = incoming.SearchConfiguration.SlowMotionDelay;
+
+        if(incoming.SearchConfiguration.ApiKey != ApplicationMetadata.Redacted)
+            existing.SearchConfiguration.ApiKey = incoming.SearchConfiguration.ApiKey;
+
+        UpsertSearchCategories(existing.SearchConfiguration, incoming.SearchConfiguration.SearchCategories);
+
+        existing.ScrapeDirectories.RootDirectory       = incoming.ScrapeDirectories.RootDirectory;
+        existing.ScrapeDirectories.BaseSaveDirectory   = incoming.ScrapeDirectories.BaseSaveDirectory;
+        existing.ScrapeDirectories.BaseDirectory       = incoming.ScrapeDirectories.BaseDirectory;
+        existing.ScrapeDirectories.BaseDirectoryFamous = incoming.ScrapeDirectories.BaseDirectoryFamous;
+        existing.ScrapeDirectories.SubDirectoryName    = incoming.ScrapeDirectories.SubDirectoryName;
+
+        await context.SaveChangesAsync(token).ConfigureAwait(false);
+
+        return Unit.Value;
+    }
+
+    private static void UpsertSearchCategories(SearchConfiguration existing, List<SearchCategories> incoming)
+    {
+        foreach(var category in incoming)
+        {
+            var existingCategory = existing.SearchCategories.FirstOrDefault(c => c.Id == category.Id);
+
+            if(existingCategory is null)
+            {
+                existing.SearchCategories.Add(new SearchCategories
+                {
+                    Id                  = category.Id,
+                    Name                = category.Name,
+                    LastKnownImageCount = category.LastKnownImageCount,
+                    LastPageVisited     = category.LastPageVisited,
+                    TotalPages          = category.TotalPages,
+                    IncludeInSearch     = category.IncludeInSearch
+                });
+            }
+            else
+            {
+                existingCategory.Name                = category.Name;
+                existingCategory.LastKnownImageCount = category.LastKnownImageCount;
+                existingCategory.LastPageVisited     = category.LastPageVisited;
+                existingCategory.TotalPages          = category.TotalPages;
+                existingCategory.IncludeInSearch     = category.IncludeInSearch;
+            }
+        }
+    }
+}
diff --git a/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAScrapeConfigurationService.cs b/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAScrapeConfigurationService.cs
new file mode 100644
index 0000000..3a67d31
--- /dev/null
+++ b/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAScrapeConfigurationService.cs
@@ -0,0 +1,243 @@
+using AStar.Dev.Infrastructure.FilesDb.Data;
+using AStar.Dev.Infrastructure.FilesDb.Models;
+using AStar.Dev.Wallpaper.Scrapper;
+using AStar.Dev.Wallpaper.Scrapper.Services;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+
+namespace AStar.Dev.Wallpaper.Scrapper.Tests.Unit.Services;
+
+public sealed class GivenAScrapeConfigurationService : IAsyncLifetime
+{
+    private const string ExistingPassword      = "real-database-password";
+    private const string ExistingSessionCookie = "real-session-cookie";
+    private const string ExistingApiKey        = "real-api-key";
+    private const string ExistingSqlite        = "Data Source=production.db";
+    private const string ExistingCategoryId    = "existing-cat";
+
+    private SqliteConnection connection = null!;
+    private DbContextOptions<FilesContext> options = null!;
+    private IDbContextFactory<FilesContext> factory = null!;
+    private ScrapeConfigurationService sut = null!;
+
+    public async ValueTask InitializeAsync()
+    {
+        connection = new SqliteConnection("Data Source=:memory:");
+        await connection.OpenAsync();
+
+        options = new DbContextOptionsBuilder<FilesContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        await using var seedContext = new FilesContext(options);
+        await seedContext.Database.EnsureCreatedAsync();
+        seedContext.ScrapeConfiguration.Add(CreateInitialScrapeConfigurationEntity());
+        await seedContext.SaveChangesAsync();
+
+        factory = Substitute.For<IDbContextFactory<FilesContext>>();
+        factory.CreateDbContextAsync(Arg.Any<CancellationToken>())
+               .Returns(_ => Task.FromResult(new FilesContext(options)));
+
+        sut = new ScrapeConfigurationService(factory);
+    }
+
+    public async ValueTask DisposeAsync() => await connection.DisposeAsync();
+
+    [Fact]
+    public async Task when_exporting_then_context_is_created()
+    {
+        await sut.ExportScrapeConfigurationAsync(TestContext.Current.CancellationToken);
+
+        await factory.Received(1).CreateDbContextAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task when_importing_then_context_is_created()
+    {
+        await sut.ImportScrapeConfigurationAsync(CreateImportEntity(), TestContext.Current.CancellationToken);
+
+        await factory.Received(1).CreateDbContextAsync(Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task when_importing_then_existing_entity_is_updated()
+    {
+        var importEntity = CreateImportEntity(sqlite: "Data Source=updated.db");
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.ConnectionStrings)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.ConnectionStrings.Sqlite.ShouldBe("Data Source=updated.db");
+    }
+
+    [Fact]
+    public async Task when_importing_password_is_redacted_then_existing_password_is_preserved()
+    {
+        var importEntity = CreateImportEntity(password: ApplicationMetadata.Redacted);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.UserConfiguration)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.UserConfiguration.Password.ShouldBe(ExistingPassword);
+    }
+
+    [Fact]
+    public async Task when_importing_session_cookie_is_redacted_then_existing_session_cookie_is_preserved()
+    {
+        var importEntity = CreateImportEntity(sessionCookie: ApplicationMetadata.Redacted);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.UserConfiguration)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.UserConfiguration.SessionCookie.ShouldBe(ExistingSessionCookie);
+    }
+
+    [Fact]
+    public async Task when_importing_api_key_is_redacted_then_existing_api_key_is_preserved()
+    {
+        var importEntity = CreateImportEntity(apiKey: ApplicationMetadata.Redacted);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.SearchConfiguration)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.SearchConfiguration.ApiKey.ShouldBe(ExistingApiKey);
+    }
+
+    [Fact]
+    public async Task when_importing_then_search_categories_are_upserted_by_id()
+    {
+        var importEntity = CreateImportEntity(categories:
+        [
+            new SearchCategories { Id = ExistingCategoryId, Name = "Updated Name",       TotalPages = 10, IncludeInSearch = true },
+            new SearchCategories { Id = "new-cat",          Name = "Brand New Category", TotalPages = 5,  IncludeInSearch = true }
+        ]);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.SearchConfiguration)
+                .ThenInclude(x => x.SearchCategories)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.SearchConfiguration.SearchCategories.Count.ShouldBe(2);
+    }
+
+    [Fact]
+    public async Task when_importing_new_search_category_then_it_is_added()
+    {
+        var importEntity = CreateImportEntity(categories:
+        [
+            new SearchCategories { Id = "new-cat", Name = "New Category", TotalPages = 5, IncludeInSearch = true }
+        ]);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.SearchConfiguration)
+                .ThenInclude(x => x.SearchCategories)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.SearchConfiguration.SearchCategories.ShouldContain(c => c.Id == "new-cat");
+    }
+
+    [Fact]
+    public async Task when_importing_existing_search_category_then_it_is_updated_not_duplicated()
+    {
+        var importEntity = CreateImportEntity(categories:
+        [
+            new SearchCategories { Id = ExistingCategoryId, Name = "Updated Category Name", TotalPages = 20, IncludeInSearch = true }
+        ]);
+
+        await sut.ImportScrapeConfigurationAsync(importEntity, TestContext.Current.CancellationToken);
+
+        await using var verifyCtx = new FilesContext(options);
+        var result = await verifyCtx.ScrapeConfiguration
+            .Include(x => x.SearchConfiguration)
+                .ThenInclude(x => x.SearchCategories)
+            .FirstAsync(TestContext.Current.CancellationToken);
+        result.SearchConfiguration.SearchCategories.Count.ShouldBe(1);
+        result.SearchConfiguration.SearchCategories[0].Name.ShouldBe("Updated Category Name");
+    }
+
+    [Fact]
+    public async Task when_exporting_returns_entity_with_connection_strings()
+    {
+        var result = await sut.ExportScrapeConfigurationAsync(TestContext.Current.CancellationToken);
+
+        result.ConnectionStrings.ShouldNotBeNull();
+        result.ConnectionStrings.Sqlite.ShouldBe(ExistingSqlite);
+    }
+
+    [Fact]
+    public async Task when_exporting_returns_entity_with_user_configuration()
+    {
+        var result = await sut.ExportScrapeConfigurationAsync(TestContext.Current.CancellationToken);
+
+        result.UserConfiguration.ShouldNotBeNull();
+        result.UserConfiguration.Password.ShouldBe(ExistingPassword);
+    }
+
+    private static ScrapeConfigurationEntity CreateInitialScrapeConfigurationEntity() => new()
+    {
+        ConnectionStrings = new ConnectionStrings { Sqlite = ExistingSqlite },
+        UserConfiguration = new UserConfiguration
+        {
+            LoginEmailAddress = "user@example.com",
+            Username          = "testuser",
+            Password          = ExistingPassword,
+            SessionCookie     = ExistingSessionCookie
+        },
+        SearchConfiguration = new SearchConfiguration
+        {
+            BaseUrl          = "https://example.com",
+            ApiKey           = ExistingApiKey,
+            SearchCategories =
+            [
+                new SearchCategories
+                {
+                    Id              = ExistingCategoryId,
+                    Name            = "Existing Category",
+                    TotalPages      = 5,
+                    IncludeInSearch = true
+                }
+            ]
+        },
+        ScrapeDirectories = new ScrapeDirectories { RootDirectory = "/tmp/scrape" }
+    };
+
+    private static ScrapeConfigurationEntity CreateImportEntity(
+        string sqlite        = "Data Source=updated.db",
+        string password      = "new-password",
+        string sessionCookie = "new-session-cookie",
+        string apiKey        = "new-api-key",
+        List<SearchCategories>? categories = null) => new()
+    {
+        ConnectionStrings = new ConnectionStrings { Sqlite = sqlite },
+        UserConfiguration = new UserConfiguration
+        {
+            LoginEmailAddress = "updated@example.com",
+            Username          = "updateduser",
+            Password          = password,
+            SessionCookie     = sessionCookie
+        },
+        SearchConfiguration = new SearchConfiguration
+        {
+            BaseUrl          = "https://updated.com",
+            ApiKey           = apiKey,
+            SearchCategories = categories ?? []
+        },
+        ScrapeDirectories = new ScrapeDirectories { RootDirectory = "/tmp/updated" }
+    };
+}
diff --git a/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAnImportExportService.cs b/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAnImportExportService.cs
index c9345b0..3645108 100644
--- a/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAnImportExportService.cs
+++ b/test/AStar.Dev.Wallpaper.Scrapper.Tests.Unit/Services/GivenAnImportExportService.cs
@@ -1,8 +1,10 @@
 using AStar.Dev.FunctionalParadigm;
+using AStar.Dev.Infrastructure.FilesDb.Models;
 using AStar.Dev.Wallpaper.Scrapper;
 using AStar.Dev.Wallpaper.Scrapper.Services;
 using Serilog;
 using System.IO.Abstractions;
+using System.Text.Json;
 using FileClassificationDomain = AStar.Dev.Infrastructure.FilesDb.Models.FileClassification;
 using ScrapedTagDomain = AStar.Dev.Infrastructure.FilesDb.Models.ScrapedTag;
 
@@ -10,15 +12,17 @@ namespace AStar.Dev.Wallpaper.Scrapper.Tests.Unit.Services;
 
 public sealed class GivenAnImportExportService
 {
-    private static readonly string scrapperDirectory     = Path.GetDirectoryName(ApplicationMetadata.FileClassificationsExportFilePath)!;
-    private static readonly string scrapperTagsDirectory = Path.GetDirectoryName(ApplicationMetadata.ScrapedTagsExportFilePath)!;
+    private static readonly string scrapperDirectory           = Path.GetDirectoryName(ApplicationMetadata.FileClassificationsExportFilePath)!;
+    private static readonly string scrapeConfigScrapperDirectory = Path.GetDirectoryName(ApplicationMetadata.ScrapeConfigurationExportFilePath)!;
+    private static readonly string scrapperTagsDirectory       = Path.GetDirectoryName(ApplicationMetadata.ScrapedTagsExportFilePath)!;
 
     private const string CelebrityClassificationName = "Test Celebrity";
     private const string NormalClassificationName    = "Test Normal";
+    private const string ValidPassword               = "super-secret-password";
 
-    private const string ActionTagValue    = "Action";
-    private const string GenreCategory = "Genre";
-    private const string ComedyTagValue    = "Comedy";
+    private const string ActionTagValue = "Action";
+    private const string GenreCategory  = "Genre";
+    private const string ComedyTagValue = "Comedy";
 
     private const string ValidClassificationsJson = """
         [
@@ -59,6 +63,34 @@ public sealed class GivenAnImportExportService
         ]
         """;
 
+    private const string ValidScrapeConfigJson = """
+        {
+          "connectionStrings": { "sqlite": "Data Source=test.db" },
+          "userConfiguration": { "loginEmailAddress": "test@example.com", "username": "testuser", "password": "REDACTED", "sessionCookie": "REDACTED" },
+          "searchConfiguration": {
+            "baseUrl": "https://example.com",
+            "apiKey": "REDACTED",
+            "searchCategories": [{ "id": "cat1", "name": "Category 1", "lastKnownImageCount": 0, "lastPageVisited": 0, "totalPages": 10, "includeInSearch": true }],
+            "searchString": "test",
+            "topWallpapers": "",
+            "searchStringPrefix": "",
+            "searchStringSuffix": "",
+            "subscriptions": "",
+            "imagePauseInSeconds": 1,
+            "startingPageNumber": 1,
+            "totalPages": 10,
+            "subscriptionsStartingPageNumber": 0,
+            "subscriptionsTotalPages": 0,
+            "topWallpapersTotalPages": 0,
+            "topWallpapersStartingPageNumber": 0,
+            "loginUrl": "",
+            "useHeadless": true,
+            "slowMotionDelay": null
+          },
+          "scrapeDirectories": { "rootDirectory": "/tmp/scrape", "baseSaveDirectory": "saves", "baseDirectory": "base", "baseDirectoryFamous": "famous", "subDirectoryName": "sub" }
+        }
+        """;
+
     private const string ValidTagsJson = """
         [
           {
@@ -204,6 +236,128 @@ public void when_file_system_throws_during_export_then_logger_receives_error_cal
         mockLogger.Received(1).Error(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
     }
 
+    [Fact]
+    public void when_importing_scrape_config_and_file_does_not_exist_then_failure_result_is_returned() =>
+        sut.ImportScrapeConfigurationFromFile()
+           .ShouldBeOfType<Fail<ScrapeConfigurationEntity, string>>();
+
+    [Fact]
+    public void when_importing_scrape_config_and_file_does_not_exist_then_logger_receives_error_call()
+    {
+        sut.ImportScrapeConfigurationFromFile();
+
+        mockLogger.Received(1).Error(Arg.Any<string>(), Arg.Any<string>());
+    }
+
+    [Fact]
+    public void when_importing_scrape_config_and_file_contains_null_json_then_failure_result_is_returned()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+        mockFileSystem.File.WriteAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath, "null");
+
+        sut.ImportScrapeConfigurationFromFile()
+           .ShouldBeOfType<Fail<ScrapeConfigurationEntity, string>>();
+    }
+
+    [Fact]
+    public void when_importing_scrape_config_and_file_contains_null_json_then_logger_receives_error_call()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+        mockFileSystem.File.WriteAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath, "null");
+
+        sut.ImportScrapeConfigurationFromFile();
+
+        mockLogger.Received(1).Error(Arg.Any<string>(), Arg.Any<string>());
+    }
+
+    [Fact]
+    public void when_importing_valid_scrape_config_then_result_is_ok()
+    {
+        SetupValidScrapeConfigImportFile();
+
+        sut.ImportScrapeConfigurationFromFile()
+           .ShouldBeOfType<Ok<ScrapeConfigurationEntity, string>>();
+    }
+
+    [Fact]
+    public void when_importing_valid_scrape_config_then_correct_connection_string_is_mapped()
+    {
+        SetupValidScrapeConfigImportFile();
+
+        sut.ImportScrapeConfigurationFromFile()
+           .ShouldBeOfType<Ok<ScrapeConfigurationEntity, string>>()
+           .Value.ConnectionStrings.Sqlite.ShouldBe("Data Source=test.db");
+    }
+
+    [Fact]
+    public void when_importing_valid_scrape_config_then_password_field_is_preserved_from_db()
+    {
+        SetupValidScrapeConfigImportFile();
+
+        sut.ImportScrapeConfigurationFromFile()
+           .ShouldBeOfType<Ok<ScrapeConfigurationEntity, string>>()
+           .Value.UserConfiguration.Password.ShouldBe(ApplicationMetadata.Redacted);
+    }
+
+    [Fact]
+    public void when_exporting_scrape_config_then_file_is_written_to_expected_path()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+
+        sut.ExportScrapeConfigurationToFile(CreateScrapeConfigurationEntityWithSensitiveData());
+
+        mockFileSystem.File.Exists(ApplicationMetadata.ScrapeConfigurationExportFilePath).ShouldBeTrue();
+    }
+
+    [Fact]
+    public void when_exporting_scrape_config_then_logger_receives_information_call()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+
+        sut.ExportScrapeConfigurationToFile(CreateScrapeConfigurationEntityWithSensitiveData());
+
+        mockLogger.Received(1).Information(Arg.Any<string>(), Arg.Any<string>());
+    }
+
+    [Fact]
+    public void when_exporting_scrape_config_then_password_is_redacted_in_exported_file()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+
+        sut.ExportScrapeConfigurationToFile(CreateScrapeConfigurationEntityWithSensitiveData());
+
+        var json = mockFileSystem.File.ReadAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath);
+        using var doc = JsonDocument.Parse(json);
+        doc.RootElement.GetProperty("userConfiguration").GetProperty("password").GetString()
+           .ShouldBe(ApplicationMetadata.Redacted);
+    }
+
+    [Fact]
+    public void when_file_system_throws_during_scrape_config_export_then_exception_is_rethrown()
+    {
+        var throwingFileSystem = Substitute.For<IFileSystem>();
+        throwingFileSystem.File.When(f => f.WriteAllText(Arg.Any<string>(), Arg.Any<string?>()))
+                               .Throw(new IOException("Disk full"));
+        var throwingSut = new ImportExportService(throwingFileSystem, mockLogger);
+
+        var act = () => throwingSut.ExportScrapeConfigurationToFile(CreateScrapeConfigurationEntityWithSensitiveData());
+
+        act.ShouldThrow<IOException>();
+    }
+
+    [Fact]
+    public void when_file_system_throws_during_scrape_config_export_then_logger_receives_error_call()
+    {
+        var throwingFileSystem = Substitute.For<IFileSystem>();
+        throwingFileSystem.File.When(f => f.WriteAllText(Arg.Any<string>(), Arg.Any<string?>()))
+                               .Throw(new IOException("Disk full"));
+        var throwingSut = new ImportExportService(throwingFileSystem, mockLogger);
+
+        Should.Throw<IOException>(() => throwingSut.ExportScrapeConfigurationToFile(CreateScrapeConfigurationEntityWithSensitiveData()));
+
+        mockLogger.Received(1).Error(Arg.Any<Exception>(), Arg.Any<string>(), Arg.Any<string>());
+    }
+
     [Fact]
     public void when_importing_tags_and_file_does_not_exist_then_failure_result_is_returned() =>
         sut.ImportScrapedTagsFromFile()
@@ -369,6 +523,12 @@ private void SetupValidImportFile()
         mockFileSystem.File.WriteAllText(ApplicationMetadata.FileClassificationsExportFilePath, ValidClassificationsJson);
     }
 
+    private void SetupValidScrapeConfigImportFile()
+    {
+        mockFileSystem.Directory.CreateDirectory(scrapeConfigScrapperDirectory);
+        mockFileSystem.File.WriteAllText(ApplicationMetadata.ScrapeConfigurationExportFilePath, ValidScrapeConfigJson);
+    }
+
     private void SetupValidTagsImportFile()
     {
         mockFileSystem.Directory.CreateDirectory(scrapperTagsDirectory);
@@ -381,6 +541,25 @@ private static List<FileClassificationDomain> CreateDomainClassifications() =>
         new() { Id = 2, Name = NormalClassificationName,    Celebrity = false, IncludeInSearch = true }
     ];
 
+    private static ScrapeConfigurationEntity CreateScrapeConfigurationEntityWithSensitiveData() => new()
+    {
+        ConnectionStrings = new ConnectionStrings { Sqlite = "Data Source=production.db" },
+        UserConfiguration = new UserConfiguration
+        {
+            LoginEmailAddress = "user@example.com",
+            Username          = "testuser",
+            Password          = ValidPassword,
+            SessionCookie     = "actual-session-cookie"
+        },
+        SearchConfiguration = new SearchConfiguration
+        {
+            BaseUrl          = "https://example.com",
+            ApiKey           = "actual-api-key",
+            SearchCategories = []
+        },
+        ScrapeDirectories = new ScrapeDirectories { RootDirectory = "/tmp/scrape" }
+    };
+
     private static List<ScrapedTagDomain> CreateDomainTags() =>
     [
         new() { Value = ActionTagValue, Category = GenreCategory, IncludeInSearch = true  },