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

# PAN (Permanent Account Number) Indien (ITD) API

> Indische PAN-Datenbankabfrage (ITD) über Didit: maßgebliche Datenbankvalidierung. Pay-per-call ab $0.42, keine Verträge, keine Mindestabnahme.

Prüft Eingabedaten gegen die Datenbank des Income Tax Department of India. Didit stellt diesen Dienst über `POST /v3/database-validation/` bereit, damit Sie die übermittelten Daten mit der maßgeblichen Quelle abgleichen und normalisierte Trefferergebnisse erhalten.

## Abdeckung

* **Abdeckung:** \~ 100%
* **Land:** Indien
* **Dienst-ID:** `ind_pan_permanent_account_number`
* **Datenbereich:** Finanzen
* **Kategorie:** TaxRegistry

## Eingaben

| Feld | Pflicht | Beispiel |
| - | -: | - |
| `full_name` | Ja | `John Doe` |
| `date_of_birth` | Ja | `1990-01-01` |
| `pan` | Ja | `ABCDE1234F` |
| `vendor_data` | Nein | `user-1234` |

* **Pflichteingaben:** `full_name`, `date_of_birth`, `pan`
* **Optionale Eingaben:** `vendor_data`
* **Einwilligung:** Erforderlich
* **Verfügbarkeit im Workflow:** Im Workflow verfügbar
* **Abdeckung:** \~ 100%
* **Preis:** \$0.42 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. Für manche Länder betrifft das einen großen Anteil der realen Nutzer. Um diese Nutzer abzudecken, sammeln Sie die Kennung zusätzlich über eine Antwort aus einem Fragebogen, ein Feld aus einer Document-AI-Extraktion oder einen Wert, den Sie beim Erstellen der Sitzung übermitteln, und ordnen Sie sie dem Schritt Datenbankvalidierung zu.

## Body-Parameter

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

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

Beispiel: `IND`

**services** `string` *required* (default: ind\_pan\_permanent\_account\_number)

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

Beispiel: `ind_pan_permanent_account_number`

**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, der validiert werden soll.

Beispiel: `John Doe`

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

Geburtsdatum im Format `YYYY-MM-DD`.

Beispiel: `1990-01-01`

**pan** `string` *required* (default: ABCDE1234F)

Permanent Account Number.

Beispiel: `ABCDE1234F`

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

Ihre dauerhafte Benutzerreferenz für diese Person, etwa Ihre interne Benutzer-ID. Didit verwendet sie, um eigenständige Prüfungen derselben Endbenutzer zuzuordnen und unnötige Dublettenerkennungen zu reduzieren.

Beispiel: `user-1234`

## Regeln für Eingaben und Validierungshinweise

* Die Buchstaben in `pan` müssen Großbuchstaben sein.
* `pan` muss dem Muster `[A-Z]{5}\d{4}[A-Z]` entsprechen.

## So rufen Sie den Dienst 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=IND" \
  -F "services=ind_pan_permanent_account_number" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "full_name=John Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "pan=ABCDE1234F"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

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

Jeder erfolgreiche Aufruf liefert HTTP `200`. Das Feld **`outcome_code`** zeigt, was tatsächlich passiert ist. So wird zum Beispiel 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 bei Teilübereinstimmung / keiner Ü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 stimmten überein.

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "IND",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "ind_pan_permanent_account_number",
      "service_name": "India PAN (Permanent Account Number) (ITD)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "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 personenbezogene 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": "IND",
  "match_type": "partial_match",
  "validations": [
    {
      "outcome_code": "PARTIAL_MATCH",
      "service_id": "ind_pan_permanent_account_number",
      "service_name": "India PAN (Permanent Account Number) (ITD)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "identification_number": "SAMPLE-ID-12345",
        "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 keinen Treffer zurückgegeben.

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "IND",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "ind_pan_permanent_account_number",
      "service_name": "India PAN (Permanent Account Number) (ITD)",
      "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 `ind_pan_permanent_account_number` dokumentiert derzeit diese normalisierte Struktur:

* `date_of_birth`
* `identification_number`

## Preise und SLAs

Abfragen der indischen PAN (Permanent Account Number) (ITD) werden nur berechnet, wenn Didit ein eindeutiges Ergebnis von der Validierungsquelle erhält.

* **Preis pro Aufruf:** \$0.42 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 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

* [Übersicht zur Datenbankvalidierung in Indien](https://docs.didit.me/api-reference/database-validation/india.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.