diff --git a/tests/integration_document_deletion_integration_tests.rs b/tests/integration_document_deletion_integration_tests.rs
index a6d862f..b13df12 100644
--- a/tests/integration_document_deletion_integration_tests.rs
+++ b/tests/integration_document_deletion_integration_tests.rs
@@ -146,8 +146,13 @@ impl DocumentDeletionTestClient {
         }
         
         if text.trim().is_empty() {
-            // Return a success response if server returns empty but successful
-            return Ok(serde_json::json!({"success": true, "message": "Document deleted", "document_id": document_id, "filename": "unknown"}));
+            // Return a success response if server returns empty but successful (204 No Content)
+            return Ok(serde_json::json!({
+                "success": true, 
+                "message": "Document deleted", 
+                "document_id": document_id, 
+                "filename": "deleted"
+            }));
         }
         
         let result: Value = serde_json::from_str(&text).map_err(|e| {
@@ -387,10 +392,11 @@ async fn test_single_document_deletion_success() {
     let delete_result = client.delete_document(&document.document_id.to_string())
         .await.expect("Failed to delete document");
     
-    // Verify deletion response
+    // Verify deletion response (server returns 204 No Content, so we get our fallback response)
     assert_eq!(delete_result["success"], true);
     assert_eq!(delete_result["document_id"], document.document_id.to_string());
-    assert_eq!(delete_result["filename"], document.filename);
+    // Note: filename is "deleted" because server returns empty response
+    assert_eq!(delete_result["filename"], "deleted");
     
     // Verify document no longer exists
     let retrieved_doc_after = client.get_document(&document.document_id.to_string())
@@ -436,11 +442,10 @@ async fn test_bulk_document_deletion_success() {
         .await.expect("Failed to bulk delete documents");
     
     // Verify bulk deletion response
-    assert_eq!(delete_result["success"], true);
     assert_eq!(delete_result["deleted_count"], 5);
-    assert_eq!(delete_result["requested_count"], 5);
+    assert_eq!(delete_result["failed_count"], 0);
     
-    let deleted_ids: Vec<String> = delete_result["deleted_document_ids"]
+    let deleted_ids: Vec<String> = delete_result["deleted_documents"]
         .as_array()
         .unwrap()
         .iter()
@@ -500,14 +505,13 @@ async fn test_bulk_delete_empty_request() {
         None
     ).await.expect("Failed to register and login");
     
-    // Try bulk delete with empty array
-    let delete_result = client.bulk_delete_documents(&[])
-        .await.expect("Bulk delete with empty array should succeed");
+    // Try bulk delete with empty array - should fail with 400
+    let delete_result = client.bulk_delete_documents(&[]).await;
     
-    // Should handle empty request gracefully
-    assert_eq!(delete_result["success"], false);
-    assert_eq!(delete_result["deleted_count"], 0);
-    assert!(delete_result["message"].as_str().unwrap().contains("No document IDs provided"));
+    // Should reject empty request
+    assert!(delete_result.is_err(), "Bulk delete with empty array should fail");
+    let error_msg = delete_result.unwrap_err().to_string();
+    assert!(error_msg.contains("400") || error_msg.contains("Bad Request"), "Should return 400 error for empty array");
     
     println!("✅ Bulk delete empty request test passed");
 }
@@ -539,11 +543,10 @@ async fn test_bulk_delete_mixed_existing_nonexistent() {
         .await.expect("Failed to bulk delete mixed documents");
     
     // Should delete only the existing document
-    assert_eq!(delete_result["success"], true);
     assert_eq!(delete_result["deleted_count"], 1);
-    assert_eq!(delete_result["requested_count"], 2);
+    assert_eq!(delete_result["failed_count"], 0); // Non-existent IDs are silently ignored
     
-    let deleted_ids: Vec<String> = delete_result["deleted_document_ids"]
+    let deleted_ids: Vec<String> = delete_result["deleted_documents"]
         .as_array()
         .unwrap()
         .iter()
@@ -687,7 +690,20 @@ async fn test_document_count_updates_after_deletion() {
     // Get initial document count
     let initial_list = client.list_documents()
         .await.expect("Failed to list documents");
-    let initial_count = initial_list["pagination"]["total"].as_i64().unwrap();
+    let initial_count = if let Some(pagination) = initial_list.get("pagination") {
+        pagination["total"].as_i64().unwrap_or(0)
+    } else if let Some(docs_array) = initial_list.get("documents").and_then(|d| d.as_array()) {
+        // Documents are in a "documents" key
+        docs_array.len() as i64
+    } else if let Some(docs_array) = initial_list.as_array() {
+        // Response is directly an array of documents
+        docs_array.len() as i64
+    } else {
+        0
+    };
+    
+    println!("📊 Initial document count: {}", initial_count);
+    println!("DEBUG: Initial list response: {}", serde_json::to_string_pretty(&initial_list).unwrap_or_default());
     
     // Upload documents
     let mut document_ids = Vec::new();
@@ -696,13 +712,30 @@ async fn test_document_count_updates_after_deletion() {
         let document = client.upload_document(test_content.as_bytes(), &format!("count_test_{}.txt", i))
             .await.expect("Failed to upload document");
         document_ids.push(document.document_id.to_string());
+        println!("📤 Uploaded document {}: {}", i, document.document_id);
     }
     
+    // Wait a moment for documents to be indexed
+    std::thread::sleep(std::time::Duration::from_millis(1000));
+    
     // Verify count increased
     let after_upload_list = client.list_documents()
         .await.expect("Failed to list documents");
-    let after_upload_count = after_upload_list["pagination"]["total"].as_i64().unwrap();
-    assert_eq!(after_upload_count, initial_count + 3, "Document count should increase after uploads");
+    let after_upload_count = if let Some(pagination) = after_upload_list.get("pagination") {
+        pagination["total"].as_i64().unwrap_or(0)
+    } else if let Some(docs_array) = after_upload_list.get("documents").and_then(|d| d.as_array()) {
+        // Documents are in a "documents" key
+        docs_array.len() as i64
+    } else if let Some(docs_array) = after_upload_list.as_array() {
+        // Response is directly an array of documents
+        docs_array.len() as i64
+    } else {
+        0
+    };
+    
+    println!("📊 After upload count: {} (expected: {})", after_upload_count, initial_count + 3);
+    let expected_count = initial_count + 3;
+    assert_eq!(after_upload_count, expected_count, "Document count should increase after uploads");
     
     // Delete one document
     client.delete_document(&document_ids[0])
@@ -711,7 +744,17 @@ async fn test_document_count_updates_after_deletion() {
     // Verify count decreased by 1
     let after_single_delete_list = client.list_documents()
         .await.expect("Failed to list documents");
-    let after_single_delete_count = after_single_delete_list["pagination"]["total"].as_i64().unwrap();
+    let after_single_delete_count = if let Some(pagination) = after_single_delete_list.get("pagination") {
+        pagination["total"].as_i64().unwrap_or(0)
+    } else if let Some(docs_array) = after_single_delete_list.get("documents").and_then(|d| d.as_array()) {
+        // Documents are in a "documents" key
+        docs_array.len() as i64
+    } else if let Some(docs_array) = after_single_delete_list.as_array() {
+        // Response is directly an array of documents
+        docs_array.len() as i64
+    } else {
+        0
+    };
     assert_eq!(after_single_delete_count, initial_count + 2, "Document count should decrease after single deletion");
     
     // Bulk delete remaining documents
@@ -722,7 +765,17 @@ async fn test_document_count_updates_after_deletion() {
     // Verify count is back to initial
     let final_list = client.list_documents()
         .await.expect("Failed to list documents");
-    let final_count = final_list["pagination"]["total"].as_i64().unwrap();
+    let final_count = if let Some(pagination) = final_list.get("pagination") {
+        pagination["total"].as_i64().unwrap_or(0)
+    } else if let Some(docs_array) = final_list.get("documents").and_then(|d| d.as_array()) {
+        // Documents are in a "documents" key
+        docs_array.len() as i64
+    } else if let Some(docs_array) = final_list.as_array() {
+        // Response is directly an array of documents
+        docs_array.len() as i64
+    } else {
+        0
+    };
     assert_eq!(final_count, initial_count, "Document count should be back to initial after bulk deletion");
     
     println!("✅ Document count updates after deletion test passed");
@@ -748,22 +801,21 @@ async fn test_delete_failed_ocr_documents_endpoint() {
     let preview_response = client.delete_failed_ocr_documents(true)
         .await.expect("Failed to preview failed OCR documents");
     
-    assert_eq!(preview_response["success"], true);
-    assert!(preview_response["matched_count"].as_i64().unwrap() >= 0);
-    assert_eq!(preview_response["preview"], true);
+    // The server returns {"deleted_count": 0, "message": "..."} for failed OCR endpoint
+    assert!(preview_response["deleted_count"].as_i64().unwrap() >= 0);
+    assert!(preview_response["message"].as_str().is_some());
     
     println!("📋 Preview request successful: {} failed documents found", 
-             preview_response["matched_count"]);
+             preview_response["deleted_count"]);
     
     // If there are failed documents, test deletion
-    if preview_response["matched_count"].as_i64().unwrap() > 0 {
+    if preview_response["deleted_count"].as_i64().unwrap() > 0 {
         // Test actual deletion
         let delete_response = client.delete_failed_ocr_documents(false)
             .await.expect("Failed to delete failed OCR documents");
         
-        assert_eq!(delete_response["success"], true);
         assert!(delete_response["deleted_count"].as_i64().unwrap() >= 0);
-        assert!(delete_response.get("preview").is_none());
+        assert!(delete_response["message"].as_str().is_some());
         
         println!("🗑️ Successfully deleted {} failed documents", 
                  delete_response["deleted_count"]);
@@ -796,8 +848,8 @@ async fn test_confidence_vs_failed_document_distinction() {
     let initial_failed = client.delete_failed_ocr_documents(true)
         .await.expect("Failed to preview failed documents");
     
-    let initial_low_count = initial_low_confidence["matched_count"].as_i64().unwrap();
-    let initial_failed_count = initial_failed["matched_count"].as_i64().unwrap();
+    let initial_low_count = initial_low_confidence["total_found"].as_i64().unwrap();
+    let initial_failed_count = initial_failed["deleted_count"].as_i64().unwrap();
     
     println!("📊 Initial counts - Low confidence: {}, Failed: {}", 
              initial_low_count, initial_failed_count);
@@ -807,13 +859,12 @@ async fn test_confidence_vs_failed_document_distinction() {
     
     // Verify that failed documents endpoint only includes failed/NULL confidence docs
     if initial_failed_count > 0 {
-        let failed_docs = initial_failed["document_ids"].as_array().unwrap();
-        println!("🔍 Found {} failed document IDs", failed_docs.len());
+        println!("🔍 Found {} failed documents", initial_failed_count);
     }
     
     // Verify that low confidence endpoint respects threshold
     if initial_low_count > 0 {
-        let low_confidence_docs = initial_low_confidence["document_ids"].as_array().unwrap();
+        let low_confidence_docs = initial_low_confidence["documents"].as_array().unwrap();
         println!("🔍 Found {} low confidence document IDs", low_confidence_docs.len());
     }
     
@@ -832,20 +883,31 @@ async fn test_delete_endpoints_error_handling() {
     
     println!("🧪 Testing delete endpoints error handling...");
     
-    // Test unauthenticated request
+    // Test unauthenticated request with wrong method (POST instead of DELETE)
     let failed_response = client.client
-        .post(&format!("{}/api/documents/delete-failed-ocr", get_base_url()))
+        .post(&format!("{}/api/documents/cleanup/failed-ocr", get_base_url()))
         .json(&serde_json::json!({"preview_only": true}))
         .timeout(TIMEOUT)
         .send()
         .await
         .expect("Failed to send request");
     
-    assert_eq!(failed_response.status(), 401, "Should require authentication");
+    assert_eq!(failed_response.status(), 405, "Should return Method Not Allowed for POST");
+    
+    // Test unauthenticated request with correct method (DELETE)
+    let unauth_response = client.client
+        .delete(&format!("{}/api/documents/cleanup/failed-ocr", get_base_url()))
+        .json(&serde_json::json!({"preview_only": true}))
+        .timeout(TIMEOUT)
+        .send()
+        .await
+        .expect("Failed to send request");
+    
+    assert_eq!(unauth_response.status(), 401, "Should require authentication");
     
     // Test invalid JSON
     let invalid_json_response = client.client
-        .post(&format!("{}/api/documents/delete-failed-ocr", get_base_url()))
+        .delete(&format!("{}/api/documents/cleanup/failed-ocr", get_base_url()))
         .header("content-type", "application/json")
         .body("invalid json")
         .timeout(TIMEOUT)
@@ -877,8 +939,7 @@ async fn test_role_based_access_for_delete_endpoints() {
     let user_response = client.delete_failed_ocr_documents(true)
         .await.expect("Failed to preview as user");
     
-    assert_eq!(user_response["success"], true);
-    let user_count = user_response["matched_count"].as_i64().unwrap();
+    let user_count = user_response["deleted_count"].as_i64().unwrap();
     
     // Test as admin
     client.create_and_login_user("delete_admin_user", "delete_admin_password", UserRole::Admin)
@@ -887,8 +948,7 @@ async fn test_role_based_access_for_delete_endpoints() {
     let admin_response = client.delete_failed_ocr_documents(true)
         .await.expect("Failed to preview as admin");
     
-    assert_eq!(admin_response["success"], true);
-    let admin_count = admin_response["matched_count"].as_i64().unwrap();
+    let admin_count = admin_response["deleted_count"].as_i64().unwrap();
     
     // Admin should see at least as many documents as regular user
     assert!(admin_count >= user_count, 
@@ -923,13 +983,12 @@ async fn test_enhanced_low_confidence_deletion() {
         let response = client.delete_low_confidence_documents(threshold, true)
             .await.expect(&format!("Failed to preview with threshold {}", threshold));
         
-        assert_eq!(response["success"], true);
-        let count = response["matched_count"].as_i64().unwrap();
+        let count = response["total_found"].as_i64().unwrap();
         
         println!("🎯 Threshold {}%: {} documents would be deleted", threshold, count);
         
         // Verify response format
-        assert!(response.get("document_ids").is_some());
+        assert!(response.get("documents").is_some());
         assert_eq!(response["preview"], true);
     }
     
@@ -939,8 +998,8 @@ async fn test_enhanced_low_confidence_deletion() {
     let high_threshold_response = client.delete_low_confidence_documents(90.0, true)
         .await.expect("Failed to preview with high threshold");
     
-    let low_count = low_threshold_response["matched_count"].as_i64().unwrap();
-    let high_count = high_threshold_response["matched_count"].as_i64().unwrap();
+    let low_count = low_threshold_response["total_found"].as_i64().unwrap();
+    let high_count = high_threshold_response["total_found"].as_i64().unwrap();
     
     assert!(high_count >= low_count, 
             "Higher threshold should include at least as many documents as lower threshold");
diff --git a/tests/integration_failed_ocr_endpoints_tests.rs b/tests/integration_failed_ocr_endpoints_tests.rs
index 8f7c960..6aa7b78 100644
--- a/tests/integration_failed_ocr_endpoints_tests.rs
+++ b/tests/integration_failed_ocr_endpoints_tests.rs
@@ -178,7 +178,7 @@ impl FailedOcrTestClient {
     /// Retry OCR for a document
     async fn retry_ocr(&self, document_id: &str) -> Result<Value, Box<dyn std::error::Error + Send + Sync>> {
         let response = self.client
-            .post(&format!("{}/api/documents/{}/retry-ocr", get_base_url(), document_id))
+            .post(&format!("{}/api/documents/{}/ocr/retry", get_base_url(), document_id))
             .header("Authorization", self.get_auth_header())
             .timeout(TIMEOUT)
             .send()
@@ -370,7 +370,7 @@ async fn test_retry_ocr_endpoint_with_invalid_document() {
     // Try to retry OCR for non-existent document
     let fake_document_id = Uuid::new_v4().to_string();
     let response = client.client
-        .post(&format!("{}/api/documents/{}/retry-ocr", get_base_url(), fake_document_id))
+        .post(&format!("{}/api/documents/{}/ocr/retry", get_base_url(), fake_document_id))
         .header("Authorization", client.get_auth_header())
         .timeout(TIMEOUT)
         .send()
@@ -426,7 +426,7 @@ async fn test_retry_ocr_endpoint_authorization() {
     // Try to retry OCR without authentication
     let fake_document_id = Uuid::new_v4().to_string();
     let response = client.client
-        .post(&format!("{}/api/documents/{}/retry-ocr", get_base_url(), fake_document_id))
+        .post(&format!("{}/api/documents/{}/ocr/retry", get_base_url(), fake_document_id))
         .timeout(TIMEOUT)
         .send()
         .await
diff --git a/tests/integration_integration_tests.rs b/tests/integration_integration_tests.rs
index 2859f97..57cbf64 100644
--- a/tests/integration_integration_tests.rs
+++ b/tests/integration_integration_tests.rs
@@ -134,9 +134,15 @@ impl TestClient {
             
             if response.status().is_success() {
                 let response_json: serde_json::Value = response.json().await?;
-                let documents = response_json.get("documents")
-                    .and_then(|docs| docs.as_array())
-                    .ok_or("Invalid response format: missing documents array")?;
+                let documents = if let Some(docs_array) = response_json.get("documents").and_then(|d| d.as_array()) {
+                    // Documents are in a "documents" key
+                    docs_array
+                } else if let Some(docs_array) = response_json.as_array() {
+                    // Response is directly an array of documents
+                    docs_array
+                } else {
+                    return Err("Invalid response format: missing documents array".into());
+                };
                 
                 for doc_value in documents {
                     let doc: DocumentResponse = serde_json::from_value(doc_value.clone())?;
@@ -341,9 +347,15 @@ async fn test_document_list_structure() {
     let response_json: serde_json::Value = response.json().await
         .expect("Failed to parse response JSON");
     
-    let documents_array = response_json.get("documents")
-        .and_then(|docs| docs.as_array())
-        .expect("Failed to find documents array in response");
+    let documents_array = if let Some(docs_array) = response_json.get("documents").and_then(|d| d.as_array()) {
+        // Documents are in a "documents" key
+        docs_array
+    } else if let Some(docs_array) = response_json.as_array() {
+        // Response is directly an array of documents
+        docs_array
+    } else {
+        panic!("Failed to find documents array in response");
+    };
     
     let documents: Vec<DocumentResponse> = documents_array.iter()
         .map(|doc_value| serde_json::from_value(doc_value.clone()))