Assinatura Biométrica + OTP (BIOMETRIC_PLUS_OTP)

Combina verificação biométrica com código OTP. Nível máximo de verificação de identidade sem certificado digital.

Etapas geradas: BIOMETRIC_LIVENESS, BIOMETRIC_MATCH, OTP_CHALLENGE, OTP_VERIFY, CLICK_ACCEPT

Passo 1: Criar transação

const tx = await client.transactions.create({
  purpose: 'DOCUMENT_SIGNATURE',
  policy: { profile: 'BIOMETRIC_PLUS_OTP' },
  signer: {
    name: 'João Silva',
    email: 'joao@example.com',
    userExternalId: 'user-001',
  },
  document: { content: pdfBase64, filename: 'contrato.pdf' },
});

tx = client.transactions.create(CreateTransactionRequest(
    purpose='DOCUMENT_SIGNATURE',
    policy=Policy(profile='BIOMETRIC_PLUS_OTP'),
    signer=Signer(name='João Silva', email='joao@example.com', user_external_id='user-001'),
    document=InlineDocument(content=pdf_base64, filename='contrato.pdf'),
))

tx, _ := client.Transactions.Create(ctx, &signdocs.CreateTransactionRequest{
    Purpose: signdocs.TransactionPurposeDocumentSignature,
    Policy:  signdocs.Policy{Profile: signdocs.PolicyProfileBiometricPlusOTP},
    Signer:  signdocs.Signer{Name: "João Silva", Email: "joao@example.com", UserExternalID: "user-001"},
    Document: &signdocs.DocumentInline{Content: pdfBase64, Filename: "contrato.pdf"},
})

CreateTransactionRequest request = new CreateTransactionRequest();
request.purpose = "DOCUMENT_SIGNATURE";
request.policy = new Policy("BIOMETRIC_PLUS_OTP");
request.signer = new Signer("João Silva", "joao@example.com", "user-001");
request.document = new CreateTransactionRequest.InlineDocument(pdfBase64, "contrato.pdf");

Transaction tx = client.transactions().create(request);

$tx = $client->transactions->create(new CreateTransactionRequest(
    purpose: 'DOCUMENT_SIGNATURE',
    policy: new Policy(profile: 'BIOMETRIC_PLUS_OTP'),
    signer: new Signer(name: 'João Silva', email: 'joao@example.com', userExternalId: 'user-001'),
    document: ['content' => $pdfBase64, 'filename' => 'contrato.pdf'],
));

Passo 2: Listar etapas

Ordem	Tipo	Descrição
1	`BIOMETRIC_LIVENESS`	Prova de vida
2	`BIOMETRIC_MATCH`	Comparação facial
3	`OTP_CHALLENGE`	Envio do código OTP
4	`OTP_VERIFY`	Verificação do código
5	`CLICK_ACCEPT`	Aceite por clique

Passo 3: Completar BIOMETRIC_LIVENESS

Inicie com captureMode e complete com livenessSessionId. Detalhes em Verificação Biométrica — Passos 3 e 4.

const livenessStart = await client.steps.start(tx.transactionId, steps[0].stepId, {
  captureMode: 'HOSTED_PAGE',
});
await client.steps.complete(tx.transactionId, steps[0].stepId, {
  livenessSessionId: livenessStart.livenessSessionId,
});

liveness_start = client.steps.start(tx.transaction_id, steps[0].step_id,
    StartStepRequest(capture_mode='HOSTED_PAGE'))
client.steps.complete(tx.transaction_id, steps[0].step_id,
    CompleteLivenessRequest(liveness_session_id=liveness_start.liveness_session_id))

livenessStart, _ := client.Steps.Start(ctx, tx.TransactionID, steps[0].StepID,
    &signdocs.StartStepRequest{CaptureMode: signdocs.CaptureModeHostedPage})
client.Steps.Complete(ctx, tx.TransactionID, steps[0].StepID,
    &signdocs.CompleteLivenessRequest{LivenessSessionID: livenessStart.LivenessSessionID})

StartStepResponse livenessStart = client.steps().start(
    tx.transactionId, steps.get(0).stepId, new StartStepRequest("HOSTED_PAGE"));
client.steps().complete(tx.transactionId, steps.get(0).stepId,
    Map.of("livenessSessionId", livenessStart.livenessSessionId));

$livenessStart = $client->steps->start($tx->transactionId, $steps[0]->stepId,
    new StartStepRequest(captureMode: 'HOSTED_PAGE'));
$client->steps->complete($tx->transactionId, $steps[0]->stepId,
    ['livenessSessionId' => $livenessStart->livenessSessionId]);

Passo 4: Completar BIOMETRIC_MATCH

Envie imagem de referência ou utilize enrollment prévio. Detalhes em Verificação Biométrica — Passo 5.

await client.steps.complete(tx.transactionId, steps[1].stepId, {
  referenceImage: { source: 'BASE64_IMAGE', data: imageBase64 },
});

client.steps.complete(tx.transaction_id, steps[1].step_id,
    CompleteBiometricMatchRequest(reference_image=ReferenceImage(data=image_base64)))

client.Steps.Complete(ctx, tx.TransactionID, steps[1].StepID,
    &signdocs.CompleteBiometricMatchRequest{
        ReferenceImage: &signdocs.ReferenceImage{Source: "BASE64_IMAGE", Data: imageBase64},
    })

client.steps().complete(tx.transactionId, steps.get(1).stepId,
    Map.of("referenceImage", Map.of("source", "BASE64_IMAGE", "data", imageBase64)));

$client->steps->complete($tx->transactionId, $steps[1]->stepId,
    ['referenceImage' => ['source' => 'BASE64_IMAGE', 'data' => $imageBase64]]);

Passo 5: OTP_CHALLENGE e OTP_VERIFY

Inicie o desafio OTP e complete com o código. Detalhes em Assinatura com OTP — Passos 4 e 5.

const otpStart = await client.steps.start(tx.transactionId, steps[2].stepId);
// Em sandbox: otpStart.otpCode contém o código

await client.steps.complete(tx.transactionId, steps[3].stepId, {
  code: '123456',
});

otp_start = client.steps.start(tx.transaction_id, steps[2].step_id)
client.steps.complete(tx.transaction_id, steps[3].step_id,
    CompleteOtpRequest(code='123456'))

otpStart, _ := client.Steps.Start(ctx, tx.TransactionID, steps[2].StepID, nil)
client.Steps.Complete(ctx, tx.TransactionID, steps[3].StepID,
    &signdocs.CompleteOTPRequest{Code: "123456"})

client.steps().start(tx.transactionId, steps.get(2).stepId);
client.steps().complete(tx.transactionId, steps.get(3).stepId,
    Map.of("code", "123456"));

$client->steps->start($tx->transactionId, $steps[2]->stepId);
$client->steps->complete($tx->transactionId, $steps[3]->stepId, ['code' => '123456']);

Passo 6: Completar CLICK_ACCEPT

await client.steps.start(tx.transactionId, steps[4].stepId);
await client.steps.complete(tx.transactionId, steps[4].stepId, { accepted: true });

client.steps.start(tx.transaction_id, steps[4].step_id)
client.steps.complete(tx.transaction_id, steps[4].step_id, CompleteClickRequest(accepted=True))

client.Steps.Start(ctx, tx.TransactionID, steps[4].StepID, nil)
client.Steps.Complete(ctx, tx.TransactionID, steps[4].StepID,
    &signdocs.CompleteClickRequest{Accepted: true})

client.steps().start(tx.transactionId, steps.get(4).stepId);
client.steps().complete(tx.transactionId, steps.get(4).stepId, Map.of("accepted", true));

$client->steps->start($tx->transactionId, $steps[4]->stepId);
$client->steps->complete($tx->transactionId, $steps[4]->stepId, ['accepted' => true]);

Passo 7: Finalizar transação

await client.transactions.finalize(tx.transactionId);
const evidence = await client.evidence.get(tx.transactionId);

client.transactions.finalize(tx.transaction_id)
evidence = client.evidence.get(tx.transaction_id)

client.Transactions.Finalize(ctx, tx.TransactionID)
evidence, _ := client.Evidence.Get(ctx, tx.TransactionID)

client.transactions().finalize(tx.transactionId);
Evidence evidence = client.evidence().get(tx.transactionId);

$client->transactions->finalize($tx->transactionId);
$evidence = $client->evidence->get($tx->transactionId);