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

# API BVN Nigeria: Validazione su database

> Bank Verification Number (BVN) Nigeria: ricerca su database ufficiale tramite Didit. A consumo da $0.35, nessun contratto, nessun minimo.

Verifica i dati inseriti rispetto al database del settore bancario nigeriano. Richiede un selfie: il ritratto di registrazione associato al BVN viene confrontato con il selfie, e il record viene restituito solo se si tratta della stessa persona. Didit espone questo servizio tramite `POST /v3/database-validation/` per permetterti di verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di corrispondenza normalizzati. Formato di input: `bvn` accetta il Bank Verification Number nigeriano (esattamente 11 cifre).

## Copertura

* **Copertura:** \~ 100%
* **Paese:** Nigeria
* **ID servizio:** `nga_bank_verification_number`
* **Dominio dei dati:** Finanziario
* **Categoria:** Bancaria

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `bvn` | 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:** `bvn`, `selfie`
* **Input facoltativi:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consenso:** Non richiesto
* **Disponibilità nel workflow:** Disponibile nel workflow con mappatura dei campi
* **Copertura:** \~ 100%
* **Prezzo:** \$0.35 per query riuscita

In un workflow, `bvn` non è stampato su nessun documento d'identità, quindi nessun passaggio lo produce da solo. Raccoglilo da una risposta di un Questionario, da un campo estratto da Document AI, oppure da un valore che invii al momento della creazione della sessione, e mappalo sul passaggio Validazione su database. Finché non è mappato, l'editor dei workflow mostra questo servizio disabilitato e indica l'input mancante; in fase di esecuzione un input mancante fa sì che il controllo venga saltato prima di qualsiasi query, quindi non ti viene mai addebitata una banca dati che non è stato possibile interrogare.

## Parametri del body

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

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

Esempio: `NGA`

**services** `string` *required* (default: nga\_bank\_verification\_number)

Array che contiene l'ID di questo servizio. Fissare il servizio mantiene la richiesta limitata a questa specifica banca dati.

Esempio: `nga_bank_verification_number`

**bvn** `string` *required* (default: 11111111111)

Bank Verification Number.

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` (default: 1990-01-01)

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, come il tuo ID utente interno. Didit lo usa per collegare i controlli autonomi allo stesso utente finale e ridurre il rumore dei rilevamenti di duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* Bank Verification Number nigeriano (esattamente 11 cifre)
* `bvn` deve contenere solo cifre; rimuovi spazi, trattini e punteggiatura prima di inviare la richiesta.
* `bvn` deve essere esattamente di 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=NGA" \
  -F "services=nga_bank_verification_number" \
  -F "vendor_data=user-1234" \
  -F "bvn=11111111111" \
  -F "selfie=@./selfie.jpg" \
  -F "date_of_birth=1990-01-01"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="NGA",
    services=["nga_bank_verification_number"],
    date_of_birth="1990-01-01",
    bvn="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: "NGA",
  services: ["nga_bank_verification_number"],
  date_of_birth: "1990-01-01",
  bvn: "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: "NGA",
	Services:     didit.Some([]string{"nga_bank_verification_number"}),
	DateOfBirth:  didit.String("1990-01-01"),
	Bvn:          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.time.LocalDate;
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("NGA")
        .services(List.of("nga_bank_verification_number"))
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .bvn("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' => 'NGA',
    'services' => ['nga_bank_verification_number'],
    'date_of_birth' => '1990-01-01',
    'bvn' => '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: "NGA",
  services: ["nga_bank_verification_number"],
  date_of_birth: "1990-01-01",
  bvn: "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 = "NGA",
    Services = new string[] { "nga_bank_verification_number" },
    DateOfBirth = "1990-01-01",
    Bvn = "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, un vero mancato confronto biometrico (`BIOMETRIC_NO_MATCH`) da un selfie che non è stato possibile leggere (`BIOMETRIC_IMAGE_UNUSABLE`). Lo `status` mostrato è lo stato predefinito della funzionalità; le [azioni per Partial Match / No Match](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) che hai configurato possono sostituirlo.

**`MATCH`**: il registro ha confermato l'identità e ogni campo verificato corrisponde.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "NGA",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "nga_bank_verification_number",
      "service_name": "Nigeria Bank Verification Number (BVN)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "last_name": "Doe"
      },
      "validation": {
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`**: il BVN è presente nel registro e il selfie corrisponde al ritratto di registrazione NIBSS, ma un nome o una data di nascita che hai inviato non coincidono con quelli del registro. Il record viene restituito così puoi vedere quale campo differisce.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "NGA",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "nga_bank_verification_number",
      "service_name": "Nigeria Bank Verification Number (BVN)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "last_name": "Doe"
      },
      "validation": {
        "date_of_birth": "no_match",
        "identification_number": "full_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": "NGA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_NO_MATCH",
      "service_id": "nga_bank_verification_number",
      "service_name": "Nigeria Bank Verification Number (BVN)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`INCONCLUSIVE`**: il registro non è in grado di determinare se la persona corrisponde al record, quindi il risultato è davvero incerto (la persona potrebbe essere presente nel registro o meno). Non è un mancato confronto e non è un problema tecnico dell'immagine; nessun campo viene confermato, quindi match\_type è null e il controllo viene inviato alla revisione manuale.

```json 200 OK — INCONCLUSIVE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "NGA",
  "match_type": null,
  "validations": [
    {
      "outcome_code": "INCONCLUSIVE",
      "service_id": "nga_bank_verification_number",
      "service_name": "Nigeria Bank Verification Number (BVN)",
      "source_data": {},
      "validation": {}
    }
  ]
}
```

**`DOCUMENT_NOT_FOUND`**: il numero di documento inviato non corrisponde ad alcun record nel registro.

```json 200 OK — DOCUMENT_NOT_FOUND theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "NGA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "DOCUMENT_NOT_FOUND",
      "service_id": "nga_bank_verification_number",
      "service_name": "Nigeria Bank Verification Number (BVN)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

## Dati restituiti

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

* `date_of_birth`
* `first_name`
* `last_name`

## Prezzi e SLA

Le query sul Bank Verification Number (BVN) della Nigeria vengono addebitate solo quando Didit riceve un risultato conclusivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.35 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à delle fonti a valle varia in base al paese e al dataset.

## Continua la lettura

* [Panoramica sulla validazione su database Nigeria](https://docs.didit.me/api-reference/database-validation/nigeria.md)
* [Panoramica sulla 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.