---
title: SDK Lite iOS
description: Rode a captura do Human Token de forma nativa no seu app iOS 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/ios/sdk-lite
locale: pt-BR
generated_by: markdown-export
---

SDK Lite iOS

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

O **SDK Lite** é o SDK iOS 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 iOS 3.6.0**, pelo Swift Package Manager.

### Como funciona

### Pré-requisitos

| Requisito | Versão / valor |
| --- | --- |
| iOS mínimo | 13 |
| Xcode | 16.0+ |
| Gerenciador de dependências | Swift Package Manager (o SDK Lite não é publicado no CocoaPods) |
| Permissões obrigatórias | `NSCameraUsageDescription` |

- 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: Instale o SDK Lite

Adicione o pacote `https://github.com/acesso-io/unico-check-ios` e selecione o produto **`unicocheck-ios-spm-lite`**.

- Xcode
- Package.swift

No Xcode, abra **File > Add Package Dependencies**, informe a URL do pacote e selecione o produto `unicocheck-ios-spm-lite`.

Package.swift

```swift
dependencies: [
    .package(url: "https://github.com/acesso-io/unico-check-ios", from: "3.6.0")
],
targets: [
    .target(
        name: "YourApp",
        dependencies: [
            .product(name: "unicocheck-ios-spm-lite", package: "unico-check-ios")
        ]
    )
]
```

O produto entrega o módulo `AcessoBio` (`import AcessoBio`).

### 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 `AcessoBioManager`, defina o ambiente e chame `prepareAndOpenSelfieCamera(_:webAppToken:)` com ele. A chamada prepara o SDK e abre a captura de uma vez.

```swift
import UIKit
import AcessoBio

final class CaptureViewController: UIViewController, AcessoBioManagerDelegate, AcessoBioSelfieDelegate {

    func startCapture() {
        Task {
            // Your backend calls Create Process and returns the `webAppToken` field of the response
            let webAppToken = try await yourBackend.createHumanTokenProcess()

            let camera = AcessoBioManager(viewController: self, delegate: self)
                .setEnvironment(.PROD) // Same environment used by your backend to create the process
                .build()
            camera?.prepareAndOpenSelfieCamera(self, webAppToken: webAppToken) // build() is imported into Swift as an optional
        }
    }

    // Journey result. Required.
    func onSuccess(_ successResult: SuccessResult) {
        // Journey completed: send successResult.processId to your backend
    }

    // Required by the protocol. The journey result arrives in onSuccess(_:).
    func onSuccessSelfie(_ result: SelfieResult) { }

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

    // AcessoBioManagerDelegate
    func onErrorAcessoBioManager(_ error: ErrorBio) { }
    func onUserClosedCameraManually() { }
    func onSystemClosedCameraTimeoutSession() { }
    func onSystemChangedTypeCameraTimeoutFaceInference() { }
}
```

> **OnSuccess é obrigatório:** O `AcessoBioSelfieDelegate` declara `onSuccess(_:)` como opcional, então o compilador não o verifica. Sem ele, a captura não abre e o `onErrorSelfie` recebe o erro `74001`. Copie a assinatura exatamente como no exemplo.

- Os callbacks chegam na main queue.
- A captura não roda no simulador (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 |
| --- | --- | --- |
| `73203` | O `webAppToken` está vazio ou só tem espaços | Passe o `webAppToken` devolvido pelo seu backend |
| `73006` | Execução no simulador | Teste em um dispositivo físico |
| `73302` | A autenticação falhou por outro motivo, como rede ou resposta inesperada | Tente de novo; se persistir, fale com o suporte |
| `73303` | A Unico recusou o preparo da captura, inclusive quando a entrada por token não está habilitada para a sua conta no ambiente | Confirme com a Unico que a entrada por token está habilitada nesse ambiente |
| `73304` | O token foi recusado (assinatura ou conteúdo inválidos), inclusive quando o campo `token` é passado no lugar do `webAppToken` | Passe o `webAppToken` de um processo válido |
| `73305` | O token expirou | Crie um processo novo e chame `prepareAndOpenSelfieCamera` de novo com o `webAppToken` novo |
| `73701` | A chamada não está disponível no SDK Lite | Use `prepareAndOpenSelfieCamera(_:webAppToken:)` |
| `74001` | O delegate não implementa `onSuccess(_:)` | Implemente `onSuccess(_:)` com a assinatura exata |

### 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 [iOS](/pt-BR/human-token/integrations/app/ios/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 Android? Veja o [SDK Lite Android](/pt-BR/human-token/integrations/app/android/sdk-lite).

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