Developer documentation

Getting Started

The INILIO API lets you integrate identity verification into your application. The typical flow is:

1

Create Verification

POST to API with user's name. Get a verification URL back.

2

User Submits Documents

Send the URL to your user. They capture their ID + selfie via camera.

3

Verification processing

INILIO extracts document data and performs face comparison.

4

Get Result

Receive webhook callback or poll the status/result endpoint.

Base URL: https://inilio.net/api/
All requests must include your API key. Get your key from the API Keys section.

Authentication

All API requests must include your API key in the X-API-Key header:

X-API-Key: your_api_key_here

API keys start with inilio_ and can be managed in your API Keys dashboard. Each key is tied to your account â€” all verifications and billing are tracked per-key.

Security: Never expose your API key in client-side code (JavaScript, mobile apps). Always make API calls from your backend server.

POST /api/?action=create

Creates a new verification request and returns a unique verification URL to send to your user.

Request Headers

Header	Value
X-API-Key	Your API key
Content-Type	application/json

Request Body (JSON)

Parameter	Type	Required	Description
first_name	string	Required	User's first name (auto-uppercased)
last_name	string	Required	User's last name (auto-uppercased)
personal_id	string	Optional	National ID / passport number for reference
callback_url	string	Optional	Webhook URL to receive status change notifications. If omitted, falls back to the Default Webhook URL configured in your API key settings.
submitted_sex	string	Optional	Compared against extracted document data. `M` or `F`
submitted_dob	string	Optional	Compared against extracted document data. Date of birth (`YYYY-MM-DD`)
submitted_nationality	string	Optional	Compared against extracted document data. ISO country code (e.g. `US`, `HR`, `DE`)
lang	`string`	Optional	Language for the verification page: `en`, `hr`, `de`, `it`, `es`, `fr`, `sl`, `cs`, `hu`, `sv`, `no`, `da`, `nl`, `pl`, `tr`. Default: `en`
service_types	array	Optional	Create one linked package from `identity`, `address` and/or `payslip`. Every selected service is an independent result and reserves one prepaid credit. Omit it for a single identity verification.

Response (201 Created)

{
  "error": false,
  "verification_code": "123-ABC-456",
  "verification_url": "https://inilio.net/verify/?code=123-ABC-456",
  "redirect_url": "https://your-app.com/done",
  "status": "pending"
}

Example

curl -X POST "https://inilio.net/api/?action=create" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "first_name": "John",
    "last_name": "Doe",
    "personal_id": "123456789",
    "callback_url": "https://your-app.com/webhook"
  }'

$ch = curl_init('https://inilio.net/api/?action=create');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'X-API-Key: your_api_key_here',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'first_name'   => 'John',
        'last_name'    => 'Doe',
        'personal_id'  => '123456789',
        'callback_url' => 'https://your-app.com/webhook',
    ]),
]);

$response = curl_exec($ch);
$data = json_decode($response, true);

// Send verification URL to your user
$verificationUrl = $data['verification_url'];
echo "Verification URL: " . $verificationUrl;

const response = await fetch('https://inilio.net/api/?action=create', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    first_name: 'John',
    last_name: 'Doe',
    personal_id: '123456789',
    callback_url: 'https://your-app.com/webhook',
  }),
});

const data = await response.json();
// Redirect user or send them the verification URL
console.log(data.verification_url);

import requests

response = requests.post(
    'https://inilio.net/api/?action=create',
    headers={
        'X-API-Key': 'your_api_key_here',
        'Content-Type': 'application/json',
    },
    json={
        'first_name': 'John',
        'last_name': 'Doe',
        'personal_id': '123456789',
        'callback_url': 'https://your-app.com/webhook',
    }
)

data = response.json()
print(f"Verification URL: {data['verification_url']}")

POST /api/?action=bulk_create

Creates multiple verification requests in a single API call. Maximum 500 verifications per request.

Request Headers

Header	Value
X-API-Key	Your API key
Content-Type	application/json

Request Body (JSON)

Parameter	Type	Required	Description
verifications	array	Required	Array of verification objects (max 500). Each object accepts the same parameters as the single `create` endpoint, including `service_types` for a linked multi-service package.

Response (201 Created)

{
  "error": false,
  "created": 2,
  "errors": 0,
  "total": 2,
  "results": [
    {
      "index": 0,
      "error": false,
      "verification_code": "123-ABC-456",
      "verification_url": "https://inilio.net/verify/?code=123-ABC-456",
      "redirect_url": "https://your-app.com/done",
      "status": "pending"
    },
    {
      "index": 1,
      "error": false,
      "verification_code": "789-DEF-012",
      "verification_url": "https://inilio.net/verify/?code=789-DEF-012",
      "redirect_url": "https://your-app.com/done",
      "status": "pending"
    }
  ]
}

Each item in results includes an index matching the input array position. Failed items have "error": true with a message.

Example

curl -X POST "https://inilio.net/api/?action=bulk_create" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "verifications": [
      {
        "first_name": "John",
        "last_name": "Doe",
        "personal_id": "123456789",
        "callback_url": "https://your-app.com/webhook"
      },
      {
        "first_name": "Jane",
        "last_name": "Smith",
        "submitted_sex": "F",
        "submitted_dob": "1985-03-20"
      }
    ]
  }'

$ch = curl_init('https://inilio.net/api/?action=bulk_create');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => [
        'X-API-Key: your_api_key_here',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'verifications' => [
            [
                'first_name'   => 'John',
                'last_name'    => 'Doe',
                'personal_id'  => '123456789',
                'callback_url' => 'https://your-app.com/webhook',
            ],
            [
                'first_name'   => 'Jane',
                'last_name'    => 'Smith',
                'submitted_sex'=> 'F',
                'submitted_dob'=> '1985-03-20',
            ],
        ],
    ]),
]);

$response = curl_exec($ch);
$data = json_decode($response, true);

echo "Created: " . $data['created'] . ", Errors: " . $data['errors'];
foreach ($data['results'] as $r) {
    if (!$r['error']) {
        echo "#{$r['index']}: {$r['verification_url']}\n";
    }
}

const response = await fetch('https://inilio.net/api/?action=bulk_create', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your_api_key_here',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    verifications: [
      {
        first_name: 'John',
        last_name: 'Doe',
        personal_id: '123456789',
        callback_url: 'https://your-app.com/webhook',
      },
      {
        first_name: 'Jane',
        last_name: 'Smith',
        submitted_sex: 'F',
        submitted_dob: '1985-03-20',
      },
    ],
  }),
});

const data = await response.json();
console.log(`Created: ${data.created}, Errors: ${data.errors}`);
data.results.forEach(r => {
  if (!r.error) console.log(`#${r.index}: ${r.verification_url}`);
});

import requests

response = requests.post(
    'https://inilio.net/api/?action=bulk_create',
    headers={
        'X-API-Key': 'your_api_key_here',
        'Content-Type': 'application/json',
    },
    json={
        'verifications': [
            {
                'first_name': 'John',
                'last_name': 'Doe',
                'personal_id': '123456789',
                'callback_url': 'https://your-app.com/webhook',
            },
            {
                'first_name': 'Jane',
                'last_name': 'Smith',
                'submitted_sex': 'F',
                'submitted_dob': '1985-03-20',
            },
        ],
    }
)

data = response.json()
print(f"Created: {data['created']}, Errors: {data['errors']}")
for r in data['results']:
    if not r['error']:
        print(f"#{r['index']}: {r['verification_url']}")

POST /api/?action=upload

Creates a verification and processes the document images in a single request â€” no need to redirect the user to a verification URL. Use this for fully server-side or backend-controlled flows where you have the document files available.

Use service_types in the request to create any combination of identity, address and payslip. Each selected service has its own result and prepaid charge.

Request Headers

Header	Value
X-API-Key	Your API key
Content-Type	multipart/form-data

Form Fields

Field	Type		Description
first_name	string	required*	User's first name. *Not required if `code` is provided.
last_name	string	required*	User's last name. *Not required if `code` is provided.
code	string	optional	Attach files to an existing pending verification instead of creating a new one. If provided, `first_name`/`last_name` are not required.
front	file	required	Front of the document. Identity: JPEG or PNG. Address/Payslip: also accepts GIF, WebP, TIFF, HEIC, PDF.
back	file	optional	Back of the document (same allowed types as `front`).
selfie1	file	optional	Identity only. Straight-facing selfie (JPEG or PNG). Used for face comparison against ID photo.
selfie2	file	optional	Identity only. Left-facing selfie.
selfie3	file	optional	Identity only. Right-facing selfie.
doc_type	string	optional	Document type hint â€” e.g. `passport`, `id_card`, `utility_bill`, `payslip`. Auto-detected if omitted.
personal_id	string	optional	National ID / passport number for reference.
callback_url	string	optional	Webhook URL for status change notifications.
submitted_sex	string	optional	Identity only. `M` or `F` â€” compared against extracted document data.
submitted_dob	string	optional	Identity only. Date of birth (`YYYY-MM-DD`) â€” compared against extracted data.
submitted_nationality	string	optional	Identity only. ISO country code â€” compared against extracted data.

Response (201 Created)

{
  "error": false,
  "verification_code": "123-ABC-456",
  "service_type": "identity",
  "status": "approved",
  "status_code": 1,
  "extracted_data": { ... },
  "auto_result": {
    "name_match": true,
    "face_match": true,
    "all_passed": true,
    "final_status": 1
  },
  "redirect_url": null
}

Immediate result: Unlike action=create, the upload endpoint processes documents synchronously and returns the final status in the same response. There is no need to poll action=status afterwards.

Example â€” cURL (Identity)

curl -X POST "https://inilio.net/api/?action=upload" \
  -H "X-API-Key: your_api_key_here" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "front=@/path/to/id_front.jpg" \
  -F "back=@/path/to/id_back.jpg" \
  -F "selfie1=@/path/to/selfie.jpg" \
  -F "callback_url=https://your-app.com/webhook"

Example â€” cURL (Address / Payslip)

# Address or payslip â€” no selfies, PDF also accepted
curl -X POST "https://inilio.net/api/?action=upload" \
  -H "X-API-Key: your_api_key_here" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "front=@/path/to/utility_bill.pdf" \
  -F "callback_url=https://your-app.com/webhook"

Example â€” PHP

$ch = curl_init('https://inilio.net/api/?action=upload');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST           => true,
    CURLOPT_HTTPHEADER     => ['X-API-Key: your_api_key_here'],
    CURLOPT_POSTFIELDS     => [
        'first_name'   => 'John',
        'last_name'    => 'Doe',
        'callback_url' => 'https://your-app.com/webhook',
        'front'        => new CURLFile('/path/to/id_front.jpg', 'image/jpeg', 'front.jpg'),
        'back'         => new CURLFile('/path/to/id_back.jpg',  'image/jpeg', 'back.jpg'),
        'selfie1'      => new CURLFile('/path/to/selfie.jpg',   'image/jpeg', 'selfie.jpg'),
    ],
]);

$response = curl_exec($ch);
$data = json_decode($response, true);

if ($data['status_code'] === 1) {
    echo "Approved! Extracted: " . $data['extracted_data']['first_name'];
} elseif ($data['status_code'] === 3) {
    echo "Rejected: " . ($data['reject_reason'] ?? 'unknown');
}

GET /api/?action=status&code={code}

Check the current status of a verification request.

Query Parameters

Parameter	Type	Required	Description
code	string	Required	The verification code (format: `000-AAA-000`)

Response (200 OK)

{
  "error": false,
  "verification_code": "123-ABC-456",
  "status": "approved",
  "status_code": 1,
  "created_at": "2025-01-15 14:30:00",
  "completed_at": "2025-01-15 14:32:15"
}

Status Codes

Code	Status	Description
`0`	pending	Waiting for user to submit documents
`1`	approved	Verification approved (manually or auto)
`2`	in_review	Documents submitted, awaiting manual review
`3`	rejected	Verification rejected

Example

curl "https://inilio.net/api/?action=status&code=123-ABC-456" \
  -H "X-API-Key: your_api_key_here"

GET /api/?action=result&code={code}

Get the full verification result including extracted document data, face match result, and auto-verify decision.

Query Parameters

Parameter	Type	Required	Description
code	string	Required	The verification code

Response (200 OK)

{
  "error": false,
  "verification_code": "123-ABC-456",
  "first_name": "JOHN",
  "last_name": "DOE",
  "personal_id": "123456789",
  "doc_type": "passport",
  "status": "approved",
  "status_code": 1,
  "verify_mode": "auto",
  "auto_result": {
    "decision": "approved",
    "name_match": true,
    "sex_match": true,
    "dob_match": true,
    "nationality_match": true,
    "face_match": true
  },
  "extracted_data": {
    "first_name": "JOHN",
    "last_name": "DOE",
    "date_of_birth": "1990-05-15",
    "sex": "M",
    "nationality": "US",
    "document_number": "AB1234567",
    "document_type": "passport",
    "issuing_country": "US",
    "expiry_date": "2030-01-01",
    "mrz_line_1": "P



            Extracted Data Fields
            
                Field Description
                first_name First name as extracted from document
                last_name Last name as extracted from document
                date_of_birth Date of birth (YYYY-MM-DD)
                sex Gender â€” M or F
                nationality ISO country code
                document_number Document serial number
                document_type passport, id_card, driving_license, etc.
                issuing_country Country that issued the document
                expiry_date Document expiration date
                place_of_birth Place of birth (if available)
                address Address (if available on document)
                mrz_line_1 Machine Readable Zone line 1
                mrz_line_2 Machine Readable Zone line 2
                mrz_line_3 Machine Readable Zone line 3 (if applicable)
                face_match Face comparison result: match / no_match / uncertain
                face_confidence Face match confidence: high / medium / low





     Service Types
    INILIO supports three verification services. Every API key can initiate any individual service or every combination through service_types; each child verification remains independently billed and reported.

    
        Service Type Use Case User Submits Verification checks
        
        
            identity
            Verify a person's identity
            Government-issued ID + selfie
            Name, face match, DOB, sex, nationality
        
        
            address
            Verify proof of address
            Utility bill, bank statement, government letter
            Name match + address extraction
        
        
            payslip
            Verify income / salary
            Payslip (salary slip) or bank statement with salary deposit
            Name match + net salary extraction
        
        
    

    
        Headless upload: All three service types work with both the standard flow (action=create â†’ user opens URL) and the direct upload flow (action=upload â†’ you send files from your backend).
    




     Address Verification
    Address verification confirms that a person lives at a specific address by analyzing an official address document (utility bill, bank statement, tax document, government letter). No selfie is required â€” INILIO extracts the name and address from the document and compares the name against the submitted data.

    How It Works
    
        Create an API key with service_type: address in your API Keys settings
        Call action=create with first_name and last_name â€” receive a verification URL
        Send the URL to your user â€” they upload a photo or PDF of an address document
        INILIO validates the document is a valid address document (not a passport or ID card)
        INILIO extracts the name and address fields from the document
        System compares the extracted name against submitted name
        If name matches and an address is present â†’ Approved. Otherwise â†’ Rejected
    

    Accepted Document Types
    
        Utility bill â€” electricity, gas, water, internet, phone
        Bank statement â€” any official bank-issued statement
        Tax document â€” tax notice, tax return confirmation
        Government letter â€” any official government correspondence with name and address
    
    Identity cards, passports, and driving licenses are not accepted as address documents â€” the system will reject them.

    Extracted Data Fields
    
        Field Description
        
        document_holder_name Full name of the person on the document
        full_address The complete address as written on the document
        address_street Street name and number
        address_city City or town
        address_postal_code Postal / ZIP code
        address_country Country (full name in English)
        document_type utility_bill, bank_statement, tax_document, government_letter, other
        document_date Date printed on the document (issue date, statement date, etc.)
        issuing_entity Company or authority that issued the document
        
    

    Auto-Verify Result
    The auto_result object returned by action=result for address verifications:
    
        
{
  "auto_result": {
    "name_match": true,
    "has_address": true,
    "all_passed": true,
    "final_status": 1,
    "details": [],
    "authenticity": {
      "assessment": "authentic",
      "confidence": "high"
    }
  }
}
    

    
        Field Description
        
        name_match true / false / "skipped" â€” whether submitted name was found in the document
        has_address true / false â€” whether a valid address was extracted
        all_passed true if both name and address checks passed
        final_status 1 = approved, 3 = rejected
        details Array of failure reason strings (empty if all passed)
        authenticity Informational document authenticity assessment (does not affect approval)
        
    

    Example â€” Create Address Verification
    
        
curl -X POST "https://inilio.net/api/?action=create" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "first_name": "John",
    "last_name": "Doe",
    "callback_url": "https://your-app.com/webhook"
  }'

# Returns verification_url â†’ send to your user
# User uploads utility bill / bank statement / government letter
    

    Example â€” Headless Upload (Address)
    
        
curl -X POST "https://inilio.net/api/?action=upload" \
  -H "X-API-Key: your_api_key_here" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "front=@/path/to/utility_bill.pdf"
  # No selfies needed for address verification
    




     Payslip Verification
    Payslip verification confirms a person's employment and income by analyzing a payslip (salary slip / pay stub) or a bank statement showing a salary deposit. INILIO extracts the employee name and net salary, then verifies the name matches the submitted data.

    How It Works
    
        Create an API key with service_type: payslip in your API Keys settings
        Call action=create with first_name and last_name â€” receive a verification URL
        Send the URL to your user â€” they upload a payslip or bank statement
        INILIO validates the document is a payslip or salary-related bank statement
        INILIO extracts employee name, net salary, currency, pay period, and employer
        System compares the extracted name against submitted name and checks that a salary amount is present
        If name matches and salary is extracted â†’ Approved. Otherwise â†’ Rejected
    

    Accepted Document Types
    
        Payslip / salary slip / pay stub â€” any format showing employee name, employer, and net pay
        Bank statement with salary deposit â€” must contain a transaction labeled as salary/wage/pay in any supported language (Gehalt, plaÄ‡a, salaire, stipendio, lĂ¶n, lĂ¸nn, plat, fizetĂ©s, salario, wynagrodzenie, maaĹź, loon, etc.)
    
    Utility bills, identity documents, and other non-salary documents are rejected.

    Extracted Data Fields
    
        Field Description
        
        document_holder_name Full name of the employee or account holder
        net_salary Net (take-home) salary as a number, e.g. 2450.50
        salary_currency Currency code, e.g. EUR, USD, HRK, GBP
        salary_period The pay period, e.g. March 2026 or 01.03.2026 - 31.03.2026
        employer_name Name of the employer (from payslip; null for bank statements)
        document_type payslip or bank_statement
        document_date Date printed on the document
        
    

    Auto-Verify Result
    The auto_result object returned by action=result for payslip verifications:
    
        
{
  "auto_result": {
    "name_match": true,
    "has_salary": true,
    "all_passed": true,
    "final_status": 1,
    "details": [],
    "authenticity": {
      "assessment": "authentic",
      "confidence": "high"
    }
  }
}
    

    
        Field Description
        
        name_match true / false / "skipped" â€” whether submitted name was found in the document
        has_salary true / false â€” whether a non-zero net salary amount was extracted
        all_passed true if both name and salary checks passed
        final_status 1 = approved, 3 = rejected
        details Array of failure reason strings (empty if all passed)
        authenticity Informational document authenticity assessment (does not affect approval)
        
    

    Example â€” Create Payslip Verification
    
        
curl -X POST "https://inilio.net/api/?action=create" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "first_name": "John",
    "last_name": "Doe",
    "callback_url": "https://your-app.com/webhook"
  }'

# Returns verification_url â†’ send to your user
# User uploads payslip or bank statement with salary deposit
    

    Example â€” Headless Upload (Payslip)
    
        
curl -X POST "https://inilio.net/api/?action=upload" \
  -H "X-API-Key: your_api_key_here" \
  -F "first_name=John" \
  -F "last_name=Doe" \
  -F "front=@/path/to/payslip.pdf"
  # No selfies needed for payslip verification
    

    Webhook Payload (Payslip)
    When the verification completes, the webhook includes the full extracted salary data:
    
        
{
  "event": "verification.status_changed",
  "verification_code": "123-ABC-456",
  "first_name": "JOHN",
  "last_name": "DOE",
  "status": "approved",
  "status_code": 1,
  "extracted_data": {
    "document_holder_name": "John Doe",
    "net_salary": 2450.50,
    "salary_currency": "EUR",
    "salary_period": "March 2026",
    "employer_name": "Acme Corp Ltd",
    "document_type": "payslip",
    "document_date": "2026-03-31"
  },
  "reviewed_at": "2026-03-31 12:00:00",
  "timestamp": "2026-03-31T12:00:00+00:00"
}
    




     Verification Flow
    Understanding how a verification moves through the system:

    
        
            1
            Pending (0)
            Verification created. Waiting for user to open the URL and submit their documents.
        
        
            2
            Processing
            User captured ID + selfie. INILIO validates image quality, extracts data and compares faces.
        
        
            3
            Decision
            Manual mode â†’ In Review (2). Auto mode â†’ Approved (1) or Rejected (3).
        
    

    Image Quality Checks
    Before processing, the system validates uploaded images:
    
        Blur detection â€” rejects blurry or out-of-focus images
        Document presence â€” confirms a valid ID document is visible
        Face presence â€” confirms a face is visible in the selfie
    
    If any check fails, the verification is rejected (status 3) with a reason code. If max_retries is set on the API key, the widget will show a "Try Again" button allowing the user to re-scan their documents.




     Retry Rejected Verification
    When a verification is rejected, you can allow the user to retry. The number of allowed retries is configured per API key in your API Key settings (0â€“3).

    How It Works
    
        Set max_retries on your API key (default: 0 = no retries)
        When a verification is rejected and retries remain, the widget automatically shows a "Try Again" button
        Clicking "Try Again" resets the verification to pending status and the user re-scans their documents
        Old images are deleted and the same verification code is reused
    

    API: Retry Endpoint
    
        POST
        /api/?action=retry
    

    
        Parameter Type Description
        
            
                code
                string
                required
                The verification code to retry
            
        
    

    Response (200 OK)
    
        
{
  "error": false,
  "verification_code": "123-ABC-456",
  "verification_url": "https://inilio.net/verify/?code=123-ABC-456",
  "retries_used": 1,
  "retries_remaining": 2
}
    

    
        Widget: The widget handles retries automatically when max_retries > 0. No additional code is needed. For API-only integrations, call the retry endpoint to reset a rejected verification.
    




     Webhooks & Callbacks
    If you set callback_url when creating a verification, the system will send a POST request to your URL when the verification status changes.
    If no callback_url is provided in the request, the system falls back to the Default Webhook URL configured in your API key settings. Both are optional â€” if neither is set, no webhook is sent.

    Webhook Payload
    
        
{
  "event": "verification.status_changed",
  "verification_code": "123-ABC-456",
  "first_name": "JOHN",
  "last_name": "DOE",
  "status": "approved",
  "status_code": 1,
  "extracted_data": { ... },
  "reviewed_at": "2025-01-15 14:35:00",
  "timestamp": "2025-01-15T14:35:00+00:00"
}
    

    Webhook Headers
    
        Header Value
        Content-Type application/json
        User-Agent INILIO-Webhook/1.0
    

    
        Timeout: Webhook requests timeout after 10 seconds. Your endpoint should respond with a 2xx status code within this window. Failed webhooks are logged but not automatically retried.
    

    Handling Webhooks (PHP Example)
    
        
// webhook.php â€” Your callback endpoint
$payload = json_decode(file_get_contents('php://input'), true);

if ($payload['event'] === 'verification.status_changed') {
    $code   = $payload['verification_code'];
    $status = $payload['status_code'];

    if ($status === 1) {
        // Approved â€” activate user account, grant access, etc.
        activateUser($code);
    } elseif ($status === 3) {
        // Rejected â€” notify user to try again
        notifyUserRejected($code);
    }
}

http_response_code(200);
echo json_encode(['received' => true]);
    




     Real-Time Updates
    INILIO uses Pusher for real-time verification status updates. If Pusher is configured, the frontend verification page automatically receives results without polling.

    Channel & Event
    
        Channel Event Description
        
            verification-{code}
            verification-result
            Fired when verification processing completes
        
    

    Event Payload
    
        
{
  "status": 1,
  "reason": null
}
    
    Status values: 1 = approved, 2 = in review, 3 = rejected. Reason is provided for rejections.




     Auto-Verify Mode
    Auto-verify lets the system make an instant decision by comparing submitted data against extracted document data, without requiring manual admin review. All verifications use auto-verify mode by default.

    How It Works
    
        Create a verification with first_name and last_name
        Optionally include submitted_sex, submitted_dob, submitted_nationality for additional checks
        User submits their document photos + selfie
        INILIO extracts document data and compares faces
        System always compares: name (first + last) and face match
        If provided, also compares: sex, date of birth, nationality
        If ALL checked fields match â†’ Approved automatically
        If ANY mismatch â†’ Rejected automatically
    

    Auto-Verify Example
    
        
curl -X POST "https://inilio.net/api/?action=create" \
  -H "X-API-Key: your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "first_name": "John",
    "last_name": "Doe",
    "submitted_sex": "M",
    "submitted_dob": "1990-05-15",
    "submitted_nationality": "US",
    "callback_url": "https://your-app.com/webhook"
  }'
    

    Auto-Result Object
    When using auto-verify, the result endpoint includes an auto_result object with comparison details:
    
        
{
  "auto_result": {
    "decision": "approved",
    "name_match": true,
    "sex_match": true,
    "dob_match": true,
    "nationality_match": true,
    "face_match": true,
    "mismatches": []
  }
}
    

    
        Note: Only first_name, last_name, and face comparison are always checked. The fields submitted_sex, submitted_dob, and submitted_nationality are optional â€” if provided they will be compared, if omitted they are skipped.
    




     Redirect URL
    You can configure a Redirect URL for each API key in your API key settings. After the verification process is completed (approved or rejected), the user can be redirected to this URL. This field is optional.

    How to Set It
    
        Go to your API Keys page in the dashboard
        Click Edit on the desired API key and enter your Redirect URL
        Click Save
    

    How It Works
    
        The redirect URL is returned in the create API response as redirect_url
        Each API key can have its own redirect URL (or none)
        If no redirect URL is set, the field returns null
    

    Example Response
    
        
{
  "error": false,
  "verification_code": "123-ABC-456",
  "verification_url": "https://inilio.net/verify/?code=123-ABC-456",
  "redirect_url": "https://your-app.com/done",
  "status": "pending"
}
    

    
        Tip: Use the redirect URL to send verified users back to your application after they complete the identity verification process. You can append the verification code as a query parameter on your end for tracking.
    




     Error Handling
    All errors return a JSON response with "error": true, an HTTP status code, and a human-readable message.

    Error Response Format
    
        
{
  "error": true,
  "message": "first_name and last_name are required."
}
    

    HTTP Status Codes
    
        Code Meaning Common Causes
        400 Bad Request Missing required fields, invalid JSON, unknown action
        401 Unauthorized Missing or invalid API key
        404 Not Found Verification code not found or doesn't belong to your API key
        405 Method Not Allowed Wrong HTTP method (e.g. GET instead of POST)
        500 Server Error Internal error â€” contact support
    




     Code Examples

    Complete PHP Integration
    
        
<?php
/**
 * INILIO Integration Example
 * Full flow: create verification â†’ poll status â†’ get result
 */

$apiKey  = 'your_api_key_here';
$apiBase = 'https://inilio.net/api/';

// Step 1: Create a verification
function createVerification($firstName, $lastName, $callbackUrl = null) {
    global $apiKey, $apiBase;

    $payload = [
        'first_name'   => $firstName,
        'last_name'    => $lastName,
        'callback_url' => $callbackUrl,
    ];

    $ch = curl_init($apiBase . '?action=create');
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST           => true,
        CURLOPT_HTTPHEADER     => [
            'X-API-Key: ' . $apiKey,
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode($payload),
    ]);

    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $response;
}

// Step 2: Check status
function checkStatus($code) {
    global $apiKey, $apiBase;

    $ch = curl_init($apiBase . '?action=status&code=' . urlencode($code));
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => ['X-API-Key: ' . $apiKey],
    ]);

    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $response;
}

// Step 3: Get full result
function getResult($code) {
    global $apiKey, $apiBase;

    $ch = curl_init($apiBase . '?action=result&code=' . urlencode($code));
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER     => ['X-API-Key: ' . $apiKey],
    ]);

    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $response;
}

// Usage
$verification = createVerification('John', 'Doe', 'https://your-app.com/webhook');
echo "Send this URL to your user: " . $verification['verification_url'];

// Later â€” check if completed
$status = checkStatus($verification['verification_code']);
if ($status['status_code'] === 1) {
    $result = getResult($verification['verification_code']);
    // Process the full result...
}
    

    Node.js Integration
    
        
const API_KEY  = 'your_api_key_here';
const API_BASE = 'https://inilio.net/api/';

async function createVerification(firstName, lastName, callbackUrl) {
  const res = await fetch(`${API_BASE}?action=create`, {
    method: 'POST',
    headers: {
      'X-API-Key': API_KEY,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      first_name: firstName,
      last_name: lastName,
      callback_url: callbackUrl,
    }),
  });
  return res.json();
}

async function getResult(code) {
  const res = await fetch(`${API_BASE}?action=result&code=${code}`, {
    headers: { 'X-API-Key': API_KEY },
  });
  return res.json();
}

// Express.js webhook handler
app.post('/webhook', (req, res) => {
  const { event, verification_code, status_code, extracted_data } = req.body;

  if (event === 'verification.status_changed') {
    if (status_code === 1) {
      console.log(`Verification ${verification_code} approved!`);
      // Grant user access, activate account, etc.
    }
  }

  res.json({ received: true });
});
    

    Python Integration
    
        
import requests

API_KEY  = 'your_api_key_here'
API_BASE = 'https://inilio.net/api/'
HEADERS  = {'X-API-Key': API_KEY, 'Content-Type': 'application/json'}

def create_verification(first_name, last_name, callback_url=None):
    response = requests.post(
        f'{API_BASE}?action=create',
        headers=HEADERS,
        json={
            'first_name': first_name,
            'last_name': last_name,
            'callback_url': callback_url,
        }
    )
    return response.json()

def get_status(code):
    response = requests.get(
        f'{API_BASE}?action=status&code={code}',
        headers=HEADERS,
    )
    return response.json()

def get_result(code):
    response = requests.get(
        f'{API_BASE}?action=result&code={code}',
        headers=HEADERS,
    )
    return response.json()

# Flask webhook handler
from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/webhook', methods=['POST'])
def webhook():
    data = request.json
    if data['event'] == 'verification.status_changed':
        if data['status_code'] == 1:
            print(f"Verification {data['verification_code']} approved!")
    return jsonify({'received': True})

Field	Description
first_name	First name as extracted from document
last_name	Last name as extracted from document
date_of_birth	Date of birth (YYYY-MM-DD)
sex	Gender â€” M or F
nationality	ISO country code
document_number	Document serial number
document_type	passport, id_card, driving_license, etc.
issuing_country	Country that issued the document
expiry_date	Document expiration date
place_of_birth	Place of birth (if available)
address	Address (if available on document)
mrz_line_1	Machine Readable Zone line 1
mrz_line_2	Machine Readable Zone line 2
mrz_line_3	Machine Readable Zone line 3 (if applicable)
face_match	Face comparison result: match / no_match / uncertain
face_confidence	Face match confidence: high / medium / low

Service Type	Use Case	User Submits	Verification checks
identity	Verify a person's identity	Government-issued ID + selfie	Name, face match, DOB, sex, nationality
address	Verify proof of address	Utility bill, bank statement, government letter	Name match + address extraction
payslip	Verify income / salary	Payslip (salary slip) or bank statement with salary deposit	Name match + net salary extraction

Field	Description
document_holder_name	Full name of the person on the document
full_address	The complete address as written on the document
address_street	Street name and number
address_city	City or town
address_postal_code	Postal / ZIP code
address_country	Country (full name in English)
document_type	`utility_bill`, `bank_statement`, `tax_document`, `government_letter`, `other`
document_date	Date printed on the document (issue date, statement date, etc.)
issuing_entity	Company or authority that issued the document

Field	Description
name_match	`true` / `false` / `"skipped"` â€” whether submitted name was found in the document
has_address	`true` / `false` â€” whether a valid address was extracted
all_passed	`true` if both name and address checks passed
final_status	`1` = approved, `3` = rejected
details	Array of failure reason strings (empty if all passed)
authenticity	Informational document authenticity assessment (does not affect approval)

Field	Description
document_holder_name	Full name of the employee or account holder
net_salary	Net (take-home) salary as a number, e.g. `2450.50`
salary_currency	Currency code, e.g. `EUR`, `USD`, `HRK`, `GBP`
salary_period	The pay period, e.g. `March 2026` or `01.03.2026 - 31.03.2026`
employer_name	Name of the employer (from payslip; `null` for bank statements)
document_type	`payslip` or `bank_statement`
document_date	Date printed on the document

Field	Description
name_match	`true` / `false` / `"skipped"` â€” whether submitted name was found in the document
has_salary	`true` / `false` â€” whether a non-zero net salary amount was extracted
all_passed	`true` if both name and salary checks passed
final_status	`1` = approved, `3` = rejected
details	Array of failure reason strings (empty if all passed)
authenticity	Informational document authenticity assessment (does not affect approval)

Code	Meaning	Common Causes
`400`	Bad Request	Missing required fields, invalid JSON, unknown action
`401`	Unauthorized	Missing or invalid API key
`404`	Not Found	Verification code not found or doesn't belong to your API key
`405`	Method Not Allowed	Wrong HTTP method (e.g. GET instead of POST)
`500`	Server Error	Internal error â€” contact support