Individual Identity

Run an end-to-end identity verification on a Brazilian individual. Each Individual Identity wraps the proofs (document and/or facial biometrics) that the holder must submit; Stark Infra orchestrates the collection, validates each proof against the bureau provider and delivers the final result through a webhook.

Use Individual Identity to onboard new customers, re-verify existing ones (reboarding) or gate any high-risk operation that requires a fresh proof of life.

The flow is asynchronous: the API returns immediately with the identity in created status, and private workers walk it through processing, pending and finally success or failed. Every transition produces an IndividualIdentityLog that is delivered through the individual-identity webhook subscription.

NOTE: Read Core Concepts before continuing this guide.

RESOURCE SUMMARY
Individual Identity
The verification request itself. Holds the holder's data, the proofs requested and the link the holder will use to submit them.
Individual Identity Proof
Each proof required by the identity (one per proofType). Generated automatically; submitted via PATCH with the holder's content.

Setup

For each environment (Sandbox and Production):

1. Create an account at Stark Bank.

2. Get in touch with your account manager to enable Individual Identity on your workspace and to choose which proof types your workspace will require — identity (document), biometric (facial selfie) or both.

3. Create a Webhook resource subscribed to individual-identity events to be notified on every state transition (created → processing → pending → success / failed).

4. Generate your ECDSA credentials by following How to Create ECDSA Keys and authenticate every request with the Access-Id, Access-Time and Access-Signature headers.

Typical flow

1. Create an Individual Identity with the holder's name, email, the list of proofs to be collected and the deliveryMethod. Stark Infra returns the identity in created status, already carrying a validatorLink — an URL with the encoded identityId that the holder can open to submit each proof.

2. If deliveryMethod = automatic, Stark Infra sends the validatorLink to the holder by e-mail. If deliveryMethod = manual, the link is returned in the response and your application is responsible for delivering it (in-app screen, SMS, push, etc.).

3. While the holder fills in each proof, Stark Infra creates one IndividualIdentityProof per proofType. The proofs start in pending and move to processing once their content is submitted via PATCH /v2/individual-identity-proof/:id. The provider validates each proof and the proof transitions to success or failed.

4. When all proofs reach success, the identity transitions to success. If any proof ends in failed or expired, the identity transitions to failed and the remaining proofs are canceled.

5. Every transition produces an IndividualIdentityLog entry, delivered in order to your webhook endpoint. React to success / failed to release the gated operation in your product.

Use cases

Onboarding: validate a new customer's identity (document + biometrics) before opening their account.

Reboarding: periodically refresh the identity proofs of long-standing customers to comply with internal KYC policies.

Step-up authentication: require a fresh facial biometric before high-value or sensitive operations (large transfers, password reset, device change).

Embedded validation: combine deliveryMethod = manual with your own in-app UI to walk the holder through proof submission without leaving your product.

Individual Identity Overview

An Individual Identity represents a single identity verification request for a Brazilian individual. Creating one triggers the asynchronous pipeline that generates the proofs, delivers the validatorLink to the holder and ends in success or failed through the individual-identity webhook subscription.

The Individual Identity Object

Attributes

id STRING

Unique id for the Individual Identity.

name STRING

Full name of the holder being verified.

taxId STRING

CPF of the holder, with or without punctuation. Optional at creation; can be patched later. Example: "012.345.678-90".

email STRING

E-mail used to deliver the validatorLink when deliveryMethod = automatic.

phone STRING

Holder's phone in international format. Optional. Example: "+5511987654321".

tags LIST OF STRINGS

Free-form tags to label the identity for future queries.

proofs LIST OF STRINGS

List of proof types required by this identity. Options: identity (document), biometric (facial selfie). Each item must be enabled on your workspace's Identity Profile.

deliveryMethod STRING

How the validatorLink reaches the holder. Options: automatic (Stark Infra sends an e-mail with the link) and manual (the link is returned in the response and your application is responsible for delivering it).

validatorLink STRING

URL the holder opens to submit each proof. Carries the identityId encoded in the info query parameter. Base URL depends on the environment: starkbank.com in Production, sandbox.starkbank.com in Sandbox.

sourceId STRING

Identifier of the entity that triggered this verification. For external callers it is filled automatically with the workspace id and cannot be sent at creation.

sourceType STRING

Origin of the verification. Options: onboarding, reboarding (both reserved for internal callers) and external — the value assigned automatically for verifications triggered by your workspace.

workspaceId STRING

Id of the workspace that owns this identity.

status STRING

Current lifecycle status of the identity. Options: created, processing, pending, success, failed.

created STRING

Creation datetime. Example: "2026-06-23T12:00:00.000000+00:00".

updated STRING

Last update datetime. Example: "2026-06-23T12:05:30.000000+00:00".

Create Individual Identities

Create one or more Individual Identities in batch. Each entry must include at least the holder's name, email, the deliveryMethod and the list of proofs to be collected.

Each identity is returned in created status, already carrying its validatorLink. Save the returned id — you'll use it as the path parameter on every subsequent call related to this verification.

Validations: the workspace must have an active Identity Profile; every value in proofs must be enabled on that profile; taxId and phone, when sent, must be valid.

ENDPOINT
POST /v2/individual-identity
REQUEST

Python

import starkinfra

identities = starkinfra.individualidentity.create([
    starkinfra.IndividualIdentity(
        name="Daenerys Targaryen Stormborn",
        email="daenerys@example.com",
        delivery_method="automatic",
        proofs=["identity", "biometric"],
        tax_id="012.345.678-90",
        phone="+5511987654321",
        tags=["onboarding-123"]
    )
])

for identity in identities:
    print(identity)

Javascript

const starkinfra = require('starkinfra')

const identities = await starkinfra.individualIdentity.create([
    {
        name: "Daenerys Targaryen Stormborn",
        email: "daenerys@example.com",
        deliveryMethod: "automatic",
        proofs: ["identity", "biometric"],
        taxId: "012.345.678-90",
        phone: "+5511987654321",
        tags: ["onboarding-123"]
    }
])

for (const identity of identities) {
    console.log(identity)
}

PHP

Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request POST '{{baseUrl}}/v2/individual-identity' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "identities": [
        {
            "name": "Daenerys Targaryen Stormborn",
            "email": "daenerys@example.com",
            "deliveryMethod": "automatic",
            "proofs": ["identity", "biometric"],
            "taxId": "012.345.678-90",
            "phone": "+5511987654321",
            "tags": ["onboarding-123"]
        }
    ]
}'
  
RESPONSE
Python
[
    IndividualIdentity(
        id="5740977003561984",
        name="Daenerys Targaryen Stormborn",
        tax_id="012.345.678-90",
        email="daenerys@example.com",
        phone="+5511987654321",
        tags=["onboarding-123"],
        proofs=["identity", "biometric"],
        delivery_method="automatic",
        validator_link="https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
        source_id="6480539068923904",
        source_type="external",
        workspace_id="6480539068923904",
        status="created",
        created="2026-06-23T12:00:00.000000+00:00",
        updated="2026-06-23T12:00:00.000000+00:00"
    )
]
  
Javascript
[
    {
        id: "5740977003561984",
        name: "Daenerys Targaryen Stormborn",
        taxId: "012.345.678-90",
        email: "daenerys@example.com",
        phone: "+5511987654321",
        tags: ["onboarding-123"],
        proofs: ["identity", "biometric"],
        deliveryMethod: "automatic",
        validatorLink: "https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
        sourceId: "6480539068923904",
        sourceType: "external",
        workspaceId: "6480539068923904",
        status: "created",
        created: "2026-06-23T12:00:00.000000+00:00",
        updated: "2026-06-23T12:00:00.000000+00:00"
    }
]
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "message": "Individual Identity(ies) successfully created",
    "identities": [
        {
            "id": "5740977003561984",
            "name": "Daenerys Targaryen Stormborn",
            "taxId": "012.345.678-90",
            "email": "daenerys@example.com",
            "phone": "+5511987654321",
            "tags": ["onboarding-123"],
            "proofs": ["identity", "biometric"],
            "deliveryMethod": "automatic",
            "validatorLink": "https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
            "sourceId": "6480539068923904",
            "sourceType": "external",
            "workspaceId": "6480539068923904",
            "status": "created",
            "created": "2026-06-23T12:00:00.000000+00:00",
            "updated": "2026-06-23T12:00:00.000000+00:00"
        }
    ]
}
  
List Individual Identities
List and filter the Individual Identities in your workspace. Results are returned paged via cursor; combine filters to narrow the search.
ENDPOINT
GET /v2/individual-identity
REQUEST
Python
import starkinfra

identities = starkinfra.individualidentity.query(
    status=["pending", "success"],
    tags=["onboarding-123"],
    limit=10
)

for identity in identities:
    print(identity)
  
Javascript
const starkinfra = require('starkinfra')

const identities = await starkinfra.individualIdentity.query({
    status: ["pending", "success"],
    tags: ["onboarding-123"],
    limit: 10
})

for await (const identity of identities) {
    console.log(identity)
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity?status=pending,success&tags=onboarding-123&limit=10' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
[
    IndividualIdentity(
        id="5740977003561984",
        name="Daenerys Targaryen Stormborn",
        tax_id="012.345.678-90",
        status="pending",
        proofs=["identity", "biometric"],
        delivery_method="automatic",
        created="2026-06-23T12:00:00.000000+00:00",
        updated="2026-06-23T12:00:10.000000+00:00"
    )
]
  
Javascript
[
    {
        id: "5740977003561984",
        name: "Daenerys Targaryen Stormborn",
        taxId: "012.345.678-90",
        status: "pending",
        proofs: ["identity", "biometric"],
        deliveryMethod: "automatic",
        created: "2026-06-23T12:00:00.000000+00:00",
        updated: "2026-06-23T12:00:10.000000+00:00"
    }
]
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "cursor": "ClsKFQoHY3JlYXRlZBIJCMWGnoWVoukCEipqE2l-c3RhcmstaW5mcmFyEwsSBkxvZ0lkGAEM",
    "identities": [
        {
            "id": "5740977003561984",
            "name": "Daenerys Targaryen Stormborn",
            "taxId": "012.345.678-90",
            "status": "pending",
            "proofs": ["identity", "biometric"],
            "deliveryMethod": "automatic",
            "created": "2026-06-23T12:00:00.000000+00:00",
            "updated": "2026-06-23T12:00:10.000000+00:00"
        }
    ]
}
  
Get an Individual Identity
Retrieve a single Individual Identity by its id. Use this to inspect the current status of the verification.
ENDPOINT
GET /v2/individual-identity/:id
REQUEST
Python
import starkinfra

identity = starkinfra.individualidentity.get("5740977003561984")
print(identity)
  
Javascript
const starkinfra = require('starkinfra')

const identity = await starkinfra.individualIdentity.get("5740977003561984")
console.log(identity)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity/5740977003561984' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
IndividualIdentity(
    id="5740977003561984",
    name="Daenerys Targaryen Stormborn",
    tax_id="012.345.678-90",
    email="daenerys@example.com",
    phone="+5511987654321",
    tags=["onboarding-123"],
    proofs=["identity", "biometric"],
    delivery_method="automatic",
    validator_link="https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
    source_id="6480539068923904",
    source_type="external",
    workspace_id="6480539068923904",
    status="success",
    created="2026-06-23T12:00:00.000000+00:00",
    updated="2026-06-23T12:05:30.000000+00:00"
)
  
Javascript
{
    id: "5740977003561984",
    name: "Daenerys Targaryen Stormborn",
    taxId: "012.345.678-90",
    email: "daenerys@example.com",
    phone: "+5511987654321",
    tags: ["onboarding-123"],
    proofs: ["identity", "biometric"],
    deliveryMethod: "automatic",
    validatorLink: "https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
    sourceId: "6480539068923904",
    sourceType: "external",
    workspaceId: "6480539068923904",
    status: "success",
    created: "2026-06-23T12:00:00.000000+00:00",
    updated: "2026-06-23T12:05:30.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "identity": {
        "id": "5740977003561984",
        "name": "Daenerys Targaryen Stormborn",
        "taxId": "012.345.678-90",
        "email": "daenerys@example.com",
        "phone": "+5511987654321",
        "tags": ["onboarding-123"],
        "proofs": ["identity", "biometric"],
        "deliveryMethod": "automatic",
        "validatorLink": "https://starkbank.com/validator-link?info=eyJpZGVudGl0eUlkIjoiNTc0MDk3NzAwMzU2MTk4NCJ9",
        "sourceId": "6480539068923904",
        "sourceType": "external",
        "workspaceId": "6480539068923904",
        "status": "success",
        "created": "2026-06-23T12:00:00.000000+00:00",
        "updated": "2026-06-23T12:05:30.000000+00:00"
    }
}
  
Update an Individual Identity
Update the taxId of an Individual Identity after it has been created. Useful when the CPF is unknown at creation time and is only collected during the proof submission flow.
Other fields of the identity are immutable through this endpoint.
ENDPOINT
PATCH /v2/individual-identity/:id
REQUEST
Python
import starkinfra

identity = starkinfra.individualidentity.update(
    id="5740977003561984",
    tax_id="012.345.678-90"
)

print(identity)
  
Javascript
const starkinfra = require('starkinfra')

const identity = await starkinfra.individualIdentity.update(
    "5740977003561984",
    { taxId: "012.345.678-90" }
)

console.log(identity)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request PATCH '{{baseUrl}}/v2/individual-identity/5740977003561984' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "taxId": "012.345.678-90"
}'
  
RESPONSE
Python
IndividualIdentity(
    id="5740977003561984",
    name="Daenerys Targaryen Stormborn",
    tax_id="012.345.678-90",
    status="pending",
    proofs=["identity", "biometric"],
    delivery_method="automatic",
    created="2026-06-23T12:00:00.000000+00:00",
    updated="2026-06-23T12:02:00.000000+00:00"
)
  
Javascript
{
    id: "5740977003561984",
    name: "Daenerys Targaryen Stormborn",
    taxId: "012.345.678-90",
    status: "pending",
    proofs: ["identity", "biometric"],
    deliveryMethod: "automatic",
    created: "2026-06-23T12:00:00.000000+00:00",
    updated: "2026-06-23T12:02:00.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "identity": {
        "id": "5740977003561984",
        "name": "Daenerys Targaryen Stormborn",
        "taxId": "012.345.678-90",
        "status": "pending",
        "proofs": ["identity", "biometric"],
        "deliveryMethod": "automatic",
        "created": "2026-06-23T12:00:00.000000+00:00",
        "updated": "2026-06-23T12:02:00.000000+00:00"
    }
}
  
Cancel an Individual Identity
Cancel an Individual Identity (soft delete). The identity transitions to failed, every pending proof is canceled and a canceled log is delivered through the webhook.
Validations: the identity must exist, must belong to your workspace and must currently be in created or pending status. Identities already in processing, success or failed cannot be canceled.
ENDPOINT
DELETE /v2/individual-identity/:id
REQUEST
Python
import starkinfra

identity = starkinfra.individualidentity.cancel("5740977003561984")
print(identity)
  
Javascript
const starkinfra = require('starkinfra')

const identity = await starkinfra.individualIdentity.cancel("5740977003561984")
console.log(identity)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request DELETE '{{baseUrl}}/v2/individual-identity/5740977003561984' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
IndividualIdentity(
    id="5740977003561984",
    name="Daenerys Targaryen Stormborn",
    status="failed",
    proofs=["identity", "biometric"],
    delivery_method="automatic",
    created="2026-06-23T12:00:00.000000+00:00",
    updated="2026-06-23T12:03:00.000000+00:00"
)
  
Javascript
{
    id: "5740977003561984",
    name: "Daenerys Targaryen Stormborn",
    status: "failed",
    proofs: ["identity", "biometric"],
    deliveryMethod: "automatic",
    created: "2026-06-23T12:00:00.000000+00:00",
    updated: "2026-06-23T12:03:00.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "identity": {
        "id": "5740977003561984",
        "name": "Daenerys Targaryen Stormborn",
        "status": "failed",
        "proofs": ["identity", "biometric"],
        "deliveryMethod": "automatic",
        "created": "2026-06-23T12:00:00.000000+00:00",
        "updated": "2026-06-23T12:03:00.000000+00:00"
    }
}
  
List Individual Identity Logs
Get a paged list of all Individual Identity logs. A log tracks a change in the identity's lifecycle and is the exact payload delivered through the webhook subscription.
ENDPOINT
GET /v2/individual-identity/log
REQUEST
Python
import starkinfra

logs = starkinfra.individualidentity.log.query(
    types=["success", "failed"],
    identity_ids=["5740977003561984"],
    limit=10
)

for log in logs:
    print(log)
  
Javascript
const starkinfra = require('starkinfra')

const logs = await starkinfra.individualIdentity.log.query({
    types: ["success", "failed"],
    identityIds: ["5740977003561984"],
    limit: 10
})

for await (const log of logs) {
    console.log(log)
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity/log?types=success,failed&identityIds=5740977003561984&limit=10' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
[
    IndividualIdentityLog(
        id="6661702144623308",
        type="success",
        identity=IndividualIdentity(id="5740977003561984", status="success"),
        errors=[],
        created="2026-06-23T12:05:30.000000+00:00"
    )
]
  
Javascript
[
    {
        id: "6661702144623308",
        type: "success",
        identity: { id: "5740977003561984", status: "success" },
        errors: [],
        created: "2026-06-23T12:05:30.000000+00:00"
    }
]
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "cursor": "ChsSFWoNZX5zdGFyay1pbmZyYXIMCxIGTG9nSWQYAQw=",
    "logs": [
        {
            "id": "6661702144623308",
            "type": "success",
            "identity": {
                "id": "5740977003561984",
                "status": "success"
            },
            "errors": [],
            "created": "2026-06-23T12:05:30.000000+00:00"
        }
    ]
}
  
Get an Individual Identity Log
Retrieve a single Individual Identity log by its id.
ENDPOINT
GET /v2/individual-identity/log/:id
REQUEST
Python
import starkinfra

log = starkinfra.individualidentity.log.get("6661702144623308")
print(log)
  
Javascript
const starkinfra = require('starkinfra')

const log = await starkinfra.individualIdentity.log.get("6661702144623308")
console.log(log)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity/log/6661702144623308' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
IndividualIdentityLog(
    id="6661702144623308",
    type="success",
    identity=IndividualIdentity(id="5740977003561984", status="success"),
    errors=[],
    created="2026-06-23T12:05:30.000000+00:00"
)
  
Javascript
{
    id: "6661702144623308",
    type: "success",
    identity: { id: "5740977003561984", status: "success" },
    errors: [],
    created: "2026-06-23T12:05:30.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "log": {
        "id": "6661702144623308",
        "type": "success",
        "identity": {
            "id": "5740977003561984",
            "status": "success"
        },
        "errors": [],
        "created": "2026-06-23T12:05:30.000000+00:00"
    }
}
  
Individual Identity Proof Overview
Each Individual Identity Proof represents one piece of evidence required by the parent Individual Identity. One proof is generated per proofType requested at creation; the holder then submits the content of each proof via PATCH /v2/individual-identity-proof/:id.
Proofs go through their own lifecycle (pending → processing → success / failed / canceled / expired). The parent identity transitions to success when every proof reaches success; it transitions to failed as soon as any proof fails or expires.
The Individual Identity Proof Object
Attributes
id STRING
Unique id for the Individual Identity Proof.
proofType STRING
Type of evidence required by this proof. Options: identity (document such as RG or CNH), biometric (facial selfie).
metadata DICTIONARY
Raw payload returned by the provider after the proof is validated. Empty ({}) until the proof reaches processing.
status STRING
Current lifecycle status of the proof. Options: pending, processing, success, failed, canceled, expired.
individualIdentityId STRING
Id of the parent Individual Identity this proof belongs to.
created STRING
Creation datetime. Example: "2026-06-23T12:00:10.000000+00:00".
updated STRING
Last update datetime. Example: "2026-06-23T12:03:00.000000+00:00".
List Individual Identity Proofs
List the proofs tied to an Individual Identity. The identityId query parameter is required — proofs are always scoped to a parent identity.
ENDPOINT
GET /v2/individual-identity-proof
REQUEST
Python
import starkinfra

proofs = starkinfra.individualidentityproof.query(
    identity_id="5740977003561984",
    status=["pending", "processing"],
    limit=10
)

for proof in proofs:
    print(proof)
  
Javascript
const starkinfra = require('starkinfra')

const proofs = await starkinfra.individualIdentityProof.query({
    identityId: "5740977003561984",
    status: ["pending", "processing"],
    limit: 10
})

for await (const proof of proofs) {
    console.log(proof)
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity-proof?identityId=5740977003561984&status=pending,processing&limit=10' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
[
    IndividualIdentityProof(
        id="4512334302912512",
        proof_type="biometric",
        metadata={},
        status="pending",
        individual_identity_id="5740977003561984",
        created="2026-06-23T12:00:10.000000+00:00",
        updated="2026-06-23T12:00:10.000000+00:00"
    )
]
  
Javascript
[
    {
        id: "4512334302912512",
        proofType: "biometric",
        metadata: {},
        status: "pending",
        individualIdentityId: "5740977003561984",
        created: "2026-06-23T12:00:10.000000+00:00",
        updated: "2026-06-23T12:00:10.000000+00:00"
    }
]
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "cursor": null,
    "proofs": [
        {
            "id": "4512334302912512",
            "proofType": "biometric",
            "metadata": {},
            "status": "pending",
            "individualIdentityId": "5740977003561984",
            "created": "2026-06-23T12:00:10.000000+00:00",
            "updated": "2026-06-23T12:00:10.000000+00:00"
        }
    ]
}
  
Get an Individual Identity Proof
Retrieve a single Individual Identity Proof by its id. Inspect the status and, once validation completes, the metadata dictionary returned by the provider.
ENDPOINT
GET /v2/individual-identity-proof/:id
REQUEST
Python
import starkinfra

proof = starkinfra.individualidentityproof.get("4512334302912512")
print(proof)
  
Javascript
const starkinfra = require('starkinfra')

const proof = await starkinfra.individualIdentityProof.get("4512334302912512")
console.log(proof)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request GET '{{baseUrl}}/v2/individual-identity-proof/4512334302912512' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}'
  
RESPONSE
Python
IndividualIdentityProof(
    id="4512334302912512",
    proof_type="identity",
    metadata={"documentId": "doc-abc-123", "documentType": "RG"},
    status="success",
    individual_identity_id="5740977003561984",
    created="2026-06-23T12:00:10.000000+00:00",
    updated="2026-06-23T12:03:00.000000+00:00"
)
  
Javascript
{
    id: "4512334302912512",
    proofType: "identity",
    metadata: { documentId: "doc-abc-123", documentType: "RG" },
    status: "success",
    individualIdentityId: "5740977003561984",
    created: "2026-06-23T12:00:10.000000+00:00",
    updated: "2026-06-23T12:03:00.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "proof": {
        "id": "4512334302912512",
        "proofType": "identity",
        "metadata": {
            "documentId": "doc-abc-123",
            "documentType": "RG"
        },
        "status": "success",
        "individualIdentityId": "5740977003561984",
        "created": "2026-06-23T12:00:10.000000+00:00",
        "updated": "2026-06-23T12:03:00.000000+00:00"
    }
}
  
Submit an Individual Identity Proof
Submit the content of a proof. This is the step in which the holder's document or biometric is uploaded for validation.
The shape of the content field depends on the proofType:
biometric — content is a base64 image string with the facial selfie. Example: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ...".
identity — content is a JSON-serialised string carrying the documentId (the provider's document identifier) and/or the document file (base64 image). Example: "{\"documentId\":\"abc-123\",\"file\":\"data:image/jpeg;base64,/9j/...\"}".
After a successful PATCH the proof transitions from pending to processing; the provider validates it asynchronously and the proof eventually reaches success or failed.
ENDPOINT
PATCH /v2/individual-identity-proof/:id
REQUEST
Python
import starkinfra

proof = starkinfra.individualidentityproof.update(
    id="4512334302912512",
    content="data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."
)

print(proof)
  
Javascript
const starkinfra = require('starkinfra')

const proof = await starkinfra.individualIdentityProof.update(
    "4512334302912512",
    { content: "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..." }
)

console.log(proof)
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
curl --location --request PATCH '{{baseUrl}}/v2/individual-identity-proof/4512334302912512' \
--header 'Access-Id: {{accessId}}' \
--header 'Access-Time: {{accessTime}}' \
--header 'Access-Signature: {{accessSignature}}' \
--header 'Content-Type: application/json' \
--data-raw '{
    "content": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."
}'
  
RESPONSE
Python
IndividualIdentityProof(
    id="4512334302912512",
    proof_type="biometric",
    metadata={},
    status="processing",
    individual_identity_id="5740977003561984",
    created="2026-06-23T12:00:10.000000+00:00",
    updated="2026-06-23T12:02:00.000000+00:00"
)
  
Javascript
{
    id: "4512334302912512",
    proofType: "biometric",
    metadata: {},
    status: "processing",
    individualIdentityId: "5740977003561984",
    created: "2026-06-23T12:00:10.000000+00:00",
    updated: "2026-06-23T12:02:00.000000+00:00"
}
  
PHP
Java
Ruby
Elixir
C#
Go
Clojure
Curl
{
    "proof": {
        "id": "4512334302912512",
        "proofType": "biometric",
        "metadata": {},
        "status": "processing",
        "individualIdentityId": "5740977003561984",
        "created": "2026-06-23T12:00:10.000000+00:00",
        "updated": "2026-06-23T12:02:00.000000+00:00"
    }
}