> ## 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.

# Validació CPF Brasil i coincidència facial: ID Match

> Validació en bases de dades al Brasil (CPF + coincidència facial) amb Didit: consulta oficial des de $0.45 per consulta, sense contractes ni mínims.

SERPRO Datavalid v4 pf-facial: valida el CPF (obligatori) amb la Receita Federal i compara el selfie en directe (obligatori) amb el retrat de la CNH emmagatzemat a Senatran. Opcionalment, comprova el nom i la data de naixement. Didit exposa aquest servei mitjançant `POST /v3/database-validation/` perquè puguis verificar les dades enviades amb la font oficial i rebre resultats de coincidència normalitzats. Format d'entrada: `tax_number` admet el CPF brasiler (exactament 11 dígits).

## Cobertura

* **Cobertura:** \~50%
* **País:** Brasil
* **ID del servei:** `bra_cpf_facial`
* **Àmbit de dades:** Biomètric
* **Categoria:** NationalIDRegistry

Aproximadament el 50% dels adults brasilers: el pas de coincidència facial depèn del retrat de la CNH que guarda Senatran, de manera que només es pot fer la coincidència dels titulars de permisos de conducció.

## Entrades

| Camp | Obligatori | Exemple |
| - | -: | - |
| `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` |

* **Entrades obligatòries:** `tax_number`, `selfie`
* **Entrades opcionals:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consentiment:** Obligatori
* **Disponibilitat al flux de treball:** Disponible al flux de treball
* **Cobertura:** \~50%
* **Preu:** \$0.45 per consulta satisfactòria

## Paràmetres del cos

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

Codi de país ISO 3166-1 alfa-3 per a aquest servei de base de dades.

Exemple: `BRA`

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

Matriu que conté aquest ID de servei. Fixar el servei manté la sol·licitud limitada a aquesta base de dades exacta.

Exemple: `bra_cpf_facial`

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

Consentiment explícit de l'usuari final per a aquest servei.

Exemple: `true`

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

Número d'identificació fiscal o tributària.

Exemple: `11111111111`

**selfie** `file` *required*

Fitxer d'imatge del selfie que s'ha de pujar per a la validació biomètrica en bases de dades. Formats acceptats: JPEG, PNG o WebP.

Exemple: `@./selfie.jpg`

**first\_name** `string`

Nom de pila que cal validar.

Exemple: `John`

**last\_name** `string`

Cognoms que cal validar.

Exemple: `Doe`

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

Data de naixement en format `YYYY-MM-DD`.

Exemple: `1990-01-01`

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

La teva referència estable d'usuari per a aquesta persona, com ara el teu ID intern d'usuari. Didit l'utilitza per vincular les comprovacions independents al mateix usuari final i reduir el soroll de detecció de duplicats.

Exemple: `user-1234`

## Regles d'entrada i notes de validació

* CPF brasiler (exactament 11 dígits)
* `tax_number` ha de contenir només dígits; elimina espais, guions i signes de puntuació abans d'enviar la sol·licitud.
* `tax_number` ha de tenir exactament 11 caràcters.

## Com fer la crida

```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));
```

Cada crida satisfactòria retorna HTTP `200`. El camp **`outcome_code`** indica què ha passat realment, i distingeix, per exemple, una discrepància biomètrica real (`BIOMETRIC_NO_MATCH`) d'un selfie que no s'ha pogut llegir (`BIOMETRIC_IMAGE_UNUSABLE`). L'`status` que es mostra és l'estat per defecte de la funcionalitat; les teves [accions configurades de coincidència parcial i sense coincidència](https://docs.didit.me/ca/core-technology/database-validation/database-validation-warnings.md) poden substituir-lo.

**`MATCH`**: el registre ha confirmat la identitat i totes les dades comprovades coincideixen.

```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`**: el registre no ha retornat cap coincidència per a les dades enviades.

```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`**: la puntuació de coincidència facial és inferior al llindar d'acceptació; la persona del selfie no és la mateixa que la de la fotografia del registre.

```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`**: no s'ha pogut processar el selfie (buit, sense cara, de baixa qualitat, o el registre no l'ha pogut llegir). Demana a l'usuari que torni a fer-se el 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`**: el registre ha confirmat el CPF (i el nom i la data de naixement que has enviat), però no s'ha pogut comparar la cara: no hi ha cap fotografia de referència registrada per a aquest CPF, o el selfie no s'ha pogut utilitzar (no s'ha trobat cap cara, la mida de la imatge no és correcta, la qualitat és baixa o hi ha més d'una cara). Els camps confirmats es mantenen a `validation`, de manera que `match_type` els reflecteix, però la comprovació facial obligatòria queda sense resoldre i la verificació s'envia a revisió. Demana un nou selfie o recorre a la verificació de documents per a les persones sense fotografia registrada.

```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"
      }
    }
  ]
}
```

## Dades retornades

Els camps exactes que apareixen a `source_data` depenen del que retorni el registre. L'exemple generat per a `bra_cpf_facial` documenta actualment aquesta forma normalitzada:

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

## Preus i SLA

Brasil: les consultes de CPF + coincidència facial (Datavalid) només es facturen quan Didit rep un resultat concloent de la font de validació.

* **Preu per crida:** \$0.45 USD.
* **Facturació:** per consulta satisfactòria. No se't cobra quan el registre no és accessible, quan falten camps obligatoris o quan la sol·licitud es rebutja abans d'arribar a la font.
* **Latència:** p95 típic inferior a 2 s.
* **Disponibilitat:** 99.9% per trimestre per part de Didit; la disponibilitat de la font final varia segons el país i el conjunt de dades.

## Sobre aquesta font

Aquesta és la font oficial del govern: [SERPRO](https://www.serpro.gov.br) Datavalid, gestionat pel servei federal brasiler de processament de dades. El CPF es comprova amb la Receita Federal, i el selfie es compara amb el retrat que el Senatran, el registre nacional de permisos de conducció, té d'aquella persona.

Com que el retrat procedeix del registre de la CNH (permís de conducció), només tenen una imatge facial registrada les persones que tenen una CNH. Això fa que la cobertura se situï al voltant del 50% de la població adulta: les dades són oficials, però falten per a tots els brasilers que mai no han tingut un permís de conducció.

**Necessites més cobertura?** Utilitza [BRA - Unico IDCloud (CPF + selfie)](https://docs.didit.me/ca/api-reference/database-validation/brazil/unico-idcloud.md). Arriba a un 96% aproximadament dels adults brasilers gràcies al registre biomètric privat d'Unico, i costa \$0.20 en lloc dels \$0.45 d'aquí. Tria Datavalid quan necessitis específicament el registre governamental com a font de referència; tria IDCloud quan necessitis verificar tothom.

## Continua llegint

* [Visió general de la validació en bases de dades del Brasil](https://docs.didit.me/api-reference/database-validation/brazil.md)
* [Visió general de la validació en bases de dades](https://docs.didit.me/ca/core-technology/database-validation/overview.md)
* [Codis de resultat](https://docs.didit.me/ca/core-technology/database-validation/database-validation-outcome-codes.md)


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