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

# Brasilien Datenbankvalidierung API: Identitätsabgleich

> Didit bietet autoritative Datenbankvalidierung für Brasilien über seine Identitätsinfrastruktur. Pro Aufruf ab $0.59, keine Verträge, keine Mindestmenge.

Prüft anhand einer kombinierten Datenbank der Wählerregistrierungen. 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: `tax_number` nimmt die brasilianische CPF entgegen (genau 11 Ziffern).

## Abdeckung

* **Abdeckung:** \~ 95%
* **Land:** Brasilien
* **Service-ID:** `bra_residential`
* **Datenbereich:** Adresse
* **Kategorie:** Wohnsitz

## Eingaben

| Feld | Pflichtfeld | Beispiel |
| - | -: | - |
| `first_name` | Ja | `John` |
| `last_name` | Ja | `Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `address.street_1` | Ja | `123 Sample Street` |
| `address.postal_code` | Ja | `10001` |
| `tax_number` | Ja | `11111111111` |
| `address.street_2` | Nein | `Unit 4` |
| `address.city` | Nein | `Sample City` |
| `address.region` | Nein | `Sample State` |
| `vendor_data` | Nein | `user-1234` |

* **Pflichteingaben:** `first_name`, `last_name`, `date_of_birth`, `address.street_1`, `address.postal_code`, `tax_number`
* **Optionale Eingaben:** `address.street_2`, `address.city`, `address.region`, `vendor_data`
* **Einwilligung:** nicht erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** \~ 95%
* **Preis:** \$0.59 pro erfolgreicher Abfrage

Nicht jedes Dokument, das dieser Dienst akzeptiert, enthält die Kennung, über die abgefragt wird. Wenn die Kennung nicht aus dem Dokument extrahiert wird, 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 tatsächlichen Nutzer. Um sie abzudecken, erfassen Sie die Kennung zusätzlich über eine Fragebogen-Antwort, ein Document-AI-Extraktionsfeld oder einen Wert, den Sie beim Erstellen der Sitzung übermitteln, und ordnen Sie sie im Schritt „Datenbankvalidierung“ zu.

## Body-Parameter

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

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

Beispiel: `BRA`

**services** `string` *required* (default: bra\_residential)

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

Beispiel: `bra_residential`

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

Vorname, der validiert werden soll.

Beispiel: `John`

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

Nachname, der validiert werden soll.

Beispiel: `Doe`

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

Geburtsdatum im Format `YYYY-MM-DD`.

Beispiel: `1990-01-01`

**address** `object` *required* (default: \{"street\_1":"123 Sample Street","street\_2":"Unit 4","city":"Sample City","region":"Sample State","postal\_code":"10001","country":"US"})

Strukturiertes Objekt für die Wohnadresse. Verwenden Sie `street_1`, `street_2`, `city`, `region`, `postal_code` und `country`. Eine vollständige Adresszeichenfolge 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"}`

**tax\_number** `string` *required* (default: 11111111111)

Steuer- oder Identifikationsnummer.

Beispiel: `11111111111`

**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 mit demselben Endbenutzer zu verknüpfen und das Rauschen bei Dublettenerkennung zu verringern.

Beispiel: `user-1234`

## Regeln für Eingaben und Validierungshinweise

* Brasilianische CPF (genau 11 Ziffern)
* `tax_number` darf nur Ziffern enthalten; entfernen Sie vor dem Senden der Anfrage Leerzeichen, Bindestriche und Satzzeichen.
* `tax_number` muss genau 11 Zeichen lang sein.
* Bei Adressdiensten 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` enthält die Wohnungs-, Einheiten-, Gebäude- oder Etagenbezeichnung bzw. eine zusätzliche Adresszeile. Senden Sie es nur, wenn Sie es 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.

## Aufruf

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=BRA" \
  -F "services=bra_residential" \
  -F "vendor_data=user-1234" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "date_of_birth=1990-01-01" \
  -F 'address={"street_1":"123 Sample Street","street_2":"Unit 4","city":"Sample City","region":"Sample State","postal_code":"10001","country":"US"}' \
  -F "tax_number=11111111111"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="BRA",
    services=["bra_residential"],
    first_name="John",
    last_name="Doe",
    date_of_birth="1990-01-01",
    tax_number="11111111111",
    address={"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"},
    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: "BRA",
  services: ["bra_residential"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  tax_number: "11111111111",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  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: "BRA",
	Services:     didit.Some([]string{"bra_residential"}),
	FirstName:    didit.String("John"),
	LastName:     didit.String("Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	TaxNumber:    didit.String("11111111111"),
	Address:      didit.Some[any](map[string]any{"street_1": "123 Sample Street", "street_2": "Unit 4", "city": "Sample City", "region": "Sample State", "postal_code": "10001", "country": "US"}),
	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("BRA")
        .services(List.of("bra_residential"))
        .firstName("John")
        .lastName("Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .taxNumber("11111111111")
        .address(DatabaseValidationValidateParams.Address.ofVariant1(DatabaseValidationValidateParams.Address.Variant1.builder()
                .street1("123 Sample Street")
                .street2("Unit 4")
                .city("Sample City")
                .region("Sample State")
                .postalCode("10001")
                .country("US")
                .build()))
        .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' => 'BRA',
    'services' => ['bra_residential'],
    'first_name' => 'John',
    'last_name' => 'Doe',
    'date_of_birth' => '1990-01-01',
    'tax_number' => '11111111111',
    'address' => ['street_1' => '123 Sample Street', 'street_2' => 'Unit 4', 'city' => 'Sample City', 'region' => 'Sample State', 'postal_code' => '10001', 'country' => 'US'],
    '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: "BRA",
  services: ["bra_residential"],
  first_name: "John",
  last_name: "Doe",
  date_of_birth: "1990-01-01",
  tax_number: "11111111111",
  address: { street_1: "123 Sample Street", street_2: "Unit 4", city: "Sample City", region: "Sample State", postal_code: "10001", country: "US" },
  vendor_data: "user-1234"
)
puts result.to_h
```

```csharp .NET theme={null}
using System;
using System.Collections.Generic;
using System.Text.Json;
using Didit;

// Reads DIDIT_API_KEY.
using var client = new DiditClient();

var result = await client.DatabaseValidation.ValidateAsync(new DatabaseValidationValidateParams
{
    IssuingState = "BRA",
    Services = new string[] { "bra_residential" },
    FirstName = "John",
    LastName = "Doe",
    DateOfBirth = "1990-01-01",
    TaxNumber = "11111111111",
    Address = new Dictionary<string, object> { ["street_1"] = "123 Sample Street", ["street_2"] = "Unit 4", ["city"] = "Sample City", ["region"] = "Sample State", ["postal_code"] = "10001", ["country"] = "US" },
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Jeder erfolgreiche Aufruf gibt HTTP `200` zurück. Das Feld **`outcome_code`** zeigt an, was tatsächlich passiert ist. Es 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 jedes geprüfte Feld stimmte überein.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "BRA",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "bra_residential",
      "service_name": "Brazil Residential",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "address": "full_match",
        "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) stimmen nicht vollständig überein.

```json 200 OK — PARTIAL_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "BRA",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "bra_residential",
      "service_name": "Brazil Residential",
      "source_data": {
        "address": "123 Sample Street",
        "date_of_birth": "1990-01-01",
        "first_name": "John",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe"
      },
      "validation": {
        "address": "full_match",
        "date_of_birth": "full_match",
        "full_name": "no_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`NO_MATCH`** — Das Register hat für die übermittelten Daten keinen Treffer zurückgegeben.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "BRA",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "bra_residential",
      "service_name": "Brazil Residential",
      "source_data": {
        "address": "NO_MATCH",
        "date_of_birth": "NO_MATCH",
        "full_name": "NO_MATCH",
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "address": "no_match",
        "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. Die generierte Beispielantwort für `bra_residential` dokumentiert derzeit diese normalisierte Struktur:

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

## Preise und SLAs

Abfragen von Brazil Residential werden nur dann abgerechnet, wenn Didit von der Validierungsquelle ein schlüssiges Ergebnis erhält.

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