diff --git a/veza-chat-server/src/websocket/handler.rs b/veza-chat-server/src/websocket/handler.rs
index 1e20c6d26..3c6632118 100644
--- a/veza-chat-server/src/websocket/handler.rs
+++ b/veza-chat-server/src/websocket/handler.rs
@@ -109,51 +109,66 @@ async fn handle_socket(socket: WebSocket, state: WebSocketState, claims: AccessT
         return;
     }
 
-    // Boucle principale de gestion des messages
-    while let Some(msg) = receiver.next().await {
-        match msg {
-            Ok(Message::Text(text)) => {
-                debug!("📨 Message WebSocket reçu: {}", text);
+    // Timeout d'inactivité (Heartbeat)
+    let keepalive_timeout = std::time::Duration::from_secs(60);
 
-                match handle_incoming_message(&text, &state, client.clone(), &claims).await {
-                    Ok(should_continue) => {
-                        if !should_continue {
+    // Boucle principale de gestion des messages avec timeout
+    loop {
+        match tokio::time::timeout(keepalive_timeout, receiver.next()).await {
+            Ok(Some(msg)) => {
+                match msg {
+                    Ok(Message::Text(text)) => {
+                        debug!("📨 Message WebSocket reçu: {}", text);
+
+                        match handle_incoming_message(&text, &state, client.clone(), &claims).await {
+                            Ok(should_continue) => {
+                                if !should_continue {
+                                    break;
+                                }
+                            }
+                            Err(e) => {
+                                error!("❌ Erreur lors du traitement du message: {}", e);
+
+                                // Envoyer un message d'erreur au client
+                                let error_msg = OutgoingMessage::Error {
+                                    message: format!("Erreur: {}", e),
+                                };
+                                if client.send_message(error_msg).await.is_err() {
+                                    error!("❌ Impossible d'envoyer le message d'erreur au client");
+                                    break; // Fermer la connexion si on ne peut même pas envoyer d'erreur
+                                }
+                            }
+                        }
+                    }
+                    Ok(Message::Close(_)) => {
+                        info!("👋 Connexion WebSocket fermée par le client");
+                        break;
+                    }
+                    Ok(Message::Ping(_)) => {
+                        debug!("🏓 Ping WebSocket reçu");
+                        if client.send_message(OutgoingMessage::Pong).await.is_err() {
+                            error!("❌ Erreur lors de l'envoi du Pong");
                             break;
                         }
                     }
+                    Ok(Message::Pong(_)) => {
+                        debug!("🏓 Pong WebSocket reçu");
+                    }
+                    Ok(_) => {
+                        debug!("⚠️ Type de message WebSocket non géré");
+                    }
                     Err(e) => {
-                        error!("❌ Erreur lors du traitement du message: {}", e);
-
-                        // Envoyer un message d'erreur au client
-                        let error_msg = OutgoingMessage::Error {
-                            message: format!("Erreur: {}", e),
-                        };
-                        if client.send_message(error_msg).await.is_err() {
-                            error!("❌ Impossible d'envoyer le message d'erreur au client");
-                            break; // Fermer la connexion si on ne peut même pas envoyer d'erreur
-                        }
+                        error!("❌ Erreur WebSocket: {}", e);
+                        break;
                     }
                 }
             }
-            Ok(Message::Close(_)) => {
-                info!("👋 Connexion WebSocket fermée par le client");
+            Ok(None) => {
+                // Fin du stream
                 break;
             }
-            Ok(Message::Ping(_)) => {
-                debug!("🏓 Ping WebSocket reçu");
-                if client.send_message(OutgoingMessage::Pong).await.is_err() {
-                    error!("❌ Erreur lors de l'envoi du Pong");
-                    break;
-                }
-            }
-            Ok(Message::Pong(_)) => {
-                debug!("🏓 Pong WebSocket reçu");
-            }
-            Ok(_) => {
-                debug!("⚠️ Type de message WebSocket non géré");
-            }
-            Err(e) => {
-                error!("❌ Erreur WebSocket: {}", e);
+            Err(_) => {
+                info!("💤 Timeout inactivité ({}s) pour client {}, fermeture", keepalive_timeout.as_secs(), client_id);
                 break;
             }
         }