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

The Global ID Recognition API processes and verifies identification documents by analyzing both the front and back images of the ID, along with the issuing country and ID type. This API ensures the authenticity and validity of the provided ID through detailed OCR (Optical Character Recognition) and provides comprehensive results.

API Overview

The Global ID Recognition API provides a powerful tool for worldwide ID document processing with the following capabilities:

Worldwide Support: Process ID documents from multiple countries
Automatic Recognition: Automatically detect ID type and issuing country
OCR Technology: Advanced optical character recognition for text extraction
Data Extraction: Extract structured data from ID documents
Verification: Verify document authenticity and validity
Multi-Format Support: Handle various ID document formats

Request Parameters

Required Parameters

idImage: Image of the front side of the ID document in base64 format
issuingCountry: The ISO 3 Alpha Country Code of the issuing country for the ID document
idType: The type of the ID document

Optional Parameters

idBackImage: Image of the back side of the ID document in base64 format
callbackUrl: The URL where the recognition results will be sent upon completion

Authentication

x-api-key: API key essential for authentication and access control purposes

Response Format

result is identical in both processing modes. Only the envelope around it differs.

apiType: fixed value id_recognition
transactionId: unique identifier for each request
result: the recognition result
- document_type: recognised document type. Falls back to <issuingCountry>.<idType> (for example KOR.drvlic) when the engine cannot determine it
- review_front: whether the front side produced a result
- review_back: whether the back side produced a result. Present only when idBackImage was sent
- data.raw: per-field raw engine output. Each field may include
  - value: the recognised value, passed through from the engine (string, number or boolean)
  - score: confidence score 0-100. Present only when the engine returns one for that field
  - accepted: validation result. Present only when the engine returns one for that field
  - coordinates: bounding box in the cropped image, with first, second, third and fourth corner points
  - original_coordinates: bounding box in the original uploaded image, before cropping
- data.ocr: the corrected, final OCR values. Each ocr_* key may be paired with accepted_ocr_*

Which keys appear depends on the document type, the issuing country and what the engine recognised. Treat every field as optional and read accepted_ocr_* before trusting a value.

Supported Countries and ID Types

Major Countries

USA: United States
CAN: Canada
MEX: Mexico
BRA: Brazil
ARG: Argentina
GBR: United Kingdom
DEU: Germany
FRA: France
ESP: Spain
ITA: Italy
KOR: South Korea
JPN: Japan
CHN: China
AUS: Australia
NZL: New Zealand

Check out list of all supported countries at Glossary/Iso alpha 3 country codes

ID Types

government_id: An official identification document issued by a government, typically used for verifying the identity of an individual
passport: An official travel document issued by a government, certifying the holder’s identity and nationality, primarily used for international travel
drivers_license: An official document permitting a specific individual to operate one or more types of motorized vehicles, such as motorcycles, cars, trucks, or buses
residence_permit: An official document that allows a foreign individual to reside in a country for a certain period, typically issued by the immigration authority
vehicle_registration_certificate: An official document providing proof of registration of a vehicle, including details about the vehicle and the owner
visa: An official endorsement placed in a passport indicating that the holder is allowed to enter, leave, or stay for a specified period in a country
aadhaar: A unique 12-digit identification number issued by the Indian government to residents of India, based on their biometric and demographic data
pancard: A permanent account number (PAN) card issued by the Indian government to individuals and entities, used primarily for tax purposes

Check out list of all supported id types for each country at Glossary/Supported id types

Use Cases

KYC Processes: Streamline customer identity verification
Banking: Verify customer identity for account opening
Travel: Process travel documents and visas
Employment: Verify employee identity and work permits
Government Services: Process official identification documents

Processing Modes

callbackUrl is optional. Whether you send it decides how the result comes back.

Synchronous - no callbackUrl

The connection stays open until processing finishes and the result arrives in the HTTP 200 body.

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

The synchronous body does not contain statusCode or webhookUrl.

Asynchronous - callbackUrl provided

The HTTP 200 returned immediately only confirms receipt.

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

The result is then delivered to your callbackUrl. That payload carries the same result plus two extra fields:

{
  "apiType": "id_recognition",
  "transactionId": "550e8400-e29b-41d4-a716-446655440000",
  "result": { "...": "same as the synchronous result" },
  "statusCode": 200,
  "webhookUrl": "https://your-domain.com/webhook"
}

A failure during processing still arrives as a webhook, with statusCode set to 400 and message / errorCode in place of result. The immediate HTTP 200 has already been sent by then, so judge the outcome from statusCode in the webhook, not from the initial response.

Validation failures (a missing idImage, issuingCountry or idType, an invalid image format, or an unsupported country or ID type) are returned as an immediate HTTP 400 in both modes.

Image Requirements

File Size

Recommended: Less than 10MB
Maximum: 50MB

Image Quality

Resolution: Minimum 300 DPI recommended
Format: High contrast, well-lit images work best
Orientation: Document should be properly oriented

Supported Formats

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

Error Handling

The 400 status code indicates that the request was unacceptable, often due to missing a required parameter. In asynchronous operations, where callbackUrl is provided, the error is detected during request validation.

errorCode Type

The following table shows specific errorCodes returned by the 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 is optional for this endpoint. Omitting it selects synchronous processing; it is not a missing required parameter.

Authorizations

x-api-key

string

header

required

Body

application/json

idImage

string

required

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

Example:

"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="

issuingCountry

string

required

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

Example:

"USA"

idType

enum<string>

required

The type of the ID document

Available options:

government_id,

passport,

drivers_license,

residence_permit,

vehicle_registration_certificate,

visa,

aadhaar,

pancard

Example:

"government_id"

idBackImage

string

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

Example:

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

Example:

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

Response

Successful ID recognition

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

apiType

string

API type identifier

Example:

"id_recognition"

transactionId

string

Unique identifier for each request

Example:

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

​API Overview

​Request Parameters

​Required Parameters

​Optional Parameters

​Authentication

​Response Format

​Supported Countries and ID Types

​Major Countries

​ID Types

​Use Cases

​Processing Modes

​Synchronous - no callbackUrl

​Asynchronous - callbackUrl provided

​Image Requirements

​File Size

​Image Quality

​Supported Formats

​Error Handling

​errorCode Type

Authorizations

Body

Response

API Overview

Request Parameters

Required Parameters

Optional Parameters

Authentication

Response Format

Supported Countries and ID Types

Major Countries

ID Types

Use Cases

Processing Modes

Synchronous - no callbackUrl

Asynchronous - callbackUrl provided

Image Requirements

File Size

Image Quality

Supported Formats

Error Handling

errorCode Type