---
title: SDK Lite Android
description: Rode a captura do Human Token de forma nativa no seu app Android com o SDK Lite, só com o token do processo gerado pelo seu backend. Sem credenciais no app.
canonical: https://developer.unico.io/pt-BR/human-token/integrations/app/android/sdk-lite
locale: pt-BR
generated_by: markdown-export
---

SDK Lite Android

Abra a captura do Human Token de forma nativa no seu app Android usando só o webAppToken do processo.

O **SDK Lite** é o SDK Android da Unico para o Human Token. Ele roda a captura na experiência web da Unico embarcada no SDK e entra **só** pelo `webAppToken` de um processo criado pelo seu backend. O app não guarda credenciais: tudo o que ele precisa vem do token.

> **Versão do SDK:** Disponível a partir do **SDK Android 6.14.0**, no artefato `io.unico:capture-lite`.

### Como funciona

### Pré-requisitos

| Requisito | Versão / valor |
| --- | --- |
| Android mínimo | 5.0 (API 21) |
| Kotlin | 1.8.22 ou superior |
| Compatibilidade Java | `JavaVersion.VERSION_1_8` |
| Android Gradle Plugin (AGP) | 8.6.0 ou superior |
| Android Studio | Koala Feature Drop (2024.1.2) ou superior |
| Permissões obrigatórias | `INTERNET`, `CAMERA` |

- Um backend que cria o processo com [Criar Processo](/pt-BR/human-token/api-reference/post-processes) e entrega o `webAppToken` da resposta ao app.
- Entrada por token habilitada pela Unico para a sua conta no ambiente de destino.

### Passo 1: Adicione a dependência

O SDK Lite é distribuído pelo repositório Maven da Unico. Adicione o repositório ao bloco `dependencyResolutionManagement` do arquivo de settings e depois adicione **`io.unico:capture-lite`** ao arquivo de build do módulo:

- Kotlin DSL
- Groovy

settings.gradle.kts

```kotlin
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven("https://maven-sdk.unico.run/sdk-mobile")
    }
}
```

app/build.gradle.kts (module)

```kotlin
dependencies {
    implementation("io.unico:capture-lite:<version>")
}
```

settings.gradle

```gradle
dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven { url "https://maven-sdk.unico.run/sdk-mobile" }
    }
}
```

app/build.gradle (module)

```gradle
dependencies {
    implementation 'io.unico:capture-lite:<version>'
}
```

### Passo 2: Obtenha o webAppToken no seu backend

O seu backend cria o processo com [Criar Processo](/pt-BR/human-token/api-reference/post-processes) e envia ao app o campo **`webAppToken`** da resposta. O app o passa ao SDK como veio. Os campos `token` e `link` da mesma resposta são de outros usos: passado ao SDK, o `token` é recusado com o erro `73304`.

- **Um processo por jornada.** Crie um processo novo, e um token novo, toda vez que o usuário iniciar a captura.
- **Vida curta.** O `webAppToken` vale 5 minutos. Crie-o logo antes de abrir a captura.
- **Mesmo ambiente.** O processo e o SDK precisam usar o mesmo ambiente (UAT ou PROD).

> **Aviso:** Nunca embarque credenciais, chaves de acesso ou um token fixo no app. O `webAppToken` é criado pelo seu backend a cada jornada.

### Passo 3: Abra a captura

Obtenha o `webAppToken` no seu backend, construa o SDK com `AcessoBio`, defina o ambiente e chame `prepareAndOpenCamera(webAppToken, listener)` com ele. A chamada prepara o SDK e abre a captura de uma vez.

```kotlin
import androidx.appcompat.app.AppCompatActivity
import androidx.lifecycle.lifecycleScope
import com.acesso.acessobio_android.AcessoBioListener
import com.acesso.acessobio_android.iAcessoBioSelfie
import com.acesso.acessobio_android.onboarding.AcessoBio
import com.acesso.acessobio_android.onboarding.models.Environment
import com.acesso.acessobio_android.services.dto.ErrorBio
import com.acesso.acessobio_android.services.dto.ResultCamera
import com.acesso.acessobio_android.services.dto.SuccessResult
import kotlinx.coroutines.launch

class CaptureActivity : AppCompatActivity() {

    // Same environment used by your backend to create the process
    private val environment = Environment.PROD

    private val callback = object : AcessoBioListener {
        override fun onErrorAcessoBio(errorBio: ErrorBio?) { }
        override fun onUserClosedCameraManually() { }
        override fun onSystemClosedCameraTimeoutSession() { }
        override fun onSystemChangedTypeCameraTimeoutFaceInference() { }
    }

    private val selfieListener = object : iAcessoBioSelfie {
        // Journey result. Required.
        override fun onSuccess(successResult: SuccessResult) {
            // Journey completed: send successResult.processId to your backend
        }

        // Required by the interface. The journey result arrives in onSuccess.
        override fun onSuccessSelfie(result: ResultCamera) { }

        override fun onErrorSelfie(errorBio: ErrorBio) {
            // 73305 (expired token): create a new process and try again
        }
    }

    fun startCapture() {
        lifecycleScope.launch {
            // Your backend calls Create Process and returns the `webAppToken` field of the response
            val webAppToken = yourBackend.createHumanTokenProcess()

            val camera = AcessoBio(this@CaptureActivity, callback)
                .setEnvironment(environment)
                .build()
            camera.prepareAndOpenCamera(webAppToken, selfieListener)
        }
    }
}
```

> **OnSuccess é obrigatório:** O `iAcessoBioSelfie` declara `onSuccess` com implementação padrão, então o compilador não exige o override. Sem ele, a captura não abre e o `onErrorSelfie` recebe o erro `74001`.

- Erros de preparo (token recusado ou expirado) e de captura chegam no `onErrorSelfie`.
- A captura não roda em emulador (erro `73006`).
- O `onSuccess` indica que a jornada terminou, **não** que o usuário foi aprovado. Sempre leia o resultado com [Obter Processo](/pt-BR/human-token/api-reference/get-process) ou por webhook.

### Ambiente

A captura usa o ambiente definido por `setEnvironment` no builder. Use o ambiente em que o processo foi criado.

### Códigos de erro

| Código | Quando | O que fazer |
| --- | --- | --- |
| `73006` | Execução em emulador | Teste em um dispositivo físico |
| `73304` | O `webAppToken` está vazio ou foi recusado (assinatura ou conteúdo inválidos), inclusive quando o campo `token` é passado no lugar dele | Passe o `webAppToken` de um processo válido |
| `73305` | O token expirou | Crie um processo novo e chame `prepareAndOpenCamera` de novo com o `webAppToken` novo |
| `73701` | A chamada não está disponível no SDK Lite | Use `prepareAndOpenCamera(webAppToken, listener)` |
| `74001` | O listener não sobrescreve `onSuccess` | Sobrescreva `onSuccess(successResult: SuccessResult)` |

### Próximos passos

- Busque o resultado com [Obter Processo](/pt-BR/human-token/api-reference/get-process) e guarde `data.humanToken.value` junto com o cadastro do usuário.
- Não dá para usar o SDK Lite? Abra o `link` da jornada, como descrito em [Android](/pt-BR/human-token/integrations/app/android/link-integration).
- Confira as versões que incluem a edição lite nas [Notas de versão do SDK Lite](/pt-BR/human-token/integrations/app/sdk-lite-release-notes).
- Vai integrar no iOS? Veja o [SDK Lite iOS](/pt-BR/human-token/integrations/app/ios/sdk-lite).

Última atualização em **12 de nov. de 2026**