> ## 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 Medicare Card Australia - API DVS

> Verifica della Medicare Card australiana su database ufficiali con Didit. A consumo da $0.75, senza contratti né minimi.

Verifica i dati inseriti rispetto al Document Verification Service (DVS). Didit espone questo servizio tramite `POST /v3/database-validation/`, così puoi confrontare i dati inviati con la fonte autorevole e ricevere risultati di corrispondenza normalizzati. Formato di input: `medicare_card_number` accetta il numero della tessera Medicare australiana (esattamente 10 cifre).

## Copertura

* **Copertura:** 100%\*
* **Paese:** Australia
* **ID servizio:** `aus_australia_medicare_card`
* **Dominio dei dati:** Salute
* **Categoria:** Assistenza sanitaria

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `first_name` | Sì | `John` |
| `last_name` | Sì | `Doe` |
| `date_of_birth` | Sì | `1990-01-01` |
| `medicare_card_number` | Sì | `1111111111` |
| `middle_name` | No | `Demo` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `first_name`, `last_name`, `date_of_birth`, `medicare_card_number`
* **Input facoltativi:** `middle_name`, `vendor_data`
* **Consenso:** Obbligatorio
* **Disponibilità nel workflow:** Disponibile nel workflow
* **Copertura:** 100%\*
* **Prezzo:** \$0.75 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**: nessun database viene interrogato e non ti viene addebitato nulla. In alcuni paesi questo riguarda una quota rilevante degli utenti reali. Per coprire questi casi, raccogli l'identificativo anche da una risposta di un Questionario, da un campo estratto da Document AI, oppure da un valore che invii quando crei la sessione, e mappalo nel passaggio Validazione su database.

## Parametri del corpo della richiesta

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

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

Esempio: `AUS`

**services** `string` *required* (default: aus\_australia\_medicare\_card)

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

Esempio: `aus_australia_medicare_card`

**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`

**medicare\_card\_number** `string` *required* (default: 1111111111)

Numero della tessera Medicare.

Esempio: `1111111111`

**middle\_name** `string`

Secondo nome, quando disponibile.

Esempio: `Demo`

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

Il tuo riferimento stabile per questa persona, ad esempio il tuo ID utente interno. Didit lo usa per collegare i controlli autonomi allo stesso utente finale e ridurre il rumore dovuto ai duplicati.

Esempio: `user-1234`

## Regole di input e note sulla validazione

* Numero della tessera Medicare australiana (esattamente 10 cifre)
* `medicare_card_number` deve contenere solo cifre: rimuovi spazi, trattini e punteggiatura prima di inviare la richiesta.
* `medicare_card_number` deve essere lungo esattamente 10 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=AUS" \
  -F "services=aus_australia_medicare_card" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "medicare_card_number=1111111111"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="AUS",
    services=["aus_australia_medicare_card"],
    consent=True,
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    medicare_card_number="1111111111",
    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: "AUS",
  services: ["aus_australia_medicare_card"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  medicare_card_number: "1111111111",
  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:       "AUS",
	Services:           didit.Some([]string{"aus_australia_medicare_card"}),
	Consent:            didit.Bool(true),
	FirstName:          didit.String("John"),
	LastName:           didit.String("Doe"),
	DateOfBirth:        didit.String("1990-01-01"),
	MedicareCardNumber: didit.String("1111111111"),
	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("AUS")
        .services(List.of("aus_australia_medicare_card"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .medicareCardNumber("1111111111")
        .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' => 'AUS',
    'services' => ['aus_australia_medicare_card'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'medicare_card_number' => '1111111111',
    '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: "AUS",
  services: ["aus_australia_medicare_card"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  medicare_card_number: "1111111111",
  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 = "AUS",
    Services = new string[] { "aus_australia_medicare_card" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    MedicareCardNumber = "1111111111",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è effettivamente successo: distingue, 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 tue [azioni Partial Match / No Match](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) configurate possono sostituirlo.

**`MATCH`**: il registro ha confermato l'identità e ogni campo verificato corrispondeva.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "AUS",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "aus_australia_medicare_card",
      "service_name": "DVS - Australia Medicare Card",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "middle_name": "Demo"
      },
      "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": "AUS",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "aus_australia_medicare_card",
      "service_name": "DVS - Australia Medicare Card",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "middle_name": "Demo"
      },
      "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": "AUS",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "aus_australia_medicare_card",
      "service_name": "DVS - Australia Medicare 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 esposti in `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `aus_australia_medicare_card` documenta al momento questa struttura normalizzata:

* `date_of_birth`
* `first_name`
* `identification_number`
* `last_name`
* `middle_name`

## Prezzi e SLA

Le query DVS per la tessera Medicare australiana vengono fatturate solo quando Didit riceve un risultato definitivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.75 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 inferiore a 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 della Validazione su database in Australia](https://docs.didit.me/api-reference/database-validation/australia.md)
* [Panoramica della Validazione su database](https://docs.didit.me/it/core-technology/database-validation/overview.md)
* [Codici degli esiti](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.