diff --git a/app/src/main/java/com/dano/test1/DatabaseDownloader.kt b/app/src/main/java/com/dano/test1/DatabaseDownloader.kt
index 2625056..b373581 100644
--- a/app/src/main/java/com/dano/test1/DatabaseDownloader.kt
+++ b/app/src/main/java/com/dano/test1/DatabaseDownloader.kt
@@ -13,7 +13,8 @@ import java.io.FileOutputStream
 object DatabaseDownloader {
 
     private const val DB_NAME = "questionnaire_database"
-    private const val SERVER_DOWNLOAD_URL = "http://49.13.157.44/uploads/exported_encrypted_database.db"
+    private const val API_TOKEN = "MEIN_SUPER_GEHEIMES_TOKEN_12345"
+    private const val SERVER_DOWNLOAD_URL = "http://49.13.157.44/download.php?token=$API_TOKEN"
 
     private val client = OkHttpClient()
 
@@ -32,7 +33,6 @@ object DatabaseDownloader {
                     return@launch
                 }
 
-                // Temporäre verschlüsselte Datei speichern
                 val encryptedFile = File(context.cacheDir, "downloaded_encrypted_database.db")
                 response.body?.byteStream()?.use { input ->
                     FileOutputStream(encryptedFile).use { output ->
@@ -41,53 +41,18 @@ object DatabaseDownloader {
                 }
                 Log.d("DOWNLOAD", "Verschlüsselte Datei gespeichert: ${encryptedFile.absolutePath}")
 
-                // Datei entschlüsseln (hier deine echte Entschlüsselungslogik einfügen)
                 val decryptedFile = File(context.cacheDir, "decrypted_database.db")
-                decryptDatabase(encryptedFile, decryptedFile)
-                Log.d("DOWNLOAD", "Datei entschlüsselt: ${decryptedFile.absolutePath}")
+                AES256Helper.decryptFile(encryptedFile, decryptedFile)
 
-                // Alte DB ersetzen
                 val dbFile = context.getDatabasePath(DB_NAME)
-                if (dbFile.exists()) {
-                    if (dbFile.delete()) {
-                        Log.d("DOWNLOAD", "Alte Datenbank gelöscht.")
-                    } else {
-                        Log.e("DOWNLOAD", "Löschen der alten Datenbank fehlgeschlagen!")
-                        return@launch
-                    }
-                }
+                if (dbFile.exists()) dbFile.delete()
                 decryptedFile.copyTo(dbFile, overwrite = true)
 
-                Log.d("DOWNLOAD", "Neue Datenbank erfolgreich eingesetzt")
-
-                // Datenbankinhalt nach Download ausgeben (Hex-String)
-                logFileContentAsHex(dbFile, "DOWNLOAD")
+                Log.d("DOWNLOAD", "Neue DB erfolgreich eingesetzt")
 
             } catch (e: Exception) {
                 Log.e("DOWNLOAD", "Fehler beim Download oder Ersetzen der DB", e)
             }
         }
     }
-
-    private fun decryptDatabase(encryptedFile: File, outputFile: File) {
-        AES256Helper.decryptFile(encryptedFile, outputFile)
-    }
-
-
-    private fun logFileContentAsHex(file: File, tag: String) {
-        try {
-            val bytes = file.readBytes()
-            // Zum Loggen den Hex-String in Blöcke teilen, max 4000 Zeichen pro Log (Android Logcat Limit)
-            val hexString = bytes.joinToString(separator = "") { "%02X".format(it) }
-            val chunkSize = 4000
-            var start = 0
-            while (start < hexString.length) {
-                val end = (start + chunkSize).coerceAtMost(hexString.length)
-                Log.d(tag, "DB HEX Content: ${hexString.substring(start, end)}")
-                start = end
-            }
-        } catch (e: Exception) {
-            Log.e(tag, "Fehler beim Lesen der Datei zum Loggen", e)
-        }
-    }
 }
diff --git a/app/src/main/java/com/dano/test1/DatabaseUploader.kt b/app/src/main/java/com/dano/test1/DatabaseUploader.kt
index d1d4a1d..b076d97 100644
--- a/app/src/main/java/com/dano/test1/DatabaseUploader.kt
+++ b/app/src/main/java/com/dano/test1/DatabaseUploader.kt
@@ -6,17 +6,18 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import okhttp3.*
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.RequestBody.Companion.asRequestBody
 import java.io.File
 import java.io.IOException
 import kotlin.system.exitProcess
-import okhttp3.MediaType.Companion.toMediaTypeOrNull
-import okhttp3.RequestBody.Companion.asRequestBody
 
 object DatabaseUploader {
 
     private const val DB_NAME = "questionnaire_database"
     private const val ENCRYPTED_FILE_NAME = "exported_encrypted_database.db"
     private const val SERVER_UPLOAD_URL = "http://49.13.157.44/upload.php"
+    private const val API_TOKEN = "MEIN_SUPER_GEHEIMES_TOKEN_12345"
 
     private val client = OkHttpClient()
 
@@ -26,13 +27,12 @@ object DatabaseUploader {
                 val dbFile = context.getDatabasePath(DB_NAME)
                 if (!dbFile.exists()) return@launch
 
-                // Verschlüsselte Datei erstellen
                 val encryptedFile = File(context.cacheDir, ENCRYPTED_FILE_NAME)
                 AES256Helper.encryptFile(dbFile, encryptedFile)
 
                 Log.d("UPLOAD", "Datei verschlüsselt: ${encryptedFile.absolutePath}")
 
-                uploadFile(context, encryptedFile, dbFile)
+                uploadFile(encryptedFile, dbFile)
 
             } catch (e: Exception) {
                 Log.e("UPLOAD", "Fehler beim Hochladen der DB", e)
@@ -40,14 +40,14 @@ object DatabaseUploader {
         }
     }
 
-
-    private fun uploadFile(context: Context, file: File, originalDbFile: File) {
+    private fun uploadFile(file: File, originalDbFile: File) {
         val requestBody = MultipartBody.Builder()
             .setType(MultipartBody.FORM)
             .addFormDataPart(
                 "file", file.name,
                 file.asRequestBody("application/octet-stream".toMediaTypeOrNull())
             )
+            .addFormDataPart("token", API_TOKEN)
             .build()
 
         val request = Request.Builder()
@@ -63,16 +63,11 @@ object DatabaseUploader {
             override fun onResponse(call: Call, response: Response) {
                 if (response.isSuccessful) {
                     Log.d("UPLOAD", "Upload erfolgreich: ${response.message}")
-
-                    // Lokale DB-Datei löschen
                     if (originalDbFile.delete()) {
-                        Log.d("UPLOAD", "Lokale Datenbank erfolgreich gelöscht.")
-
-                        // App schließen
-                        Log.d("UPLOAD", "App wird beendet.")
+                        Log.d("UPLOAD", "Lokale DB gelöscht.")
                         exitProcess(0)
                     } else {
-                        Log.e("UPLOAD", "Löschen der lokalen Datenbank fehlgeschlagen.")
+                        Log.e("UPLOAD", "Löschen der lokalen DB fehlgeschlagen.")
                     }
                 } else {
                     Log.e("UPLOAD", "Upload fehlgeschlagen: ${response.code} ${response.message}")
@@ -80,21 +75,4 @@ object DatabaseUploader {
             }
         })
     }
-
-    private fun logFileContentAsHex(file: File, tag: String) {
-        try {
-            val bytes = file.readBytes()
-            // Zum Loggen den Hex-String in Blöcke teilen, max 4000 Zeichen pro Log (Android Logcat Limit)
-            val hexString = bytes.joinToString(separator = "") { "%02X".format(it) }
-            val chunkSize = 4000
-            var start = 0
-            while (start < hexString.length) {
-                val end = (start + chunkSize).coerceAtMost(hexString.length)
-                Log.d(tag, "DB HEX Content: ${hexString.substring(start, end)}")
-                start = end
-            }
-        } catch (e: Exception) {
-            Log.e(tag, "Fehler beim Lesen der Datei zum Loggen", e)
-        }
-    }
 }