diff --git a/app/api/analyze.py b/app/api/analyze.py
index 92934ca..c096493 100644
--- a/app/api/analyze.py
+++ b/app/api/analyze.py
@@ -1,10 +1,10 @@
 import os
 import filetype
-from fastapi import APIRouter, UploadFile, WebSocket, WebSocketDisconnect, Request
+from fastapi import APIRouter, HTTPException, WebSocketException, UploadFile, WebSocket, WebSocketDisconnect, Request
 from services import rate_limit
-from models.response import riskAssesment
+from models.response import riskAssessment
 from models.request import information
-from services.risk import get_assesment
+from services.risk import get_assessment
 from services.transcription import audio_transcript
 
 router = APIRouter()
@@ -21,35 +21,34 @@
 }
 
 @router.post("/email")
-def email_check(item: information, request: Request)-> riskAssesment | dict | None:
+def email_check(item: information, request: Request)-> riskAssessment | dict | None:
     assert request.client is not None
     if not rate_limit.check_rate_limit(request.client.host):
-        return {"error": "Reached your limit, wait 60 seconds before requesting again"}
-    return get_assesment(item.body)
+        raise HTTPException (status_code= 429, detail= {"error":"Reached your limit, wait 60 seconds before requesting again"})
+    return get_assessment(item.body)
 
 @router.post("/audio")
-async def audio_check(file:UploadFile, request: Request)-> riskAssesment | dict | None:
+async def audio_check(file:UploadFile, request: Request)-> riskAssessment | dict | None:
 
 
     assert request.client is not None
     if not rate_limit.check_rate_limit(request.client.host):
-        return {"error": "Reached your limit, wait 60 seconds before requesting again"}
+        raise HTTPException (status_code= 429, detail= {"error":"Reached your limit, wait 60 seconds before requesting again"})
     byte = await file.read()
     kind = filetype.guess(byte)
 
     if kind is None or kind.mime not in Allowed:
-        print("Not allowed type")
-        return
+        raise HTTPException (status_code= 415, detail= {"error":"Content type not allowed"})
     tmp_dir = "/dev/shm/" if os.path.exists("/dev/shm") else ""
     filename = f"{tmp_dir}audio.{kind.extension}"
     with open(filename, "wb") as f:
         f.write(byte)
     transcript = audio_transcript(filename)
     os.remove(filename)
-    return get_assesment(transcript)
+    return get_assessment(transcript)
 
 @router.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket)-> riskAssesment | str | None:
+async def websocket_endpoint(websocket: WebSocket)-> riskAssessment | str | None:
     await websocket.accept()
 
     file_count = 0
@@ -60,12 +59,11 @@ async def websocket_endpoint(websocket: WebSocket)-> riskAssesment | str | None:
 
             assert websocket.client is not None
             if not rate_limit.check_rate_limit(websocket.client.host):
-                await websocket.send_json({"error": "Reached your limit, wait 60 seconds before requesting again"})
-                continue
+                raise WebSocketException(code = 1008, reason="Reached your limit, wait 60 seconds before requesting again")
             kind = filetype.guess(byte) 
 
             if kind is None or kind.mime not in Allowed:
-                print("Not allowed type")
+                await websocket.send_json({"error": "Content type not allowed"})
                 continue
             tmp_dir = "/dev/shm/" if os.path.exists("/dev/shm") else ""
             filename = f"{tmp_dir}audio{file_count}.{kind.extension}"
@@ -74,11 +72,11 @@ async def websocket_endpoint(websocket: WebSocket)-> riskAssesment | str | None:
             transcript = audio_transcript(filename)
             os.remove(filename)
             file_count += 1
-            assesment =  get_assesment(transcript)
-            if assesment is None: 
-                await websocket.send_json({"error": "Assessment failed"})
+            assessment =  get_assessment(transcript)
+            if assessment is None: 
+                await websocket.send_json({"error": "Failed to analyze the audio. Try again"})
             else:
-                await websocket.send_json(assesment.model_dump())
+                await websocket.send_json(assessment.model_dump())
     except WebSocketDisconnect:
         print("Client disconnected")
 
diff --git a/app/models/response.py b/app/models/response.py
index cce4ffd..428d03c 100644
--- a/app/models/response.py
+++ b/app/models/response.py
@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 from typing import Literal
 
-class riskAssesment(BaseModel):
+class riskAssessment(BaseModel):
     label : Literal["Scam" , "Scam Likely" , "Safe"]
     score : Literal["High" , "Low" , "Medium"]
     certainty:int 
diff --git a/app/services/risk.py b/app/services/risk.py
index 17c7b31..ca7d55d 100644
--- a/app/services/risk.py
+++ b/app/services/risk.py
@@ -1,20 +1,20 @@
 
 from pydantic import ValidationError
 
-from models.response import riskAssesment
+from models.response import riskAssessment
 from services.ai import ask_deepseek
 
 
-def get_assesment(transcription: str) -> riskAssesment | None:
+def get_assessment(transcription: str) -> riskAssessment | None:
     for _ in range(5):
         response = ask_deepseek(transcription)
         if response is None:
             continue
-        assesment = None
+        assessment = None
         try:
-            assesment = riskAssesment(**response)
+            assessment = riskAssessment(**response)
 
         except ValidationError as e:
             print(e.errors())
 
-        return assesment
+        return assessment