> ## 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 – DVS Heiratsurkunde API

> Australische Datenbankabfrage für Heiratsurkunden über Didit (DVS). Pay-per-call ab $0.75, ohne Verträge und ohne Mindestabnahme.

Überprüft Eingabedaten im 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.

## Abdeckung

* **Abdeckung:** 100%\*
* **Land:** Australien
* **Service-ID:** `aus_marriage_certificate`
* **Datenbereich:** Identität
* **Kategorie:** CivilRegistry

## Eingaben

| Feld | Erforderlich | Beispiel |
| - | -: | - |
| `first_name` | Ja | `John` |
| `last_name` | Ja | `Doe` |
| `first_partner_name` | Ja | `Jamie` |
| `last_partner_name` | Ja | `Example` |
| `marriage_certificate_number` | Ja | `SAMPLE-MARRIAGE-12345` |
| `birth_registration_number` | Ja | `SAMPLE-BIRTH-12345` |
| `birth_registration_state` | Ja | `Sample State` |
| `birth_registration_date` | Ja | `1990-01-01` |
| `vendor_data` | Nein | `user-1234` |

* **Pflicht-Eingaben:** `first_name`, `last_name`, `first_partner_name`, `last_partner_name`, `marriage_certificate_number`, `birth_registration_number`, `birth_registration_state`, `birth_registration_date`
* **Optionale Eingaben:** `vendor_data`
* **Einwilligung:** Erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow mit Feldzuordnung verfügbar
* **Abdeckung:** 100%\*
* **Preis:** \$0.75 pro erfolgreiche Abfrage

Im Workflow sind `first_partner_name`, `last_partner_name`, `birth_registration_state` und `birth_registration_date` nicht auf einem Ausweisdokument aufgedruckt, daher erzeugt kein Schritt diese Werte allein. Erfassen Sie sie über eine Antwort aus einem Fragebogen, ein Document-AI-Extraktionsfeld oder einen Wert, den Sie beim Erstellen der Sitzung übergeben, und ordnen Sie jeden davon im Schritt Datenbankvalidierung zu. Solange sie nicht zugeordnet sind, zeigt der Workflow-Editor diesen Dienst als deaktiviert an und benennt die fehlende Eingabe. Fehlt eine Eingabe zur Laufzeit, wird die Prüfung vor jeder Abfrage übersprungen. So wird Ihnen nie eine Datenbankabfrage berechnet, die nicht hätte ausgeführt werden können.

## 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\_marriage\_certificate)

Array mit der ID dieses Dienstes. Durch das Festlegen dieses Dienstes bleibt die Anfrage auf genau diese Datenbank beschränkt.

Beispiel: `aus_marriage_certificate`

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

**first\_partner\_name** `string` *required* (default: Jamie)

Von diesem Datenbankdienst erforderlicher Wert `first_partner_name`.

Beispiel: `Jamie`

**last\_partner\_name** `string` *required* (default: Example)

Von diesem Datenbankdienst erforderlicher Wert `last_partner_name`.

Beispiel: `Example`

**marriage\_certificate\_number** `string` *required* (default: SAMPLE-MARRIAGE-12345)

Von diesem Datenbankdienst erforderlicher Wert `marriage_certificate_number`.

Beispiel: `SAMPLE-MARRIAGE-12345`

**birth\_registration\_number** `string` *required* (default: SAMPLE-BIRTH-12345)

Von diesem Datenbankdienst erforderlicher Wert `birth_registration_number`.

Beispiel: `SAMPLE-BIRTH-12345`

**birth\_registration\_state** `string` *required* (default: Sample State)

Von diesem Datenbankdienst erforderlicher Wert `birth_registration_state`.

Beispiel: `Sample State`

**birth\_registration\_date** `string` *required* (default: 1990-01-01)

Von diesem Datenbankdienst erforderlicher Wert `birth_registration_date`.

Beispiel: `1990-01-01`

**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 demselben Endbenutzer zuzuordnen und das Rauschen bei der Dublettenerkennung zu verringern.

Beispiel: `user-1234`

## Regeln für Eingaben und Validierungshinweise

* Senden Sie die oben aufgeführten Felder exakt so, wie sie vom Benutzer oder aus dem Dokument erfasst wurden.
* Didit prüft Pflichtfelder, bevor die Datenbank aufgerufen wird. Anfragen, die vor der Abfrage der Quelle abgelehnt werden, werden nicht berechnet.

## So rufen Sie sie 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_marriage_certificate" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "first_partner_name=Jamie" \
  -F "last_partner_name=Example" \
  -F "marriage_certificate_number=SAMPLE-MARRIAGE-12345" \
  -F "birth_registration_number=SAMPLE-BIRTH-12345" \
  -F "birth_registration_state=Sample State" \
  -F "birth_registration_date=1990-01-01"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="AUS",
    services=["aus_marriage_certificate"],
    consent=True,
    first_name="John",
    last_name="Doe",
    birth_registration_number="SAMPLE-BIRTH-12345",
    birth_registration_date="1990-01-01",
    birth_registration_state="Sample State",
    marriage_certificate_number="SAMPLE-MARRIAGE-12345",
    first_partner_name="Jamie",
    last_partner_name="Example",
    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_marriage_certificate"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  birth_registration_number: "SAMPLE-BIRTH-12345",
  birth_registration_date: "1990-01-01",
  birth_registration_state: "Sample State",
  marriage_certificate_number: "SAMPLE-MARRIAGE-12345",
  first_partner_name: "Jamie",
  last_partner_name: "Example",
  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_marriage_certificate"}),
	Consent:                   didit.Bool(true),
	FirstName:                 didit.String("John"),
	LastName:                  didit.String("Doe"),
	BirthRegistrationNumber:   didit.String("SAMPLE-BIRTH-12345"),
	BirthRegistrationDate:     didit.String("1990-01-01"),
	BirthRegistrationState:    didit.String("Sample State"),
	MarriageCertificateNumber: didit.String("SAMPLE-MARRIAGE-12345"),
	FirstPartnerName:          didit.String("Jamie"),
	LastPartnerName:           didit.String("Example"),
	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_marriage_certificate"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .birthRegistrationNumber("SAMPLE-BIRTH-12345")
        .birthRegistrationDate(LocalDate.parse("1990-01-01"))
        .birthRegistrationState("Sample State")
        .marriageCertificateNumber("SAMPLE-MARRIAGE-12345")
        .firstPartnerName("Jamie")
        .lastPartnerName("Example")
        .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_marriage_certificate'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'birth_registration_number' => 'SAMPLE-BIRTH-12345',
    'birth_registration_date' => '1990-01-01',
    'birth_registration_state' => 'Sample State',
    'marriage_certificate_number' => 'SAMPLE-MARRIAGE-12345',
    'first_partner_name' => 'Jamie',
    'last_partner_name' => 'Example',
    '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_marriage_certificate"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  birth_registration_number: "SAMPLE-BIRTH-12345",
  birth_registration_date: "1990-01-01",
  birth_registration_state: "Sample State",
  marriage_certificate_number: "SAMPLE-MARRIAGE-12345",
  first_partner_name: "Jamie",
  last_partner_name: "Example",
  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_marriage_certificate" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    BirthRegistrationNumber = "SAMPLE-BIRTH-12345",
    BirthRegistrationDate = "1990-01-01",
    BirthRegistrationState = "Sample State",
    MarriageCertificateNumber = "SAMPLE-MARRIAGE-12345",
    FirstPartnerName = "Jamie",
    LastPartnerName = "Example",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Jeder erfolgreiche Aufruf liefert HTTP `200` zurück. Das Feld **`outcome_code`** zeigt, was tatsächlich passiert ist, und unterscheidet zum Beispiel eine echte biometrische Nichtübereinstimmung (`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_marriage_certificate",
      "service_name": "Australia - DVS – Marriage Certificate",
      "source_data": {
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "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_marriage_certificate",
      "service_name": "Australia - DVS – Marriage Certificate",
      "source_data": {
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "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_marriage_certificate",
      "service_name": "Australia - DVS – Marriage Certificate",
      "source_data": {
        "full_name": "NO_MATCH",
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "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 automatisch generierte Beispiel für `aus_marriage_certificate` dokumentiert derzeit diese normalisierte Struktur:

* `first_name`
* `identification_number`
* `last_name`

## Preise & SLAs

Australia - DVS – Marriage Certificate-Abfragen werden nur abgerechnet, wenn Didit ein eindeutiges Ergebnis von der Validierungsquelle erhält.

* **Preis pro Aufruf:** \$0.75 USD.
* **Abrechnung:** pro erfolgreicher Abfrage. Ihnen wird nichts berechnet, wenn das Register nicht erreichbar ist, wenn erforderliche Felder 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

* [Australien-Datenbankvalidierung – Übersicht](https://docs.didit.me/api-reference/database-validation/australia.md)
* [Datenbankvalidierung – Übersicht](https://docs.didit.me/de/core-technology/database-validation/overview.md)
* [Outcome-Codes](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.