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

# Finnische Ausweisverifizierung per API: Datenbankabgleich

> Finnische Datenbankvalidierung der Ausweisnummer über Didits Identitäts-Infrastruktur. Abrechnung pro Aufruf ab $3.50, keine Verträge, keine Mindestabnahme.

Prüft Eingabedaten gegen die offizielle ausstellende Behörde des finnischen Personalausweises. Didit stellt diesen Service über `POST /v3/database-validation/` bereit, damit Sie die übermittelten Daten gegen die maßgebliche Quelle prüfen und normalisierte Übereinstimmungsergebnisse erhalten.

## Abdeckung

* **Abdeckung:** \~ 100%
* **Land:** Finnland
* **Service-ID:** `fin_national_id`
* **Datenbereich:** Identität
* **Kategorie:** NationalIDRegistry

## Eingaben

| Feld | Pflicht | Beispiel |
| - | -: | - |
| `first_name` | Ja | `John` |
| `last_name` | Ja | `Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `national_id` | Ja | `010190-123A` |
| `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` |
| `vendor_data` | Nein | `user-1234` |

* **Pflichteingaben:** `first_name`, `last_name`, `date_of_birth`, `national_id`
* **Optionale Eingaben:** `address.street_1`, `address.street_2`, `address.city`, `address.region`, `address.postal_code`, `vendor_data`
* **Einwilligung:** Erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** \~ 100%
* **Preis:** \$3.50 pro erfolgreiche Abfrage

Nicht jedes Dokument, das dieser Service akzeptiert, enthält den Identifikator, über den abgefragt wird. Wird der Identifikator nicht aus dem Dokument extrahiert, wird die Prüfung als **nicht zutreffend** erfasst – es wird keine Datenbank abgefragt, und Ihnen wird nichts berechnet. Bei manchen Ländern betrifft das einen großen Teil der realen Nutzer. Um auch diese Nutzer abzudecken, erfassen Sie den Identifikator zusätzlich über eine Antwort aus einem Fragebogen, ein Document-AI-Extraktionsfeld oder einen Wert, den Sie beim Erstellen der Sitzung senden, und ordnen ihn im Schritt zur Datenbankvalidierung zu.

## Body-Parameter

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

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

Beispiel: `FIN`

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

Array mit der ID dieses Service. Das Festlegen des Service hält die Anfrage auf genau diese Datenbank beschränkt.

Beispiel: `fin_national_id`

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

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

Beispiel: `true`

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

Zu prüfender Vorname.

Beispiel: `John`

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

Zu prüfender Nachname.

Beispiel: `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: 010190-123A)

Personenidentifikationsnummer für diesen Service.

Beispiel: `010190-123A`

**address** `object`

Strukturiertes Objekt für die Wohnadresse. Verwenden Sie `street_1`, `street_2`, `city`, `region`, `postal_code` und `country`. Ein vollständiger Adressstring im alten Format wird weiterhin akzeptiert, ist aber nicht empfohlen.

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

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

Ihre stabile Benutzerreferenz für diese Person, etwa Ihre interne Benutzer-ID. Didit nutzt sie, um eigenständige Prüfungen derselben Endbenutzer zuzuordnen und das Rauschen bei der Erkennung von Duplikaten zu reduzieren.

Beispiel: `user-1234`

## Eingaberegeln und Hinweise zur Validierung

* `address` ist für diesen Service optional. Sie können einen vollständigen `address`-String senden, den Didit nach Möglichkeit in strukturierte Adressbestandteile aufteilt, oder Sie senden die strukturierten Felder explizit.
* `national_id` muss dem Muster `(?:\d{6}[-+A]\d{3}[0-9A-Z]|\d{6}\d{3}[0-9A-Z])` entsprechen.
* Bei Adress-Services senden Sie nach Möglichkeit strukturierte Adressfelder statt eines einzelnen `address`-Strings.
* `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 es nur, wenn Sie diese Angabe haben.
* `address.city` ist Stadt, Vorort, Bezirk, Ortschaft oder Viertel.
* `address.region` ist Bundesland, Provinz, Region oder Ort.
* `address.postal_code` ist die Postleitzahl.
* Adressbasierte Datenbankservices erfordern mindestens eine Straßenadresse und eine Postleitzahl. Anfragen, die vor der Quellenabfrage abgelehnt werden, werden nicht berechnet.

## So rufen Sie es 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=FIN" \
  -F "services=fin_national_id" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=010190-123A"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="FIN",
    services=["fin_national_id"],
    consent=True,
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    national_id="010190-123A",
    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: "FIN",
  services: ["fin_national_id"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "010190-123A",
  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: "FIN",
	Services:     didit.Some([]string{"fin_national_id"}),
	Consent:      didit.Bool(true),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	NationalID:   didit.String("010190-123A"),
	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("FIN")
        .services(List.of("fin_national_id"))
        .consent(true)
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("010190-123A")
        .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' => 'FIN',
    'services' => ['fin_national_id'],
    'consent' => true,
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'national_id' => '010190-123A',
    '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: "FIN",
  services: ["fin_national_id"],
  consent: true,
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "010190-123A",
  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 = "FIN",
    Services = new string[] { "fin_national_id" },
    Consent = true,
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    NationalId = "010190-123A",
    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. So wird etwa eine echte biometrische Nichtübereinstimmung (`BIOMETRIC_NO_MATCH`) von einem Selfie unterschieden, 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 alle geprüften Felder stimmten überein.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "FIN",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland National ID",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "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": "FIN",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland National ID",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "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": "FIN",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "fin_national_id",
      "service_name": "Finland 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 genau in `source_data` erscheinen, hängt davon ab, was das Register zurückgibt. Das generierte Beispiel für `fin_national_id` dokumentiert derzeit diese normalisierte Struktur:

* `address`
* `date_of_birth`
* `first_name`
* `identification_number`
* `last_name`

## Preise & SLAs

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

* **Preis pro Aufruf:** \$3.50 USD.
* **Abrechnung:** pro erfolgreicher 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 \< 2 s.
* **Verfügbarkeit:** 99.9% pro Quartal auf Seiten von Didit. Die Verfügbarkeit der nachgelagerten Quellen variiert je nach Land und Datensatz.

## Weiterlesen

* [Übersicht zur Datenbankvalidierung für Finnland](https://docs.didit.me/api-reference/database-validation/finland.md)
* [Übersicht zur Datenbankvalidierung](https://docs.didit.me/de/core-technology/database-validation/overview.md)
* [Ergebnis-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.