diff --git a/README.md b/README.md
index ad2c2c0..967ea6a 100644
--- a/README.md
+++ b/README.md
@@ -110,6 +110,7 @@ app/src/main/java/com/pledgerio/app/
 - [Account types](docs/ACCOUNTS.md) — Owned vs counterparty accounts, type codes, transaction mapping
 - [Budgets](docs/BUDGETS.md) — Initial setup, expense groups, API mapping
 - [Transaction form redesign](docs/TRANSACTION_FORM_REDESIGN.md) — Planned UX for creating transactions (type-first flow, amount hero, contextual account labels)
+- [Invoice scan to transaction plan](docs/INVOICE_SCAN_TRANSACTION_PLAN.md) — Proposed OCR + text extraction pipeline to prefill new transactions
 - [Usability modes](docs/USABILITY_MODES.md) — Guided mode for novices and Power mode for advanced users
 - [Localization](docs/LOCALIZATION.md) — English, Dutch, and German (extensible)
 - [Architecture Decision Records](docs/adr/README.md) — Rationale for major technical choices
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index e0d03c6..e752b43 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -106,6 +106,7 @@ dependencies {
     implementation(libs.vico.compose.m3)
     implementation(libs.coil.compose)
     implementation(libs.androidx.core.splashscreen)
+    implementation(libs.mlkit.text.recognition)
     implementation(libs.androidx.compose.ui.text.google.fonts)
 
     testImplementation(libs.junit)
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 44962ef..3fd6433 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -38,6 +38,16 @@
             </intent-filter>
         </activity>
 
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.fileprovider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
+
         <!--
             Disable the default `WorkManagerInitializer` so WorkManager is initialized
             on-demand from `PledgerApp.onCreate()` AFTER Hilt has injected
diff --git a/app/src/main/java/com/pledgerio/app/data/ocr/InvoiceTextExtractor.kt b/app/src/main/java/com/pledgerio/app/data/ocr/InvoiceTextExtractor.kt
new file mode 100644
index 0000000..bc572fe
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/data/ocr/InvoiceTextExtractor.kt
@@ -0,0 +1,68 @@
+package com.pledgerio.app.data.ocr
+
+import android.content.Context
+import android.net.Uri
+import com.google.mlkit.vision.text.Text
+import com.google.android.gms.tasks.Task
+import com.google.mlkit.vision.common.InputImage
+import com.google.mlkit.vision.text.TextRecognition
+import com.google.mlkit.vision.text.latin.TextRecognizerOptions
+import com.pledgerio.app.R
+import com.pledgerio.app.util.Resource
+import dagger.hilt.android.qualifiers.ApplicationContext
+import javax.inject.Inject
+import javax.inject.Singleton
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+@Singleton
+class InvoiceTextExtractor @Inject constructor(
+    @ApplicationContext private val context: Context,
+) {
+    suspend fun extractText(uri: Uri): Resource<String> {
+        return try {
+            val image = InputImage.fromFilePath(context, uri)
+            val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)
+            val result = recognizer.process(image).awaitResult()
+            val text = formatResultText(result)
+            recognizer.close()
+            if (text.isBlank()) {
+                Resource.Error(context.getString(R.string.invoice_scan_error_no_readable_text))
+            } else {
+                Resource.Success(text)
+            }
+        } catch (e: Exception) {
+            Resource.Error(context.getString(R.string.invoice_scan_error_read_failed))
+        }
+    }
+
+    private fun formatResultText(result: Text): String {
+        val lines = result.textBlocks
+            .flatMap { block -> block.lines }
+            .mapNotNull { line ->
+                val box = line.boundingBox ?: return@mapNotNull null
+                OcrTextFormatter.OcrLine(
+                    text = line.text,
+                    left = box.left,
+                    top = box.top,
+                    right = box.right,
+                    bottom = box.bottom,
+                )
+            }
+        if (lines.isEmpty()) return result.text.trim()
+        return OcrTextFormatter.format(lines).trim()
+    }
+}
+
+private suspend fun <T> Task<T>.awaitResult(): T = suspendCancellableCoroutine { continuation ->
+    addOnSuccessListener { result ->
+        if (continuation.isActive) continuation.resume(result)
+    }
+    addOnFailureListener { error ->
+        if (continuation.isActive) continuation.resumeWith(Result.failure(error))
+    }
+    addOnCanceledListener {
+        if (continuation.isActive) continuation.cancel()
+    }
+}
diff --git a/app/src/main/java/com/pledgerio/app/data/ocr/OcrTextFormatter.kt b/app/src/main/java/com/pledgerio/app/data/ocr/OcrTextFormatter.kt
new file mode 100644
index 0000000..9849cb7
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/data/ocr/OcrTextFormatter.kt
@@ -0,0 +1,144 @@
+package com.pledgerio.app.data.ocr
+
+import kotlin.math.abs
+import kotlin.math.max
+
+/**
+ * Rebuilds OCR lines into a transaction-extraction friendly text stream.
+ *
+ * Invoices often contain a left description column and a right amount column.
+ * When OCR returns those as separate reading-order blocks, this formatter pairs
+ * rows by Y-position and emits tab-separated "description<TAB>amount" rows.
+ */
+object OcrTextFormatter {
+
+    data class OcrLine(
+        val text: String,
+        val left: Int,
+        val top: Int,
+        val right: Int,
+        val bottom: Int,
+    ) {
+        val cleanText: String = text.trim()
+        val centerX: Float = (left + right) / 2f
+        val centerY: Float = (top + bottom) / 2f
+        val height: Int = max(1, bottom - top)
+    }
+
+    private val amountLikeRegex = Regex(
+        pattern = """^[\p{Sc}]?\s*[-+]?\d{1,3}(?:[.,\s]\d{3})*(?:[.,]\d{2})?(?:\s?[A-Z]{3})?$|^[\p{Sc}]?\s*[-+]?\d+(?:[.,]\d{2})?(?:\s?[A-Z]{3})?$""",
+    )
+
+    fun format(lines: List<OcrLine>): String {
+        val cleaned = lines.mapNotNull { line ->
+            if (line.cleanText.isBlank()) null else line.copy(text = line.cleanText)
+        }
+        if (cleaned.isEmpty()) return ""
+
+        val twoColumn = tryFormatTwoColumnRows(cleaned)
+        if (twoColumn != null) {
+            return twoColumn.joinToString("\n")
+        }
+        return formatByRows(cleaned).joinToString("\n")
+    }
+
+    private fun tryFormatTwoColumnRows(lines: List<OcrLine>): List<String>? {
+        if (lines.size < 4) return null
+        val sortedByX = lines.sortedBy { it.centerX }
+        val minLeft = sortedByX.minOf { it.left }
+        val maxRight = sortedByX.maxOf { it.right }
+        val totalWidth = max(1, maxRight - minLeft)
+
+        var maxGap = 0f
+        var splitIndex = -1
+        for (index in 0 until sortedByX.lastIndex) {
+            val gap = sortedByX[index + 1].centerX - sortedByX[index].centerX
+            if (gap > maxGap) {
+                maxGap = gap
+                splitIndex = index
+            }
+        }
+
+        if (splitIndex < 0 || maxGap < totalWidth * 0.22f) return null
+
+        val splitX = (sortedByX[splitIndex].centerX + sortedByX[splitIndex + 1].centerX) / 2f
+        val leftColumn = lines.filter { it.centerX < splitX }.sortedBy { it.centerY }
+        val rightColumn = lines.filter { it.centerX >= splitX }.sortedBy { it.centerY }
+
+        if (leftColumn.isEmpty() || rightColumn.isEmpty()) return null
+
+        val rightAmountRatio = rightColumn.count { isAmountLike(it.cleanText) }.toFloat() / rightColumn.size
+        val leftAmountRatio = leftColumn.count { isAmountLike(it.cleanText) }.toFloat() / leftColumn.size
+        if (rightAmountRatio < 0.6f || leftAmountRatio > 0.45f) return null
+
+        val medianHeight = medianHeight(lines)
+        val yThreshold = max(8f, medianHeight * 0.95f)
+        val usedRightIndices = mutableSetOf<Int>()
+        val merged = mutableListOf<Pair<Float, String>>()
+
+        leftColumn.forEach { left ->
+            val candidate = rightColumn
+                .withIndex()
+                .filter { (index, line) ->
+                    index !in usedRightIndices &&
+                        abs(line.centerY - left.centerY) <= yThreshold
+                }
+                .minByOrNull { (_, line) -> abs(line.centerY - left.centerY) }
+
+            if (candidate != null) {
+                usedRightIndices += candidate.index
+                merged += ((left.centerY + candidate.value.centerY) / 2f) to
+                    "${left.cleanText}\t${candidate.value.cleanText}"
+            } else {
+                merged += left.centerY to left.cleanText
+            }
+        }
+
+        rightColumn.withIndex()
+            .filter { (index, _) -> index !in usedRightIndices }
+            .forEach { (_, line) ->
+                merged += line.centerY to line.cleanText
+            }
+
+        return merged
+            .sortedBy { it.first }
+            .map { it.second }
+    }
+
+    private fun formatByRows(lines: List<OcrLine>): List<String> {
+        val sorted = lines.sortedWith(compareBy<OcrLine> { it.centerY }.thenBy { it.left })
+        val threshold = max(8f, medianHeight(lines) * 0.65f)
+        val rows = mutableListOf<MutableList<OcrLine>>()
+
+        sorted.forEach { line ->
+            val current = rows.lastOrNull()
+            if (current == null) {
+                rows += mutableListOf(line)
+                return@forEach
+            }
+            val rowCenterY = current.map { it.centerY }.average().toFloat()
+            if (abs(line.centerY - rowCenterY) <= threshold) {
+                current += line
+            } else {
+                rows += mutableListOf(line)
+            }
+        }
+
+        return rows.map { row ->
+            row.sortedBy { it.left }
+                .joinToString(separator = "\t") { it.cleanText }
+        }
+    }
+
+    private fun medianHeight(lines: List<OcrLine>): Float {
+        val sorted = lines.map { it.height }.sorted()
+        if (sorted.isEmpty()) return 12f
+        return if (sorted.size % 2 == 1) {
+            sorted[sorted.size / 2].toFloat()
+        } else {
+            (sorted[sorted.size / 2 - 1] + sorted[sorted.size / 2]) / 2f
+        }
+    }
+
+    private fun isAmountLike(text: String): Boolean = amountLikeRegex.matches(text.trim())
+}
diff --git a/app/src/main/java/com/pledgerio/app/data/remote/api/PledgerApiService.kt b/app/src/main/java/com/pledgerio/app/data/remote/api/PledgerApiService.kt
index fd5548a..ab67ac6 100644
--- a/app/src/main/java/com/pledgerio/app/data/remote/api/PledgerApiService.kt
+++ b/app/src/main/java/com/pledgerio/app/data/remote/api/PledgerApiService.kt
@@ -109,6 +109,11 @@ interface PledgerApiService {
         @Query("destination") destination: String? = null,
     ): Response<TransactionClassificationSuggestionDto>
 
+    @POST("v2/api/ai/extract")
+    suspend fun extractTransactionFromText(
+        @Body request: TransactionExtract,
+    ): Response<Map<String, @JvmSuppressWildcards Any?>>
+
     // Categories
     @GET("v2/api/categories")
     suspend fun getCategories(
diff --git a/app/src/main/java/com/pledgerio/app/data/remote/dto/TransactionExtract.kt b/app/src/main/java/com/pledgerio/app/data/remote/dto/TransactionExtract.kt
new file mode 100644
index 0000000..7f53976
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/data/remote/dto/TransactionExtract.kt
@@ -0,0 +1,9 @@
+package com.pledgerio.app.data.remote.dto
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+data class TransactionExtract(
+    @Json(name = "text") val text: String
+)
diff --git a/app/src/main/java/com/pledgerio/app/data/repository/TransactionRepositoryImpl.kt b/app/src/main/java/com/pledgerio/app/data/repository/TransactionRepositoryImpl.kt
index 5986708..f057f54 100644
--- a/app/src/main/java/com/pledgerio/app/data/repository/TransactionRepositoryImpl.kt
+++ b/app/src/main/java/com/pledgerio/app/data/repository/TransactionRepositoryImpl.kt
@@ -5,10 +5,12 @@ import com.pledgerio.app.data.local.entity.TransactionEntity
 import com.pledgerio.app.data.remote.api.PledgerApiService
 import com.pledgerio.app.data.remote.dto.CreateTransactionRequest
 import com.pledgerio.app.data.remote.dto.TransactionDto
+import com.pledgerio.app.data.remote.dto.TransactionExtract
 import com.pledgerio.app.data.remote.dto.TransactionSplitDto
 import com.pledgerio.app.domain.model.TransactionSplit
 import com.pledgerio.app.domain.model.Transaction
 import com.pledgerio.app.domain.model.TransactionClassificationSuggestion
+import com.pledgerio.app.domain.model.TransactionExtractionDraft
 import com.pledgerio.app.domain.model.TransactionFilters
 import com.pledgerio.app.domain.model.TransactionType
 import com.pledgerio.app.domain.repository.PagedResult
@@ -235,6 +237,46 @@ class TransactionRepositoryImpl @Inject constructor(
         }
     }
 
+    override suspend fun extractTransactionFromText(text: String): Resource<TransactionExtractionDraft> {
+        if (text.isBlank()) return Resource.Error("No text found in document")
+        return try {
+            val response = apiService.extractTransactionFromText(
+                request = TransactionExtract(text),
+            )
+            if (response.isSuccessful) {
+                val body = response.body().orEmpty()
+                val sourceMap = body.readMap("source")
+                val targetMap = body.readMap("target")
+                val metadata = body.readMap("metadata")
+                val rawDate = body.readString("date") ?: body.readString("transactionDate")
+                Resource.Success(
+                    TransactionExtractionDraft(
+                        description = body.readString("description") ?: body.readString("title"),
+                        amount = body.readDouble("amount") ?: metadata.readDouble("amount"),
+                        currency = body.readString("currency"),
+                        date = rawDate?.let(::parseLocalDateOrNull),
+                        type = body.readString("type")?.let(::parseExtractionType),
+                        sourceName = body.readString("sourceName")
+                            ?: sourceMap.readString("name")
+                            ?: sourceMap.readString("label"),
+                        targetName = body.readString("targetName")
+                            ?: body.readString("counterparty")
+                            ?: targetMap.readString("name")
+                            ?: targetMap.readString("label")
+                            ?: body.readString("merchant"),
+                        confidence = body.readDouble("confidence")
+                            ?: metadata.readDouble("confidence"),
+                        rawText = text,
+                    ),
+                )
+            } else {
+                Resource.Error("Failed to extract transaction from text: ${response.code()}")
+            }
+        } catch (e: Exception) {
+            Resource.Error(e.message ?: "Network error")
+        }
+    }
+
     override fun getRecentTransactions(limit: Int): Flow<Resource<List<Transaction>>> = flow {
         emit(Resource.Loading)
         try {
@@ -286,4 +328,37 @@ class TransactionRepositoryImpl @Inject constructor(
                 ?: emptyList(),
         )
     }
+
+    private fun parseLocalDateOrNull(value: String): LocalDate? {
+        return runCatching { LocalDate.parse(value) }.getOrNull()
+    }
+
+    private fun parseExtractionType(value: String): TransactionType? {
+        return when (value.trim().uppercase()) {
+            "CREDIT", "EXPENSE" -> TransactionType.CREDIT
+            "DEBIT", "INCOME" -> TransactionType.DEBIT
+            "TRANSFER" -> TransactionType.TRANSFER
+            else -> null
+        }
+    }
+
+    private fun Map<String, Any?>.readString(key: String): String? {
+        val value = this[key] ?: return null
+        return (value as? String)?.trim()?.takeIf { it.isNotBlank() }
+    }
+
+    private fun Map<String, Any?>.readDouble(key: String): Double? {
+        val value = this[key] ?: return null
+        return when (value) {
+            is Number -> value.toDouble()
+            is String -> value.toDoubleOrNull()
+            else -> null
+        }
+    }
+
+    private fun Map<String, Any?>.readMap(key: String): Map<String, Any?> {
+        val value = this[key] ?: return emptyMap()
+        @Suppress("UNCHECKED_CAST")
+        return value as? Map<String, Any?> ?: emptyMap()
+    }
 }
diff --git a/app/src/main/java/com/pledgerio/app/domain/model/TransactionExtractionDraft.kt b/app/src/main/java/com/pledgerio/app/domain/model/TransactionExtractionDraft.kt
new file mode 100644
index 0000000..219a24b
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/domain/model/TransactionExtractionDraft.kt
@@ -0,0 +1,15 @@
+package com.pledgerio.app.domain.model
+
+import java.time.LocalDate
+
+data class TransactionExtractionDraft(
+    val description: String? = null,
+    val amount: Double? = null,
+    val currency: String? = null,
+    val date: LocalDate? = null,
+    val type: TransactionType? = null,
+    val sourceName: String? = null,
+    val targetName: String? = null,
+    val confidence: Double? = null,
+    val rawText: String? = null,
+)
diff --git a/app/src/main/java/com/pledgerio/app/domain/repository/TransactionRepository.kt b/app/src/main/java/com/pledgerio/app/domain/repository/TransactionRepository.kt
index 17b5220..2330b58 100644
--- a/app/src/main/java/com/pledgerio/app/domain/repository/TransactionRepository.kt
+++ b/app/src/main/java/com/pledgerio/app/domain/repository/TransactionRepository.kt
@@ -2,6 +2,7 @@ package com.pledgerio.app.domain.repository
 
 import com.pledgerio.app.domain.model.Transaction
 import com.pledgerio.app.domain.model.TransactionClassificationSuggestion
+import com.pledgerio.app.domain.model.TransactionExtractionDraft
 import com.pledgerio.app.domain.model.TransactionFilters
 import com.pledgerio.app.domain.model.TransactionSplit
 import com.pledgerio.app.domain.model.TransactionType
@@ -42,5 +43,6 @@ interface TransactionRepository {
         source: String? = null,
         destination: String? = null,
     ): Resource<TransactionClassificationSuggestion>
+    suspend fun extractTransactionFromText(text: String): Resource<TransactionExtractionDraft>
     fun getRecentTransactions(limit: Int = 5): Flow<Resource<List<Transaction>>>
 }
diff --git a/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardAddFabMenu.kt b/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardAddFabMenu.kt
index 516c135..2b6affa 100644
--- a/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardAddFabMenu.kt
+++ b/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardAddFabMenu.kt
@@ -26,6 +26,7 @@ import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.AccountBalance
 import androidx.compose.material.icons.filled.Add
 import androidx.compose.material.icons.filled.Receipt
+import androidx.compose.material.icons.filled.DocumentScanner
 import androidx.compose.material3.Card
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.FloatingActionButton
@@ -42,7 +43,9 @@ import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.unit.dp
+import com.pledgerio.app.R
 import com.pledgerio.app.ui.theme.EmeraldGreen
 
 @Composable
@@ -50,6 +53,7 @@ fun DashboardAddFabMenu(
     expanded: Boolean,
     onExpandedChange: (Boolean) -> Unit,
     onAddTransaction: () -> Unit,
+    onScanInvoice: () -> Unit,
     onAddAccount: () -> Unit,
     modifier: Modifier = Modifier,
 ) {
@@ -104,18 +108,28 @@ fun DashboardAddFabMenu(
                         AddMenuActionRow(
                             icon = Icons.Default.Receipt,
                             iconTint = EmeraldGreen,
-                            title = "New transaction",
-                            subtitle = "Record income, expense or transfer",
+                            title = stringResource(R.string.fab_new_transaction),
+                            subtitle = stringResource(R.string.fab_new_transaction_subtitle),
                             onClick = {
                                 onExpandedChange(false)
                                 onAddTransaction()
                             },
                         )
+                        AddMenuActionRow(
+                            icon = Icons.Default.DocumentScanner,
+                            iconTint = MaterialTheme.colorScheme.primary,
+                            title = stringResource(R.string.fab_scan_invoice),
+                            subtitle = stringResource(R.string.fab_scan_invoice_subtitle),
+                            onClick = {
+                                onExpandedChange(false)
+                                onScanInvoice()
+                            },
+                        )
                         AddMenuActionRow(
                             icon = Icons.Default.AccountBalance,
                             iconTint = MaterialTheme.colorScheme.tertiary,
-                            title = "New account",
-                            subtitle = "Add a bank account or wallet",
+                            title = stringResource(R.string.fab_new_account),
+                            subtitle = stringResource(R.string.fab_new_account_subtitle),
                             onClick = {
                                 onExpandedChange(false)
                                 onAddAccount()
diff --git a/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardScreen.kt b/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardScreen.kt
index bbcd415..be214a9 100644
--- a/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardScreen.kt
+++ b/app/src/main/java/com/pledgerio/app/ui/dashboard/DashboardScreen.kt
@@ -76,6 +76,7 @@ fun DashboardScreen(
     onNavigateToTransactions: () -> Unit,
     onNavigateToTransaction: (Long) -> Unit,
     onNavigateToAddTransaction: () -> Unit,
+    onNavigateToScanInvoice: () -> Unit,
     onNavigateToAddAccount: () -> Unit,
     onNavigateToSettings: () -> Unit,
     onNavigateToSearch: () -> Unit = {},
@@ -230,6 +231,7 @@ fun DashboardScreen(
                 expanded = showAddMenu,
                 onExpandedChange = { showAddMenu = it },
                 onAddTransaction = onNavigateToAddTransaction,
+                onScanInvoice = onNavigateToScanInvoice,
                 onAddAccount = onNavigateToAddAccount,
             )
         }
diff --git a/app/src/main/java/com/pledgerio/app/ui/navigation/NavGraph.kt b/app/src/main/java/com/pledgerio/app/ui/navigation/NavGraph.kt
index a759604..5fac9f4 100644
--- a/app/src/main/java/com/pledgerio/app/ui/navigation/NavGraph.kt
+++ b/app/src/main/java/com/pledgerio/app/ui/navigation/NavGraph.kt
@@ -27,6 +27,7 @@ import com.pledgerio.app.ui.settings.SettingsScreen
 import com.pledgerio.app.ui.transactions.TransactionDetailScreen
 import com.pledgerio.app.ui.transactions.TransactionFormScreen
 import com.pledgerio.app.ui.transactions.TransactionsScreen
+import com.pledgerio.app.ui.transactions.scan.InvoiceScanScreen
 
 @Composable
 fun NavGraph(
@@ -88,7 +89,10 @@ fun NavGraph(
                     navController.navigate(Screen.TransactionDetail.createRoute(id))
                 },
                 onNavigateToAddTransaction = {
-                    navController.navigate(Screen.AddTransaction.route)
+                    navController.navigate(Screen.AddTransaction.createRoute())
+                },
+                onNavigateToScanInvoice = {
+                    navController.navigate(Screen.InvoiceScan.route)
                 },
                 onNavigateToAddAccount = {
                     navController.navigate(Screen.AddAccount.createRoute())
@@ -132,7 +136,7 @@ fun NavGraph(
                     navController.navigate(Screen.TransactionDetail.createRoute(id))
                 },
                 onNavigateToAdd = {
-                    navController.navigate(Screen.AddTransaction.route)
+                    navController.navigate(Screen.AddTransaction.createRoute())
                 },
                 onNavigateToSettings = {
                     navController.navigate(Screen.Settings.route)
@@ -140,7 +144,39 @@ fun NavGraph(
             )
         }
 
-        composable(Screen.AddTransaction.route) {
+        composable(
+            route = Screen.AddTransaction.route,
+            arguments = listOf(
+                navArgument("prefillDescription") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillAmount") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillCurrency") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillDate") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillType") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillSource") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+                navArgument("prefillTarget") {
+                    type = NavType.StringType
+                    defaultValue = ""
+                },
+            ),
+        ) {
             TransactionFormScreen(
                 onNavigateBack = { navController.popBackStack() },
                 onNavigateToAddAccount = { typeCode ->
@@ -149,6 +185,28 @@ fun NavGraph(
             )
         }
 
+        composable(Screen.InvoiceScan.route) {
+            InvoiceScanScreen(
+                onNavigateBack = { navController.popBackStack() },
+                onUseDraft = { draft ->
+                    navController.navigate(
+                        Screen.AddTransaction.createRoute(
+                            prefillDescription = draft.description,
+                            prefillAmount = draft.amount?.toString(),
+                            prefillCurrency = draft.currency,
+                            prefillDate = draft.date?.toString(),
+                            prefillType = draft.type?.name,
+                            prefillSource = draft.sourceName,
+                            prefillTarget = draft.targetName,
+                        ),
+                    )
+                },
+                onManualEntry = {
+                    navController.navigate(Screen.AddTransaction.createRoute())
+                },
+            )
+        }
+
         composable(
             route = Screen.EditTransaction.route,
             arguments = listOf(navArgument("transactionId") { type = NavType.LongType }),
diff --git a/app/src/main/java/com/pledgerio/app/ui/navigation/Screen.kt b/app/src/main/java/com/pledgerio/app/ui/navigation/Screen.kt
index b0e2ffe..fc3d655 100644
--- a/app/src/main/java/com/pledgerio/app/ui/navigation/Screen.kt
+++ b/app/src/main/java/com/pledgerio/app/ui/navigation/Screen.kt
@@ -1,5 +1,7 @@
 package com.pledgerio.app.ui.navigation
 
+import android.net.Uri
+
 sealed class Screen(val route: String) {
     data object ServerSetup : Screen("server_setup?changeServer={changeServer}") {
         fun createRoute(changeServer: Boolean = false) =
@@ -17,7 +19,40 @@ sealed class Screen(val route: String) {
     data object TransactionDetail : Screen("transaction/{transactionId}") {
         fun createRoute(transactionId: Long) = "transaction/$transactionId"
     }
-    data object AddTransaction : Screen("transaction/add")
+    data object AddTransaction : Screen(
+        "transaction/add?" +
+            "prefillDescription={prefillDescription}&" +
+            "prefillAmount={prefillAmount}&" +
+            "prefillCurrency={prefillCurrency}&" +
+            "prefillDate={prefillDate}&" +
+            "prefillType={prefillType}&" +
+            "prefillSource={prefillSource}&" +
+            "prefillTarget={prefillTarget}"
+    ) {
+        fun createRoute(
+            prefillDescription: String? = null,
+            prefillAmount: String? = null,
+            prefillCurrency: String? = null,
+            prefillDate: String? = null,
+            prefillType: String? = null,
+            prefillSource: String? = null,
+            prefillTarget: String? = null,
+        ): String {
+            val params = listOf(
+                "prefillDescription" to prefillDescription,
+                "prefillAmount" to prefillAmount,
+                "prefillCurrency" to prefillCurrency,
+                "prefillDate" to prefillDate,
+                "prefillType" to prefillType,
+                "prefillSource" to prefillSource,
+                "prefillTarget" to prefillTarget,
+            ).joinToString("&") { (key, value) ->
+                "$key=${Uri.encode(value.orEmpty())}"
+            }
+            return "transaction/add?$params"
+        }
+    }
+    data object InvoiceScan : Screen("transaction/scan")
     data object EditTransaction : Screen("transaction/{transactionId}/edit") {
         fun createRoute(transactionId: Long) = "transaction/$transactionId/edit"
     }
diff --git a/app/src/main/java/com/pledgerio/app/ui/transactions/TransactionFormViewModel.kt b/app/src/main/java/com/pledgerio/app/ui/transactions/TransactionFormViewModel.kt
index aaa8f6f..175b4a4 100644
--- a/app/src/main/java/com/pledgerio/app/ui/transactions/TransactionFormViewModel.kt
+++ b/app/src/main/java/com/pledgerio/app/ui/transactions/TransactionFormViewModel.kt
@@ -173,6 +173,16 @@ data class TransactionFormUiState(
     }
 }
 
+private data class PrefillDraft(
+    val description: String?,
+    val amount: String?,
+    val currency: String?,
+    val date: LocalDate?,
+    val type: TransactionType?,
+    val sourceName: String?,
+    val targetName: String?,
+)
+
 @OptIn(FlowPreview::class, kotlinx.coroutines.ExperimentalCoroutinesApi::class)
 @HiltViewModel
 class TransactionFormViewModel @Inject constructor(
@@ -189,6 +199,11 @@ class TransactionFormViewModel @Inject constructor(
 ) : ViewModel() {
 
     private val editTransactionId: Long? = savedStateHandle.get<Long>("transactionId")
+    private val prefillDraft: PrefillDraft? = if (editTransactionId == null) {
+        savedStateHandle.toPrefillDraft()
+    } else {
+        null
+    }
 
     private val _uiState = MutableStateFlow(
         TransactionFormUiState(
@@ -1332,6 +1347,7 @@ class TransactionFormViewModel @Inject constructor(
                     _uiState.update { it.copy(ownedAccounts = result.data) }
                     if (editTransactionId == null) {
                         applyLastTransactionType()
+                        applyPrefillIfPresent()
                     } else {
                         _uiState.update { it.copy(isLoading = false) }
                     }
@@ -1356,6 +1372,47 @@ class TransactionFormViewModel @Inject constructor(
         }
     }
 
+    private fun applyPrefillIfPresent() {
+        val prefill = prefillDraft ?: return
+        _uiState.update { state ->
+            val type = prefill.type ?: state.type
+            state.copy(
+                type = type,
+                description = prefill.description ?: state.description,
+                amount = prefill.amount ?: state.amount,
+                currency = prefill.currency
+                    ?.takeIf { state.currencies.contains(it) }
+                    ?: state.currency,
+                date = prefill.date ?: state.date,
+                sourceAccountId = null,
+                sourceSelected = null,
+                sourceQuery = prefill.sourceName.orEmpty(),
+                sourceSuggestions = emptyList(),
+                targetAccountId = null,
+                targetSelected = null,
+                targetQuery = prefill.targetName.orEmpty(),
+                targetSuggestions = emptyList(),
+                error = null,
+            )
+        }
+
+        viewModelScope.launch {
+            val current = _uiState.value
+            if (
+                current.sourceInputKind != AccountInputKind.OWNED_DROPDOWN &&
+                current.sourceQuery.isNotBlank()
+            ) {
+                searchSourceAccounts(current.sourceQuery)
+            }
+            if (
+                current.targetInputKind != AccountInputKind.OWNED_DROPDOWN &&
+                current.targetQuery.isNotBlank()
+            ) {
+                searchTargetAccounts(current.targetQuery)
+            }
+        }
+    }
+
     private fun observeExperienceMode() {
         viewModelScope.launch {
             userPreferences.financeExperienceMode.collect { mode ->
@@ -1423,3 +1480,50 @@ internal fun List<TransactionSplitLineUi>.toDomainSplits(): List<TransactionSpli
         TransactionSplit(description = description, amount = amountValue)
     }
 }
+
+private fun SavedStateHandle.toPrefillDraft(): PrefillDraft? {
+    val description = get<String>("prefillDescription")?.trim().orEmpty().ifBlank { null }
+    val amount = get<String>("prefillAmount")?.trim().orEmpty().ifBlank { null }
+    val currency = get<String>("prefillCurrency")?.trim().orEmpty().ifBlank { null }
+    val date = get<String>("prefillDate")
+        ?.trim()
+        ?.takeIf { it.isNotBlank() }
+        ?.let { value -> runCatching { LocalDate.parse(value) }.getOrNull() }
+    val type = get<String>("prefillType")
+        ?.trim()
+        ?.takeIf { it.isNotBlank() }
+        ?.let(::toTransactionTypeOrNull)
+    val source = get<String>("prefillSource")?.trim().orEmpty().ifBlank { null }
+    val target = get<String>("prefillTarget")?.trim().orEmpty().ifBlank { null }
+
+    return if (
+        description == null &&
+        amount == null &&
+        currency == null &&
+        date == null &&
+        type == null &&
+        source == null &&
+        target == null
+    ) {
+        null
+    } else {
+        PrefillDraft(
+            description = description,
+            amount = amount,
+            currency = currency,
+            date = date,
+            type = type,
+            sourceName = source,
+            targetName = target,
+        )
+    }
+}
+
+private fun toTransactionTypeOrNull(raw: String): TransactionType? {
+    return when (raw.uppercase()) {
+        "CREDIT", "EXPENSE" -> TransactionType.CREDIT
+        "DEBIT", "INCOME" -> TransactionType.DEBIT
+        "TRANSFER" -> TransactionType.TRANSFER
+        else -> null
+    }
+}
diff --git a/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanScreen.kt b/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanScreen.kt
new file mode 100644
index 0000000..a094717
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanScreen.kt
@@ -0,0 +1,598 @@
+package com.pledgerio.app.ui.transactions.scan
+
+import android.Manifest
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import android.content.pm.PackageManager
+import androidx.activity.compose.rememberLauncherForActivityResult
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.asPaddingValues
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBars
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.filled.AutoAwesome
+import androidx.compose.material.icons.filled.CalendarMonth
+import androidx.compose.material.icons.filled.Description
+import androidx.compose.material.icons.filled.Image
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.material.icons.filled.PhotoCamera
+import androidx.compose.material.icons.filled.Sell
+import androidx.compose.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.LinearProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.core.content.ContextCompat
+import androidx.hilt.navigation.compose.hiltViewModel
+import androidx.core.content.FileProvider
+import coil.compose.AsyncImage
+import com.pledgerio.app.R
+import com.pledgerio.app.domain.model.TransactionExtractionDraft
+import com.pledgerio.app.ui.components.PledgerCard
+import com.pledgerio.app.ui.components.PledgerTopBar
+import com.pledgerio.app.util.formatCurrency
+import java.io.File
+import kotlin.math.roundToInt
+
+@Composable
+fun InvoiceScanScreen(
+    onNavigateBack: () -> Unit,
+    onUseDraft: (TransactionExtractionDraft) -> Unit,
+    onManualEntry: () -> Unit,
+    viewModel: InvoiceScanViewModel = hiltViewModel(),
+) {
+    val context = LocalContext.current
+    val uiState by viewModel.uiState.collectAsState()
+    val extractedDraft = uiState.draft
+    var pendingCameraUri by remember { mutableStateOf<Uri?>(null) }
+    val scanProgress = when (uiState.stage) {
+        InvoiceScanStage.IDLE -> 0f
+        InvoiceScanStage.READING_TEXT -> 0.4f
+        InvoiceScanStage.EXTRACTING_TRANSACTION -> 0.8f
+    }
+    val canExtract = uiState.extractedText.isNotBlank() && !uiState.isWorking
+    val imagePickerLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.GetContent(),
+    ) { uri ->
+        if (uri != null) viewModel.onImageSelected(uri)
+    }
+    val cameraLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.TakePicture(),
+    ) { success ->
+        val capturedUri = pendingCameraUri
+        pendingCameraUri = null
+        if (success && capturedUri != null) {
+            viewModel.onImageSelected(capturedUri)
+        }
+    }
+    val cameraPermissionLauncher = rememberLauncherForActivityResult(
+        contract = ActivityResultContracts.RequestPermission(),
+    ) { granted ->
+        if (granted) {
+            launchCameraCapture(
+                context = context,
+                onUriReady = { uri ->
+                    pendingCameraUri = uri
+                    cameraLauncher.launch(uri)
+                },
+                onFailure = {
+                    pendingCameraUri = null
+                    viewModel.onCameraCaptureLaunchFailed()
+                },
+                onNoCameraApp = viewModel::onCameraAppUnavailable,
+            )
+        } else {
+            viewModel.onCameraPermissionDenied()
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            PledgerTopBar(
+                title = stringResource(R.string.invoice_scan_title),
+                subtitle = stringResource(R.string.invoice_scan_subtitle),
+                navigationIcon = {
+                    IconButton(onClick = onNavigateBack) {
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.ArrowBack,
+                            contentDescription = stringResource(R.string.nav_back),
+                        )
+                    }
+                },
+            )
+        },
+        bottomBar = {
+            if (extractedDraft != null) {
+                PledgerCard(
+                    modifier = Modifier.padding(
+                        start = 16.dp,
+                        end = 16.dp,
+                        bottom = 8.dp,
+                    ),
+                ) {
+                    Text(
+                        text = stringResource(R.string.invoice_scan_ready_title),
+                        style = MaterialTheme.typography.titleMedium,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                    Spacer(modifier = Modifier.height(10.dp))
+                    Button(
+                        onClick = { onUseDraft(extractedDraft) },
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .defaultMinSize(minHeight = 48.dp),
+                    ) {
+                        Text(stringResource(R.string.invoice_scan_use_draft_button))
+                    }
+                    Spacer(modifier = Modifier.height(8.dp))
+                    OutlinedButton(
+                        onClick = onManualEntry,
+                        modifier = Modifier.fillMaxWidth(),
+                    ) {
+                        Text(stringResource(R.string.invoice_scan_manual_entry))
+                    }
+                }
+            }
+        },
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues)
+                .padding(horizontal = 16.dp)
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(12.dp),
+        ) {
+            Spacer(modifier = Modifier.height(4.dp))
+
+            PledgerCard {
+                Text(
+                    text = stringResource(R.string.invoice_scan_steps_title),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                )
+                Spacer(modifier = Modifier.height(8.dp))
+                StepPillRow(
+                    currentStage = uiState.stage,
+                    hasSelectedImage = uiState.selectedImageUri != null,
+                    hasDraft = uiState.draft != null,
+                )
+                if (uiState.isWorking) {
+                    Spacer(modifier = Modifier.height(12.dp))
+                    LinearProgressIndicator(
+                        progress = { scanProgress },
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(modifier = Modifier.height(6.dp))
+                    Text(
+                        text = when (uiState.stage) {
+                            InvoiceScanStage.READING_TEXT ->
+                                stringResource(R.string.invoice_scan_reading_text)
+                            InvoiceScanStage.EXTRACTING_TRANSACTION ->
+                                stringResource(R.string.invoice_scan_extracting_transaction)
+                            InvoiceScanStage.IDLE -> ""
+                        },
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+                }
+            }
+
+            PledgerCard {
+                Text(
+                    text = stringResource(R.string.invoice_scan_import_title),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = stringResource(R.string.invoice_scan_import_hint),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(modifier = Modifier.height(12.dp))
+                Button(
+                    onClick = {
+                        val hasPermission = ContextCompat.checkSelfPermission(
+                            context,
+                            Manifest.permission.CAMERA,
+                        ) == PackageManager.PERMISSION_GRANTED
+                        if (hasPermission) {
+                            launchCameraCapture(
+                                context = context,
+                                onUriReady = { uri ->
+                                    pendingCameraUri = uri
+                                    cameraLauncher.launch(uri)
+                                },
+                                onFailure = {
+                                    pendingCameraUri = null
+                                    viewModel.onCameraCaptureLaunchFailed()
+                                },
+                                onNoCameraApp = viewModel::onCameraAppUnavailable,
+                            )
+                        } else {
+                            cameraPermissionLauncher.launch(Manifest.permission.CAMERA)
+                        }
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .defaultMinSize(minHeight = 48.dp),
+                    enabled = !uiState.isWorking,
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.PhotoCamera,
+                        contentDescription = null,
+                    )
+                    Text(
+                        text = stringResource(R.string.invoice_scan_take_photo),
+                        modifier = Modifier.padding(start = 8.dp),
+                    )
+                }
+                Spacer(modifier = Modifier.height(8.dp))
+                OutlinedButton(
+                    onClick = { imagePickerLauncher.launch("image/*") },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .defaultMinSize(minHeight = 48.dp),
+                    enabled = !uiState.isWorking,
+                ) {
+                    Icon(
+                        imageVector = Icons.Default.Image,
+                        contentDescription = null,
+                    )
+                    Text(
+                        text = stringResource(R.string.invoice_scan_pick_image),
+                        modifier = Modifier.padding(start = 8.dp),
+                    )
+                }
+            }
+
+            uiState.selectedImageUri?.let { uri ->
+                PledgerCard {
+                    Text(
+                        text = stringResource(R.string.invoice_scan_preview_image_title),
+                        style = MaterialTheme.typography.titleSmall,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                    Spacer(modifier = Modifier.height(8.dp))
+                    AsyncImage(
+                        model = uri,
+                        contentDescription = stringResource(R.string.invoice_scan_image_preview),
+                        contentScale = ContentScale.Crop,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clip(RoundedCornerShape(12.dp))
+                            .height(180.dp),
+                    )
+                }
+            }
+
+            PledgerCard {
+                Text(
+                    text = stringResource(R.string.invoice_scan_text_title),
+                    style = MaterialTheme.typography.titleMedium,
+                    fontWeight = FontWeight.SemiBold,
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = stringResource(R.string.invoice_scan_text_hint),
+                    style = MaterialTheme.typography.bodySmall,
+                    color = MaterialTheme.colorScheme.onSurfaceVariant,
+                )
+                Spacer(modifier = Modifier.height(12.dp))
+                OutlinedTextField(
+                    value = uiState.extractedText,
+                    onValueChange = viewModel::onTextChanged,
+                    label = { Text(stringResource(R.string.invoice_scan_text_label)) },
+                    placeholder = { Text(stringResource(R.string.invoice_scan_text_placeholder)) },
+                    minLines = 4,
+                    maxLines = 10,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+                Spacer(modifier = Modifier.height(12.dp))
+                Button(
+                    onClick = viewModel::extractFromCurrentText,
+                    enabled = canExtract,
+                    modifier = Modifier.fillMaxWidth(),
+                ) {
+                    Icon(imageVector = Icons.Default.AutoAwesome, contentDescription = null)
+                    Text(
+                        text = stringResource(R.string.invoice_scan_extract_button),
+                        modifier = Modifier.padding(start = 8.dp),
+                    )
+                }
+            }
+
+            uiState.error?.takeIf { it.isNotBlank() }?.let { message ->
+                PledgerCard(
+                    modifier = Modifier
+                        .border(
+                            width = 1.dp,
+                            color = MaterialTheme.colorScheme.error.copy(alpha = 0.35f),
+                            shape = RoundedCornerShape(16.dp),
+                        ),
+                ) {
+                    Text(
+                        text = stringResource(R.string.error_title),
+                        style = MaterialTheme.typography.titleSmall,
+                        color = MaterialTheme.colorScheme.error,
+                        fontWeight = FontWeight.SemiBold,
+                    )
+                    Spacer(modifier = Modifier.height(4.dp))
+                    Text(
+                        text = message,
+                        style = MaterialTheme.typography.bodyMedium,
+                        color = MaterialTheme.colorScheme.onSurface,
+                    )
+                }
+            }
+
+            uiState.draft?.let { draft ->
+                DraftPreviewCard(
+                    draft = draft,
+                )
+            }
+
+            Spacer(
+                modifier = Modifier.height(
+                    WindowInsets.navigationBars.asPaddingValues().calculateBottomPadding() + 16.dp,
+                ),
+            )
+        }
+    }
+}
+
+private fun launchCameraCapture(
+    context: Context,
+    onUriReady: (Uri) -> Unit,
+    onFailure: () -> Unit,
+    onNoCameraApp: () -> Unit,
+) {
+    val cameraIntent = Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE)
+    if (cameraIntent.resolveActivity(context.packageManager) == null) {
+        onNoCameraApp()
+        return
+    }
+    runCatching {
+        createTempImageUri(context)
+    }.onSuccess(onUriReady).onFailure {
+        onFailure()
+    }
+}
+
+private fun createTempImageUri(context: Context): Uri {
+    val imageDirectory = File(context.cacheDir, "invoice-scan").apply {
+        if (!exists()) mkdirs()
+    }
+    val imageFile = File.createTempFile(
+        "invoice-scan-",
+        ".jpg",
+        imageDirectory,
+    )
+    return FileProvider.getUriForFile(
+        context,
+        "${context.packageName}.fileprovider",
+        imageFile,
+    )
+}
+
+@Composable
+private fun DraftPreviewCard(
+    draft: TransactionExtractionDraft,
+) {
+    val confidence = draft.confidence?.coerceIn(0.0, 1.0)
+    val confidencePercent = confidence?.times(100)?.roundToInt()
+    val confidenceColor = when {
+        confidence == null -> MaterialTheme.colorScheme.onSurfaceVariant
+        confidence >= 0.85 -> MaterialTheme.colorScheme.primary
+        confidence >= 0.60 -> MaterialTheme.colorScheme.tertiary
+        else -> MaterialTheme.colorScheme.error
+    }
+    val confidenceLabel = when {
+        confidence == null -> stringResource(R.string.settings_not_configured)
+        confidence >= 0.85 -> stringResource(R.string.invoice_scan_confidence_high, confidencePercent ?: 0)
+        confidence >= 0.60 -> stringResource(R.string.invoice_scan_confidence_medium, confidencePercent ?: 0)
+        else -> stringResource(R.string.invoice_scan_confidence_low, confidencePercent ?: 0)
+    }
+
+    PledgerCard {
+        Row(
+            horizontalArrangement = Arrangement.SpaceBetween,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        {
+            Text(
+                text = stringResource(R.string.invoice_scan_preview_title),
+                style = MaterialTheme.typography.titleMedium,
+                fontWeight = FontWeight.SemiBold,
+            )
+            ConfidenceBadge(
+                text = confidenceLabel,
+                color = confidenceColor,
+            )
+        }
+        Spacer(modifier = Modifier.height(8.dp))
+        DraftLine(
+            icon = Icons.Default.Description,
+            label = stringResource(R.string.transaction_description_label),
+            value = draft.description,
+        )
+        DraftLine(
+            icon = Icons.Default.Sell,
+            label = stringResource(R.string.transaction_amount_label),
+            value = draft.amount?.formatCurrency(draft.currency ?: "EUR"),
+        )
+        DraftLine(
+            icon = Icons.Default.CalendarMonth,
+            label = stringResource(R.string.transaction_date_label),
+            value = draft.date?.toString(),
+        )
+        DraftLine(
+            icon = Icons.Default.Person,
+            label = stringResource(R.string.invoice_scan_preview_counterparty),
+            value = draft.targetName ?: draft.sourceName,
+        )
+        if (draft.description.isNullOrBlank() || draft.amount == null) {
+            Spacer(modifier = Modifier.height(8.dp))
+            Text(
+                text = stringResource(R.string.invoice_scan_draft_incomplete_hint),
+                style = MaterialTheme.typography.bodySmall,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+        }
+    }
+}
+
+@Composable
+private fun DraftLine(
+    icon: ImageVector,
+    label: String,
+    value: String?,
+) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = null,
+            tint = MaterialTheme.colorScheme.onSurfaceVariant,
+            modifier = Modifier
+                .size(18.dp)
+                .padding(top = 2.dp),
+        )
+        Column(modifier = Modifier.weight(1f)) {
+            Text(
+                text = label,
+                style = MaterialTheme.typography.labelMedium,
+                color = MaterialTheme.colorScheme.onSurfaceVariant,
+            )
+            Text(
+                text = value?.takeIf { it.isNotBlank() } ?: stringResource(R.string.settings_not_configured),
+                style = MaterialTheme.typography.bodyMedium,
+            )
+        }
+    }
+    Spacer(modifier = Modifier.height(8.dp))
+}
+
+@Composable
+private fun ConfidenceBadge(
+    text: String,
+    color: Color,
+) {
+    Text(
+        text = text,
+        style = MaterialTheme.typography.labelSmall,
+        color = color,
+        fontWeight = FontWeight.SemiBold,
+        modifier = Modifier
+            .clip(CircleShape)
+            .background(color.copy(alpha = 0.16f))
+            .padding(horizontal = 10.dp, vertical = 6.dp),
+    )
+}
+
+@Composable
+private fun StepPillRow(
+    currentStage: InvoiceScanStage,
+    hasSelectedImage: Boolean,
+    hasDraft: Boolean,
+) {
+    Row(
+        horizontalArrangement = Arrangement.spacedBy(8.dp),
+        modifier = Modifier.fillMaxWidth(),
+    ) {
+        StepPill(
+            label = stringResource(R.string.invoice_scan_step_import),
+            isActive = currentStage == InvoiceScanStage.IDLE && !hasSelectedImage,
+            isCompleted = hasSelectedImage,
+            modifier = Modifier.weight(1f),
+        )
+        StepPill(
+            label = stringResource(R.string.invoice_scan_step_extract),
+            isActive = currentStage == InvoiceScanStage.READING_TEXT ||
+                currentStage == InvoiceScanStage.EXTRACTING_TRANSACTION ||
+                (hasSelectedImage && !hasDraft),
+            isCompleted = hasDraft,
+            modifier = Modifier.weight(1f),
+        )
+        StepPill(
+            label = stringResource(R.string.invoice_scan_step_review),
+            isActive = hasDraft,
+            isCompleted = hasDraft,
+            modifier = Modifier.weight(1f),
+        )
+    }
+}
+
+@Composable
+private fun StepPill(
+    label: String,
+    isActive: Boolean,
+    isCompleted: Boolean,
+    modifier: Modifier = Modifier,
+) {
+    val tone = when {
+        isCompleted -> MaterialTheme.colorScheme.primary
+        isActive -> MaterialTheme.colorScheme.tertiary
+        else -> MaterialTheme.colorScheme.onSurfaceVariant
+    }
+    val backgroundAlpha = when {
+        isCompleted -> 0.18f
+        isActive -> 0.18f
+        else -> 0.08f
+    }
+
+    Row(
+        modifier = modifier
+            .clip(RoundedCornerShape(999.dp))
+            .background(tone.copy(alpha = backgroundAlpha))
+            .padding(horizontal = 10.dp, vertical = 8.dp),
+        horizontalArrangement = Arrangement.Center,
+    ) {
+        Text(
+            text = label,
+            style = MaterialTheme.typography.labelSmall,
+            color = tone,
+            fontWeight = if (isActive || isCompleted) FontWeight.SemiBold else FontWeight.Medium,
+        )
+    }
+}
diff --git a/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanViewModel.kt b/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanViewModel.kt
new file mode 100644
index 0000000..0830a82
--- /dev/null
+++ b/app/src/main/java/com/pledgerio/app/ui/transactions/scan/InvoiceScanViewModel.kt
@@ -0,0 +1,150 @@
+package com.pledgerio.app.ui.transactions.scan
+
+import android.content.Context
+import android.net.Uri
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.pledgerio.app.R
+import com.pledgerio.app.data.ocr.InvoiceTextExtractor
+import com.pledgerio.app.domain.model.TransactionExtractionDraft
+import com.pledgerio.app.domain.repository.TransactionRepository
+import com.pledgerio.app.util.Resource
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.lifecycle.HiltViewModel
+import javax.inject.Inject
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+enum class InvoiceScanStage {
+    IDLE,
+    READING_TEXT,
+    EXTRACTING_TRANSACTION,
+}
+
+data class InvoiceScanUiState(
+    val stage: InvoiceScanStage = InvoiceScanStage.IDLE,
+    val selectedImageUri: Uri? = null,
+    val extractedText: String = "",
+    val draft: TransactionExtractionDraft? = null,
+    val error: String? = null,
+) {
+    val isWorking: Boolean
+        get() = stage != InvoiceScanStage.IDLE
+}
+
+@HiltViewModel
+class InvoiceScanViewModel @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val invoiceTextExtractor: InvoiceTextExtractor,
+    private val transactionRepository: TransactionRepository,
+) : ViewModel() {
+
+    private val _uiState = MutableStateFlow(InvoiceScanUiState())
+    val uiState: StateFlow<InvoiceScanUiState> = _uiState.asStateFlow()
+
+    fun onTextChanged(value: String) {
+        _uiState.update {
+            it.copy(
+                extractedText = value,
+                error = null,
+                draft = null,
+            )
+        }
+    }
+
+    fun onImageSelected(uri: Uri) {
+        viewModelScope.launch {
+            _uiState.update {
+                it.copy(
+                    selectedImageUri = uri,
+                    stage = InvoiceScanStage.READING_TEXT,
+                    error = null,
+                    draft = null,
+                )
+            }
+            when (val ocrResult = invoiceTextExtractor.extractText(uri)) {
+                is Resource.Success -> {
+                    _uiState.update {
+                        it.copy(
+                            extractedText = ocrResult.data,
+                            stage = InvoiceScanStage.EXTRACTING_TRANSACTION,
+                        )
+                    }
+                    extractFromCurrentText()
+                }
+
+                is Resource.Error -> {
+                    _uiState.update {
+                        it.copy(
+                            stage = InvoiceScanStage.IDLE,
+                            error = ocrResult.message,
+                        )
+                    }
+                }
+
+                is Resource.Loading -> Unit
+            }
+        }
+    }
+
+    fun onCameraCaptureLaunchFailed() {
+        _uiState.update {
+            it.copy(error = context.getString(R.string.invoice_scan_error_open_camera_failed))
+        }
+    }
+
+    fun onCameraPermissionDenied() {
+        _uiState.update {
+            it.copy(error = context.getString(R.string.invoice_scan_error_camera_permission_denied))
+        }
+    }
+
+    fun onCameraAppUnavailable() {
+        _uiState.update {
+            it.copy(error = context.getString(R.string.invoice_scan_error_no_camera_app))
+        }
+    }
+
+    fun extractFromCurrentText() {
+        val text = _uiState.value.extractedText.trim()
+        if (text.isBlank()) {
+            _uiState.update {
+                it.copy(error = context.getString(R.string.invoice_scan_error_no_text))
+            }
+            return
+        }
+        viewModelScope.launch {
+            _uiState.update {
+                it.copy(
+                    stage = InvoiceScanStage.EXTRACTING_TRANSACTION,
+                    error = null,
+                    draft = null,
+                )
+            }
+            when (val result = transactionRepository.extractTransactionFromText(text)) {
+                is Resource.Success -> {
+                    _uiState.update {
+                        it.copy(
+                            stage = InvoiceScanStage.IDLE,
+                            draft = result.data.copy(rawText = text),
+                        )
+                    }
+                }
+
+                is Resource.Error -> {
+                    _uiState.update {
+                        it.copy(
+                            stage = InvoiceScanStage.IDLE,
+                            error = context.getString(R.string.invoice_scan_error_extract_failed),
+                        )
+                    }
+                }
+
+                is Resource.Loading -> Unit
+            }
+        }
+    }
+}
diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml
index 7dd8162..da59c7e 100644
--- a/app/src/main/res/values-de/strings.xml
+++ b/app/src/main/res/values-de/strings.xml
@@ -175,6 +175,8 @@
     <string name="dashboard_expenses">Ausgaben</string>
     <string name="fab_new_transaction">Neue Transaktion</string>
     <string name="fab_new_transaction_subtitle">Einnahme, Ausgabe oder Überweisung erfassen</string>
+    <string name="fab_scan_invoice">Rechnung/Beleg scannen</string>
+    <string name="fab_scan_invoice_subtitle">Text extrahieren und Transaktion vorbefüllen</string>
     <string name="fab_new_account">Neues Konto</string>
     <string name="fab_new_account_subtitle">Bankkonto oder Wallet hinzufügen</string>
 
@@ -404,6 +406,42 @@
     <string name="transaction_owned_account_no_accounts">Keine Konten verfügbar</string>
     <string name="transaction_owned_account_no_matches">Keine Treffer</string>
     <string name="transaction_template_default_name">Neue Vorlage</string>
+    <string name="invoice_scan_title">Rechnung oder Beleg scannen</string>
+    <string name="invoice_scan_subtitle">Bild importieren, Text extrahieren und Entwurf prüfen</string>
+    <string name="invoice_scan_steps_title">3-Schritte-Ablauf</string>
+    <string name="invoice_scan_step_import">1. Import</string>
+    <string name="invoice_scan_step_extract">2. Extrahieren</string>
+    <string name="invoice_scan_step_review">3. Prüfen</string>
+    <string name="invoice_scan_import_title">Schritt 1 — Rechnungsbild importieren</string>
+    <string name="invoice_scan_import_hint">Wähle ein klares Foto oder einen Screenshot deines Belegs.</string>
+    <string name="invoice_scan_take_photo">Foto aufnehmen</string>
+    <string name="invoice_scan_pick_image">Rechnungsbild auswählen</string>
+    <string name="invoice_scan_preview_image_title">Bildvorschau</string>
+    <string name="invoice_scan_reading_text">Text aus Bild wird gelesen…</string>
+    <string name="invoice_scan_extracting_transaction">Transaktionsdetails werden extrahiert…</string>
+    <string name="invoice_scan_image_preview">Ausgewähltes Rechnungsbild</string>
+    <string name="invoice_scan_text_title">Schritt 2 — Extrahierten Text prüfen</string>
+    <string name="invoice_scan_text_hint">Korrigiere OCR-Fehler, bevor du Transaktionsdetails extrahierst.</string>
+    <string name="invoice_scan_text_label">Extrahierter Text</string>
+    <string name="invoice_scan_text_placeholder">Der Rechnungstext erscheint hier nach der OCR.</string>
+    <string name="invoice_scan_extract_button">Transaktionsentwurf extrahieren</string>
+    <string name="invoice_scan_preview_title">Entwurfsvorschau</string>
+    <string name="invoice_scan_preview_counterparty">Gegenpartei</string>
+    <string name="invoice_scan_preview_confidence">Sicherheit</string>
+    <string name="invoice_scan_confidence_high">Hohe Sicherheit · %1$d%%</string>
+    <string name="invoice_scan_confidence_medium">Mittlere Sicherheit · %1$d%%</string>
+    <string name="invoice_scan_confidence_low">Niedrige Sicherheit · %1$d%%</string>
+    <string name="invoice_scan_ready_title">Schritt 3 — Bereit zum Fortfahren</string>
+    <string name="invoice_scan_manual_entry">Mit manueller Eingabe fortfahren</string>
+    <string name="invoice_scan_draft_incomplete_hint">Einige Werte fehlen. Du kannst fortfahren und sie im Transaktionsformular ergänzen.</string>
+    <string name="invoice_scan_error_no_text">Kein Text zum Extrahieren. Importiere zuerst ein Rechnungsfoto.</string>
+    <string name="invoice_scan_error_no_readable_text">Kein lesbarer Text gefunden. Versuche ein klareres Foto.</string>
+    <string name="invoice_scan_error_read_failed">Text aus dem ausgewählten Bild konnte nicht gelesen werden.</string>
+    <string name="invoice_scan_error_camera_permission_denied">Kameraberechtigung ist erforderlich, um ein Foto aufzunehmen.</string>
+    <string name="invoice_scan_error_no_camera_app">Auf diesem Gerät ist keine Kamera-App verfügbar.</string>
+    <string name="invoice_scan_error_open_camera_failed">Kamera konnte nicht geöffnet werden. Bitte versuche es erneut oder wähle ein bestehendes Bild aus.</string>
+    <string name="invoice_scan_error_extract_failed">Transaktionsdetails konnten aus diesem Text nicht extrahiert werden. Bitte prüfe den Text und versuche es erneut.</string>
+    <string name="invoice_scan_use_draft_button">Entwurf im Transaktionsformular verwenden</string>
     <string name="filter_autocomplete_no_results">Keine Ergebnisse</string>
     <string name="content_description_clear">Löschen</string>
 
diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml
index 62cd2aa..e57ceac 100644
--- a/app/src/main/res/values-nl/strings.xml
+++ b/app/src/main/res/values-nl/strings.xml
@@ -175,6 +175,8 @@
     <string name="dashboard_expenses">Uitgaven</string>
     <string name="fab_new_transaction">Nieuwe transactie</string>
     <string name="fab_new_transaction_subtitle">Inkomsten, uitgaven of overboeking registreren</string>
+    <string name="fab_scan_invoice">Factuur/rekening scannen</string>
+    <string name="fab_scan_invoice_subtitle">Tekst ophalen en transactie vooraf invullen</string>
     <string name="fab_new_account">Nieuwe rekening</string>
     <string name="fab_new_account_subtitle">Bankrekening of portemonnee toevoegen</string>
 
@@ -404,6 +406,42 @@
     <string name="transaction_owned_account_no_accounts">Geen rekeningen beschikbaar</string>
     <string name="transaction_owned_account_no_matches">Geen resultaten</string>
     <string name="transaction_template_default_name">Nieuw sjabloon</string>
+    <string name="invoice_scan_title">Factuur of rekening scannen</string>
+    <string name="invoice_scan_subtitle">Importeer een afbeelding, haal tekst op en controleer het concept</string>
+    <string name="invoice_scan_steps_title">Stappenplan in 3 stappen</string>
+    <string name="invoice_scan_step_import">1. Importeren</string>
+    <string name="invoice_scan_step_extract">2. Uitlezen</string>
+    <string name="invoice_scan_step_review">3. Controleren</string>
+    <string name="invoice_scan_import_title">Stap 1 — Factuurafbeelding importeren</string>
+    <string name="invoice_scan_import_hint">Kies een duidelijke foto of screenshot van je rekening.</string>
+    <string name="invoice_scan_take_photo">Foto maken</string>
+    <string name="invoice_scan_pick_image">Factuurafbeelding kiezen</string>
+    <string name="invoice_scan_preview_image_title">Voorbeeldafbeelding</string>
+    <string name="invoice_scan_reading_text">Tekst uit afbeelding lezen…</string>
+    <string name="invoice_scan_extracting_transaction">Transactiegegevens extraheren…</string>
+    <string name="invoice_scan_image_preview">Geselecteerde factuurafbeelding</string>
+    <string name="invoice_scan_text_title">Stap 2 — Opgehaalde tekst controleren</string>
+    <string name="invoice_scan_text_hint">Corrigeer OCR-fouten voordat je transactiegegevens extraheert.</string>
+    <string name="invoice_scan_text_label">Opgehaalde tekst</string>
+    <string name="invoice_scan_text_placeholder">De factuurtekst verschijnt hier na OCR.</string>
+    <string name="invoice_scan_extract_button">Transactieconcept extraheren</string>
+    <string name="invoice_scan_preview_title">Conceptvoorbeeld</string>
+    <string name="invoice_scan_preview_counterparty">Tegenpartij</string>
+    <string name="invoice_scan_preview_confidence">Betrouwbaarheid</string>
+    <string name="invoice_scan_confidence_high">Hoge betrouwbaarheid · %1$d%%</string>
+    <string name="invoice_scan_confidence_medium">Gemiddelde betrouwbaarheid · %1$d%%</string>
+    <string name="invoice_scan_confidence_low">Lage betrouwbaarheid · %1$d%%</string>
+    <string name="invoice_scan_ready_title">Stap 3 — Klaar om door te gaan</string>
+    <string name="invoice_scan_manual_entry">Doorgaan met handmatige invoer</string>
+    <string name="invoice_scan_draft_incomplete_hint">Sommige waarden ontbreken. Je kunt doorgaan en ze invullen in het transactiescherm.</string>
+    <string name="invoice_scan_error_no_text">Geen tekst om te extraheren. Importeer eerst een factuurfoto.</string>
+    <string name="invoice_scan_error_no_readable_text">Geen leesbare tekst gevonden. Probeer een duidelijkere foto.</string>
+    <string name="invoice_scan_error_read_failed">Kon geen tekst lezen uit de geselecteerde afbeelding.</string>
+    <string name="invoice_scan_error_camera_permission_denied">Cameratoestemming is vereist om een foto te maken.</string>
+    <string name="invoice_scan_error_no_camera_app">Er is geen camera-app beschikbaar op dit apparaat.</string>
+    <string name="invoice_scan_error_open_camera_failed">Kon de camera niet openen. Probeer het opnieuw of kies een bestaande afbeelding.</string>
+    <string name="invoice_scan_error_extract_failed">Kon geen transactiegegevens uit deze tekst halen. Controleer en probeer opnieuw.</string>
+    <string name="invoice_scan_use_draft_button">Concept gebruiken in transactiescherm</string>
     <string name="filter_autocomplete_no_results">Geen resultaten</string>
     <string name="content_description_clear">Wissen</string>
 
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml
index 4f9add0..f3e80d7 100644
--- a/app/src/main/res/values/strings.xml
+++ b/app/src/main/res/values/strings.xml
@@ -180,6 +180,8 @@
     <string name="dashboard_expenses">Expenses</string>
     <string name="fab_new_transaction">New transaction</string>
     <string name="fab_new_transaction_subtitle">Record income, expense or transfer</string>
+    <string name="fab_scan_invoice">Scan invoice/bill</string>
+    <string name="fab_scan_invoice_subtitle">Extract text and prefill a transaction</string>
     <string name="fab_new_account">New account</string>
     <string name="fab_new_account_subtitle">Add a bank account or wallet</string>
 
@@ -405,6 +407,42 @@
     <string name="transaction_owned_account_no_accounts">No accounts available</string>
     <string name="transaction_owned_account_no_matches">No matches</string>
     <string name="transaction_template_default_name">New template</string>
+    <string name="invoice_scan_title">Scan invoice or bill</string>
+    <string name="invoice_scan_subtitle">Import an image, extract text, and review the draft</string>
+    <string name="invoice_scan_steps_title">3-step flow</string>
+    <string name="invoice_scan_step_import">1. Import</string>
+    <string name="invoice_scan_step_extract">2. Extract</string>
+    <string name="invoice_scan_step_review">3. Review</string>
+    <string name="invoice_scan_import_title">Step 1 — Import invoice image</string>
+    <string name="invoice_scan_import_hint">Choose a clear photo or screenshot of your bill.</string>
+    <string name="invoice_scan_take_photo">Take a photo</string>
+    <string name="invoice_scan_pick_image">Pick invoice image</string>
+    <string name="invoice_scan_preview_image_title">Image preview</string>
+    <string name="invoice_scan_reading_text">Reading text from image…</string>
+    <string name="invoice_scan_extracting_transaction">Extracting transaction details…</string>
+    <string name="invoice_scan_image_preview">Selected invoice image</string>
+    <string name="invoice_scan_text_title">Step 2 — Review extracted text</string>
+    <string name="invoice_scan_text_hint">Fix OCR mistakes before extracting transaction details.</string>
+    <string name="invoice_scan_text_label">Extracted text</string>
+    <string name="invoice_scan_text_placeholder">The invoice text will appear here after OCR.</string>
+    <string name="invoice_scan_extract_button">Extract transaction draft</string>
+    <string name="invoice_scan_preview_title">Draft preview</string>
+    <string name="invoice_scan_preview_counterparty">Counterparty</string>
+    <string name="invoice_scan_preview_confidence">Confidence</string>
+    <string name="invoice_scan_confidence_high">High confidence · %1$d%%</string>
+    <string name="invoice_scan_confidence_medium">Medium confidence · %1$d%%</string>
+    <string name="invoice_scan_confidence_low">Low confidence · %1$d%%</string>
+    <string name="invoice_scan_ready_title">Step 3 — Ready to continue</string>
+    <string name="invoice_scan_manual_entry">Continue with manual entry</string>
+    <string name="invoice_scan_draft_incomplete_hint">Some values are missing. You can continue and complete them in the transaction form.</string>
+    <string name="invoice_scan_error_no_text">No text to extract. Import an invoice photo first.</string>
+    <string name="invoice_scan_error_no_readable_text">No readable text found. Try a clearer photo.</string>
+    <string name="invoice_scan_error_read_failed">Could not read text from the selected image.</string>
+    <string name="invoice_scan_error_camera_permission_denied">Camera permission is required to take a photo.</string>
+    <string name="invoice_scan_error_no_camera_app">No camera app is available on this device.</string>
+    <string name="invoice_scan_error_open_camera_failed">Could not open camera. Please try again or choose an existing image.</string>
+    <string name="invoice_scan_error_extract_failed">Couldn\'t extract transaction details from this text. Please review and try again.</string>
+    <string name="invoice_scan_use_draft_button">Use draft in transaction form</string>
     <string name="filter_autocomplete_no_results">No results</string>
     <string name="content_description_clear">Clear</string>
     <string name="content_description_collapse">Collapse</string>
diff --git a/app/src/main/res/xml/file_paths.xml b/app/src/main/res/xml/file_paths.xml
new file mode 100644
index 0000000..81e43db
--- /dev/null
+++ b/app/src/main/res/xml/file_paths.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths xmlns:android="http://schemas.android.com/apk/res/android">
+    <cache-path
+        name="invoice_scan_images"
+        path="invoice-scan/" />
+</paths>
diff --git a/app/src/test/java/com/pledgerio/app/data/ocr/OcrTextFormatterTest.kt b/app/src/test/java/com/pledgerio/app/data/ocr/OcrTextFormatterTest.kt
new file mode 100644
index 0000000..85f2fb5
--- /dev/null
+++ b/app/src/test/java/com/pledgerio/app/data/ocr/OcrTextFormatterTest.kt
@@ -0,0 +1,42 @@
+package com.pledgerio.app.data.ocr
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class OcrTextFormatterTest {
+
+    @Test
+    fun `formats two-column invoice rows as paired lines`() {
+        val lines = listOf(
+            OcrTextFormatter.OcrLine("Bread", left = 10, top = 10, right = 180, bottom = 32),
+            OcrTextFormatter.OcrLine("2.50", left = 280, top = 11, right = 340, bottom = 31),
+            OcrTextFormatter.OcrLine("Milk", left = 10, top = 40, right = 180, bottom = 62),
+            OcrTextFormatter.OcrLine("1.20", left = 280, top = 41, right = 340, bottom = 61),
+        )
+
+        val formatted = OcrTextFormatter.format(lines)
+        val rows = formatted.lines()
+
+        assertEquals(2, rows.size)
+        assertEquals("Bread\t2.50", rows[0])
+        assertEquals("Milk\t1.20", rows[1])
+    }
+
+    @Test
+    fun `keeps single-column OCR order when no amount column exists`() {
+        val lines = listOf(
+            OcrTextFormatter.OcrLine("Invoice ACME BV", left = 10, top = 10, right = 210, bottom = 32),
+            OcrTextFormatter.OcrLine("Date 2026-05-18", left = 10, top = 40, right = 210, bottom = 62),
+            OcrTextFormatter.OcrLine("Thank you for your purchase", left = 10, top = 70, right = 250, bottom = 92),
+        )
+
+        val formatted = OcrTextFormatter.format(lines)
+        val rows = formatted.lines()
+
+        assertEquals(3, rows.size)
+        assertTrue(rows[0].contains("Invoice ACME BV"))
+        assertTrue(rows[1].contains("Date 2026-05-18"))
+        assertTrue(rows[2].contains("Thank you for your purchase"))
+    }
+}
diff --git a/app/src/test/java/com/pledgerio/app/ui/accounts/AccountTypePickerTest.kt b/app/src/test/java/com/pledgerio/app/ui/accounts/AccountTypePickerTest.kt
index c1f7125..f468b7b 100644
--- a/app/src/test/java/com/pledgerio/app/ui/accounts/AccountTypePickerTest.kt
+++ b/app/src/test/java/com/pledgerio/app/ui/accounts/AccountTypePickerTest.kt
@@ -47,7 +47,9 @@ class AccountTypePickerTest {
     )
 
     assertEquals(2, entries.size)
-    val card = entries.single { (it.label as AccountPickerLabel.Custom).value == "Credit card" }
+    val card = entries.single { it.soloTypeCode == "credit_card" }
+    assertTrue(card.label is AccountPickerLabel.Custom)
+    assertEquals("Credit card", (card.label as AccountPickerLabel.Custom).value)
     assertNull(card.jointTypeCode)
     assertNull(card.family)
     assertEquals("credit_card", card.soloTypeCode)
diff --git a/docs/INVOICE_SCAN_TRANSACTION_PLAN.md b/docs/INVOICE_SCAN_TRANSACTION_PLAN.md
new file mode 100644
index 0000000..f3e81ae
--- /dev/null
+++ b/docs/INVOICE_SCAN_TRANSACTION_PLAN.md
@@ -0,0 +1,258 @@
+# Invoice and bill scan to transaction: design plan
+
+This document proposes an end-to-end flow for scanning invoices/bills, extracting text, and turning that into a prefilled transaction.
+
+## 1) Goal
+
+Allow users to:
+
+1. Capture or import an invoice/bill image.
+2. Extract readable text from it.
+3. Reuse the existing backend API that converts text into transaction data.
+4. Open the existing transaction form with prefilled values for user confirmation.
+5. Save as a normal transaction via `POST /v2/api/transactions`.
+
+This keeps final user control and avoids silent bookkeeping mistakes.
+
+---
+
+## 2) Product flow (user journey)
+
+### Entry points
+
+- Dashboard FAB menu: add a third action, **Scan invoice/bill**.
+- Transaction list screen (optional): toolbar action for scan.
+
+### Happy path
+
+1. User taps **Scan invoice/bill**.
+2. User chooses **Camera** or **Import from gallery/PDF**.
+3. App performs OCR and shows progress.
+4. App sends extracted text to the existing backend text-to-transaction endpoint.
+5. App opens a **Review draft** step:
+   - amount
+   - date
+   - merchant/payee
+   - description
+   - suggested type (expense/income/transfer)
+   - currency
+   - confidence and missing fields
+6. User confirms or edits fields.
+7. App opens `TransactionFormScreen` prefilled.
+8. User taps **Create transaction** (existing behavior).
+
+### Failure path
+
+- If OCR fails: user can retry capture/import or switch to manual transaction.
+- If extraction API fails: keep OCR text visible and allow manual entry with text copy support.
+- If confidence is low: flag uncertain fields and require manual confirmation.
+
+---
+
+## 3) Architecture fit (Clean Architecture)
+
+## UI layer
+
+Add:
+
+- `InvoiceScanScreen` (capture/import, progress, retry)
+- `InvoiceScanReviewScreen` (draft review and corrections)
+- Navigation route(s):
+  - `transaction/scan`
+  - `transaction/scan/review`
+
+Reuse:
+
+- Existing `TransactionFormScreen` for final creation.
+- Existing account pickers/autocomplete for source/destination corrections.
+
+## Domain layer
+
+Add use cases:
+
+- `ExtractTextFromDocumentUseCase` (OCR abstraction)
+- `ExtractTransactionFromTextUseCase` (calls existing backend extraction API)
+- `BuildTransactionDraftUseCase` (maps OCR + API output to form state)
+
+Add models:
+
+- `ScannedDocument` (uri/pages, optional image hash, source)
+- `OcrResult` (fullText, line blocks, locale hint)
+- `TransactionExtractionDraft` (prefill candidates + confidence per field)
+
+## Data layer
+
+Add repository interfaces + implementations:
+
+- `DocumentTextExtractor`:
+  - on-device OCR engine (ML Kit Text Recognition)
+- `TransactionExtractionRepository`:
+  - Retrofit call to existing backend text-extraction endpoint
+
+Keep image handling local by default. Send text only unless backend image upload becomes mandatory.
+
+---
+
+## 4) API integration plan
+
+The backend capability already exists: "extract transaction information from text".
+The Android client should integrate it as a draft-generation step, not an auto-save step.
+
+### Request payload (proposed)
+
+Use extracted OCR text and optional context:
+
+- `text` (required)
+- `locale` (optional)
+- `defaultCurrency` (optional)
+- `timezone` (optional)
+- `hints` (optional; e.g., expected type = expense)
+
+### Response mapping (proposed)
+
+Expected output fields mapped into existing transaction form state:
+
+- amount
+- currency
+- date
+- description
+- merchant / counterparty name
+- transaction type
+- optional category/tag suggestions
+- per-field confidence
+
+### Retrofit addition
+
+Add a new method to `PledgerApiService` for the existing extraction endpoint and wire it through `TransactionRepository` (or a dedicated extraction repository) so ViewModels stay thin.
+
+---
+
+## 5) OCR strategy
+
+### Phase 1 choice: on-device OCR first
+
+Use ML Kit text recognition locally:
+
+- Better privacy (no image upload)
+- Fast feedback
+- Works with flaky connectivity (only extraction API call needs network)
+
+### Preprocessing for quality
+
+Before OCR:
+
+- auto-crop document bounds (if available)
+- perspective correction
+- grayscale/contrast normalization
+- rotate by EXIF + orientation detection
+
+These steps significantly improve extraction quality on receipts.
+
+---
+
+## 6) Confidence and validation strategy
+
+Never create transactions automatically from scan results.
+
+Rules:
+
+- Always require user confirmation before save.
+- Highlight uncertain fields (confidence below threshold).
+- If critical fields are missing (`amount`, `date`, or payee/account side), block one-tap continue and prompt completion.
+- Keep raw OCR text expandable so user can verify.
+
+Suggested thresholds:
+
+- `>= 0.85`: prefill silently
+- `0.60 - 0.84`: prefill with warning badge
+- `< 0.60`: leave empty + ask user input
+
+---
+
+## 7) UX details
+
+- Progress states:
+  - "Preparing image"
+  - "Reading text"
+  - "Extracting transaction details"
+- Show editable preview cards for key fields before entering full form.
+- Keep "Manual entry instead" action visible at all times.
+- Persist last scan draft in `SavedStateHandle` during process death to avoid user frustration.
+
+---
+
+## 8) Security and privacy
+
+- Default mode: images remain on device; send text only to backend.
+- Do not store raw document images in Room.
+- If temporary files are created, delete them after review/save/cancel.
+- Redact sensitive numbers in logs.
+- Respect existing session auth pipeline (JWT via `AuthInterceptor`).
+
+---
+
+## 9) Telemetry and quality metrics
+
+Track (locally or analytics backend if enabled):
+
+- scan started/completed
+- OCR success rate
+- extraction API success rate
+- percentage of drafts accepted with no edits
+- average number of edited fields before save
+- drop-off step (scan, extraction, review, create)
+
+These metrics identify whether OCR or mapping is the bottleneck.
+
+---
+
+## 10) Test plan
+
+### Unit tests
+
+- `BuildTransactionDraftUseCase` mapping and confidence logic.
+- Validation rules for required fields.
+- Fallback behavior when extraction API errors.
+
+### Integration tests
+
+- ViewModel state progression (idle -> scanning -> extracted -> review -> form).
+- Retry flow after OCR/API failure.
+
+### UI tests
+
+- End-to-end happy path with mocked OCR/API.
+- Low-confidence highlighting and manual correction path.
+
+---
+
+## 11) Delivery phases
+
+### Phase A (MVP)
+
+- Scan/import single image.
+- Local OCR.
+- Call existing text extraction endpoint.
+- Review screen.
+- Prefill and handoff to current `TransactionFormScreen`.
+
+### Phase B (quality)
+
+- Better preprocessing/crop.
+- Multi-page document support.
+- Improved confidence display and field-level explanations.
+
+### Phase C (advanced)
+
+- Optional PDF import and page selection.
+- Learning from user corrections (future backend support).
+- Optional category/tag auto-apply when confidence is high.
+
+---
+
+## 12) Open decisions
+
+1. Confirm backend endpoint path and DTO schema for text extraction in Android client.
+2. Decide whether scan entry belongs only in dashboard FAB or also transaction list.
+3. Confirm whether PDF scanning is MVP or Phase B.
+4. Confirm privacy policy wording for OCR + text extraction processing.
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index a1d783f..0551b7b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -34,6 +34,7 @@ paging = "3.3.6"
 vico = "2.0.1"
 coil = "2.7.0"
 splashscreen = "1.0.1"
+mlkitTextRecognition = "16.0.1"
 
 junit = "4.13.2"
 coroutinesTest = "1.10.2"
@@ -94,6 +95,7 @@ androidx-paging-compose = { group = "androidx.paging", name = "paging-compose",
 vico-compose-m3 = { group = "com.patrykandpatrick.vico", name = "compose-m3", version.ref = "vico" }
 coil-compose = { group = "io.coil-kt", name = "coil-compose", version.ref = "coil" }
 androidx-core-splashscreen = { group = "androidx.core", name = "core-splashscreen", version.ref = "splashscreen" }
+mlkit-text-recognition = { group = "com.google.mlkit", name = "text-recognition", version.ref = "mlkitTextRecognition" }
 
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 kotlinx-coroutines-test = { group = "org.jetbrains.kotlinx", name = "kotlinx-coroutines-test", version.ref = "coroutinesTest" }