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

# API de PAN de India (Permanent Account Number, ITD)

> Valida el PAN (Permanent Account Number) de India en la base oficial del ITD con Didit. Pago por consulta desde $0.42, sin contratos ni mínimos.

Verifica los datos de entrada con la base de datos del Departamento de Impuesto sobre la Renta de la India. Didit ofrece este servicio a través de `POST /v3/database-validation/` para que puedas verificar los datos enviados con la fuente oficial y recibir resultados de coincidencia normalizados.

## Cobertura

* **Cobertura:** \~ 100%
* **País:** India
* **ID de servicio:** `ind_pan_permanent_account_number`
* **Dominio de datos:** Financiero
* **Categoría:** TaxRegistry

## Datos de entrada

| Campo | Obligatorio | Ejemplo |
| - | -: | - |
| `full_name` | Sí | `John Doe` |
| `date_of_birth` | Sí | `1990-01-01` |
| `pan` | Sí | `ABCDE1234F` |
| `vendor_data` | No | `user-1234` |

* **Datos obligatorios:** `full_name`, `date_of_birth`, `pan`
* **Datos opcionales:** `vendor_data`
* **Consentimiento:** Obligatorio
* **Disponibilidad en el flujo de verificación (workflow):** Disponible en el flujo
* **Cobertura:** \~ 100%
* **Precio:** \$0.42 por consulta exitosa

No todos los documentos que acepta este servicio contienen el identificador con el que se realiza la consulta. Cuando el identificador no se extrae del documento, la comprobación se registra como **no aplicable** (no se consulta ninguna base de datos y no se te cobra), lo que, en algunos países, afecta a una gran proporción de usuarios reales. Para cubrirlos, recoge también el identificador a partir de una respuesta de un Cuestionario, un campo de extracción de Document AI o un valor que envíes al crear la sesión, y asígnalo al paso de Validación de base de datos.

## Parámetros del cuerpo

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

Código de país ISO 3166-1 alfa-3 de este servicio de base de datos.

Ejemplo: `IND`

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

Array que contiene el ID de este servicio. Fijar el servicio limita la solicitud a esta base de datos concreta.

Ejemplo: `ind_pan_permanent_account_number`

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

Consentimiento explícito del usuario final para este servicio.

Ejemplo: `true`

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

Nombre legal completo que se va a validar.

Ejemplo: `John Doe`

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

Fecha de nacimiento en formato `YYYY-MM-DD`.

Ejemplo: `1990-01-01`

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

Número de cuenta permanente.

Ejemplo: `ABCDE1234F`

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

Tu referencia de usuario estable para esta persona, como tu ID de usuario interno. Didit la usa para vincular las comprobaciones independientes al mismo usuario final y reducir el ruido en la detección de duplicados.

Ejemplo: `user-1234`

## Reglas de entrada y notas de validación

* `pan` debe usar letras mayúsculas.
* `pan` debe coincidir con `[A-Z]{5}\d{4}[A-Z]`.

## Cómo invocarlo

```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));
```

Toda llamada exitosa devuelve HTTP `200`. El campo **`outcome_code`** te indica lo que ocurrió realmente; distingue, por ejemplo, una falta de coincidencia biométrica real (`BIOMETRIC_NO_MATCH`) de una selfie que no se pudo leer (`BIOMETRIC_IMAGE_UNUSABLE`). El `status` que se muestra es el estado predeterminado de la función; las [acciones de coincidencia parcial / sin coincidencia](https://docs.didit.me/es/core-technology/database-validation/database-validation-warnings.md) que hayas configurado pueden anularlo.

**`MATCH`**: el registro confirmó la identidad y todos los campos comprobados coincidieron.

```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`**: se encontró el número de identificación, pero uno o varios campos personales (normalmente el nombre o la fecha de nacimiento) no coincidieron por completo.

```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`**: el registro no devolvió ninguna coincidencia para los datos enviados.

```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"
      }
    }
  ]
}
```

## Datos devueltos

Los campos exactos que aparecen en `source_data` dependen de lo que devuelva el registro. El ejemplo generado para `ind_pan_permanent_account_number` documenta actualmente esta estructura normalizada:

* `date_of_birth`
* `identification_number`

## Precios y SLA

Las consultas de PAN (Permanent Account Number) de India (ITD) solo se facturan cuando Didit recibe un resultado concluyente de la fuente de validación.

* **Precio por llamada:** \$0.42 USD.
* **Facturación:** por consulta exitosa. No se te cobra cuando no se puede acceder al registro, cuando faltan campos obligatorios o cuando la solicitud se rechaza antes de llegar a la fuente.
* **Latencia:** p95 típico \< 2 s.
* **Disponibilidad:** 99.9% por trimestre por parte de Didit; la disponibilidad de la fuente externa varía según el país y el conjunto de datos.

## Sigue leyendo

* [Descripción general de la validación de bases de datos de India](https://docs.didit.me/api-reference/database-validation/india.md)
* [Descripción general de la validación de bases de datos](https://docs.didit.me/es/core-technology/database-validation/overview.md)
* [Códigos de resultado](https://docs.didit.me/es/core-technology/database-validation/database-validation-outcome-codes.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.