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

# Datenbankvalidierung Australien: Medicare-Karte (DVS) API

> Australische Medicare-Karten per autoritativer Datenbankvalidierung prüfen – mit Didit. Ab $0.75 pro Abfrage, ohne Verträge oder Mindestabnahme.

Prüft Eingabedaten anhand des Document Verification Service (DVS). Didit stellt diesen Dienst über `POST /v3/database-validation/` bereit, damit Sie die übermittelten Daten mit der maßgeblichen Quelle abgleichen und normalisierte Übereinstimmungsergebnisse erhalten. Eingabeformat: `medicare_card_number` nimmt die australische Medicare-Kartennummer entgegen (genau 10 Ziffern).

## Abdeckung

* **Abdeckung:** 100%\*
* **Land:** Australien
* **Service-ID:** `aus_australia_medicare_card`
* **Datenbereich:** Gesundheit
* **Kategorie:** Gesundheitswesen

## Eingaben

| Feld | Erforderlich | Beispiel |
| - | -: | - |
| `first_name` | Ja | `John` |
| `last_name` | Ja | `Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `medicare_card_number` | Ja | `1111111111` |
| `middle_name` | Nein | `Demo` |
| `vendor_data` | Nein | `user-1234` |

* **Erforderliche Eingaben:** `first_name`, `last_name`, `date_of_birth`, `medicare_card_number`
* **Optionale Eingaben:** `middle_name`, `vendor_data`
* **Einwilligung:** Erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** 100%\*
* **Preis:** \$0.75 pro erfolgreiche Abfrage

Nicht jedes Dokument, das dieser Dienst akzeptiert, enthält den Identifikator, anhand dessen die Abfrage durchgeführt wird. Wird der Identifikator nicht aus dem Dokument extrahiert, wird die Prüfung als **nicht anwendbar** erfasst - es wird keine Datenbank abgefragt und Ihnen wird nichts berechnet. In manchen Ländern betrifft dies einen großen Anteil der tatsächlichen Benutzer. Um sie abzudecken, erfassen Sie den Identifikator zusätzlich über eine Antwort aus einem Fragebogen, ein Feld aus der Document-AI-Extraktion oder einen Wert, den Sie beim Erstellen der Sitzung übermitteln, und ordnen Sie ihn dem Schritt Datenbankvalidierung zu.

## Body-Parameter

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

ISO-3166-1-Alpha-3-Ländercode für diesen Datenbankdienst.

Beispiel: `AUS`

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

Array mit dieser Service-ID. Das Festlegen des Dienstes beschränkt die Anfrage auf genau diese Datenbank.

Beispiel: `aus_australia_medicare_card`

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

Ausdrückliche Einwilligung des Endbenutzers für diesen Dienst.

Beispiel: `true`

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

Zu validierender Vorname.

Beispiel: `John`

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

Zu validierender Nachname.

Beispiel: `Doe`

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

Geburtsdatum im Format `YYYY-MM-DD`.

Beispiel: `1990-01-01`

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

Medicare-Kartennummer.

Beispiel: `1111111111`

**middle\_name** `string`

Zweiter Vorname, sofern verfügbar.

Beispiel: `Demo`

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

Ihre stabile Benutzerreferenz für diese Person, etwa Ihre interne Benutzer-ID. Didit verwendet sie, um eigenständige Prüfungen derselben Endbenutzer zuzuordnen und Fehlalarme bei der Dublettenerkennung zu verringern.

Beispiel: `user-1234`

## Eingaberegeln und Validierungshinweise

* Australische Medicare-Kartennummer (genau 10 Ziffern)
* `medicare_card_number` darf nur Ziffern enthalten; entfernen Sie vor dem Senden der Anfrage Leerzeichen, Bindestriche und Satzzeichen.
* `medicare_card_number` muss genau 10 Zeichen lang sein.

## So rufen Sie den Dienst auf

```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));
```

Jeder erfolgreiche Aufruf liefert HTTP `200` zurück. Das Feld **`outcome_code`** zeigt an, was tatsächlich passiert ist, und unterscheidet zum Beispiel einen echten biometrischen Nichtabgleich (`BIOMETRIC_NO_MATCH`) von einem Selfie, das nicht gelesen werden konnte (`BIOMETRIC_IMAGE_UNUSABLE`). Der angezeigte `status` ist der Standardstatus der Funktion; Ihre konfigurierten [Aktionen für Partial Match / No Match](https://docs.didit.me/de/core-technology/database-validation/database-validation-warnings.md) können ihn überschreiben.

**`MATCH`**: Das Register hat die Identität bestätigt, und jedes geprüfte Feld stimmte überein.

```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`**: Die Identifikationsnummer wurde gefunden, aber ein oder mehrere persönliche Felder (meist Name oder Geburtsdatum) stimmten nicht vollständig überein.

```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`**: Das Register hat für die übermittelten Daten keine Übereinstimmung zurückgegeben.

```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"
      }
    }
  ]
}
```

## Zurückgegebene Daten

Welche Felder genau in `source_data` erscheinen, hängt davon ab, was das Register zurückgibt. Das generierte Beispiel für `aus_australia_medicare_card` dokumentiert derzeit diese normalisierte Struktur:

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

## Preise & SLAs

Abfragen zur DVS – Australia Medicare Card werden nur berechnet, wenn Didit von der Validierungsquelle ein eindeutiges Ergebnis erhält.

* **Preis pro Aufruf:** \$0.75 USD.
* **Abrechnung:** pro erfolgreiche Abfrage. Ihnen wird nichts berechnet, wenn das Register nicht erreichbar ist, wenn Pflichtfelder fehlen oder wenn die Anfrage abgelehnt wird, bevor sie die Quelle erreicht.
* **Latenz:** typischerweise p95 unter 2 s.
* **Verfügbarkeit:** 99.9% pro Quartal auf Seiten von Didit; die Verfügbarkeit der nachgelagerten Quelle variiert je nach Land und Datensatz.

## Weiterlesen

* [Überblick über Datenbankvalidierung für Australien](https://docs.didit.me/api-reference/database-validation/australia.md)
* [Überblick über Datenbankvalidierung](https://docs.didit.me/de/core-technology/database-validation/overview.md)
* [Ergebniscodes](https://docs.didit.me/de/core-technology/database-validation/database-validation-outcome-codes.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.