diff --git a/RelayCore/Endpoints/AuthEndpoints.cs b/RelayCore/Endpoints/AuthEndpoints.cs
index 47ff950..debada4 100644
--- a/RelayCore/Endpoints/AuthEndpoints.cs
+++ b/RelayCore/Endpoints/AuthEndpoints.cs
@@ -14,16 +14,13 @@ public static class AuthEndpoints
         });
         app.MapPost("/user/register", async (AuthRegister request, APIAuthService service) =>
         {
-            throw new NotImplementedException();
-            return Results.Ok();
+            var token = await service.UserRegisterAsync(request);
+            return token  != null  ? Results.Ok(token) : Results.Unauthorized();
         });
         app.MapPost("/server/verify/user", async (AuthUserVerify request, APIAuthService service) =>
         {
-            throw new NotImplementedException();
-        });
-        app.MapPost("/server/user/profile", async (AuthUserVerify request, APIAuthService service) =>
-        {
-            throw new NotImplementedException();
+            bool valid = await service.ServerVerifyUser(request);
+            return Results.Ok(valid);
         });
         app.MapPost("/server/verify/license", async (AuthServerLicense request, APIAuthService service) =>
         {
diff --git a/RelayCore/Models/PasswordHasher.cs b/RelayCore/Models/PasswordHasher.cs
index 866af9a..eecc9d6 100644
--- a/RelayCore/Models/PasswordHasher.cs
+++ b/RelayCore/Models/PasswordHasher.cs
@@ -22,7 +22,7 @@ namespace RelayCore.Models
         /// <summary>
         /// Number of threads to use for parallel computation
         /// </summary>
-        private const int DegreeOfParallelism = 1;
+        private const int DegreeOfParallelism = 2;
 
         /// <summary>
         /// Number of iterations for the Argon2id algorithm
diff --git a/RelayCore/Models/Sessions.cs b/RelayCore/Models/Sessions.cs
index 92da4ed..8443ba8 100644
--- a/RelayCore/Models/Sessions.cs
+++ b/RelayCore/Models/Sessions.cs
@@ -4,7 +4,7 @@ namespace RelayCore.Models;
 
 public class Sessions : Record
 {
-    public required string UserId { get; set; }
+    public required RecordId UserId { get; set; }
     public required string TokenHash { get; set; }
     public required DateTime IssuedAt { get; set; }
     public required DateTime ExpiresAt { get; set; }
diff --git a/RelayCore/Program.cs b/RelayCore/Program.cs
index b1bb2d4..44d0bed 100644
--- a/RelayCore/Program.cs
+++ b/RelayCore/Program.cs
@@ -66,7 +66,7 @@ static async Task<Users> CreateUserAsync(SurrealDbClient db, string username, st
         OnlineStatus = (int)OnlineStatuses.Online,
     };
 
-    var created = await db.Create("users", user);
+    var created = await db.Create("auth_users", user);
 
     var hasher = new PasswordHasher();
     var passwordHash = hasher.HashPassword(created.Id.ToString() + rawPassword);
diff --git a/RelayCore/Services/APIAuthService.cs b/RelayCore/Services/APIAuthService.cs
index 481bf6c..e271ff5 100644
--- a/RelayCore/Services/APIAuthService.cs
+++ b/RelayCore/Services/APIAuthService.cs
@@ -1,19 +1,48 @@
 using RelayCore.Endpoints;
+using RelayCore.Models;
 using SurrealDb.Net;
+using SurrealDb.Net.Models;
 
 namespace RelayCore.Services;
 
-public class APIAuthService(SurrealDbClient db)
+public class APIAuthService(SurrealDbClient _db)
 {
-    private readonly SurrealDbClient _db = db;
+    
+    public async Task<string> UserSigninAsync(AuthSignin request)
+    {
+        var hasher = new PasswordHasher();
+        var users = await _db.Select<Users>("auth_users");
+        var user = users.FirstOrDefault(x => (x.Username == request.UserName || x.Email == request.UserName) 
+                                             && hasher.VerifyPassword(request.Password, x.Password));
+        var tokens = await _db.Select<Sessions>("auth_sessions");
+        var token = tokens.Where(x => x.UserId == user.Id && !x.Revoked).OrderByDescending(x => x.ExpiresAt).FirstOrDefault();
+        if (token.ExpiresAt > DateTime.UtcNow)
+            return token.TokenHash;
+        
+        //TODO: Generate TOKEN
+        var newToken = hasher.HashPassword($"{user.Email}{user.Username}{user.Password}");
+        //TODO: Store TOKEN and Username for verification
+        var sessionId = await _db.Create<Sessions>(new Sessions
+        {
+            UserId = user.Id,
+            TokenHash = newToken,
+            IssuedAt = DateTime.UtcNow,
+            ExpiresAt = DateTime.UtcNow.AddDays(30),
+            DeviceName = "",
+            Revoked = false,
+            IpAddress = "",
+            UserAgent = ""
+        });
+        //TODO: Add invalidation to TOKENs
+        return newToken;
+    }
 
-
-    public async Task<object?> GetUsersAsync()
+    public async Task<string> UserRegisterAsync(AuthRegister request)
     {
         throw new NotImplementedException();
     }
 
-    public async Task<object?> UserSigninAsync(AuthSignin request)
+    public async Task<bool> ServerVerifyUser(AuthUserVerify request)
     {
         throw new NotImplementedException();
     }