> ## 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 del CPR danese: API di confronto dei dati

> Validazione su database del CPR danese tramite Didit: fonte autorevole, pagamento a chiamata da $2.32, nessun contratto né minimo.

Verifica i dati inseriti rispetto al servizio Civil Registration. Didit espone questo servizio tramite `POST /v3/database-validation/` in modo che tu possa confrontare i dati inviati con la fonte autorevole e ricevere risultati normalizzati del confronto.

## Copertura

* **Copertura:** \~ 100%
* **Paese:** Danimarca
* **ID servizio:** `dnk_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ì | `0101901234` |
| `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:** Non richiesto
* **Disponibilità nel workflow:** Disponibile nel workflow
* **Copertura:** \~ 100%
* **Prezzo:** \$2.32 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. In alcuni paesi questo riguarda una parte consistente degli utenti reali. Per coprire anche questi casi, raccogli l'identificativo anche da una risposta di un questionario, da un campo di estrazione di Document AI oppure da un valore che invii quando crei la sessione, e mappalo nel passaggio Validazione su database.

## Parametri del corpo

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

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

Esempio: `DNK`

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

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

Esempio: `dnk_national_id`

**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: 0101901234)

Numero identificativo nazionale per questo servizio.

Esempio: `0101901234`

**address** `object`

Oggetto strutturato dell'indirizzo di residenza. Usa `street_1`, `street_2`, `city`, `region`, `postal_code` e `country`. Una stringa di indirizzo completa nel vecchio formato è 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 stabile per questa persona, come il tuo ID utente interno. Didit lo usa per collegare le verifiche autonome allo stesso utente finale e ridurre i falsi positivi nel rilevamento dei duplicati.

Esempio: `user-1234`

## Regole di input e note sulla validazione

* `address` è facoltativo per questo servizio. Puoi inviare un'unica 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}-?\d{4}`.
* Per i servizi basati sull'indirizzo, invia i campi strutturati dell'indirizzo invece di un'unica 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 ce l'hai.
* `address.city` è la città, il quartiere, il distretto, la località o il rione.
* `address.region` è lo stato, la provincia, la regione o la cittadina.
* `address.postal_code` è il CAP o il codice postale.
* I servizi di database basati sull'indirizzo richiedono almeno l'indirizzo stradale e il codice postale; le richieste rifiutate prima della ricerca nella 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=DNK" \
  -F "services=dnk_national_id" \
  -F "vendor_data=user-1234" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=0101901234"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="DNK",
    services=["dnk_national_id"],
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    national_id="0101901234",
    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: "DNK",
  services: ["dnk_national_id"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "0101901234",
  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: "DNK",
	Services:     didit.Some([]string{"dnk_national_id"}),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	NationalID:   didit.String("0101901234"),
	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("DNK")
        .services(List.of("dnk_national_id"))
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("0101901234")
        .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' => 'DNK',
    'services' => ['dnk_national_id'],
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'national_id' => '0101901234',
    '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: "DNK",
  services: ["dnk_national_id"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "0101901234",
  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 = "DNK",
    Services = new string[] { "dnk_national_id" },
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    NationalId = "0101901234",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è realmente 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 [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 ogni campo verificato corrisponde.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "DNK",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "dnk_national_id",
      "service_name": "Denmark National ID",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000",
        "verifications": {
          "date_of_birth": true,
          "full_name": true,
          "identification_number": true
        }
      },
      "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ù dati 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": "DNK",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "dnk_national_id",
      "service_name": "Denmark National ID",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000",
        "verifications": {
          "date_of_birth": true,
          "full_name": false,
          "identification_number": true
        }
      },
      "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": "DNK",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "dnk_national_id",
      "service_name": "Denmark 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 di `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `dnk_national_id` documenta attualmente questa struttura normalizzata:

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

## Prezzi e SLA

Le query per l'ID nazionale danese vengono fatturate solo quando Didit riceve un risultato definitivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$2.32 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.

## Continua la lettura

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