> ## 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 carta d'identità residenziale Indonesia API

> Verifica della carta d'identità residenziale indonesiana su database ufficiale con Didit. Da $0.35 a chiamata, senza contratti né minimi.

Verifica i dati di input rispetto a un ente governativo. Didit espone questo servizio tramite `POST /v3/database-validation/` in modo che tu possa verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di corrispondenza normalizzati.

## Copertura

* **Copertura:** \~ 90%
* **Paese:** Indonesia
* **ID servizio:** `idn_residential_identity_card`
* **Dominio dei dati:** Indirizzo
* **Categoria:** Residenziale

## Input

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

* **Input obbligatori:** `full_name`, `date_of_birth`, `national_id`, `address.street_1`, `address.postal_code`
* **Input facoltativi:** `address.street_2`, `address.city`, `address.region`, `gender`, `vendor_data`
* **Consenso:** Obbligatorio
* **Disponibilità nel workflow:** Disponibile nel workflow
* **Copertura:** \~ 90%
* **Prezzo:** \$0.35 per query riuscita

Non tutti i documenti accettati da questo servizio contengono l'identificativo con cui viene interrogato. 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 coprire anche questi casi, raccogli l'identificativo anche da una risposta del questionario, da un campo estratto da Document AI o da un valore che invii al momento della creazione della sessione, e mappalo nel passaggio di Validazione su database.

## Parametri del body

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

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

Esempio: `IDN`

**services** `string` *required* (default: idn\_residential\_identity\_card)

Array contenente questo ID servizio. Specificare il servizio limita la richiesta esattamente a questo database.

Esempio: `idn_residential_identity_card`

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

Consenso esplicito dell'utente finale per questo servizio.

Esempio: `true`

**full\_name** `string` *required* (default: John Doe)

Nome completo ufficiale da validare.

Esempio: `John 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: 1111111111111111)

Numero di identità nazionale per questo servizio.

Esempio: `1111111111111111`

**address** `object` *required* (default: \{"street\_1":"123 Sample Street","street\_2":"Unit 4","city":"Sample City","region":"Sample State","postal\_code":"10001","country":"US"})

Oggetto strutturato dell'indirizzo residenziale. Usa `street_1`, `street_2`, `city`, `region`, `postal_code` e `country`. Una stringa di indirizzo completa nel formato precedente è 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"}`

**gender** `string`

Valore del sesso, quando richiesto dal database.

Valori consentiti: `M` (maschio), `F` (femmina), `X` (altro o sconosciuto).

Esempio: `M`

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

Il tuo identificativo 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 segnali nel rilevamento dei duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* `national_id` deve contenere solo cifre; rimuovi spazi, trattini e segni di punteggiatura prima di inviare la richiesta.
* `national_id` deve essere lungo esattamente 16 caratteri.
* 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 se 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 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=IDN" \
  -F "services=idn_residential_identity_card" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "full_name=John Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=1111111111111111" \
  -F 'address={"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}'
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="IDN",
    services=["idn_residential_identity_card"],
    consent=True,
    full_name="John Doe",
    date_of_birth="1990-01-01",
    address={"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"},
    national_id="1111111111111111",
    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: "IDN",
  services: ["idn_residential_identity_card"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  national_id: "1111111111111111",
  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: "IDN",
	Services:     didit.Some([]string{"idn_residential_identity_card"}),
	Consent:      didit.Bool(true),
	FullName:     didit.String("John Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	Address:      didit.Some[any](map[string]any{"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"}),
	NationalID:   didit.String("1111111111111111"),
	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("IDN")
        .services(List.of("idn_residential_identity_card"))
        .consent(true)
        .fullName("John Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .address(DatabaseValidationValidateParams.Address.ofVariant1(DatabaseValidationValidateParams.Address.Variant1.builder()
                .street1("123 Sample Street")
                .street2("Unit 4")
                .city("Sample City")
                .region("Sample State")
                .postalCode("10001")
                .country("US")
                .build()))
        .nationalId("1111111111111111")
        .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' => 'IDN',
    'services' => ['idn_residential_identity_card'],
    'consent' => true,
    'full_name' => 'John Doe',
    'date_of_birth' => '1990-01-01',
    'address' => ['street_1' => '123 Sample Street', 'street_2' => 'Unit 4', 'city' => 'Sample City', 'region' => 'Sample State', 'postal_code' => '10001', 'country' => 'US'],
    'national_id' => '1111111111111111',
    '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: "IDN",
  services: ["idn_residential_identity_card"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  national_id: "1111111111111111",
  vendor_data: "user-1234"
)
puts result.to_h
```

```csharp .NET theme={null}
using System;
using System.Collections.Generic;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.DatabaseValidation.ValidateAsync(new DatabaseValidationValidateParams
{
    IssuingState = "IDN",
    Services = new string[] { "idn_residential_identity_card" },
    Consent = true,
    FullName = "John Doe",
    DateOfBirth = "1990-01-01",
    Address = new Dictionary<string, object> { ["street_1"] = "123 Sample Street", ["street_2"] = "Unit 4", ["city"] = "Sample City", ["region"] = "Sample State", ["postal_code"] = "10001", ["country"] = "US" },
    NationalId = "1111111111111111",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è successo effettivamente, 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 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": "IDN",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "idn_residential_identity_card",
      "service_name": "Indonesia Residential Identity Card",
      "source_data": {
        "address_match_score": "1.000",
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "verifications": {
          "address": true,
          "date_of_birth": true,
          "full_name": true,
          "identification_number": true
        }
      },
      "validation": {
        "address": "full_match",
        "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": "IDN",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "idn_residential_identity_card",
      "service_name": "Indonesia Residential Identity Card",
      "source_data": {
        "address_match_score": "1.000",
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "verifications": {
          "address": true,
          "date_of_birth": true,
          "full_name": false,
          "identification_number": true
        }
      },
      "validation": {
        "address": "full_match",
        "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": "IDN",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "idn_residential_identity_card",
      "service_name": "Indonesia Residential Identity Card",
      "source_data": {
        "address": "NO_MATCH",
        "date_of_birth": "NO_MATCH",
        "full_name": "NO_MATCH",
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "address": "no_match",
        "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 `idn_residential_identity_card` documenta attualmente questa struttura normalizzata:

* `address_match_score`
* `date_of_birth`
* `identification_number`

## Prezzi e SLA

Le query sulla Carta d'identità residenziale dell'Indonesia vengono fatturate 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 a seconda del paese e del dataset.

## Continua la lettura

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