diff --git a/.github/workflows/CodeQL_PR_Analysis.yml b/.github/workflows/CodeQL_PR_Analysis.yml
index 528deeb..df1c07d 100644
--- a/.github/workflows/CodeQL_PR_Analysis.yml
+++ b/.github/workflows/CodeQL_PR_Analysis.yml
@@ -31,7 +31,7 @@ jobs:
           dotnet-version: '8.0.x' 
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3
+        uses: github/codeql-action/init@v4
         with:
           languages: csharp
 
@@ -39,4 +39,4 @@ jobs:
         run: dotnet build src/RandomAPI/RandomAPI.csproj
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3
+        uses: github/codeql-action/analyze@v4
diff --git a/src/RandomAPI/APIServices/ServiceInterfaces/IWebhookService.cs b/src/RandomAPI/APIServices/ServiceInterfaces/IWebhookService.cs
index 4eac03a..b578d0f 100644
--- a/src/RandomAPI/APIServices/ServiceInterfaces/IWebhookService.cs
+++ b/src/RandomAPI/APIServices/ServiceInterfaces/IWebhookService.cs
@@ -1,3 +1,7 @@
+using Microsoft.AspNetCore.Mvc;
+using RandomAPI.Models;
+using RandomAPI.Services.Webhooks;
+
 public interface IWebhookService
 {
     /// <summary>
@@ -9,16 +13,36 @@ public interface IWebhookService
     /// Registers a new webhook listener URL.
     /// </summary>
     /// <returns>True if added, false if it already existed.</returns>
-    bool AddListener(string url);
+    Task AddListenerAsync(string url, WebhookType type = default);
 
     /// <summary>
     /// Removes a webhook listener URL.
     /// </summary>
     /// <returns>True if removed, false if not found.</returns>
-    bool RemoveListener(string url);
+    Task<bool> RemoveListenerAsync(string url);
 
     /// <summary>
     /// Returns a snapshot of all registered listener URLs.
     /// </summary>
-    IEnumerable<string> GetListeners();
+    Task<IEnumerable<string>> GetListenersAsync();
+
+    /// <summary>
+    /// returns a snapshot of all registered listenrs of a given type
+    /// </summary>
+    /// <param name="type"> the type of url</param>
+
+    Task<IEnumerable<string>> GetListenersAsync(WebhookType type = WebhookType.Default);
+
+    // Controller Logic Methods (Implemented in the derived class)
+    public Task<IActionResult> HandleGetListenersActionAsync();
+    public Task<IActionResult> HandleGetListenersOfTypeAsync(WebhookType type);
+    public Task<IActionResult> HandleRegisterActionAsync(string url, WebhookType type = default);
+    public Task<IActionResult> HandleUnregisterActionAsync(string url);
+    public Task<IActionResult> HandleBroadcastActionAsync(IWebHookPayload payload);
+
+    public enum WebhookType
+    {
+        Default = 0, 
+        Discord = 1,
+    }
 }
diff --git a/src/RandomAPI/APIServices/Services/BaseWebhookService.cs b/src/RandomAPI/APIServices/Services/BaseWebhookService.cs
new file mode 100644
index 0000000..1884ff1
--- /dev/null
+++ b/src/RandomAPI/APIServices/Services/BaseWebhookService.cs
@@ -0,0 +1,152 @@
+using Microsoft.AspNetCore.Mvc;
+using RandomAPI.Models;
+using RandomAPI.Repository;
+using static IWebhookService;
+
+namespace RandomAPI.Services.Webhooks
+{
+    public class WebhookActionService : BaseWebhookService, IWebhookService
+    {
+
+        public WebhookActionService(IWebhookRepository repo, ILogger<IWebhookService> logger)
+            : base(repo, logger) {  }
+
+        public async Task<IActionResult> HandleGetListenersActionAsync()
+        {
+            var urls = await base.GetListenersAsync();
+            return new OkObjectResult(urls);
+        }
+
+        public async Task<IActionResult> HandleGetListenersOfTypeAsync(WebhookType type)
+        {
+            var urls = await base.GetListenersAsync(type);
+            return new OkObjectResult(urls);
+        }
+
+        public async Task<IActionResult> HandleRegisterActionAsync([FromBody] string url, IWebhookService.WebhookType type = default)
+        {
+            if (string.IsNullOrWhiteSpace(url))
+                return new BadRequestObjectResult("URL cannot be empty.");
+            //neede both on regisdter and deregister
+            url = url.Trim();
+            var safeUrlForLog = url.Replace("\r", "").Replace("\n", "");
+
+            await base.AddListenerAsync(url, type);
+
+            _logger.LogInformation("Registered new webhook listener: {Url}", safeUrlForLog);
+
+            return new OkObjectResult(new { Message = $"Listener added successfully: {url}" });
+        }
+
+        public async Task<IActionResult> HandleUnregisterActionAsync([FromBody] string url)
+        {
+            string safeUrlForLog = url;
+            if (string.IsNullOrWhiteSpace(url))
+            {
+            safeUrlForLog = url.Replace("\r", "").Replace("\n", "");
+                return new BadRequestObjectResult("URL cannot be empty.");
+            }
+            url = url.Trim();
+
+            var removed = await base.RemoveListenerAsync(url);
+
+            if (!removed)
+            {
+                return new NotFoundObjectResult(new { Message = $"URL not found: {url}" });
+            }
+
+            _logger.LogInformation("Unregistered webhook listener: {Url}", safeUrlForLog);
+            return new OkObjectResult(new { Message = $"Listener removed: {url}" });
+        }
+
+        public async Task<IActionResult> HandleBroadcastActionAsync([FromBody] IWebHookPayload payload)
+        {
+            var listeners = await base.GetListenersAsync();
+
+            if (!listeners.Any())
+                return new BadRequestObjectResult("No listeners registered to broadcast to.");
+
+            switch (payload)
+            {
+                case WebhookPayload p:
+                    p.Timestamp = DateTime.UtcNow;
+
+                    break;
+
+                case DiscordWebhookPayload p:
+                    break;
+
+                default:
+                    _logger.LogWarning("Received unsupported payload type: {Type}", payload.GetType().Name);
+                    return new BadRequestObjectResult(new { Message = "Unsupported webhook payload type." });
+            }
+
+            _logger.LogInformation("Broadcasting test payload: {Message}", payload.content);
+            await base.BroadcastAsync(payload);
+            return new OkObjectResult(new
+            {
+                Message = $"Broadcast sent for message: '{payload.content}'. Check logs for delivery status."
+            });
+        }
+    }
+
+
+    public class BaseWebhookService
+    {
+        protected readonly IWebhookRepository _repo;
+        protected readonly HttpClient _client = new();
+        protected readonly ILogger<IWebhookService> _logger;
+
+        public BaseWebhookService(IWebhookRepository repo, ILogger<IWebhookService> logger)
+        {
+            _repo = repo;
+            _logger = logger;
+        }
+
+        public async Task<IEnumerable<string>> GetListenersAsync()
+        {
+            var urls = await _repo.GetAllUrlsAsync();
+            return urls.Select(u => u.Url);
+        }
+
+        public async Task<IEnumerable<string>> GetListenersAsync(WebhookType type = WebhookType.Default)
+        {
+            var urls = await _repo.GetUrlsOfTypeAsync(type);
+            return urls.Select(u => u.Url);
+        }
+
+        public async Task AddListenerAsync(string url, WebhookType type = default)
+        {
+            await _repo.AddUrlAsync(url, type);
+        }
+
+        public async Task<bool> RemoveListenerAsync(string url)
+        {
+            var result = await _repo.DeleteUrlAsync(url);
+            return result > 0;
+        }
+
+        //basic broadcast for all
+        public async Task BroadcastAsync<T>(T payload) where T : class
+        {
+            IEnumerable<string> urls = await GetListenersAsync();
+            await BroadcastAsync(payload, urls);
+        }
+        //derived for the payloads
+        public async Task BroadcastAsync<T>(T payload, IEnumerable<string> urls) where T : class
+        {
+            var tasks = urls.Select(async url =>
+            {
+                try
+                {
+                    await _client.PostAsJsonAsync(url, payload);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Webhook POST failed for URL: {url}", url);
+                }
+            });
+            await Task.WhenAll(tasks);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/RandomAPI/APIServices/Services/DatabaseService.cs b/src/RandomAPI/APIServices/Services/DatabaseService.cs
index 978643e..7f37ce8 100644
--- a/src/RandomAPI/APIServices/Services/DatabaseService.cs
+++ b/src/RandomAPI/APIServices/Services/DatabaseService.cs
@@ -24,7 +24,7 @@ public void Execute(Action<SqliteConnection> action)
     /// <summary>
     /// Opens a connection, executes a Dapper query, and returns a collection of results.
     /// </summary>
-    /// <typeparam name="T">The type of object to map the result rows to (e.g., Event).</typeparam>
+    /// <typeparam name="T">The Type of object to map the result rows to (e.g., Event).</typeparam>
     /// <param name="sql">The SQL SELECT statement to execute.</param>
     /// <param name="param">Optional parameters object for Dapper.</param>
     /// <returns>A collection of mapped objects.</returns>
@@ -55,7 +55,7 @@ public async Task<int> ExecuteAsync(string sql, object? param = null)
     /// <summary>
     /// Opens a connection, executes a command, and returns a single value (e.g., the last inserted ID).
     /// </summary>
-    /// <typeparam name="T">The type of the scalar result (e.g., int).</typeparam>
+    /// <typeparam name="T">The Type of the scalar result (e.g., int).</typeparam>
     /// <param name="sql">The SQL command to execute.</param>
     /// <param name="param">Optional parameters object for Dapper.</param>
     /// <returns>The single scalar result.</returns>
diff --git a/src/RandomAPI/APIServices/Services/WebhookPayload.cs b/src/RandomAPI/APIServices/Services/WebhookPayload.cs
index cf36fe2..27489dc 100644
--- a/src/RandomAPI/APIServices/Services/WebhookPayload.cs
+++ b/src/RandomAPI/APIServices/Services/WebhookPayload.cs
@@ -1,3 +1,6 @@
+using RandomAPI.Models;
+using RandomAPI.Services.Webhooks;
+
 namespace RandomAPI.Services.Webhooks
 {
     public class WebhookPayload : ICustomWebhookPayload
@@ -10,4 +13,4 @@ public class DiscordWebhookPayload : IWebHookPayload
     {
         public string content { get; set; } = "";
     }
-}
+}
\ No newline at end of file
diff --git a/src/RandomAPI/APIServices/Services/WebhookService.cs b/src/RandomAPI/APIServices/Services/WebhookService.cs
deleted file mode 100644
index 2844a17..0000000
--- a/src/RandomAPI/APIServices/Services/WebhookService.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using System.Collections.Concurrent;
-
-namespace RandomAPI.Services.Webhooks
-{
-    public class WebhookService : IWebhookService
-    {
-        private readonly ConcurrentDictionary<string, byte> _webhookUrls = new();
-        private readonly HttpClient _client = new();
-        private readonly ILogger<IWebhookService> _logger;
-
-        public WebhookService(ILogger<IWebhookService> logger)
-        {
-            _logger = logger;
-        }
-
-        public IEnumerable<string> GetListeners() => _webhookUrls.Keys;
-
-        public bool AddListener(string url) => _webhookUrls.TryAdd(url, 0);
-
-        public bool RemoveListener(string url) => _webhookUrls.TryRemove(url, out _);
-
-        public async Task BroadcastAsync<T>(T payload) where T : class
-        {
-            // Snapshot-safe enumeration
-            var tasks = _webhookUrls.Keys.Select(async url =>
-            {
-                try
-                {
-                    await _client.PostAsJsonAsync(url, payload);
-                }
-                catch (Exception ex)
-                {
-                    {
-                        _logger.LogWarning(ex, "WebhookPayload failed to Post");
-                    }
-                }
-            });
-            await Task.WhenAll(tasks);
-        }
-    }
-}
diff --git a/src/RandomAPI/Controllers/WebhookController.cs b/src/RandomAPI/Controllers/WebhookController.cs
index 2c9d8a7..229e6fb 100644
--- a/src/RandomAPI/Controllers/WebhookController.cs
+++ b/src/RandomAPI/Controllers/WebhookController.cs
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Mvc;
 using RandomAPI.Services.Webhooks;
+using static IWebhookService;
 
 namespace RandomAPI.Controllers
 {
@@ -10,7 +11,9 @@ public class WebhookController : ControllerBase
         private readonly ILogger<WebhookController> _logger;
         private readonly IWebhookService _webhookService;
 
-        public WebhookController(ILogger<WebhookController> logger, IWebhookService webhookService)
+        public WebhookController(
+            ILogger<WebhookController> logger,
+            IWebhookService webhookService)
         {
             _logger = logger;
             _webhookService = webhookService;
@@ -20,105 +23,77 @@ public WebhookController(ILogger<WebhookController> logger, IWebhookService webh
         /// Gets a list of all currently registered webhook listener URLs.
         /// </summary>
         [HttpGet("listeners")]
-        public IActionResult GetListeners()
+        public async Task<IActionResult> GetListeners()
         {
-            return Ok(_webhookService.GetListeners());
+            var urls = await _webhookService.GetListenersAsync();
+            return Ok(urls);
         }
 
         /// <summary>
         /// Registers a new URL to receive webhook payloads.
         /// </summary>
-        /// <param name="url">The URL to register.</param>
         [HttpPost("register")]
-        public IActionResult Register([FromBody] string url)
+        public async Task<IActionResult> RegisterUrl([FromBody] string url)
         {
-            if (string.IsNullOrWhiteSpace(url))
-            {
-                return BadRequest("URL cannot be empty.");
-            }
-
-            if (_webhookService.AddListener(url))
-            {
-                _logger.LogInformation("Registered new webhook listener: {Url}", url);
-                return Ok(new { Message = $"Listener added successfully for {url}" });
-            }
-
-            return Conflict(new { Message = $"URL is already registered: {url}" });
+            return await _webhookService.HandleRegisterActionAsync(url);
+        }
+        /// <summary>
+        /// Registers a new URL to receive webhook payloads.
+        /// </summary>
+        [HttpPost("register-discord")]
+        public async Task<IActionResult> RegisterDiscordUrl([FromBody] string url)
+        {
+            return await _webhookService.HandleRegisterActionAsync(url, WebhookType.Discord);
         }
 
         /// <summary>
         /// Removes a URL from the list of webhook listeners.
         /// </summary>
-        /// <param name="url">The URL to unregister.</param>
         [HttpDelete("unregister")]
-        public IActionResult Unregister([FromBody] string url)
+        public async Task<IActionResult> UnregisterUrl([FromBody] string url)
         {
-            if (string.IsNullOrWhiteSpace(url))
-            {
-                return BadRequest("URL cannot be empty.");
-            }
-
-            if (_webhookService.RemoveListener(url))
-            {
-                _logger.LogInformation("Unregistered webhook listener: {Url}", url);
-                return Ok(new { Message = $"Listener removed successfully for {url}" });
-            }
-
-            return NotFound(new { Message = $"URL not found in listener list: {url}" });
+            return await _webhookService.HandleUnregisterActionAsync(url);
         }
 
         /// <summary>
-        /// Endpoint to manually trigger a test broadcast of a payload.
+        /// Endpoint to manually trigger a test broadcast.
         /// </summary>
-        /// <param name="payload">The payload message to send.</param>
         [HttpPost("debug/broadcast-test")]
         public async Task<IActionResult> BroadcastTest([FromBody] WebhookPayload payload)
         {
-            if (!_webhookService.GetListeners().Any())
-            {
+            var listeners = await _webhookService.GetListenersAsync();
+
+            if (!listeners.Any())
                 return BadRequest("No listeners registered to broadcast to.");
-            }
 
-            // Ensure the payload has a fresh timestamp
             payload.Timestamp = DateTime.UtcNow;
 
             _logger.LogInformation("Broadcasting test payload: {Message}", payload.content);
 
-            // This runs asynchronously in the background. We don't wait for every success.
             await _webhookService.BroadcastAsync(payload);
 
-            return Ok(
-                new
-                {
-                    Message = $"Broadcast initiated successfully for message: '{payload.content}'. Check logs for delivery status.",
-                }
-            );
+            return Ok(new
+            {
+                Message = $"Broadcast sent for message: '{payload.content}'. Check logs for delivery status."
+            });
         }
 
         [HttpPost("debug/discord-broadcast-test")]
-        public async Task<IActionResult> BroadcastDiscordTest(
-            [FromBody] DiscordWebhookPayload payload
-        )
+        public async Task<IActionResult> BroadcastDiscordTest([FromBody] DiscordWebhookPayload payload)
         {
-            if (!_webhookService.GetListeners().Any())
-            {
+            var listeners = await _webhookService.GetListenersAsync();
+
+            if (!listeners.Any())
                 return BadRequest("No listeners registered to broadcast to.");
-            }
 
-            // Ensure the payload has a fresh timestamp
-            //payload.Timestamp = DateTime.UtcNow;
+            _logger.LogInformation("Broadcasting Discord payload: {Message}", payload.content?.Replace("\r", "").Replace("\n", ""));
 
-            _logger.LogInformation("Broadcasting test payload: {Message}", payload.content);
-
-            // This runs asynchronously in the background. We don't wait for every success.
             await _webhookService.BroadcastAsync(payload);
 
-            return Ok(
-                new
-                {
-                    Message = $"Broadcast initiated successfully for message: '{payload.content}'. Check logs for delivery status.",
-                }
-            );
+            return Ok(new
+            {
+                Message = $"Broadcast sent for message: '{payload.content}'. Check logs for delivery status."
+            });
         }
     }
 }
diff --git a/src/RandomAPI/APIServices/Services/ICustomWebhookPayload.cs b/src/RandomAPI/Models/ICustomWebhookPayload.cs
similarity index 84%
rename from src/RandomAPI/APIServices/Services/ICustomWebhookPayload.cs
rename to src/RandomAPI/Models/ICustomWebhookPayload.cs
index 30efdac..3493eca 100644
--- a/src/RandomAPI/APIServices/Services/ICustomWebhookPayload.cs
+++ b/src/RandomAPI/Models/ICustomWebhookPayload.cs
@@ -1,4 +1,4 @@
-namespace RandomAPI.Services.Webhooks
+namespace RandomAPI.Models
 {
     public interface ICustomWebhookPayload : IWebHookPayload
     {
diff --git a/src/RandomAPI/Models/WebhookUrl.cs b/src/RandomAPI/Models/WebhookUrl.cs
index ddd799f..49c1940 100644
--- a/src/RandomAPI/Models/WebhookUrl.cs
+++ b/src/RandomAPI/Models/WebhookUrl.cs
@@ -1,4 +1,5 @@
-namespace RandomAPI.Models
+
+namespace RandomAPI.Models
 {
     /// <summary>
     /// Represents a registered webhook listener URL stored in the database.
@@ -7,5 +8,6 @@ public class WebhookUrl
     {
         public int Id { get; set; }
         public required string Url { get; set; }
+        public IWebhookService.WebhookType Type { get; set; }
     }
 }
diff --git a/src/RandomAPI/PersonalDev.db b/src/RandomAPI/PersonalDev.db
index 7a824e9..3d02038 100644
Binary files a/src/RandomAPI/PersonalDev.db and b/src/RandomAPI/PersonalDev.db differ
diff --git a/src/RandomAPI/Program.cs b/src/RandomAPI/Program.cs
index 8fc75b1..7e769de 100644
--- a/src/RandomAPI/Program.cs
+++ b/src/RandomAPI/Program.cs
@@ -12,13 +12,20 @@
 // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
 builder.Services.AddEndpointsApiExplorer();
 builder.Services.AddSwaggerGen();
-builder.Services.AddTransient<IDbConnection>(_ => new SqliteConnection(
-    DBInitialization.CONNECTIONSTRING
-));
+builder.Services.AddScoped<IDbConnection>(sp =>
+{
+    var conn = new SqliteConnection("Data Source=PersonalDev.db;Cache=Shared");
+    conn.Open();
+    return conn;
+});
+builder.Services.AddScoped<Func<IDbConnection>>(sp =>
+    () => sp.GetRequiredService<IDbConnection>());
+
 
 #region Add Services
 //webhook
-builder.Services.AddSingleton<IWebhookService, WebhookService>();
+builder.Services.AddScoped<IWebhookService, WebhookActionService>();
+
 
 //time clock service
 builder.Services.AddSingleton<IHoursService, TimeOutService>();
diff --git a/src/RandomAPI/Repository/DBInitialization.cs b/src/RandomAPI/Repository/DBInitialization.cs
deleted file mode 100644
index 3d2b41d..0000000
--- a/src/RandomAPI/Repository/DBInitialization.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System.Data;
-using Dapper;
-
-public static class DBInitialization
-{
-    public const string CONNECTIONSTRING = "Data Source=PersonalDev.db";
-
-    public static async Task EnsureDb(IServiceProvider services)
-    {
-        // Use an isolated scope for startup to safely create the connection
-        using var scope = services.CreateScope();
-        var db = scope.ServiceProvider.GetRequiredService<IDbConnection>();
-
-        //to make more tasbles, write the sql and await and chain it :)
-        var sql =
-            @"
-        CREATE TABLE IF NOT EXISTS Events (
-            Id          INTEGER PRIMARY KEY AUTOINCREMENT,
-            Timestamp   TEXT NOT NULL,
-            Service     TEXT NOT NULL,
-            Type        TEXT NOT NULL,
-            DataType    TEXT,
-            JsonData    TEXT NOT NULL,
-            EventId     TEXT NOT NULL,
-            CONSTRAINT UQ_EventId UNIQUE (EventId)
-        );";
-        await db.ExecuteAsync(sql);
-    }
-}
diff --git a/src/RandomAPI/Repository/EventRepository.cs b/src/RandomAPI/Repository/EventRepository.cs
index 0695d12..8ea37d1 100644
--- a/src/RandomAPI/Repository/EventRepository.cs
+++ b/src/RandomAPI/Repository/EventRepository.cs
@@ -7,17 +7,25 @@ namespace RandomAPI.Repository
 {
     public class EventRepository : IEventRepository, IInitializer
     {
-        private readonly IDbConnection _db;
+        private readonly Func<IDbConnection> _connectionFactory;
         private readonly ILogger<EventRepository> _logger;
 
-        public EventRepository(IDbConnection db, ILogger<EventRepository> logger)
+        public EventRepository(Func<IDbConnection> connectionFactory, ILogger<EventRepository> logger)
         {
-            _db = db;
+            _connectionFactory = connectionFactory;
             _logger = logger;
         }
 
+        private IDbConnection CreateConnection()
+        {
+            var conn = _connectionFactory();
+            conn.Open();
+            return conn;
+        }
+
         public async Task InitializeAsync()
         {
+            using var db = CreateConnection();
             var sql =
                     @"
         CREATE TABLE IF NOT EXISTS Events (
@@ -30,12 +38,13 @@ CREATE TABLE IF NOT EXISTS Events (
             EventId     TEXT NOT NULL,
             CONSTRAINT UQ_EventId UNIQUE (EventId)
         );";
-            await _db.ExecuteAsync(sql);
+            await db.ExecuteAsync(sql);
         }
 
         /// <inheritdoc />
         public async Task<int> AddEventAsync(Event eventModel)
         {
+            using var db = CreateConnection();
             const string sql =
                 @"
                 INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData) 
@@ -45,7 +54,7 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
 
             try
             {
-                var newId = await _db.ExecuteScalarAsync<int>(sql, eventModel);
+                var newId = await db.ExecuteScalarAsync<int>(sql, eventModel);
                 return newId;
             }
             catch (SqliteException ex) when (ex.SqliteErrorCode == 19) // Error code 19 is 'CONSTRAINT'
@@ -54,7 +63,7 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
                     $"WARNING: Duplicate event detected. EventId: {eventModel.EventId}"
                 );
                 const string selectExistingSql = "SELECT Id FROM Events WHERE EventId = @EventId";
-                var existingId = await _db.ExecuteScalarAsync<int>(
+                var existingId = await db.ExecuteScalarAsync<int>(
                     selectExistingSql,
                     new { eventModel.EventId }
                 );
@@ -70,19 +79,21 @@ INSERT INTO Events (Timestamp, EventId, Service, Type, DataType, JsonData)
         /// <inheritdoc />
         public async Task<IEnumerable<Event>> GetAllEventsAsync()
         {
+            using var db = CreateConnection();
             // Retrieves all records, ordered by newest first.
             const string sql = "SELECT * FROM Events ORDER BY Timestamp DESC";
 
-            var events = await _db.QueryAsync<Event>(sql);
+            var events = await db.QueryAsync<Event>(sql);
             return events;
         }
 
         /// <inheritdoc />
         public async Task<IEnumerable<Event>> GetRangeOfRecentEventsAsync(int count)
         {
+            using var db = CreateConnection();
             const string sql = "SELECT * FROM Events ORDER BY Timestamp DESC LIMIT @Count";
 
-            var events = await _db.QueryAsync<Event>(sql, new { Count = count });
+            var events = await db.QueryAsync<Event>(sql, new { Count = count });
             return events;
         }
 
@@ -92,18 +103,20 @@ public async Task<IEnumerable<Event>> GetEventsByIdsAsync(IEnumerable<int> ids)
             if (ids == null || !ids.Any())
                 return Enumerable.Empty<Event>();
 
+            using var db = CreateConnection();
             const string sql = "SELECT * FROM Events WHERE Id IN @Ids ORDER BY Timestamp DESC";
 
-            var events = await _db.QueryAsync<Event>(sql, new { Ids = ids });
+            var events = await db.QueryAsync<Event>(sql, new { Ids = ids });
             return events;
         }
 
         /// <inheritdoc />
         public async Task<int> RemoveEventAsync(int id)
         {
+            using var db = CreateConnection();
             const string sql = "DELETE FROM Events WHERE Id = @Id";
 
-            var rowsAffected = await _db.ExecuteAsync(sql, new { Id = id });
+            var rowsAffected = await db.ExecuteAsync(sql, new { Id = id });
             return rowsAffected;
         }
 
@@ -112,11 +125,13 @@ public async Task<int> RemoveEventsByIdsAsync(IEnumerable<int> ids)
         {
             if (ids == null || !ids.Any())
                 return 0;
-
+            using var db = CreateConnection();
             const string sql = "DELETE FROM Events WHERE Id IN @Ids";
 
-            var rowsAffected = await _db.ExecuteAsync(sql, new { Ids = ids });
+            var rowsAffected = await db.ExecuteAsync(sql, new { Ids = ids });
             return rowsAffected;
         }
     }
 }
+
+
diff --git a/src/RandomAPI/Repository/IWebhookRepository.cs b/src/RandomAPI/Repository/IWebhookRepository.cs
index 511da29..9e9cbd7 100644
--- a/src/RandomAPI/Repository/IWebhookRepository.cs
+++ b/src/RandomAPI/Repository/IWebhookRepository.cs
@@ -8,7 +8,8 @@ namespace RandomAPI.Repository
     public interface IWebhookRepository
     {
         Task<IEnumerable<WebhookUrl>> GetAllUrlsAsync();
-        Task AddUrlAsync(string url);
+        Task<IEnumerable<WebhookUrl>> GetUrlsOfTypeAsync(IWebhookService.WebhookType type);
+        Task AddUrlAsync(string url, IWebhookService.WebhookType type);
         Task<int> DeleteUrlAsync(string url);
     }
 }
diff --git a/src/RandomAPI/Repository/WebhookRepository.cs b/src/RandomAPI/Repository/WebhookRepository.cs
index 7e0f4d7..5fa1d0a 100644
--- a/src/RandomAPI/Repository/WebhookRepository.cs
+++ b/src/RandomAPI/Repository/WebhookRepository.cs
@@ -1,4 +1,5 @@
 using Dapper;
+using Microsoft.Data.Sqlite;
 using RandomAPI.Models;
 using System.Data;
 
@@ -10,11 +11,18 @@ namespace RandomAPI.Repository
     /// </summary>
     public class WebhookRepository : IWebhookRepository, IInitializer
     {
-        private readonly IDbConnection _db;
+        private readonly Func<IDbConnection> _connectionFactory;
 
-        public WebhookRepository(IDbConnection dbService)
+        public WebhookRepository(Func<IDbConnection> connectionFactory)
         {
-            _db = dbService;
+            _connectionFactory = connectionFactory;
+        }
+
+        private IDbConnection CreateConnection()
+        {
+            var conn = _connectionFactory();
+            conn.Open();
+            return conn;
         }
 
         /// <summary>
@@ -22,14 +30,27 @@ public WebhookRepository(IDbConnection dbService)
         /// </summary>
         public async Task InitializeAsync()
         {
-            // Define the table structure with a unique constraint on the Url to prevent duplicates
+            using var db = CreateConnection();
+
             const string sql = @"
             CREATE TABLE IF NOT EXISTS WebhookUrls (
                 Id INTEGER PRIMARY KEY AUTOINCREMENT,
-                Url TEXT NOT NULL UNIQUE
+                Url TEXT NOT NULL UNIQUE,
+                Type INTEGER NOT NULL DEFAULT 0
             );";
 
-            await _db.ExecuteAsync(sql);
+            await db.ExecuteAsync(sql);
+            try
+            {
+                const string alterTableSql = "ALTER TABLE WebhookUrls ADD COLUMN Type INTEGER NOT NULL DEFAULT 0;";
+                await db.ExecuteAsync(alterTableSql);
+            }
+            catch (SqliteException ex) when (ex.SqliteErrorCode == 1) { }
+            catch (Exception)
+            {
+                //re-throw any critical exceptions
+                throw;
+            }
         }
 
         /// <summary>
@@ -38,20 +59,35 @@ Url TEXT NOT NULL UNIQUE
         /// <returns>A collection of WebhookUrl objects.</returns>
         public async Task<IEnumerable<WebhookUrl>> GetAllUrlsAsync()
         {
+            using var db = CreateConnection();
             const string sql = "SELECT Id, Url FROM WebhookUrls ORDER BY Id;";
-            // Dapper maps the columns to the WebhookUrl model properties
-            return await _db.QueryAsync<WebhookUrl>(sql);
+            return await db.QueryAsync<WebhookUrl>(sql);
+        }
+
+        public async Task<IEnumerable<WebhookUrl>> GetUrlsOfTypeAsync(IWebhookService.WebhookType type)
+        {
+            using var db = CreateConnection();
+            const string sql = "SELECT Id, Url, Type FROM WebhookUrls WHERE Type = @Type;";
+            var parameters = new { Type = (int)type };
+
+            return await db.QueryAsync<WebhookUrl>(sql, parameters);
         }
 
         /// <summary>
         /// Adds a new URL to the database. Uses INSERT OR IGNORE to handle duplicates gracefully.
         /// </summary>
         /// <param name="url">The URL string to add.</param>
-        public async Task AddUrlAsync(string url)
+        public async Task AddUrlAsync(string url, IWebhookService.WebhookType type)
         {
-            // SQLITE specific command to ignore unique constraint errors if URL already exists
-            const string sql = "INSERT OR IGNORE INTO WebhookUrls (Url) VALUES (@Url);";
-            await _db.ExecuteAsync(sql, new { Url = url });
+            using var db = CreateConnection();
+            const string sql = "INSERT OR IGNORE INTO WebhookUrls (Url, Type) VALUES (@Url, @Type);";
+            var parameters = new
+            {
+                Url = url,
+                Type = (int)type
+            };
+
+            await db.ExecuteAsync(sql, parameters);
         }
 
         /// <summary>
@@ -61,8 +97,9 @@ public async Task AddUrlAsync(string url)
         /// <returns>The number of rows deleted (0 or 1).</returns>
         public async Task<int> DeleteUrlAsync(string url)
         {
+            using var db = CreateConnection();
             const string sql = "DELETE FROM WebhookUrls WHERE Url = @Url;";
-            return await _db.ExecuteAsync(sql, new { Url = url });
+            return await db.ExecuteAsync(sql, new { Url = url });
         }
     }
 }