diff --git a/client/src/app/(auth)/layout.css b/client/src/app/(auth)/layout.css
index dd1246b..c575e36 100644
--- a/client/src/app/(auth)/layout.css
+++ b/client/src/app/(auth)/layout.css
@@ -33,12 +33,21 @@
   padding: 2rem;
   display: flex;
   flex-direction: column;
+  align-items: center;
   gap: 2rem;
   text-align: center;
   text-wrap: balance;
-  width: min(95%, 600px);
+  width: min(95%, 500px);
   background: var(--primary-900);
   box-shadow: var(--box-shadow-xl);
+
+  & h1 {
+    font-size: 2rem;
+  }
+
+  & button {
+    width: max-content;
+  }
 }
 
 .form-container {
diff --git a/client/src/app/(auth)/verify/VerifyContent.tsx b/client/src/app/(auth)/verify/VerifyContent.tsx
new file mode 100644
index 0000000..a2034c5
--- /dev/null
+++ b/client/src/app/(auth)/verify/VerifyContent.tsx
@@ -0,0 +1,26 @@
+import { verifyAccount } from "@/lib/api/auth";
+
+import { Button } from "@/components/ui/button/Button";
+import { LinkButton } from "@/components/ui/button/LinkButton";
+
+export default async function VerifyContent({ token }: { token: string }) {
+  const res = await verifyAccount(token);
+
+  if (res.success) {
+    return (
+      <>
+        <h1>All good!</h1>
+        <p>You can now log in with your email/username</p>
+        <LinkButton href="/login">Go to login</LinkButton>
+      </>
+    );
+  }
+
+  return (
+    <>
+      <h1>Verification failed</h1>
+      <p>{res.error}</p>
+      {res.status === 410 && <Button>Resend verification email</Button>}
+    </>
+  );
+}
diff --git a/client/src/app/(auth)/verify/page.tsx b/client/src/app/(auth)/verify/page.tsx
index 9203eac..50f9eee 100644
--- a/client/src/app/(auth)/verify/page.tsx
+++ b/client/src/app/(auth)/verify/page.tsx
@@ -1,20 +1,22 @@
-"use client";
-import { useSearchParams } from "next/navigation";
+import VerifyContent from "./VerifyContent";
+import { Suspense } from "react";
 
-export default function VerifyPage() {
-  const searchParams = useSearchParams();
-  const token = searchParams.get("token");
+type VerifyPageProps = {
+  searchParams: Promise<{
+    token?: string;
+  }>;
+};
 
-  // TODO: Implement actual verification logic by sending the token to the server for validation
+export default async function VerifyPage({ searchParams }: VerifyPageProps) {
+  const params = await searchParams;
+  const token = params.token?.trim();
 
   return (
     <div className="auth-verify">
       <div className="container">
-        <h1>Verify your email</h1>
-        <p>
-          A verification link has been sent to your email. Please check your
-          inbox and click the link to verify your account.
-        </p>
+        <Suspense fallback={<p>Verifying account...</p>}>
+          <VerifyContent token={token ?? ""} />
+        </Suspense>
       </div>
     </div>
   );
diff --git a/client/src/lib/api/auth.ts b/client/src/lib/api/auth.ts
index 2ff7399..1a84250 100644
--- a/client/src/lib/api/auth.ts
+++ b/client/src/lib/api/auth.ts
@@ -1,3 +1,5 @@
+import { ApiResponse } from "../types/apiResponse";
+
 import { config } from "../utils/envConfig";
 
 import type {
@@ -9,7 +11,7 @@ import type {
 
 const AUTH_URL = `${config.BACKEND_URL}/api/auth`;
 
-// auth/available
+// api/auth/available
 // GET
 // Check if email/username is available
 const checkDuplicateField = async (
@@ -37,7 +39,7 @@ export const checkDuplicateEmail = (value: string) =>
 export const checkDuplicateUsername = (value: string) =>
   checkDuplicateField("username", value);
 
-// auth/register
+// api/auth/register
 // POST
 // Create new user
 export const createUser = async (
@@ -62,7 +64,7 @@ export const createUser = async (
   }
 };
 
-// auth/login
+// api/auth/login
 // POST
 // Log in
 export const loggingIn = async (
@@ -87,9 +89,33 @@ export const loggingIn = async (
   }
 };
 
-// auth/verify
+// api/auth/verify - params: token
 // GET
 // Verify email with token
-// export const verifyAccount = async
+export const verifyAccount = async (token: string): Promise<ApiResponse> => {
+  try {
+    const res = await fetch(
+      `${AUTH_URL}/verify?token=${encodeURIComponent(token)}`,
+      {
+        cache: "no-store",
+      },
+    );
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      return {
+        success: false,
+        error: data.error ?? "Verification request failed.",
+        status: res.status,
+      };
+    }
+
+    return data;
+  } catch (err) {
+    console.error("Error: ", err);
+    return { success: false, error: "Network error" };
+  }
+};
 
 // TOdO: Implement verifyAccount function when needed
diff --git a/client/src/lib/types/apiResponse.ts b/client/src/lib/types/apiResponse.ts
index eec85f3..8e5cd75 100644
--- a/client/src/lib/types/apiResponse.ts
+++ b/client/src/lib/types/apiResponse.ts
@@ -2,4 +2,5 @@ export type ApiResponse = {
   success: boolean;
   error?: string;
   message?: string;
+  status?: number;
 };
diff --git a/rust-server/src/db/queries.rs b/rust-server/src/db/queries.rs
index ee1ebc5..935c842 100644
--- a/rust-server/src/db/queries.rs
+++ b/rust-server/src/db/queries.rs
@@ -21,7 +21,7 @@ pub async fn find_user_by_username(db: &PgPool, username: &str) -> Result<Option
 
 #[allow(dead_code)]
 pub async fn find_user_by_id(db: &PgPool, id: Uuid) -> Result<Option<PgRow>, AppError> {
-    sqlx::query("SELECT id FROM users WHERE id = $1")
+    sqlx::query("SELECT id, email FROM users WHERE id = $1")
         .bind(id)
         .fetch_optional(db)
         .await
diff --git a/rust-server/src/errors.rs b/rust-server/src/errors.rs
index 727a82d..73b99d8 100644
--- a/rust-server/src/errors.rs
+++ b/rust-server/src/errors.rs
@@ -12,14 +12,16 @@ use crate::db::connect::DbError;
 #[derive(Debug)]
 #[allow(dead_code)]
 pub enum AppError {
-    NotFound(String),
-    Internal(String),
-    Database(String),
-    BadRequest(String),
-    Json(JsonRejection),
-    Validation(ValidationErrors),
-    Sql(sqlx::Error),
-    Conflict(String),
+    NotFound(String),             // 404
+    Internal(String),             // 500
+    Database(String),             // 503
+    BadRequest(String),           // 400
+    Json(JsonRejection),          // 400 with detailed JSON error
+    Validation(ValidationErrors), // 400 with validation error details
+    Sql(sqlx::Error), // 404 for RowNotFound, 409 for unique constraint violation, 500 for others
+    Conflict(String), // 409
+    Gone(String),     // 410
+    TooManyRequests(String), // 429
 }
 
 #[derive(Serialize)]
@@ -30,25 +32,40 @@ struct ErrorBody {
 
 #[allow(dead_code)]
 impl AppError {
+    // 404 Not Found
     pub fn not_found(message: impl Into<String>) -> Self {
         Self::NotFound(message.into())
     }
 
+    // 500 Internal Server Error
     pub fn internal(message: impl Into<String>) -> Self {
         Self::Internal(message.into())
     }
 
+    // 503 Service Unavailable (for database errors)
     pub fn database(message: impl Into<String>) -> Self {
         Self::Database(message.into())
     }
 
+    // 400 Bad Request
     pub fn bad_request(message: impl Into<String>) -> Self {
         Self::BadRequest(message.into())
     }
 
+    // 409 Conflict
     pub fn conflict(message: impl Into<String>) -> Self {
         Self::Conflict(message.into())
     }
+
+    // 410 Gone
+    pub fn gone(message: impl Into<String>) -> Self {
+        Self::Gone(message.into())
+    }
+
+    // 429 Too Many Requests
+    pub fn too_many_requests(message: impl Into<String>) -> Self {
+        Self::TooManyRequests(message.into())
+    }
 }
 
 impl IntoResponse for AppError {
@@ -58,6 +75,8 @@ impl IntoResponse for AppError {
             AppError::Internal(message) => (StatusCode::INTERNAL_SERVER_ERROR, message),
             AppError::Database(message) => (StatusCode::SERVICE_UNAVAILABLE, message),
             AppError::BadRequest(message) => (StatusCode::BAD_REQUEST, message),
+            AppError::Gone(message) => (StatusCode::GONE, message),
+            AppError::TooManyRequests(message) => (StatusCode::TOO_MANY_REQUESTS, message),
             AppError::Json(rejection) => {
                 let message = match rejection {
                     JsonRejection::JsonDataError(e) => format!("Invalid JSON: {}", e),
diff --git a/rust-server/src/features/auth/handlers.rs b/rust-server/src/features/auth/handlers.rs
index 02a6968..f778e2a 100644
--- a/rust-server/src/features/auth/handlers.rs
+++ b/rust-server/src/features/auth/handlers.rs
@@ -1,7 +1,9 @@
-use crate::db::queries::{find_token_by_value, find_user_by_email, find_user_by_username};
-use crate::features::auth::queries::{delete_user, verify_user};
+use crate::db::queries::{
+    find_token_by_value, find_user_by_email, find_user_by_id, find_user_by_username,
+};
+use crate::features::auth::queries::{delete_user, update_verification_token, verify_user};
 use crate::features::auth::service::new_user;
-use crate::features::auth::types::{AvailabilityQuery, VerifyQuery};
+use crate::features::auth::types::{AvailabilityQuery, ResendTokenData, VerifyQuery};
 use crate::state::AppState;
 use crate::utils::api_response::ApiResponse;
 use crate::utils::password::hash_password;
@@ -142,7 +144,7 @@ pub async fn verify_account(
     let expires_at: DateTime<Utc> = row.get("expires_at");
 
     if Utc::now() > expires_at {
-        return Err(AppError::bad_request("Token has expired"));
+        return Err(AppError::gone("Token has expired"));
     }
 
     verify_user(db, user_id).await?;
@@ -150,6 +152,47 @@ pub async fn verify_account(
     Ok(ApiResponse::ok("Email verified successfully", None))
 }
 
+// ----------------------
+// /api/auth/verify
+// POST
+// Update verification token (for resending verification email)
+// ----------------------
+pub async fn resend_token(
+    State(state): State<AppState>,
+    Json(params): Json<ResendTokenData>,
+) -> Result<ApiResponse<()>, AppError> {
+    let token = params.token.trim();
+    if token.is_empty() {
+        return Err(AppError::bad_request("Invalid token"));
+    }
+
+    let db = state.db()?;
+    let result = find_token_by_value(db, token)
+        .await?
+        .ok_or_else(|| AppError::not_found("Token not found"));
+
+    let user = find_user_by_id(db, result?.get("user_id"))
+        .await?
+        .ok_or_else(|| AppError::not_found("User not found"))?;
+
+    let new_token = update_verification_token(db, user.get("id")).await?;
+
+    if !state.config.app_env.is_test()
+        && let Err(email_err) = state
+            .email
+            .send_verification_email(user.get("email"), &new_token)
+            .await
+    {
+        tracing::error!("Failed to send verification email: {:#?}", email_err);
+        return Err(email_err);
+    }
+
+    Ok(ApiResponse::ok(
+        "Verification email resent. Check your inbox.",
+        None,
+    ))
+}
+
 // -----------------
 // Validate data
 // -----------------
diff --git a/rust-server/src/features/auth/queries.rs b/rust-server/src/features/auth/queries.rs
index 38bc103..c145533 100644
--- a/rust-server/src/features/auth/queries.rs
+++ b/rust-server/src/features/auth/queries.rs
@@ -4,7 +4,7 @@ use sqlx::{Executor, Postgres, types::Uuid};
 
 use crate::errors::AppError;
 
-// Create user - POST
+// Create user - CREATE
 pub async fn create_user<'e, E>(
     db: E,
     email: &str,
@@ -27,7 +27,7 @@ where
     Ok(row)
 }
 
-// Create verification token - POST
+// Create verification token - CREATE
 pub async fn create_verification_token<'e, E>(
     db: E,
     user_id: Uuid,
@@ -75,3 +75,22 @@ where
 
     Ok(())
 }
+
+// Update token - UPDATE (for resending verification email)
+pub async fn update_verification_token<'e, E>(db: E, user_id: Uuid) -> Result<String, AppError>
+where
+    E: Executor<'e, Database = Postgres>,
+{
+    let new_token = Uuid::new_v4().to_string();
+    let new_expires_at = Utc::now() + chrono::Duration::hours(24);
+
+    sqlx::query("UPDATE tokens SET token = $1, expires_at = $2 WHERE user_id = $3")
+        .bind(&new_token)
+        .bind(new_expires_at)
+        .bind(user_id)
+        .execute(db)
+        .await
+        .map_err(AppError::Sql)?;
+
+    Ok(new_token)
+}
diff --git a/rust-server/src/features/auth/routes.rs b/rust-server/src/features/auth/routes.rs
index 0786300..cb723e0 100644
--- a/rust-server/src/features/auth/routes.rs
+++ b/rust-server/src/features/auth/routes.rs
@@ -1,6 +1,6 @@
 use super::handlers::register_user;
 use crate::{
-    features::auth::handlers::{check_availability, verify_account},
+    features::auth::handlers::{check_availability, resend_token, verify_account},
     state::AppState,
 };
 use axum::{
@@ -12,5 +12,5 @@ pub fn auth_router() -> Router<AppState> {
     Router::new()
         .route("/register", post(register_user))
         .route("/available", get(check_availability))
-        .route("/verify", get(verify_account))
+        .route("/verify", get(verify_account).post(resend_token))
 }
diff --git a/rust-server/src/features/auth/types.rs b/rust-server/src/features/auth/types.rs
index 5124ed7..fe46c7e 100644
--- a/rust-server/src/features/auth/types.rs
+++ b/rust-server/src/features/auth/types.rs
@@ -28,6 +28,14 @@ pub struct RegisterData {
     pub password: String,
 }
 
+// -----------------------
+// Resend token data
+// -----------------------
+#[derive(Deserialize)]
+pub struct ResendTokenData {
+    pub token: String,
+}
+
 // -----------------------
 // Queries (params)
 // -----------------------
@@ -38,7 +46,6 @@ pub struct AvailabilityQuery {
 }
 
 #[derive(Deserialize)]
-
 pub struct VerifyQuery {
     pub token: Option<String>,
 }