> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# Brasile CPF + confronto facciale (Datavalid): ID Match

> Brasile - CPF + confronto facciale (Datavalid): verifica su database ufficiale brasiliano con Didit. Da $0.45 a chiamata, senza contratti né minimi.

SERPRO Datavalid v4 pf-facial convalida il CPF (obbligatorio) presso la Receita Federal e confronta il selfie in tempo reale (obbligatorio) con la foto della CNH conservata presso Senatran. Facoltativamente verifica anche nome e data di nascita. Didit espone questo servizio tramite `POST /v3/database-validation/`, così puoi verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di confronto normalizzati. Formato di input: `tax_number` accetta il CPF brasiliano (esattamente 11 cifre).

## Copertura

* **Copertura:** \~50%
* **Paese:** Brasile
* **ID servizio:** `bra_cpf_facial`
* **Dominio dei dati:** Biometrico
* **Categoria:** NationalIDRegistry

Circa il 50% degli adulti brasiliani: il passaggio di confronto facciale si basa sulla foto della CNH conservata presso Senatran, quindi possono essere confrontate solo le persone titolari di patente di guida.

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `tax_number` | Sì | `11111111111` |
| `selfie` | Sì | `@./selfie.jpg` |
| `first_name` | No | `John` |
| `last_name` | No | `Doe` |
| `date_of_birth` | No | `1990-01-01` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `tax_number`, `selfie`
* **Input facoltativi:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consenso:** Obbligatorio
* **Disponibilità nel workflow:** Disponibile nel workflow
* **Copertura:** \~50%
* **Prezzo:** \$0.45 per query riuscita

## Parametri del corpo

**issuing\_state** `string` *required* (default: BRA)

Codice paese ISO 3166-1 alpha-3 per questo servizio di database.

Esempio: `BRA`

**services** `string` *required* (default: bra\_cpf\_facial)

Array che contiene questo ID servizio. Specificare il servizio limita la richiesta a questo specifico database.

Esempio: `bra_cpf_facial`

**consent** `boolean` *required* (default: true)

Consenso esplicito dell'utente finale per questo servizio.

Esempio: `true`

**tax\_number** `string` *required* (default: 11111111111)

Numero di identificazione fiscale.

Esempio: `11111111111`

**selfie** `file` *required*

File immagine del selfie da caricare per la validazione biometrica su database. Formati accettati: JPEG, PNG o WebP.

Esempio: `@./selfie.jpg`

**first\_name** `string`

Nome da validare.

Esempio: `John`

**last\_name** `string`

Cognome da validare.

Esempio: `Doe`

**date\_of\_birth** `string`

Data di nascita nel formato `YYYY-MM-DD`.

Esempio: `1990-01-01`

**vendor\_data** `string` (default: user-1234)

Il tuo riferimento utente stabile per questa persona, ad esempio il tuo ID utente interno. Didit lo usa per collegare i controlli autonomi allo stesso utente finale e ridurre il rumore nel rilevamento dei duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* CPF brasiliano (esattamente 11 cifre)
* `tax_number` deve contenere solo cifre: rimuovi spazi, trattini e punteggiatura prima di inviare la richiesta.
* `tax_number` deve essere lungo esattamente 11 caratteri.

## Come effettuare la chiamata

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=BRA" \
  -F "services=bra_cpf_facial" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "tax_number=11111111111" \
  -F "selfie=@./selfie.jpg"
```

```python Python theme={null}
from didit import Didit

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="BRA",
    services=["bra_cpf_facial"],
    consent=True,
    tax_number="11111111111",
    vendor_data="user-1234",
    selfie=open("selfie.jpg", "rb"),
)
print(result)
```

```javascript Node.js theme={null}
import Didit, { fileFromPath } from "@didit-protocol/sdk-node";

// Reads DIDIT_API_KEY.
const didit = new Didit();

const result = await didit.databaseValidation.validate({
  issuing_state: "BRA",
  services: ["bra_cpf_facial"],
  consent: true,
  tax_number: "11111111111",
  vendor_data: "user-1234",
  selfie: await fileFromPath("selfie.jpg"),
});
console.log(result);
```

```go Go theme={null}
ctx := context.Background()
// Reads DIDIT_API_KEY.
client := didit.NewClient()

result, err := client.DatabaseValidation.Validate(ctx, didit.DatabaseValidationValidateParams{
	IssuingState: "BRA",
	Services:     didit.Some([]string{"bra_cpf_facial"}),
	Consent:      didit.Bool(true),
	TaxNumber:    didit.String("11111111111"),
	VendorData:   didit.String("user-1234"),
	Selfie:       didit.Some(didit.FileFromPath("selfie.jpg")),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
import java.nio.file.Path;
import java.util.List;
import me.didit.Didit;
import me.didit.types.DatabaseValidationValidateParams;

// Reads DIDIT_API_KEY.
Didit client = new Didit();

var result = client.databaseValidation().validate(DatabaseValidationValidateParams.builder()
        .issuingState("BRA")
        .services(List.of("bra_cpf_facial"))
        .consent(true)
        .taxNumber("11111111111")
        .vendorData("user-1234")
        .selfie(Path.of("selfie.jpg"))
        .build());
System.out.println(result);
```

```php PHP theme={null}
<?php

require 'vendor/autoload.php';

use Didit\DiditClient;
use Didit\File;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'BRA',
    'services' => ['bra_cpf_facial'],
    'consent' => true,
    'tax_number' => '11111111111',
    'vendor_data' => 'user-1234',
    'selfie' => File::fromPath('selfie.jpg'),
]);
print_r($result->toArray());
```

```ruby Ruby theme={null}
require "didit"

# Reads DIDIT_API_KEY.
didit = Didit::Client.new

result = didit.database_validation.validate(
  issuing_state: "BRA",
  services: ["bra_cpf_facial"],
  consent: true,
  tax_number: "11111111111",
  vendor_data: "user-1234",
  selfie: Pathname("selfie.jpg")
)
puts result.to_h
```

```csharp .NET theme={null}
using System;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.DatabaseValidation.ValidateAsync(new DatabaseValidationValidateParams
{
    IssuingState = "BRA",
    Services = new string[] { "bra_cpf_facial" },
    Consent = true,
    TaxNumber = "11111111111",
    VendorData = "user-1234",
    Selfie = FileUpload.FromPath("selfie.jpg"),
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è effettivamente accaduto, distinguendo ad esempio una vera mancata corrispondenza biometrica (`BIOMETRIC_NO_MATCH`) da un selfie che non è stato possibile leggere (`BIOMETRIC_IMAGE_UNUSABLE`). Lo `status` mostrato è lo stato predefinito della funzionalità; le tue [azioni configurate per corrispondenza parziale / nessuna corrispondenza](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) possono sovrascriverlo.

**`MATCH`**: il registro ha confermato l'identità e tutti i campi controllati corrispondono.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "BRA",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "bra_cpf_facial",
      "service_name": "Brazil - CPF + face match (Datavalid)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "face_match_probability": "Altíssima probabilidade",
        "face_match_score": "0.990",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000",
        "verifications": {
          "identification_number": true
        }
      },
      "validation": {
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`NO_MATCH`**: il registro non ha restituito alcuna corrispondenza per i dati inviati.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "BRA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "bra_cpf_facial",
      "service_name": "Brazil - CPF + face match (Datavalid)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_NO_MATCH`**: il punteggio di confronto facciale è inferiore alla soglia di accettazione, quindi il selfie non appartiene alla stessa persona della foto del registro.

```json 200 OK — BIOMETRIC_NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "BRA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_NO_MATCH",
      "service_id": "bra_cpf_facial",
      "service_name": "Brazil - CPF + face match (Datavalid)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_IMAGE_UNUSABLE`**: non è stato possibile elaborare il selfie (vuoto, senza volto, di bassa qualità, oppure il registro non è riuscito a leggerlo). Invita l'utente a rifare il selfie.

```json 200 OK — BIOMETRIC_IMAGE_UNUSABLE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "BRA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_IMAGE_UNUSABLE",
      "service_id": "bra_cpf_facial",
      "service_name": "Brazil - CPF + face match (Datavalid)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`INCONCLUSIVE`**: il registro ha confermato il CPF (e il nome e la data di nascita inviati), ma il volto non è stato confrontato: non esiste una foto di riferimento registrata per questo CPF, oppure il selfie non è stato utilizzabile (nessun volto rilevato, dimensioni dell'immagine errate, bassa qualità o più di un volto). I campi confermati restano in `validation`, quindi `match_type` li riflette, ma il controllo facciale obbligatorio è irrisolto e il controllo viene inviato in revisione. Chiedi un nuovo selfie oppure ricorri alla verifica del documento per le persone senza foto registrata.

```json 200 OK — INCONCLUSIVE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "BRA",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "INCONCLUSIVE",
      "service_id": "bra_cpf_facial",
      "service_name": "Brazil - CPF + face match (Datavalid)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000"
      },
      "validation": {
        "identification_number": "full_match"
      }
    }
  ]
}
```

## Dati restituiti

I campi esatti esposti in `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `bra_cpf_facial` documenta attualmente questa struttura normalizzata:

* `date_of_birth`
* `first_name`
* `identification_number`
* `last_name`
* `name_match_score`

## Prezzi e SLA

Brasile: le query CPF + confronto facciale (Datavalid) vengono fatturate solo quando Didit riceve un risultato definitivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.45 USD.
* **Fatturazione:** per query riuscita. Non ti viene addebitato nulla quando il registro non è raggiungibile, quando mancano campi obbligatori o quando la richiesta viene rifiutata prima di raggiungere la fonte.
* **Latenza:** p95 tipico \< 2 s.
* **Disponibilità:** 99.9% per trimestre lato Didit; la disponibilità della fonte a valle varia in base al paese e al dataset.

## Informazioni su questa fonte

Si tratta della fonte governativa ufficiale: [SERPRO](https://www.serpro.gov.br) Datavalid, gestita dal servizio federale brasiliano di elaborazione dati. Il CPF viene verificato con la Receita Federal, mentre il selfie viene confrontato con il ritratto custodito per quella persona presso la Senatran, il registro nazionale delle patenti di guida.

Poiché il ritratto proviene dal registro della CNH (patente di guida), solo le persone in possesso di una CNH hanno un volto registrato. È questo che limita la copertura a circa il 50% della popolazione adulta: i dati sono autorevoli, ma mancano per tutti i brasiliani che non hanno mai conseguito una patente di guida.

**Hai bisogno di una copertura più ampia?** Usa invece [BRA - Unico IDCloud (CPF + selfie)](https://docs.didit.me/it/api-reference/database-validation/brazil/unico-idcloud.md). Raggiunge circa il 96% degli adulti brasiliani tramite il registro biometrico privato di Unico, e costa \$0.20 contro i \$0.45 previsti qui. Scegli Datavalid quando ti serve in particolare il registro governativo come fonte di riferimento; scegli IDCloud quando devi verificare tutti.

## Continua a leggere

* [Panoramica della validazione su database per il Brasile](https://docs.didit.me/api-reference/database-validation/brazil.md)
* [Panoramica della validazione su database](https://docs.didit.me/it/core-technology/database-validation/overview.md)
* [Codici di esito](https://docs.didit.me/it/core-technology/database-validation/database-validation-outcome-codes.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.