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

# Malaysia-Nationalausweis-Verifizierung API: Datenabgleich

> Malaysia-Nationalausweis-Prüfung per autoritativer Datenbank über Didit. Abrechnung pro Aufruf ab $0.59, keine Verträge, keine Mindestabnahme.

Prüft Eingabedaten gegen eine Datenbank einer Regierungsbehörde mit Daten malaysischer Staatsbürger. 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:** > 75%
* **Land:** Malaysia
* **Dienst-ID:** `mys_national_id`
* **Datendomäne:** Identität
* **Kategorie:** NationalIDRegistry

## Eingaben

| Feld | Erforderlich | Beispiel |
| - | -: | - |
| `full_name` | Ja | `John Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `national_id` | Ja | `111111111111` |
| `address.street_1` | Nein | `123 Sample Street` |
| `address.street_2` | Nein | `Unit 4` |
| `address.city` | Nein | `Sample City` |
| `address.region` | Nein | `Sample State` |
| `address.postal_code` | Nein | `10001` |
| `phone` | Nein | `+15550101000` |
| `vendor_data` | Nein | `user-1234` |

* **Pflichtfelder:** `full_name`, `date_of_birth`, `national_id`
* **Optionale Felder:** `address.street_1`, `address.street_2`, `address.city`, `address.region`, `address.postal_code`, `phone`, `vendor_data`
* **Einwilligung:** Erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** > 75%
* **Preis:** \$0.59 pro erfolgreiche Abfrage

Nicht jedes Dokument, das dieser Dienst akzeptiert, enthält den Identifikator, mit dem abgefragt wird. Wenn der Identifikator nicht aus dem Dokument extrahiert wird, wird die Prüfung als **nicht zutreffend** erfasst: Es wird keine Datenbank abgefragt, und Ihnen wird nichts berechnet. Für manche Länder betrifft das einen großen Anteil der tatsächlichen Nutzer. Um diese Nutzer abzudecken, erfassen Sie den Identifikator zusätzlich über eine Antwort aus einem Fragebogen, ein Extraktionsfeld von Document AI oder einen Wert, den Sie beim Erstellen der Sitzung übermitteln, und ordnen Sie ihn im Schritt „Datenbankvalidierung“ zu.

## Body-Parameter

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

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

Beispiel: `MYS`

**services** `string` *required* (default: mys\_national\_id)

Array mit der ID dieses Dienstes. Die Festlegung des Dienstes hält die Anfrage auf genau diese Datenbank beschränkt.

Beispiel: `mys_national_id`

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

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

Beispiel: `true`

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

Vollständiger amtlicher Name zur Validierung.

Beispiel: `John Doe`

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

Geburtsdatum im Format `YYYY-MM-DD`.

Beispiel: `1990-01-01`

**national\_id** `string` *required* (default: 111111111111)

Nationale Identitätsnummer für diesen Dienst.

Beispiel: `111111111111`

**address** `object`

Strukturiertes Objekt für die Wohnadresse. Verwenden Sie `street_1`, `street_2`, `city`, `region`, `postal_code` und `country`. Eine vollständige Legacy-Adresszeichenkette wird weiterhin akzeptiert, wird aber nicht empfohlen.

Beispiel: `{"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}`

**phone** `string`

Telefonnummer im internationalen Format.

Beispiel: `+15550101000`

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

Ihre stabile Benutzerreferenz für diese Person, zum Beispiel 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

* `address` ist für diesen Dienst optional. Sie können eine vollständige `address`-Zeichenkette senden, und Didit zerlegt sie nach Möglichkeit in strukturierte Adressbestandteile. Alternativ übermitteln Sie die strukturierten Felder explizit.
* `national_id` darf nur Ziffern enthalten. Entfernen Sie Leerzeichen, Bindestriche und Satzzeichen, bevor Sie die Anfrage senden.
* `national_id` muss genau 12 Zeichen lang sein.
* Verwenden Sie bei Adressdiensten nach Möglichkeit strukturierte Adressfelder statt einer einzelnen `address`-Zeichenkette.
* `address.street_1` ist die Straßenadresse einschließlich Hausnummer und Straßentyp.
* `address.street_2` ist Wohnung, Einheit, Gebäude, Etage oder eine zusätzliche Adresszeile. Senden Sie das Feld nur, wenn Sie diese Angabe haben.
* `address.city` ist Stadt, Vorort, Bezirk, Ortschaft oder Stadtteil.
* `address.region` ist Bundesstaat, Provinz, Region oder Stadt.
* `address.postal_code` ist die Postleitzahl.
* Adressbasierte Datenbankdienste erfordern mindestens Straßenadresse und Postleitzahl. Anfragen, die vor der Quellenabfrage 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=MYS" \
  -F "services=mys_national_id" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "full_name=John Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=111111111111"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="MYS",
    services=["mys_national_id"],
    consent=True,
    full_name="John Doe",
    date_of_birth="1990-01-01",
    national_id="111111111111",
    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: "MYS",
  services: ["mys_national_id"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  national_id: "111111111111",
  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: "MYS",
	Services:     didit.Some([]string{"mys_national_id"}),
	Consent:      didit.Bool(true),
	FullName:     didit.String("John Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	NationalID:   didit.String("111111111111"),
	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("MYS")
        .services(List.of("mys_national_id"))
        .consent(true)
        .fullName("John Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("111111111111")
        .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' => 'MYS',
    'services' => ['mys_national_id'],
    'consent' => true,
    'full_name' => 'John Doe',
    'date_of_birth' => '1990-01-01',
    'national_id' => '111111111111',
    '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: "MYS",
  services: ["mys_national_id"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  national_id: "111111111111",
  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 = "MYS",
    Services = new string[] { "mys_national_id" },
    Consent = true,
    FullName = "John Doe",
    DateOfBirth = "1990-01-01",
    NationalId = "111111111111",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Jeder erfolgreiche Aufruf liefert HTTP `200`. Das Feld **`outcome_code`** zeigt Ihnen, 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 [Teilübereinstimmung und keine Übereinstimmung](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 alle geprüften Felder stimmen überein.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "MYS",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "mys_national_id",
      "service_name": "Malaysia National ID",
      "source_data": {
        "address": "123 Sample Street",
        "address_match_score": "1.000",
        "city": "Sample City",
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "postal_code": "10001",
        "state": "Sample State",
        "street": "sample_value"
      },
      "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 (in der Regel Name oder Geburtsdatum) stimmen nicht vollständig überein.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "MYS",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "mys_national_id",
      "service_name": "Malaysia National ID",
      "source_data": {
        "address": "123 Sample Street",
        "address_match_score": "1.000",
        "city": "Sample City",
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "postal_code": "10001",
        "state": "Sample State",
        "street": "sample_value"
      },
      "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": "MYS",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "mys_national_id",
      "service_name": "Malaysia National ID",
      "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 konkret in `source_data` erscheinen, hängt davon ab, was das Register zurückgibt. Das generierte Beispiel für `mys_national_id` dokumentiert derzeit diese normalisierte Struktur:

* `address`
* `address_match_score`
* `city`
* `date_of_birth`
* `identification_number`
* `postal_code`
* `state`
* `street`

## Preise und SLAs

Abfragen der malaysischen nationalen ID werden nur abgerechnet, wenn Didit von der Validierungsquelle ein eindeutiges Ergebnis erhält.

* **Preis pro Aufruf:** \$0.59 USD.
* **Abrechnung:** pro erfolgreicher Abfrage. Sie zahlen nichts, wenn das Register nicht erreichbar ist, wenn erforderliche Felder fehlen oder wenn die Anfrage abgelehnt wird, bevor sie die Quelle erreicht.
* **Latenz:** typisch p95 \< 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

* [Übersicht Datenbankvalidierung für Malaysia](https://docs.didit.me/api-reference/database-validation/malaysia.md)
* [Übersicht 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.