> ## 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 EPIC India (ECI) di validazione su database

> Ricerca autorevole nel database indiano EPIC (Registrazione elettori, ECI) tramite Didit. Pay-per-call da $0.25, senza contratti né minimi.

Verifica i dati di input rispetto al database della Election Commission of India. Didit espone questo servizio tramite `POST /v3/database-validation/`, così puoi verificare i dati inviati rispetto alla fonte autorevole e ricevere risultati di corrispondenza normalizzati.

## Copertura

* **Copertura:** > 75%
* **Paese:** India
* **ID del servizio:** `ind_epic_voter_s_registration`
* **Dominio dei dati:** Governativo
* **Categoria:** ElectoralRoll

## Input

| Campo | Obbligatorio | Esempio |
| - | -: | - |
| `full_name` | Sì | `John Doe` |
| `date_of_birth` | Sì | `1990-01-01` |
| `epic_card` | Sì | `ABC1234567` |
| `vendor_data` | No | `user-1234` |

* **Input obbligatori:** `full_name`, `date_of_birth`, `epic_card`
* **Input facoltativi:** `vendor_data`
* **Consenso:** obbligatorio
* **Disponibilità nel workflow:** disponibile nel workflow con mappatura dei campi
* **Copertura:** > 75%
* **Prezzo:** \$0.25 per query riuscita

In un workflow, `epic_card` non è stampato su alcun documento d'identità, quindi nessun passaggio lo produce da solo. Raccoglilo da una risposta di un questionario, da un campo estratto da Document AI oppure da un valore che invii al momento della creazione della sessione, e mappalo sul passaggio Validazione su database. Finché non è mappato, l'editor del workflow mostra questo servizio disabilitato e indica l'input mancante. In esecuzione, un input mancante fa sì che il controllo venga saltato prima di qualsiasi query, così non ti viene mai addebitata una query su un database che non è stato possibile interrogare.

Non tutti i documenti accettati da questo servizio riportano l'identificativo con cui il servizio effettua la ricerca. Quando l'identificativo non viene estratto dal documento, il controllo viene registrato come **non applicabile**: non viene interrogato alcun database e non ti viene addebitato nulla. Per alcuni paesi questo riguarda una quota consistente degli utenti reali. Per coprirli, raccogli anche l'identificativo da una risposta di un questionario, da un campo estratto da Document AI oppure da un valore che invii al momento della creazione della sessione, e mappalo sul passaggio Validazione su database.

## Parametri del body

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

Codice paese ISO 3166-1 alpha-3 per questo servizio di database.

Esempio: `IND`

**services** `string` *required* (default: ind\_epic\_voter\_s\_registration)

Array che contiene l'ID di questo servizio. Specificare il servizio limita la richiesta a questo specifico database.

Esempio: `ind_epic_voter_s_registration`

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

Consenso esplicito dell'utente finale per questo servizio.

Esempio: `true`

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

Nome legale completo da validare.

Esempio: `John Doe`

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

Data di nascita nel formato `YYYY-MM-DD`.

Esempio: `1990-01-01`

**epic\_card** `string` *required* (default: ABC1234567)

Numero della tessera elettorale EPIC.

Esempio: `ABC1234567`

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

Il tuo riferimento stabile per questa persona, ad esempio il tuo ID utente interno. Didit lo usa per collegare i controlli indipendenti allo stesso utente finale e ridurre il rumore dovuto ai duplicati.

Esempio: `user-1234`

## Regole di input e note di validazione

* `epic_card` deve corrispondere a `[A-Za-z]{3}\d{7,14}`.

## Come effettuare la chiamata

```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_epic_voter_s_registration" \
  -F "vendor_data=user-1234" \
  -F "consent=true" \
  -F "full_name=John Doe" \
  -F "date_of_birth=1990-01-01" \
  -F "epic_card=ABC1234567"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="IND",
    services=["ind_epic_voter_s_registration"],
    consent=True,
    full_name="John Doe",
    date_of_birth="1990-01-01",
    epic_card="ABC1234567",
    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_epic_voter_s_registration"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  epic_card: "ABC1234567",
  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_epic_voter_s_registration"}),
	Consent:      didit.Bool(true),
	FullName:     didit.String("John Doe"),
	DateOfBirth:  didit.String("1990-01-01"),
	EpicCard:     didit.String("ABC1234567"),
	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_epic_voter_s_registration"))
        .consent(true)
        .fullName("John Doe")
        .dateOfBirth(LocalDate.parse("1990-01-01"))
        .epicCard("ABC1234567")
        .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_epic_voter_s_registration'],
    'consent' => true,
    'full_name' => 'John Doe',
    'date_of_birth' => '1990-01-01',
    'epic_card' => 'ABC1234567',
    '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_epic_voter_s_registration"],
  consent: true,
  full_name: "John Doe",
  date_of_birth: "1990-01-01",
  epic_card: "ABC1234567",
  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_epic_voter_s_registration" },
    Consent = true,
    FullName = "John Doe",
    DateOfBirth = "1990-01-01",
    EpicCard = "ABC1234567",
    VendorData = "user-1234",
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

Ogni chiamata riuscita restituisce HTTP `200`. Il campo **`outcome_code`** indica cosa è effettivamente accaduto, distinguendo ad esempio una reale mancata corrispondenza biometrica (`BIOMETRIC_NO_MATCH`) da un selfie che non è stato possibile leggere (`BIOMETRIC_IMAGE_UNUSABLE`). Lo `status` mostrato è lo stato predefinito della funzionalità; le tue [azioni Partial Match / No Match](https://docs.didit.me/it/core-technology/database-validation/database-validation-warnings.md) configurate possono sostituirlo.

**`MATCH`**: il registro ha confermato l'identità e ogni campo controllato corrispondeva.

```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_epic_voter_s_registration",
      "service_name": "India EPIC (Voter's Registration) (ECI)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345"
      },
      "validation": {
        "date_of_birth": "full_match",
        "full_name": "full_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`PARTIAL_MATCH`**: il numero di identificazione è stato trovato, ma uno o più campi personali (di solito nome o data di nascita) non corrispondevano completamente.

```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_epic_voter_s_registration",
      "service_name": "India EPIC (Voter's Registration) (ECI)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345"
      },
      "validation": {
        "date_of_birth": "full_match",
        "full_name": "no_match",
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`NO_MATCH`**: il registro non ha restituito alcuna corrispondenza per i dati inviati.

```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_epic_voter_s_registration",
      "service_name": "India EPIC (Voter's Registration) (ECI)",
      "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"
      }
    }
  ]
}
```

## Dati restituiti

I campi esatti esposti in `source_data` dipendono da ciò che restituisce il registro. L'esempio generato per `ind_epic_voter_s_registration` documenta al momento questa struttura normalizzata:

* `date_of_birth`
* `full_name`
* `identification_number`

## Prezzi e SLA

Le query India EPIC (Voter's Registration) (ECI) vengono fatturate solo quando Didit riceve un risultato conclusivo dalla fonte di validazione.

* **Prezzo per chiamata:** \$0.25 USD.
* **Fatturazione:** per query riuscita. Non ti viene addebitato nulla quando il registro non è raggiungibile, quando mancano campi obbligatori o quando la richiesta viene rifiutata prima di raggiungere la fonte.
* **Latenza:** p95 tipico \< 2 s.
* **Disponibilità:** 99.9% per trimestre lato Didit; la disponibilità della fonte a valle varia in base al paese e al dataset.

## Continua la lettura

* [Panoramica della Validazione su database per l'India](https://docs.didit.me/api-reference/database-validation/india.md)
* [Panoramica della Validazione su database](https://docs.didit.me/it/core-technology/database-validation/overview.md)
* [Codici di esito](https://docs.didit.me/it/core-technology/database-validation/database-validation-outcome-codes.md)


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