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

# अर्जेंटीना DNI सत्यापन (RENAPER) API

> Didit के माध्यम से अर्जेंटीना के आधिकारिक डेटाबेस में DNI सत्यापन (RENAPER)। प्रति कॉल $0.20 से, कोई अनुबंध नहीं, कोई न्यूनतम नहीं।

आधिकारिक RENAPER नागरिक रजिस्ट्री के विरुद्ध अर्जेंटीना DNI का सत्यापन करता है, और रिकॉर्ड में मौजूद फ़ोटो से बायोमेट्रिक चेहरा मिलान करता है। जनसंख्या कवरेज 100%। Didit इस सेवा को `POST /v3/database-validation/` के ज़रिए उपलब्ध कराता है, ताकि आप सबमिट किए गए डेटा की प्रामाणिक स्रोत से तुलना कर सकें और नॉर्मलाइज़्ड मिलान परिणाम पा सकें। इनपुट फ़ॉर्मैट: `document_number` में अर्जेंटीना DNI लिया जाता है (7-8 अंक, वैकल्पिक M/F उपसर्ग)।

## कवरेज

* **कवरेज:** 100%
* **देश:** अर्जेंटीना
* **सेवा ID:** `arg_renaper`
* **डेटा डोमेन:** पहचान
* **श्रेणी:** राष्ट्रीय पहचान रजिस्ट्री

RENAPER वह रजिस्ट्री है जो हर अर्जेंटीना DNI जारी करती है, इसलिए हर DNI नंबर रिकॉर्ड में होता है, जिसमें विदेशी निवासियों को जारी किए गए DNI भी शामिल हैं। चेहरा मिलान सेल्फ़ी की तुलना उस फ़ोटो से करता है जो RENAPER के पास उस DNI के लिए होती है।

## इनपुट

| फ़ील्ड | आवश्यक | उदाहरण |
| - | -: | - |
| `document_number` | हाँ | `11111111` |
| `selfie` | हाँ | `@./selfie.jpg` |
| `gender` | हाँ | `M` |
| `first_name` | नहीं | `John` |
| `last_name` | नहीं | `Doe` |
| `date_of_birth` | नहीं | `1990-01-01` |
| `vendor_data` | नहीं | `user-1234` |

* **आवश्यक इनपुट:** `document_number`, `selfie`, `gender`
* **वैकल्पिक इनपुट:** `first_name`, `last_name`, `date_of_birth`, `vendor_data`
* **सहमति:** आवश्यक नहीं
* **वर्कफ़्लो में उपलब्धता:** वर्कफ़्लो में उपलब्ध
* **कवरेज:** 100%
* **मूल्य:** प्रति सफल क्वेरी \$0.20

## बॉडी पैरामीटर

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

इस डेटाबेस सेवा के लिए ISO 3166-1 alpha-3 देश कोड।

उदाहरण: `ARG`

**services** `string` *required* (default: arg\_renaper)

इस सेवा ID वाला एक ऐरे। सेवा को पिन करने से अनुरोध इसी सटीक डेटाबेस तक सीमित रहता है।

उदाहरण: `arg_renaper`

**document\_number** `string` *required* (default: 11111111)

उपयोगकर्ता से निकाला गया या उपयोगकर्ता द्वारा दिया गया दस्तावेज़ नंबर।

उदाहरण: `11111111`

**selfie** `file` *required*

बायोमेट्रिक डेटाबेस सत्यापन के लिए अपलोड की जाने वाली सेल्फ़ी इमेज फ़ाइल। स्वीकृत फ़ॉर्मैट: JPEG, PNG या WebP।

उदाहरण: `@./selfie.jpg`

**gender** `string` *required* (default: M)

लिंग मान, जब डेटाबेस द्वारा आवश्यक हो।

अनुमत मान: `M` (पुरुष), `F` (महिला), `X` (अन्य या अज्ञात)।

उदाहरण: `M`

**first\_name** `string`

सत्यापित किया जाने वाला पहला नाम।

उदाहरण: `John`

**last\_name** `string`

सत्यापित किया जाने वाला उपनाम।

उदाहरण: `Doe`

**date\_of\_birth** `string`

`YYYY-MM-DD` फ़ॉर्मैट में जन्म तिथि।

उदाहरण: `1990-01-01`

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

इस व्यक्ति के लिए आपका स्थिर उपयोगकर्ता संदर्भ, जैसे आपका आंतरिक उपयोगकर्ता ID। Didit इसका उपयोग अलग-अलग जाँचों को एक ही अंतिम उपयोगकर्ता से जोड़ने और डुप्लिकेट-पहचान के शोर को कम करने के लिए करता है।

उदाहरण: `user-1234`

## इनपुट नियम और सत्यापन नोट्स

* अर्जेंटीना DNI (7-8 अंक, वैकल्पिक M/F उपसर्ग)
* `document_number` का 7-9 अक्षर लंबा होना अनिवार्य है।
* `document_number` का `[MFmf]?\d{7,8}` से मेल खाना अनिवार्य है।

## इसे कैसे कॉल करें

```bash cURL theme={null}
curl -X POST "https://verification.didit.me/v3/database-validation/" \
  -H "x-api-key: YOUR_API_KEY" \
  -F "issuing_state=ARG" \
  -F "services=arg_renaper" \
  -F "vendor_data=user-1234" \
  -F "document_number=11111111" \
  -F "selfie=@./selfie.jpg" \
  -F "gender=M"
```

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

# Reads DIDIT_API_KEY.
client = Didit()

result = client.database_validation.validate(
    issuing_state="ARG",
    services=["arg_renaper"],
    document_number="11111111",
    gender="M",
    vendor_data="user-1234",
    selfie=open("selfie.jpg", "rb"),
)
print(result)
```

```javascript Node.js theme={null}
import Didit, { fileFromPath } from "@didit-protocol/sdk-node";

// Reads DIDIT_API_KEY.
const didit = new Didit();

const result = await didit.databaseValidation.validate({
  issuing_state: "ARG",
  services: ["arg_renaper"],
  document_number: "11111111",
  gender: "M",
  vendor_data: "user-1234",
  selfie: await fileFromPath("selfie.jpg"),
});
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:   "ARG",
	Services:       didit.Some([]string{"arg_renaper"}),
	DocumentNumber: didit.String("11111111"),
	Gender:         didit.Some(didit.DatabaseValidationValidateParamsGender("M")),
	VendorData:     didit.String("user-1234"),
	Selfie:         didit.Some(didit.FileFromPath("selfie.jpg")),
})
if err != nil {
	log.Fatal(err)
}
fmt.Printf("%+v\n", result)
```

```java Java theme={null}
import java.nio.file.Path;
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("ARG")
        .services(List.of("arg_renaper"))
        .documentNumber("11111111")
        .gender(DatabaseValidationValidateParams.Gender.of("M"))
        .vendorData("user-1234")
        .selfie(Path.of("selfie.jpg"))
        .build());
System.out.println(result);
```

```php PHP theme={null}
<?php

require 'vendor/autoload.php';

use Didit\DiditClient;
use Didit\File;

// Reads DIDIT_API_KEY.
$didit = new DiditClient();

$result = $didit->databaseValidation->validate([
    'issuing_state' => 'ARG',
    'services' => ['arg_renaper'],
    'document_number' => '11111111',
    'gender' => 'M',
    'vendor_data' => 'user-1234',
    'selfie' => File::fromPath('selfie.jpg'),
]);
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: "ARG",
  services: ["arg_renaper"],
  document_number: "11111111",
  gender: "M",
  vendor_data: "user-1234",
  selfie: Pathname("selfie.jpg")
)
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 = "ARG",
    Services = new string[] { "arg_renaper" },
    DocumentNumber = "11111111",
    Gender = new DatabaseValidationValidateParamsGender("M"),
    VendorData = "user-1234",
    Selfie = FileUpload.FromPath("selfie.jpg"),
});
Console.WriteLine(JsonSerializer.Serialize(result));
```

हर सफल कॉल HTTP `200` लौटाती है। **`outcome_code`** फ़ील्ड बताता है कि वास्तव में क्या हुआ, जैसे वास्तविक बायोमेट्रिक असंगति (`BIOMETRIC_NO_MATCH`) को उस सेल्फ़ी से अलग करना जिसे पढ़ा नहीं जा सका (`BIOMETRIC_IMAGE_UNUSABLE`)। दिखाया गया `status` डिफ़ॉल्ट सुविधा स्थिति है; आपकी कॉन्फ़िगर की गई [आंशिक मिलान / कोई मिलान नहीं कार्रवाइयाँ](https://docs.didit.me/hi/core-technology/database-validation/database-validation-warnings.md) इसे बदल सकती हैं।

**`MATCH`**: रजिस्ट्री ने पहचान की पुष्टि की और जाँचे गए हर फ़ील्ड का मिलान हुआ।

```json 200 OK — MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Approved",
  "issuing_state": "ARG",
  "match_type": "full_match",
  "validations": [
    {
      "outcome_code": "MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "date_of_birth": "1990-01-01",
        "face_match_score": "92",
        "first_name": "John",
        "full_name": "John Doe",
        "identification_number": "SAMPLE-ID-12345",
        "last_name": "Doe",
        "tax_id": "SAMPLE-12345",
        "tax_id_type": "SAMPLE-12345"
      },
      "validation": {
        "identification_number": "full_match"
      }
    }
  ]
}
```

**`NO_MATCH`**: सबमिट किए गए डेटा के लिए रजिस्ट्री से कोई मिलान नहीं मिला।

```json 200 OK — NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "NO_MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_NO_MATCH`**: चेहरा मिलान स्कोर स्वीकृति थ्रेशोल्ड से कम था, यानी सेल्फ़ी रजिस्ट्री की फ़ोटो वाले व्यक्ति की नहीं है।

```json 200 OK — BIOMETRIC_NO_MATCH theme={null}
{
  "request_id": "req_01H…",
  "status": "Declined",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_NO_MATCH",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

**`BIOMETRIC_IMAGE_UNUSABLE`**: सेल्फ़ी प्रोसेस नहीं की जा सकी (खाली हो, चेहरा न हो, गुणवत्ता कम हो, या रजिस्ट्री उसे पढ़ न सकी)। उपयोगकर्ता से सेल्फ़ी दोबारा लेने के लिए कहें।

```json 200 OK — BIOMETRIC_IMAGE_UNUSABLE theme={null}
{
  "request_id": "req_01H…",
  "status": "In Review",
  "issuing_state": "ARG",
  "match_type": "no_match",
  "validations": [
    {
      "outcome_code": "BIOMETRIC_IMAGE_UNUSABLE",
      "service_id": "arg_renaper",
      "service_name": "Argentina - DNI verification (RENAPER)",
      "source_data": {
        "identification_number": "NO_MATCH"
      },
      "validation": {
        "identification_number": "no_match"
      }
    }
  ]
}
```

## लौटाया गया डेटा

`source_data` में दिखाए जाने वाले सटीक फ़ील्ड इस बात पर निर्भर करते हैं कि रजिस्ट्री क्या लौटाती है। `arg_renaper` के लिए जेनरेट किया गया उदाहरण वर्तमान में यह नॉर्मलाइज़्ड संरचना दस्तावेज़ करता है:

* `date_of_birth`
* `face_match_score`
* `first_name`
* `full_name`
* `identification_number`
* `last_name`
* `tax_id`
* `tax_id_type`

## मूल्य निर्धारण और SLA

अर्जेंटीना - DNI सत्यापन (RENAPER) क्वेरी केवल तभी बिल की जाती हैं जब Didit को सत्यापन स्रोत से निर्णायक परिणाम मिलता है।

* **प्रति कॉल मूल्य:** \$0.20 USD।
* **बिलिंग:** प्रति सफल क्वेरी। जब रजिस्ट्री तक पहुँच न हो, आवश्यक फ़ील्ड गायब हों, या अनुरोध स्रोत तक पहुँचने से पहले अस्वीकार कर दिया जाए, तब आपसे शुल्क नहीं लिया जाता।
* **विलंबता:** सामान्य p95 \< 2 s।
* **उपलब्धता:** Didit की ओर से प्रति तिमाही 99.9%; आगे के स्रोत की उपलब्धता देश और डेटासेट के अनुसार बदलती है।

## चेहरा मिलान स्कोर

`face_match_score` RENAPER द्वारा सेल्फ़ी और DNI के लिए रिकॉर्ड में मौजूद फ़ोटो के बीच की समानता है। यह 0 से 100 के बीच की पूर्ण संख्या है, जो `"92"` जैसे स्ट्रिंग मान के रूप में भेजी जाती है। यह 0 और 1 के बीच की प्रायिकता नहीं है।

जब RENAPER बताता है कि चेहरा मेल नहीं खाता, या जब स्कोर 50 से कम होता है, तो जाँच `BIOMETRIC_NO_MATCH` लौटाती है। 50 या उससे अधिक होने पर चेहरा स्वीकार किया जाता है, और उसके बाद रजिस्टर्ड नाम और जन्म तिथि की तुलना आपके भेजे गए डेटा से की जाती है।

रिकॉर्ड में मौजूद फ़ोटो कई साल पुरानी हो सकती है, इसलिए किसी उपयोगकर्ता की दिखावट में बड़ा बदलाव होने पर, वास्तविक उपयोगकर्ता होने के बावजूद उसे कम स्कोर मिल सकता है। `BIOMETRIC_NO_MATCH` को सीधे अस्वीकार करने के बजाय, इसे [‘आंशिक मिलान / कोई मिलान नहीं’ कार्रवाइयाँ](https://docs.didit.me/hi/core-technology/database-validation/database-validation-warnings.md) के साथ मैन्युअल समीक्षा के लिए भेजने पर विचार करें।

## जब RENAPER जवाब नहीं देता

अगर RENAPER तक पहुँचा नहीं जा सकता या वह कोई त्रुटि लौटाता है, तो परिणाम `REGISTRY_UNAVAILABLE` होता है: व्यक्ति के बारे में कुछ भी जाँचा नहीं गया, और कॉल का बिल नहीं बनता। बाद में उसी अनुरोध को दोबारा भेजने पर वह सफल हो सकता है। इसे संभालने के तरीके के लिए [परिणाम कोड](https://docs.didit.me/hi/core-technology/database-validation/database-validation-outcome-codes.md) देखें।

## वर्कफ़्लो जिन दस्तावेज़ों को पढ़ता है

वर्कफ़्लो के भीतर DNI नंबर और लिंग, पहचान सत्यापन चरण से आते हैं, जो अर्जेंटीना के DNI कार्ड और डिजिटल DNI को पढ़ता है। विदेशी निवासी भी वही DNI कार्ड रखते हैं और उसी तरह सत्यापित होते हैं।

पुरानी DNI पुस्तिका (*libreta*) पहचान सत्यापन का समर्थित दस्तावेज़ नहीं है, इसलिए जिस उपयोगकर्ता के पास केवल यही हो, वह यह चरण पूरा नहीं कर सकता। फिर भी आप `POST /v3/database-validation/` से उनका DNI नंबर सीधे जाँच सकते हैं।

## वर्कफ़्लो में इसका उपयोग करें

सेवा को पहचान सत्यापन के बाद के एक डेटाबेस सत्यापन चरण में जोड़ें। उदाहरण के लिए, [`POST /v3/workflows/`](https://docs.didit.me/hi/management-api/workflows/create) के साथ:

```json theme={null}
{
  "workflow_label": "Argentina KYC with RENAPER",
  "features": [
    {"feature": "OCR"},
    {"feature": "LIVENESS", "config": {"face_liveness_method": "PASSIVE"}},
    {
      "feature": "DATABASE_VALIDATION",
      "config": {"database_validation_countries": {"ARG": {"services": ["arg_renaper"]}}}
    }
  ]
}
```

अगर उससे पहले लाइवनेस चरण है, तो RENAPER लाइव सेल्फ़ी की तुलना करता है। उसके बिना, Didit दस्तावेज़ पर छपी फ़ोटो भेजता है, जो दस्तावेज़ की फ़ोटो की पुष्टि करती है, पर यह नहीं कि कैमरे के सामने खड़ा व्यक्ति उसका धारक है। जिसे वर्कफ़्लो चला नहीं सकता, उसे उसी ID का नाम लेने वाली `400` त्रुटि के साथ अस्वीकार किया जाता है, ताकि चरण उस जाँच के बिना कभी सेव न हो जो आपने माँगी थी। डेटाबेस सत्यापन की हर सेटिंग के लिए [वर्कफ़्लो सुविधा कॉन्फ़िगरेशन](https://docs.didit.me/hi/management-api/workflows/feature-configs.md#डेटाबेस-सत्यापन) देखें।

## आगे पढ़ें

* [अर्जेंटीना डेटाबेस सत्यापन का अवलोकन](https://docs.didit.me/api-reference/database-validation/argentina.md)
* [डेटाबेस सत्यापन का अवलोकन](https://docs.didit.me/hi/core-technology/database-validation/overview.md)
* [परिणाम कोड](https://docs.didit.me/hi/core-technology/database-validation/database-validation-outcome-codes.md)


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