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

# Validazione su database Finlandia: ID nazionale API

> Validazione su database dell'ID nazionale finlandese tramite Didit. Verifica autorevole, a consumo da $3.50, senza contratti né minimi.

Verifica i dati inseriti con l'ente emittente ufficiale della carta d'identità finlandese. 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:** Finlandia
* **ID del servizio:** `fin_national_id`
* **Dominio dei dati:** Identità
* **Categoria:** NationalIDRegistry

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `first_name` | Sì | `John` |
| `last_name` | Sì | `Doe` |
| `date_of_birth` | Sì | `1990-01-01` |
| `national_id` | Sì | `010190-123A` |
| `address.street_1` | No | `123 Sample Street` |
| `address.street_2` | No | `Unit 4` |
| `address.city` | No | `Sample City` |
| `address.region` | No | `Sample State` |
| `address.postal_code` | No | `10001` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `first_name`, `last_name`, `date_of_birth`, `national_id`
* **Input facoltativi:** `address.street_1`, `address.street_2`, `address.city`, `address.region`, `address.postal_code`, `vendor_data`
* **Consenso:** obbligatorio
* **Disponibilità nel workflow:** disponibile nel workflow
* **Copertura:** \~ 100%
* **Prezzo:** \$3.50 per query riuscita

Non tutti i documenti accettati da questo servizio contengono l'identificativo con cui viene effettuata la query. 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 alcun costo. Per alcuni paesi, questo riguarda una quota rilevante degli utenti reali. Per coprire questi casi, raccogli l'identificativo anche da una risposta al questionario, da un campo di estrazione di Document AI oppure da un valore che invii al momento della creazione della sessione, e mappalo nel passaggio di Validazione su database.

## Parametri del corpo della richiesta

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

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

Esempio: `FIN`

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

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

Esempio: `fin_national_id`

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

Consenso esplicito dell'utente finale per questo servizio.

Esempio: `true`

**first\_name** `string` *required* (default: John)

Nome da validare.

Esempio: `John`

**last\_name** `string` *required* (default: Doe)

Cognome da validare.

Esempio: `Doe`

**date\_of\_birth** `string` *required* (default: 1990-01-01)

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

Esempio: `1990-01-01`

**national\_id** `string` *required* (default: 010190-123A)

Numero identificativo nazionale per questo servizio.

Esempio: `010190-123A`

**address** `object`

Oggetto strutturato con l'indirizzo di residenza. Usa `street_1`, `street_2`, `city`, `region`, `postal_code` e `country`. Una stringa di indirizzo completa in formato legacy è ancora accettata, ma non è consigliata.

Esempio: `{"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}`

**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 indipendenti allo stesso utente finale e ridurre i falsi positivi nel rilevamento dei duplicati.

Esempio: `user-1234`

## Regole sugli input e note di validazione

* `address` è facoltativo per questo servizio. Puoi inviare una stringa `address` completa e Didit la suddividerà in elementi strutturati dell'indirizzo, quando possibile, oppure puoi inviare esplicitamente i campi strutturati.
* `national_id` deve corrispondere a `(?:\d{6}[-+A]\d{3}[0-9A-Z]|\d{6}\d{3}[0-9A-Z])`.
* Per i servizi basati sull'indirizzo, invia i campi strutturati dell'indirizzo invece di una singola stringa `address`, quando possibile.
* `address.street_1` è l'indirizzo stradale, incluso il numero civico e il tipo di via.
* `address.street_2` è l'interno, l'unità, l'edificio, il piano o una riga aggiuntiva dell'indirizzo. Invialo solo quando lo hai.
* `address.city` è la città, il quartiere, il distretto, la località o il rione.
* `address.region` è lo stato, la provincia, la regione o il comune.
* `address.postal_code` è il codice di avviamento postale (CAP).
* I servizi database basati sull'indirizzo richiedono almeno la via e il codice postale; le richieste rifiutate prima della consultazione della fonte non vengono addebitate.

## 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=FIN" \
  -F "services=fin_national_id" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=010190-123A"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="FIN",
    services=["fin_national_id"],
    consent=True,
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    national_id="010190-123A",
    vendor_data="user-1234",
)
print(result)
```

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

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

const result = await didit.databaseValidation.validate({
  issuing_state: "FIN",
  services: ["fin_national_id"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "010190-123A",
  vendor_data: "user-1234",
});
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: "FIN",
	Services:     didit.Some([]string{"fin_national_id"}),
	Consent:      didit.Bool(true),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	NationalID:   didit.String("010190-123A"),
	VendorData:   didit.String("user-1234"),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
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("FIN")
        .services(List.of("fin_national_id"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("010190-123A")
        .vendorData("user-1234")
        .build());
System.out.println(result);
```

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

require 'vendor/autoload.php';

use Didit\DiditClient;

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

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'FIN',
    'services' => ['fin_national_id'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'national_id' => '010190-123A',
    'vendor_data' => 'user-1234',
]);
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: "FIN",
  services: ["fin_national_id"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "010190-123A",
  vendor_data: "user-1234"
)
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 = "FIN",
    Services = new string[] { "fin_national_id" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    NationalId = "010190-123A",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica l'esito effettivo, distinguendo ad esempio una reale 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 [azioni Corrispondenza parziale / Nessuna corrispondenza](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": "FIN",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland National ID",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "date_of_birth": "full_match",
        "full_name": "full_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`**: il numero di identificazione è stato trovato, ma uno o più campi personali (di solito nome o data di nascita) non corrispondono completamente.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "FIN",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland National ID",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "date_of_birth": "full_match",
        "full_name": "no_match",
        "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": "FIN",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland National ID",
      "source_data": {
        "date_of_birth": "NO_MATCH",
        "full_name": "NO_MATCH",
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "date_of_birth": "no_match",
        "full_name": "no_match",
        "identification_number": "no_match"
      }
    }
  ]
}
```

## Dati restituiti

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

* `address`
* `date_of_birth`
* `first_name`
* `identification_number`
* `last_name`

## Prezzi e SLA

Le interrogazioni dell'ID nazionale finlandese vengono fatturate solo quando Didit riceve un risultato conclusivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$3.50 USD.
* **Fatturazione:** per interrogazione 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 a leggere

* [Panoramica sulla validazione su database per la Finlandia](https://docs.didit.me/api-reference/database-validation/finland.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.