> ## 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 bancaria Cina: API di lookup in tempo reale

> Validazione su database cinese delle carte bancarie con Didit. A consumo da $0.67, senza contratti né minimi.

Verifica i dati inseriti rispetto al servizio dati ufficiale in Cina. 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. Formato di input: `date_of_birth` accetta la data di nascita, che deve corrispondere alla data di nascita codificata nel documento d'identità nazionale cinese (cifre da 7 a 14 di un numero di 18 caratteri, cifre da 7 a 12 di un numero legacy di 15 cifre); `national_id` accetta il numero della carta d'identità di residente cinese (15 cifre oppure 18 caratteri con checksum).

## Copertura

* **Copertura:** \~ 100%
* **Paese:** Cina
* **ID servizio:** `chn_bank_card`
* **Dominio dei dati:** Finanziario
* **Categoria:** Bancario

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `full_name` | Sì | `王新伟` |
| `date_of_birth` | Sì | `1990-01-01` |
| `national_id` | Sì | `11010519900101003X` |
| `bank_card_number` | Sì | `4111111111111111` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `full_name`, `date_of_birth`, `national_id`, `bank_card_number`
* **Input facoltativi:** `vendor_data`
* **Consenso:** obbligatorio
* **Disponibilità nel workflow:** disponibile nel workflow con mappatura dei campi
* **Copertura:** \~ 100%
* **Prezzo:** \$0.67 per query riuscita

In un workflow, `bank_card_number` non è stampato su un documento d'identità, quindi nessun passaggio lo produce da solo. Raccoglilo da una risposta di un 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. Finché non è mappato, l'editor del workflow mostra questo servizio come disabilitato e indica l'input mancante; in fase di esecuzione, un input mancante fa sì che il controllo venga saltato prima di qualsiasi query, così non ti viene addebitato un database che non poteva essere interrogato.

## Parametri del body

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

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

Esempio: `CHN`

**services** `string` *required* (default: chn\_bank\_card)

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

Esempio: `chn_bank_card`

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

Consenso esplicito dell'utente finale per questo servizio.

Esempio: `true`

**full\_name** `string` *required* (default: 王新伟)

Nome legale completo da validare.

Esempio: `王新伟`

**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: 11010519900101003X)

Numero di identità nazionale per questo servizio.

Esempio: `11010519900101003X`

**bank\_card\_number** `string` *required* (default: 4111111111111111)

Numero della carta bancaria.

Esempio: `4111111111111111`

**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 nel rilevamento dei duplicati.

Esempio: `user-1234`

## Regole di input e note sulla validazione

* La data di nascita deve corrispondere alla data di nascita codificata nel documento d'identità nazionale cinese (cifre da 7 a 14 di un numero di 18 caratteri, cifre da 7 a 12 di un numero legacy di 15 cifre)
* `date_of_birth` deve corrispondere alla data di nascita codificata in `national_id`; la fonte rifiuta la richiesta immediatamente quando i due valori non coincidono, quindi una mancata corrispondenza viene respinta prima della ricerca e non viene addebitata.
* Numero della carta d'identità di residente cinese (15 cifre oppure 18 caratteri con checksum)
* `national_id` deve corrispondere a `(?:\d{15}|\d{17}[\dXx])`.
* Viene validato il carattere di controllo finale della Carta d'identità di residente cinese.
* `full_name` deve essere il nome originale in caratteri cinesi così come appare nel registro o sul documento. Non inviare la traslitterazione latina per i controlli sui database cinesi.

## 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=CHN" \
  -F "services=chn_bank_card" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "full_name=王新伟" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=11010519900101003X" \
  -F "bank_card_number=4111111111111111"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="CHN",
    services=["chn_bank_card"],
    consent=True,
    full_name="王新伟",
    date_of_birth="1990-01-01",
    national_id="11010519900101003X",
    bank_card_number="4111111111111111",
    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: "CHN",
  services: ["chn_bank_card"],
  consent: true,
  full_name: "王新伟",
  date_of_birth: "1990-01-01",
  national_id: "11010519900101003X",
  bank_card_number: "4111111111111111",
  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:   "CHN",
	Services:       didit.Some([]string{"chn_bank_card"}),
	Consent:        didit.Bool(true),
	FullName:       didit.String("王新伟"),
	DateOfBirth:    didit.String("1990-01-01"),
	NationalID:     didit.String("11010519900101003X"),
	BankCardNumber: didit.String("4111111111111111"),
	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("CHN")
        .services(List.of("chn_bank_card"))
        .consent(true)
        .fullName("王新伟")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("11010519900101003X")
        .bankCardNumber("4111111111111111")
        .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' => 'CHN',
    'services' => ['chn_bank_card'],
    'consent' => true,
    'full_name' => '王新伟',
    'date_of_birth' => '1990-01-01',
    'national_id' => '11010519900101003X',
    'bank_card_number' => '4111111111111111',
    '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: "CHN",
  services: ["chn_bank_card"],
  consent: true,
  full_name: "王新伟",
  date_of_birth: "1990-01-01",
  national_id: "11010519900101003X",
  bank_card_number: "4111111111111111",
  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 = "CHN",
    Services = new string[] { "chn_bank_card" },
    Consent = true,
    FullName = "王新伟",
    DateOfBirth = "1990-01-01",
    NationalId = "11010519900101003X",
    BankCardNumber = "4111111111111111",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** ti indica cosa è effettivamente accaduto, distinguendo, per 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 [Partial Match / No Match](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": "CHN",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "chn_bank_card",
      "service_name": "China Bank Card",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "full_name": "王新伟",
        "identification_number": "11010519900101003X"
      },
      "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": "CHN",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "chn_bank_card",
      "service_name": "China Bank Card",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "full_name": "王新伟",
        "identification_number": "11010519900101003X"
      },
      "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": "CHN",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "chn_bank_card",
      "service_name": "China Bank Card",
      "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 che compaiono in `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `chn_bank_card` documenta attualmente questa struttura normalizzata:

* `date_of_birth`
* `full_name`
* `identification_number`

## Prezzi e SLA

Le query China Bank Card vengono fatturate solo quando Didit riceve un risultato definitivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.67 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 della validazione su database in Cina](https://docs.didit.me/api-reference/database-validation/china.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.