**update**

src/Domain/Core/Abstraction/ILinkdingService.cs

@@ -8,6 +8,10 @@ namespace Linkding.Client
     {
         Task<IEnumerable<Bookmark>> GetBookmarksAsync(int limit = 100, int offset = 0);
         Task<IEnumerable<Bookmark>> GetAllBookmarksAsync();
+        Task AddBookmarkCollectionAsync(IEnumerable<Bookmark> bookmarks);
+        Task AddBookmarkCollectionAsync(IEnumerable<BookmarkCreatePayload> bookmarks);
+        Task AddBookmarkAsync(BookmarkCreatePayload bookmark);
+        
         Task UpdateBookmarkCollectionAsync(IEnumerable<Bookmark> bookmarks);
         Task UpdateBookmarkCollectionAsync(IEnumerable<BookmarkUpdatePayload> bookmarks);
         Task UpdateBookmarkAsync(BookmarkUpdatePayload bookmark);

src/Domain/Core/Handler/ILinkdingSyncTaskHandler.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Core.Entities.Linkding;
+using Linkding.Client;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace Core.Handler
+{
+    public interface ILinkdingSyncTaskHandler
+    {
+        string Command { get; }
+        Task ProcessAsync(IEnumerable<Bookmark> bookmarks, ILinkdingService linkdingService, ILogger logger, IConfiguration configuration);
+    }
+}

src/Linkding/Handler/UpdateTargetLinkdingHandler.cs

@@ -0,0 +1,73 @@
+using Core.Entities.Linkding;
+using Core.Handler;
+using Linkding.Client;
+using Linkding.Client.Extensions;
+
+namespace Linkding.Handler;
+
+public class UpdateTargetLinkdingHandler : ILinkdingSyncTaskHandler
+{
+    public string Command { get; } = "UpdateTargetLinkding";
+
+    public async Task ProcessAsync(IEnumerable<Bookmark> bookmarks, ILinkdingService linkdingService, ILogger logger,
+        IConfiguration configuration)
+    {
+        var linkdingBookmarks = await linkdingService.GetAllBookmarksAsync();
+        var addedBookmarks = new List<BookmarkCreatePayload>();
+        var updatedBookmarks = new List<BookmarkUpdatePayload>();
+
+        if (linkdingBookmarks.Count() > 0)
+        {
+            
+            foreach (var bookmark in bookmarks)
+            {
+                var linkdingBookmark = linkdingBookmarks.FirstOrDefault(x => x.Url == bookmark.Url);
+                if (linkdingBookmark == null)
+                {
+                    addedBookmarks.Add(bookmark.MapToCreatePayload());
+                }
+                else
+                {
+                    bookmark.Id = linkdingBookmark.Id;
+                    bookmark.Title = !string.IsNullOrEmpty(bookmark.Title) ? bookmark.Title.Trim() : bookmark.WebsiteTitle;
+                    bookmark.Description = !string.IsNullOrEmpty(bookmark.Description) ? bookmark.Description.Trim() : bookmark.WebsiteDescription;
+
+                    if (!string.IsNullOrEmpty(bookmark.Title) && !string.IsNullOrEmpty(bookmark.Description) &&
+                        (!linkdingBookmark.Title.Equals(bookmark.Title.Trim(), StringComparison.OrdinalIgnoreCase) || 
+                        !linkdingBookmark.Description.Equals(bookmark.Description.Trim(), StringComparison.OrdinalIgnoreCase) ||
+                        linkdingBookmark.TagNames.Count() != bookmark.TagNames.Count()))
+                    {
+                        updatedBookmarks.Add(bookmark.MapToUpdatePayload());
+                    }
+                    else
+                    {
+                        var difference = linkdingBookmark.TagNames.Where(t =>
+                            !bookmark.TagNames.Any(b => b.Equals(t, StringComparison.OrdinalIgnoreCase)));
+
+                        if (difference.Count() > 0)
+                        {
+                            updatedBookmarks.Add(bookmark.MapToUpdatePayload());
+                        }
+                    }
+                }
+            }
+        }
+        else
+        {
+            foreach (var bookmark in linkdingBookmarks)
+            {
+                addedBookmarks.Add(bookmark.MapToCreatePayload());
+            }
+        }
+        
+        if (updatedBookmarks.Count > 0)
+        {
+            await linkdingService.UpdateBookmarkCollectionAsync(updatedBookmarks);
+        }
+
+        if (addedBookmarks.Count > 0)
+        {
+            await linkdingService.AddBookmarkCollectionAsync(addedBookmarks);
+        }
+    }
+}

src/Linkding/Options/WorkerSettings.cs

@@ -7,4 +7,6 @@ public class WorkerSettings
     public int Interval { get; set; } = 0;
     public int TagNameLength { get; set; } = 64;
     public List<string> Tasks { get; set; } = new List<string>();
+    public List<string> TargetLinkdingUrl { get; set; } = new List<string>();
+    public List<string> TargetLinkdingKey { get; set; } = new List<string>();
 }

src/Linkding/Worker.cs

@@ -53,28 +53,29 @@ public class Worker : BackgroundService
     
     public async Task RunBookmarksTaskHandler()
     {
+        IEnumerable<Bookmark> linkdingBookmarks = null;
         if (!string.IsNullOrEmpty(_linkdingSettings.Url) && _linkdingSettings.UpdateBookmarks)
         {
             _logger.LogInformation($"Starting updating bookmarks for {_linkdingSettings.Url}");
 
-            _logger.LogInformation("Collecting Handler");
+            _logger.LogInformation("Collecting Tag Handler");
-            var handlers = AppDomain.CurrentDomain.GetAssemblies()
+            var tagHandlers = AppDomain.CurrentDomain.GetAssemblies()
                 .SelectMany(s => s.GetTypes())
                 .Where(p => typeof(ILinkdingTaskHandler).IsAssignableFrom(p) && p.IsClass);
 
             var updatedBookmarksCount = 0;
             var updateBookmarks = new List<Bookmark>();
             var deleteBookmarks = new List<Bookmark>();
-            if (handlers != null && handlers.Count() > 0)
+            if (tagHandlers != null && tagHandlers.Count() > 0)
             {
-                var linkdingBookmarks = await _linkdingService.GetAllBookmarksAsync();
+                linkdingBookmarks = await _linkdingService.GetAllBookmarksAsync();
                 if (linkdingBookmarks.Count() > 0)
                 {
                     var tasksLowerCase = _settings.Tasks.Select(x => x.ToLower());
 
                     _logger.LogInformation($"{linkdingBookmarks.Count()} bookmarks found in {_linkdingSettings.Url}");
 
-                    foreach (var handler in handlers)
+                    foreach (var handler in tagHandlers)
                     {
                         ILinkdingTaskHandler handlerInstance = null;
                         try
@@ -93,7 +94,7 @@ public class Worker : BackgroundService
                             {
                                 try
                                 {
-                                    _logger.LogDebug($"Start executing {handlerInstance.Command}");
+                                    _logger.LogDebug($"Start executing {task}");
                                     // var updateBookmark = updateBookmarks.FirstOrDefault(x => x.Id == linkdingBookmark.Id);
                                     var existingBookmarkIndexInt =
                                         updateBookmarks.FindIndex(x => x.Id == linkdingBookmark.Id);
@@ -136,6 +137,8 @@ public class Worker : BackgroundService
                                                 {
                                                     updateBookmarks.Add(result.Instance);
                                                 }
+
+                                                linkdingBookmark.TagNames = result.Instance.TagNames;
                                             }
                                         }
                                     }
@@ -164,7 +167,7 @@ public class Worker : BackgroundService
                         catch (Exception e)
                         {
                             Console.WriteLine(e);
-                            throw;
+                            // throw;
                         }
                     }
                 }
@@ -182,6 +185,85 @@ public class Worker : BackgroundService
             }
 
             _logger.LogInformation($"Finished updating bookmarks for {_linkdingSettings.Url}");
+            
+            _logger.LogInformation("Collecting Sync Handler");
+            var syncHandlers = AppDomain.CurrentDomain.GetAssemblies()
+                .SelectMany(s => s.GetTypes())
+                .Where(p => typeof(ILinkdingSyncTaskHandler).IsAssignableFrom(p) && p.IsClass);
+
+            if (syncHandlers != null && syncHandlers.Count() > 0)
+            {
+                if (linkdingBookmarks == null)
+                {
+                    linkdingBookmarks = await _linkdingService.GetAllBookmarksAsync();
+                }
+
+                if (linkdingBookmarks.Count() > 0)
+                {
+                    var tasksLowerCase = _settings.Tasks.Select(x => x.ToLower());
+
+                    if (_settings.TargetLinkdingKey.Count == _settings.TargetLinkdingUrl.Count)
+                    {
+                        var targetInstances = new Dictionary<string, string>();
+                        for (var i = 0; i < _settings.TargetLinkdingKey.Count(); i++)
+                        {
+                            LinkdingService targetService = null;
+                            try
+                            {
+                                var url = _settings.TargetLinkdingUrl[i];
+                                var key = _settings.TargetLinkdingKey[i];
+                                targetService = LinkdingService.Create(url, key);
+                                
+                                foreach (var syncHandler in syncHandlers)
+                                {
+                                    ILinkdingSyncTaskHandler handlerInstance = null;
+                                    try
+                                    {
+                                        handlerInstance = (ILinkdingSyncTaskHandler) Activator.CreateInstance(syncHandler);
+
+                                        var task = tasksLowerCase.FirstOrDefault(x =>
+                                            x.Equals(handlerInstance.Command, StringComparison.InvariantCultureIgnoreCase));
+
+                                        if (string.IsNullOrEmpty(task))
+                                        {
+                                            continue;
+                                        }
+                            
+                                        _logger.LogDebug($"Start executing {task}");
+                                        await handlerInstance.ProcessAsync(linkdingBookmarks, targetService, _logger, _configuration);
+                                        _logger.LogDebug($"{task} executed successfully!");
+                                    }
+                                    catch (Exception ex)
+                                    {
+                                        Console.WriteLine(ex);
+                                        var message = $"... {ex.Message}";
+
+                                        if (handlerInstance != null && !string.IsNullOrEmpty(handlerInstance.Command))
+                                        {
+                                            message = $"Error while executing {handlerInstance.Command}! {message}";
+                                        }
+                                        else
+                                        {
+                                            message = $"Error while executing handler! {message}";
+                                        }
+
+                                        _logger.LogError(message, "Calling Handler", ex);
+                                    }
+                                }
+                            }
+                            catch (Exception e)
+                            {
+                                Console.WriteLine(e);
+                                {throw;}
+                            }
+                            finally
+                            {
+                                targetService = null;
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 }

src/Services/Linkding.Client/Automapper/LinkdingBookmarkProfile.cs

@@ -8,5 +8,6 @@ public class LinkdingBookmarkProfile : Profile
     public LinkdingBookmarkProfile()
     {
         CreateMap<Bookmark, BookmarkUpdatePayload>();
+        CreateMap<Bookmark, BookmarkCreatePayload>();
     }
 }

src/Services/Linkding.Client/Extensions/BookmarkExtensions.cs

@@ -0,0 +1,38 @@
+using Core.Entities.Linkding;
+
+namespace Linkding.Client.Extensions;
+
+public static class BookmarkExtensions
+{
+    public static BookmarkCreatePayload MapToCreatePayload(this Bookmark bookmark)
+    {
+        var payload = new BookmarkCreatePayload();
+        payload.Title = bookmark.Title;
+        payload.Description = bookmark.Description;
+        payload.Url = bookmark.Url;
+        payload.Unread = bookmark.Unread;
+        payload.IsArchived = payload.IsArchived;
+        
+        foreach (var tagName in bookmark.TagNames)
+        {
+            payload.TagNames = payload.TagNames.Add(tagName);
+        }
+
+        return payload;
+    }
+    
+    public static BookmarkUpdatePayload MapToUpdatePayload(this Bookmark bookmark)
+    {
+        var payload = new BookmarkUpdatePayload();
+        payload.Title = bookmark.Title;
+        payload.Description = bookmark.Description;
+        payload.Url = bookmark.Url;
+        
+        foreach (var tagName in bookmark.TagNames)
+        {
+            payload.TagNames = payload.TagNames.Add(tagName);
+        }
+        
+        return payload;
+    }
+}

src/Services/Linkding.Client/LinkdingService.cs

@@ -70,12 +70,50 @@ public class LinkdingService : ILinkdingService
         return bookmarks;
     }
 
+    public async Task AddBookmarkCollectionAsync(IEnumerable<Bookmark> bookmarks)
+    {
+        foreach (var bookmark in bookmarks)
+        {
+            var payload = _mapper.Map<BookmarkCreatePayload>(bookmark);
+            await AddBookmarkAsync(payload);
+        }
+    }
+    
+    public async Task AddBookmarkCollectionAsync(IEnumerable<BookmarkCreatePayload> bookmarks)
+    {
+        foreach (var bookmark in bookmarks)
+        {
+            await AddBookmarkAsync(bookmark);
+        }
+    }
+
+    public async Task AddBookmarkAsync(BookmarkCreatePayload bookmark)
+    {
+        var result = await _client.PostAsJsonAsync($"/api/bookmarks/", bookmark);
+        if (result.IsSuccessStatusCode)
+        {
+                
+        }
+        else
+        {
+                
+        }
+    }
+
     public async Task UpdateBookmarkCollectionAsync(IEnumerable<Bookmark> bookmarks)
     {
         foreach (var bookmark in bookmarks)
         {
-            var payload = _mapper.Map<BookmarkUpdatePayload>(bookmark);
+            try
-            await UpdateBookmarkAsync(payload);
+            {
+                var payload = _mapper.Map<Bookmark, BookmarkUpdatePayload>(bookmark);
+                await UpdateBookmarkAsync(payload);
+            }
+            catch (Exception e)
+            {
+                Console.WriteLine(e);
+                // throw;
+            }
         }
     }