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

# Verifica ID nazionale Nigeria + selfie (NIMC) API

> Verifica ID nazionale Nigeria + selfie (NIMC) con Didit: controllo su database ufficiale. Da $0.35 a chiamata, senza contratti né minimi.

Verifica un numero di identificazione nazionale nigeriano (NIN) nel registro della National Identity Management Commission. Richiede un selfie: il ritratto di registrazione associato al NIN viene confrontato con il selfie, e il record viene restituito solo quando i due appartengono alla stessa persona. Didit espone questo servizio tramite `POST /v3/database-validation/`, così puoi verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di corrispondenza normalizzati.

## Copertura

* **Copertura:** \~ 100%
* **Paese:** Nigeria
* **ID servizio:** `nga_national_id_facial`
* **Dominio dei dati:** Identità
* **Categoria:** NationalIDRegistry

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `national_id` | 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:** `national_id`, `selfie`
* **Input facoltativi:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **Consenso:** non richiesto
* **Disponibilità nel workflow:** disponibile nel workflow
* **Copertura:** \~ 100%
* **Prezzo:** \$0.35 per query riuscita

Non tutti i documenti accettati da questo servizio contengono l'identificativo con cui il servizio effettua la ricerca. Quando l'identificativo non viene estratto dal documento, il controllo viene registrato come **non applicabile**: non viene interrogato alcun database e non ti viene addebitato nulla. Per alcuni paesi questo riguarda una quota rilevante degli utenti reali. Per coprirli, raccogli l'identificativo anche da una risposta di un Questionario, da un campo estratto da Document AI o da un valore che invii alla creazione della sessione, e mappalo nel passaggio Validazione su database.

## Parametri del body

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

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

Esempio: `NGA`

**services** `string` *required* (default: nga\_national\_id\_facial)

Array che contiene l'ID di questo servizio. Specificare il servizio vincola la richiesta a questo database.

Esempio: `nga_national_id_facial`

**national\_id** `string` *required* (default: 11111111111)

Numero di identificazione nazionale per questo servizio.

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 di battesimo da verificare.

Esempio: `John`

**last\_name** `string`

Cognome da verificare.

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 le verifiche indipendenti allo stesso utente finale e ridurre il rumore del rilevamento dei duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* `first_name` deve corrispondere a `[A-Za-zÀ-ÖØ-öø-ÿ .'-]+`.
* `national_id` deve contenere solo cifre: rimuovi spazi, trattini e punteggiatura prima di inviare la richiesta.
* `national_id` 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=NGA" \
  -F "services=nga_national_id_facial" \
  -F "vendor_data=user-1234" \
  -F "national_id=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="NGA",
    services=["nga_national_id_facial"],
    national_id="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_national_id_facial"],
  national_id: "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_national_id_facial"}),
	NationalID:   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("NGA")
        .services(List.of("nga_national_id_facial"))
        .nationalId("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_national_id_facial'],
    'national_id' => '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_national_id_facial"],
  national_id: "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_national_id_facial" },
    NationalId = "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 è realmente successo, 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 di corrispondenza parziale / nessuna corrispondenza](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) che hai configurato possono sovrascriverlo.

**`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_national_id_facial",
      "service_name": "Nigeria National ID + Selfie (NIMC)",
      "source_data": {
        "address": "1 SAMPLE STREET",
        "birth_country": "nigeria",
        "birth_lga": "Ikeja",
        "birth_state": "Lagos",
        "date_of_birth": "1990-01-01",
        "face_match_score": 92.4,
        "first_name": "JOHN",
        "gender": "Male",
        "identification_number": "11111111111",
        "last_name": "DOE",
        "marital_status": "single",
        "middle_name": "SAMUEL",
        "phone_number": "08000000000",
        "photo_available": true,
        "residence_lga": "Ikeja",
        "residence_state": "Lagos",
        "residence_town": "IKEJA"
      },
      "validation": {
        "date_of_birth": "full_match",
        "full_name": "full_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`**: il selfie corrisponde alla foto registrata e il NIN è presente nel registro, ma un nome o una data di nascita che hai inviato differisce dal record NIMC. 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_national_id_facial",
      "service_name": "Nigeria National ID + Selfie (NIMC)",
      "source_data": {
        "address": "1 SAMPLE STREET",
        "birth_country": "nigeria",
        "birth_lga": "Ikeja",
        "birth_state": "Lagos",
        "date_of_birth": "1990-02-01",
        "face_match_score": 92.4,
        "first_name": "JOHN",
        "gender": "Male",
        "identification_number": "11111111111",
        "last_name": "DOE",
        "marital_status": "single",
        "middle_name": "SAMUEL",
        "phone_number": "08000000000",
        "photo_available": true,
        "residence_lga": "Ikeja",
        "residence_state": "Lagos",
        "residence_town": "IKEJA"
      },
      "validation": {
        "date_of_birth": "no_match",
        "full_name": "full_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`BIOMETRIC_NO_MATCH`**: il NIN è presente nel registro, ma il selfie non ritrae la stessa persona della foto di registrazione NIMC (punteggio di corrispondenza facciale sotto la soglia di accettazione). Non viene restituito nulla dal record, solo il punteggio.

```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_national_id_facial",
      "service_name": "Nigeria National ID + Selfie (NIMC)",
      "source_data": {
        "face_match_score": 12.5,
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`INCONCLUSIVE`**: il NIN è presente nel registro, ma non è stato possibile eseguire il confronto facciale: manca la foto di registrazione oppure non è stato rilevato alcun volto. Non viene restituito nulla dal record, `match_type` è null e il controllo viene inviato a revisione.

```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_national_id_facial",
      "service_name": "Nigeria National ID + Selfie (NIMC)",
      "source_data": {},
      "validation": {}
    }
  ]
}
```

**`DOCUMENT_NOT_FOUND`**: il NIN è ben formato, ma il registro NIMC non contiene alcun record per esso. La ricerca viene addebitata.

```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_national_id_facial",
      "service_name": "Nigeria National ID + Selfie (NIMC)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

## Dati restituiti

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

* `address`
* `birth_country`
* `birth_lga`
* `birth_state`
* `date_of_birth`
* `face_match_score`
* `first_name`
* `gender`
* `identification_number`
* `last_name`
* `marital_status`
* `middle_name`
* `phone_number`
* `photo_available`
* `residence_lga`
* `residence_state`
* `residence_town`

## Prezzi e SLA

Le query Nigeria National ID + Selfie (NIMC) vengono fatturate solo quando Didit riceve un risultato conclusivo dalla fonte di verifica.

* **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 dal lato di Didit; la disponibilità delle fonti a valle varia in base al paese e al dataset.

## Selfie e confronto facciale

Il registro NIMC restituisce l'intero record del titolare per un NIN valido, quindi conoscere un numero non dimostra di esserne il titolare. Per questo ogni ricerca è legata a un selfie: il selfie viene confrontato con la foto di registrazione che NIMC conserva per quel NIN, e il record viene restituito solo quando si tratta della stessa persona.

* **Corrispondenza:** `source_data` contiene il record NIMC e `face_match_score`. Nome e data di nascita che invii vengono confrontati con quelli del registro e riportati in `validation`; inviali per ottenere l'esito su nome e data di nascita, oppure omettili e leggi i valori del registro in `source_data`.
* **Persona diversa:** `BIOMETRIC_NO_MATCH`. Viene restituito solo `face_match_score`, senza dati personali.
* **Confronto non possibile:** `INCONCLUSIVE` quando NIMC non dispone di una foto per il NIN o quando non è stato possibile rilevare un volto. Non viene restituito nulla e la verifica viene inviata in revisione.
* **NIN sconosciuto:** `DOCUMENT_NOT_FOUND`. La ricerca viene comunque fatturata.

In un workflow, il selfie viene preso dal passaggio di rilevamento della vitalità o di confronto facciale, oppure dal ritratto presente sul documento caricato quando il workflow non prevede un passaggio facciale. Una richiesta senza selfie, o con un NIN che non è composto da 11 cifre, viene rifiutata prima di qualsiasi addebito.

## Continua a leggere

* [Panoramica della Validazione su database per la Nigeria](https://docs.didit.me/api-reference/database-validation/nigeria.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.