Global ID Recognition API - ARGOS Identity

POST

recognition

Recognize and verify ID document

curl --request POST \
  --url https://idverify-api.argosidentity.com/modules/recognition \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "idImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
  "issuingCountry": "USA",
  "idType": "government_id",
  "idBackImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
  "callbackUrl": "https://your-domain.com/callback"
}
'

import requests

url = "https://idverify-api.argosidentity.com/modules/recognition"

payload = {
    "idImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
    "issuingCountry": "USA",
    "idType": "government_id",
    "idBackImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
    "callbackUrl": "https://your-domain.com/callback"
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    idImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    issuingCountry: 'USA',
    idType: 'government_id',
    idBackImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    callbackUrl: 'https://your-domain.com/callback'
  })
};

fetch('https://idverify-api.argosidentity.com/modules/recognition', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://idverify-api.argosidentity.com/modules/recognition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'idImage' => 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    'issuingCountry' => 'USA',
    'idType' => 'government_id',
    'idBackImage' => 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    'callbackUrl' => 'https://your-domain.com/callback'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://idverify-api.argosidentity.com/modules/recognition"

	payload := strings.NewReader("{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://idverify-api.argosidentity.com/modules/recognition")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://idverify-api.argosidentity.com/modules/recognition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}"

response = http.request(request)
puts response.read_body

{
  "apiType": "id_recognition",
  "transactionId": "e0nvom3caiis7",
  "result": {
    "data": {
      "raw": {
        "address": {
          "value": "ADDRESS 110, SOMEWHERE STREET",
          "score": 89,
          "coordinates": {
            "first": {
              "x": 95,
              "y": 221
            },
            "fourth": {
              "x": 95,
              "y": 258
            },
            "second": {
              "x": 430,
              "y": 221
            },
            "third": {
              "x": 430,
              "y": 258
            }
          },
          "original_coordinates": {
            "first": {
              "x": 211,
              "y": 714
            },
            "fourth": {
              "x": 213,
              "y": 752
            },
            "second": {
              "x": 553,
              "y": 713
            },
            "third": {
              "x": 554,
              "y": 751
            }
          }
        },
        "authority": {
          "value": "{{value}}",
          "score": 4,
          "coordinates": {
            "first": {
              "x": 796,
              "y": 1460
            },
            "fourth": {
              "x": 799,
              "y": 1637
            },
            "second": {
              "x": 1931,
              "y": 1461
            },
            "third": {
              "x": 1925,
              "y": 1641
            }
          }
        },
        "name": {
          "value": "{{value}}",
          "score": 61,
          "coordinates": {
            "first": {
              "x": 367,
              "y": 462
            },
            "fourth": {
              "x": 375,
              "y": 669
            },
            "second": {
              "x": 1379,
              "y": 454
            },
            "third": {
              "x": 1378,
              "y": 663
            }
          }
        },
        "name_chn": {
          "value": "{{value}}",
          "score": 61,
          "coordinates": {
            "first": {
              "x": 367,
              "y": 462
            },
            "fourth": {
              "x": 375,
              "y": 669
            },
            "second": {
              "x": 1379,
              "y": 454
            },
            "third": {
              "x": 1378,
              "y": 663
            }
          }
        },
        "number": {
          "value": "{{value}}",
          "score": 95,
          "accepted": true,
          "coordinates": {
            "first": {
              "x": 248,
              "y": 698
            },
            "fourth": {
              "x": 256,
              "y": 867
            },
            "second": {
              "x": 1423,
              "y": 691
            },
            "third": {
              "x": 1421,
              "y": 861
            }
          }
        },
        "rotate": {
          "value": "0"
        }
      },
      "ocr": {
        "ocr_fullName": "{{ocr_fullName}}",
        "ocr_firstName": "{{ocr_firstName}}",
        "ocr_middleName": "{{ocr_middleName}}",
        "ocr_lastName": "{{ocr_lastName}}",
        "ocr_gender": "{{ocr_gender}}",
        "ocr_nationality": "{{ocr_nationality}}",
        "ocr_birthDate": "{{ocr_birthDate}}",
        "ocr_identityNumber": "{{ocr_identityNumber}}",
        "ocr_issueDate": "{{ocr_issueDate}}",
        "ocr_expireDate": "{{ocr_expireDate}}",
        "ocr_version": "{{ocr_version}}",
        "ocr_number": "{{ocr_number}}",
        "full_mrz": "{{full_mrz}}",
        "mrz_line1": "{{mrz_line1}}",
        "mrz_line2": "{{mrz_line2}}"
      }
    },
    "review_front": true,
    "review_back": false,
    "document_type": "{{document_type}}"
  }
}

La API de Global ID Recognition procesa y verifica documentos de identificación analizando tanto las imágenes del frente como del reverso de la identificación, junto con el país emisor y el tipo de identificación. Esta API garantiza la autenticidad y validez de la identificación proporcionada a través de OCR detallado (Reconocimiento Óptico de Caracteres) y proporciona resultados integrales.

Descripción General de la API

La API de Global ID Recognition proporciona una herramienta potente para el procesamiento de documentos de identificación a nivel mundial con las siguientes capacidades:

Soporte Mundial: Procese documentos de identificación de múltiples países
Reconocimiento Automático: Detecte automáticamente el tipo de identificación y el país emisor
Tecnología OCR: Reconocimiento óptico de caracteres avanzado para extracción de texto
Extracción de Datos: Extraiga datos estructurados de documentos de identificación
Verificación: Verifique la autenticidad y validez del documento
Soporte Multi-Formato: Maneje varios formatos de documentos de identificación

Parámetros de Solicitud

Parámetros Requeridos

idImage: Imagen del lado frontal del documento de identificación en formato base64
issuingCountry: El Código de País ISO 3 Alpha del país emisor del documento de identificación
idType: El tipo del documento de identificación

Parámetros Opcionales

idBackImage: Imagen del lado posterior del documento de identificación en formato base64
callbackUrl: La URL donde se enviarán los resultados del reconocimiento al completarse

Autenticación

x-api-key: Clave API esencial para fines de autenticación y control de acceso

Formato de Respuesta

El contenido de result es idéntico en ambos modos de procesamiento. Solo cambia la envoltura.

apiType: valor fijo id_recognition
transactionId: identificador único de cada solicitud
result: el resultado del reconocimiento
- document_type: tipo de documento reconocido. Si el motor no puede determinarlo, se usa <issuingCountry>.<idType> (por ejemplo KOR.drvlic)
- review_front: indica si el anverso produjo un resultado
- review_back: indica si el reverso produjo un resultado. Presente solo si se envió idBackImage
- data.raw: salida en bruto del motor por campo. Cada campo puede incluir
  - value: el valor reconocido, tal como lo devuelve el motor (string, number o boolean)
  - score: puntuación de confianza 0-100. Presente solo si el motor la devuelve para ese campo
  - accepted: resultado de la validación. Presente solo si el motor lo devuelve para ese campo
  - coordinates: bounding box en la imagen recortada, con los vértices first, second, third y fourth
  - original_coordinates: bounding box en la imagen original subida, antes del recorte
- data.ocr: los valores OCR finales ya corregidos. Cada clave ocr_* puede venir acompañada de accepted_ocr_*

Qué claves aparecen depende del tipo de documento, del país emisor y de lo que el motor haya reconocido. Trate todos los campos como opcionales y consulte accepted_ocr_* antes de confiar en un valor.

Países y Tipos de Identificación Soportados

Países Principales

USA: Estados Unidos
CAN: Canadá
MEX: México
BRA: Brasil
ARG: Argentina
GBR: Reino Unido
DEU: Alemania
FRA: Francia
ESP: España
ITA: Italia
KOR: Corea del Sur
JPN: Japón
CHN: China
AUS: Australia
NZL: Nueva Zelanda

Consulte la lista de todos los países soportados en Glosario/Códigos de País ISO Alpha 3

Tipos de Identificación

government_id: Un documento de identificación oficial emitido por un gobierno, típicamente utilizado para verificar la identidad de una persona
passport: Un documento de viaje oficial emitido por un gobierno, que certifica la identidad y nacionalidad del titular, utilizado principalmente para viajes internacionales
drivers_license: Un documento oficial que permite a una persona específica operar uno o más tipos de vehículos motorizados, como motocicletas, automóviles, camiones o autobuses
residence_permit: Un documento oficial que permite a una persona extranjera residir en un país durante un período determinado, típicamente emitido por la autoridad de inmigración
vehicle_registration_certificate: Un documento oficial que proporciona prueba de registro de un vehículo, incluyendo detalles sobre el vehículo y el propietario
visa: Un respaldo oficial colocado en un pasaporte que indica que el titular puede entrar, salir o permanecer durante un período específico en un país
aadhaar: Un número de identificación único de 12 dígitos emitido por el gobierno indio a los residentes de India, basado en sus datos biométricos y demográficos
pancard: Una tarjeta de número de cuenta permanente (PAN) emitida por el gobierno indio a personas y entidades, utilizada principalmente para fines fiscales

Consulte la lista de todos los tipos de identificación soportados para cada país en Glosario/Tipos de Identificación Soportados

Casos de Uso

Procesos KYC: Optimice la verificación de identidad del cliente
Banca: Verifique la identidad del cliente para apertura de cuentas
Viajes: Procese documentos de viaje y visas
Empleo: Verifique la identidad del empleado y permisos de trabajo
Servicios Gubernamentales: Procese documentos de identificación oficiales

Modos de Procesamiento

callbackUrl es opcional. Enviarlo o no determina cómo se recibe el resultado.

Síncrono: sin callbackUrl

La conexión permanece abierta hasta que termina el procesamiento y el resultado llega en el cuerpo del HTTP 200.

{
  "apiType": "id_recognition",
  "transactionId": "550e8400-e29b-41d4-a716-446655440000",
  "result": { "document_type": "kor.rp.type1", "review_front": true, "data": { "raw": {}, "ocr": {} } }
}

El cuerpo síncrono no contiene statusCode ni webhookUrl.

Asíncrono: con callbackUrl

El HTTP 200 que se devuelve de inmediato solo confirma la recepción.

{
  "transactionId": "550e8400-e29b-41d4-a716-446655440000",
  "message": "request has been successfully received. The response will be sent to https://your-domain.com/webhook"
}

El resultado se envía después a su callbackUrl. Ese contenido lleva el mismo result más dos campos adicionales:

{
  "apiType": "id_recognition",
  "transactionId": "550e8400-e29b-41d4-a716-446655440000",
  "result": { "...": "igual que el resultado síncrono" },
  "statusCode": 200,
  "webhookUrl": "https://your-domain.com/webhook"
}

Un fallo durante el procesamiento también llega como webhook, con statusCode en 400 y message / errorCode en lugar de result. El HTTP 200 inmediato ya se ha enviado para entonces, así que determine el resultado final por el statusCode del webhook.

Los fallos de validación (falta idImage, issuingCountry o idType, formato de imagen no válido, o país o tipo de documento no admitidos) se devuelven como HTTP 400 inmediato en ambos modos.

Requisitos de Imagen

Tamaño de Archivo

Recomendado: Menos de 10MB
Máximo: 50MB

Calidad de Imagen

Resolución: Se recomienda un mínimo de 300 DPI
Formato: Las imágenes de alto contraste y bien iluminadas funcionan mejor
Orientación: El documento debe estar correctamente orientado

Formatos Soportados

JPEG (.jpg, .jpeg)
PNG (.png)

Manejo de Errores

El código de estado 400 indica que la solicitud fue inaceptable, a menudo debido a la falta de un parámetro requerido. En operaciones asíncronas, donde se proporciona callbackUrl, el error se detecta durante la validación de la solicitud.

Tipo de errorCode

La siguiente tabla muestra los errorCodes específicos devueltos por la API:

Status Code	errorCode	Description	Detailed
400	1001	Workspace is unavailable	workspace is not currently operating
400	1003	Fail to process data	Server had problem in processing data please retry
400	1005	idImage is required	idImage is not entered
400	1006	issuingCountry is required	issuingCountry is missing
400	1011	Fail to recognize idCard	the idCard’s image is different from issuingCountry and idType
400	1012	Fail to recognize back of an idCard	the idCard’s image is different from issuingCountry and idType
400	1013	Invalid image format	the image is not in Base64 format
400	1014	idType is required	idType is missing
400	1015	invalid inputs : missing fields	field is missing

callbackUrl es opcional en este endpoint. Omitirlo selecciona el procesamiento síncrono; no es un parámetro obligatorio que falte.

Autorizaciones

x-api-key

string

header

requerido

Cuerpo

application/json

idImage

string

requerido

Image of the front side of the ID document in base64 format. Base64 encoded characters in the payload must not include the MIME type. For example, if the encoded base64 characters are "image/png;base64,/9j/2wBDABQODxIP...", then remove "image/png;base64," and send only the encoded data "/9j/2wBDABQODxIP...".

Ejemplo:

"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

issuingCountry

string

requerido

The ISO 3 Alpha Country Code of the issuing country for the ID document.

Ejemplo:

"USA"

idType

enum<string>

requerido

The type of the ID document

Opciones disponibles:

government_id,

passport,

drivers_license,

residence_permit,

vehicle_registration_certificate,

visa,

aadhaar,

pancard

Ejemplo:

"government_id"

idBackImage

string

Image of the back side of the ID document in base64 format.

Ejemplo:

"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

callbackUrl

string<uri>

The URL where the recognition results will be sent upon completion. If a callbackUrl is provided, the process works asynchronously. If no callbackUrl is provided, the process operates synchronously.

Ejemplo:

"https://your-domain.com/callback"

Respuesta

Successful ID recognition

Synchronous result (no callbackUrl)
Asynchronous acknowledgement (callbackUrl provided)

apiType

string

API type identifier

Ejemplo:

"id_recognition"

transactionId

string

Unique identifier for each request

Ejemplo:

"txn_123456789"

result

object

Object containing the processing result

Show child attributes

⌘I

Recognize and verify ID document

curl --request POST \
  --url https://idverify-api.argosidentity.com/modules/recognition \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: <api-key>' \
  --data '
{
  "idImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
  "issuingCountry": "USA",
  "idType": "government_id",
  "idBackImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
  "callbackUrl": "https://your-domain.com/callback"
}
'

import requests

url = "https://idverify-api.argosidentity.com/modules/recognition"

payload = {
    "idImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
    "issuingCountry": "USA",
    "idType": "government_id",
    "idBackImage": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==",
    "callbackUrl": "https://your-domain.com/callback"
}
headers = {
    "x-api-key": "<api-key>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {'x-api-key': '<api-key>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    idImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    issuingCountry: 'USA',
    idType: 'government_id',
    idBackImage: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    callbackUrl: 'https://your-domain.com/callback'
  })
};

fetch('https://idverify-api.argosidentity.com/modules/recognition', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://idverify-api.argosidentity.com/modules/recognition",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'idImage' => 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    'issuingCountry' => 'USA',
    'idType' => 'government_id',
    'idBackImage' => 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==',
    'callbackUrl' => 'https://your-domain.com/callback'
  ]),
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "x-api-key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://idverify-api.argosidentity.com/modules/recognition"

	payload := strings.NewReader("{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-api-key", "<api-key>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://idverify-api.argosidentity.com/modules/recognition")
  .header("x-api-key", "<api-key>")
  .header("Content-Type", "application/json")
  .body("{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://idverify-api.argosidentity.com/modules/recognition")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-api-key"] = '<api-key>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"idImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"issuingCountry\": \"USA\",\n  \"idType\": \"government_id\",\n  \"idBackImage\": \"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==\",\n  \"callbackUrl\": \"https://your-domain.com/callback\"\n}"

response = http.request(request)
puts response.read_body

{
  "apiType": "id_recognition",
  "transactionId": "e0nvom3caiis7",
  "result": {
    "data": {
      "raw": {
        "address": {
          "value": "ADDRESS 110, SOMEWHERE STREET",
          "score": 89,
          "coordinates": {
            "first": {
              "x": 95,
              "y": 221
            },
            "fourth": {
              "x": 95,
              "y": 258
            },
            "second": {
              "x": 430,
              "y": 221
            },
            "third": {
              "x": 430,
              "y": 258
            }
          },
          "original_coordinates": {
            "first": {
              "x": 211,
              "y": 714
            },
            "fourth": {
              "x": 213,
              "y": 752
            },
            "second": {
              "x": 553,
              "y": 713
            },
            "third": {
              "x": 554,
              "y": 751
            }
          }
        },
        "authority": {
          "value": "{{value}}",
          "score": 4,
          "coordinates": {
            "first": {
              "x": 796,
              "y": 1460
            },
            "fourth": {
              "x": 799,
              "y": 1637
            },
            "second": {
              "x": 1931,
              "y": 1461
            },
            "third": {
              "x": 1925,
              "y": 1641
            }
          }
        },
        "name": {
          "value": "{{value}}",
          "score": 61,
          "coordinates": {
            "first": {
              "x": 367,
              "y": 462
            },
            "fourth": {
              "x": 375,
              "y": 669
            },
            "second": {
              "x": 1379,
              "y": 454
            },
            "third": {
              "x": 1378,
              "y": 663
            }
          }
        },
        "name_chn": {
          "value": "{{value}}",
          "score": 61,
          "coordinates": {
            "first": {
              "x": 367,
              "y": 462
            },
            "fourth": {
              "x": 375,
              "y": 669
            },
            "second": {
              "x": 1379,
              "y": 454
            },
            "third": {
              "x": 1378,
              "y": 663
            }
          }
        },
        "number": {
          "value": "{{value}}",
          "score": 95,
          "accepted": true,
          "coordinates": {
            "first": {
              "x": 248,
              "y": 698
            },
            "fourth": {
              "x": 256,
              "y": 867
            },
            "second": {
              "x": 1423,
              "y": 691
            },
            "third": {
              "x": 1421,
              "y": 861
            }
          }
        },
        "rotate": {
          "value": "0"
        }
      },
      "ocr": {
        "ocr_fullName": "{{ocr_fullName}}",
        "ocr_firstName": "{{ocr_firstName}}",
        "ocr_middleName": "{{ocr_middleName}}",
        "ocr_lastName": "{{ocr_lastName}}",
        "ocr_gender": "{{ocr_gender}}",
        "ocr_nationality": "{{ocr_nationality}}",
        "ocr_birthDate": "{{ocr_birthDate}}",
        "ocr_identityNumber": "{{ocr_identityNumber}}",
        "ocr_issueDate": "{{ocr_issueDate}}",
        "ocr_expireDate": "{{ocr_expireDate}}",
        "ocr_version": "{{ocr_version}}",
        "ocr_number": "{{ocr_number}}",
        "full_mrz": "{{full_mrz}}",
        "mrz_line1": "{{mrz_line1}}",
        "mrz_line2": "{{mrz_line2}}"
      }
    },
    "review_front": true,
    "review_back": false,
    "document_type": "{{document_type}}"
  }
}

​Descripción General de la API

​Parámetros de Solicitud

​Parámetros Requeridos

​Parámetros Opcionales

​Autenticación

​Formato de Respuesta

​Países y Tipos de Identificación Soportados

​Países Principales

​Tipos de Identificación

​Casos de Uso

​Modos de Procesamiento

​Síncrono: sin callbackUrl

​Asíncrono: con callbackUrl

​Requisitos de Imagen

​Tamaño de Archivo

​Calidad de Imagen

​Formatos Soportados

​Manejo de Errores

​Tipo de errorCode

Autorizaciones

Cuerpo

Respuesta

Descripción General de la API

Parámetros de Solicitud

Parámetros Requeridos

Parámetros Opcionales

Autenticación

Formato de Respuesta

Países y Tipos de Identificación Soportados

Países Principales

Tipos de Identificación

Casos de Uso

Modos de Procesamiento

Síncrono: sin callbackUrl

Asíncrono: con callbackUrl

Requisitos de Imagen

Tamaño de Archivo

Calidad de Imagen

Formatos Soportados

Manejo de Errores

Tipo de errorCode