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

# Schweden Ausweisverifizierung: API für Identitätsabgleich

> Didit validiert schwedische nationale IDs gegen autoritative Datenbanken. Pay-per-Call ab $0.59, ohne Verträge und Mindestabnahme.

Prüft Eingabedaten gegen den Dienst der schwedischen Polizeibehörde. 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:** Schweden
* **Dienst-ID:** `swe_national_id`
* **Datenbereich:** Identität
* **Kategorie:** NationalIDRegistry

## Eingaben

| Feld | Erforderlich | Beispiel |
| - | -: | - |
| `first_name` | Ja | `John` |
| `last_name` | Ja | `Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `national_id` | Ja | `199001011234` |
| `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` |

* **Erforderliche Eingaben:** `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:** Nicht erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** \~ 100%
* **Preis:** \$0.59 pro erfolgreiche Abfrage

Nicht jedes Dokument, das dieser Dienst akzeptiert, enthält den Identifikator, über den 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 einige Länder betrifft dies einen großen Anteil realer Nutzer. Um diese Fälle 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 dem Schritt Datenbankvalidierung zu.

## Body-Parameter

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

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

Beispiel: `SWE`

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

Array, das diese Dienst-ID enthält. Das Festlegen des Dienstes beschränkt die Anfrage auf genau diese Datenbank.

Beispiel: `swe_national_id`

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

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

Nationale Personenkennziffer für diesen Dienst.

Beispiel: `199001011234`

**address** `object`

Strukturiertes Objekt für die Wohnadresse. Verwenden Sie `street_1`, `street_2`, `city`, `region`, `postal_code` und `country`. Eine vollständige Adresszeichenfolge im Altformat 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 demselben Endbenutzer zuzuordnen und Rauschen bei der Duplikaterkennung zu verringern.

Beispiel: `user-1234`

## Eingaberegeln und Validierungshinweise

* `address` ist für diesen Dienst optional. Sie können eine vollständige `address`-Zeichenfolge übermitteln, und Didit zerlegt sie nach Möglichkeit in strukturierte Adressbestandteile. Alternativ können Sie die strukturierten Felder explizit übermitteln.
* `national_id` darf nur Ziffern enthalten. Entfernen Sie Leerzeichen, Bindestriche und Satzzeichen, bevor Sie die Anfrage senden.
* `national_id` muss dem Muster `(\d{10}|\d{12})` entsprechen.
* Verwenden Sie bei Adressdiensten nach Möglichkeit strukturierte Adressfelder statt einer einzelnen `address`-Zeichenfolge.
* `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. Übermitteln Sie sie nur, wenn Sie sie haben.
* `address.city` ist Stadt, Stadtteil, Bezirk, Ortschaft oder Viertel.
* `address.region` ist Bundesland, Provinz, Region oder Stadt.
* `address.postal_code` ist die Postleitzahl.
* Adressbasierte Datenbankdienste erfordern mindestens Straßenadresse und Postleitzahl. Anfragen, die vor der Abfrage der Quelle abgelehnt werden, werden nicht berechnet.

## So wird die Funktion aufgerufen

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=SWE" \
  -F "services=swe_national_id" \
  -F "vendor_data=user-1234" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "national_id=199001011234"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="SWE",
    services=["swe_national_id"],
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    national_id="199001011234",
    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: "SWE",
  services: ["swe_national_id"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "199001011234",
  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: "SWE",
	Services:     didit.Some([]string{"swe_national_id"}),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	NationalID:   didit.String("199001011234"),
	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("SWE")
        .services(List.of("swe_national_id"))
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .nationalId("199001011234")
        .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' => 'SWE',
    'services' => ['swe_national_id'],
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'national_id' => '199001011234',
    '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: "SWE",
  services: ["swe_national_id"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  national_id: "199001011234",
  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 = "SWE",
    Services = new string[] { "swe_national_id" },
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    NationalId = "199001011234",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Jeder erfolgreiche Aufruf gibt HTTP `200` zurück. 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 Standard-Funktionsstatus. 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": "SWE",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "swe_national_id",
      "service_name": "Sweden National ID",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000",
        "verifications": {
          "date_of_birth": true,
          "full_name": true,
          "identification_number": true
        }
      },
      "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": "SWE",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "swe_national_id",
      "service_name": "Sweden National ID",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "name_match_score": "1.000",
        "verifications": {
          "date_of_birth": true,
          "full_name": false,
          "identification_number": true
        }
      },
      "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": "SWE",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "swe_national_id",
      "service_name": "Sweden 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 `swe_national_id` dokumentiert derzeit diese normalisierte Struktur:

* `date_of_birth`
* `first_name`
* `full_name`
* `identification_number`
* `last_name`
* `name_match_score`

## Preise & SLAs

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

* **Preis pro Aufruf:** \$0.59 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:** typischer p95-Wert \< 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 zur schwedischen Datenbankvalidierung](https://docs.didit.me/api-reference/database-validation/sweden.md)
* [Übersicht zur Datenbankvalidierung](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.