> ## Documentation Index
> Fetch the complete documentation index at: https://docs.urtentic.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Send verification inputs

> Submits verification inputs (documents, selfie, etc.) for processing.
Supports multipart form data for file uploads.

### Use Cases
- Uploading document images for verification
- Submitting selfie videos for liveness detection
- Providing user information for verification processes

### Notes
- This endpoint accepts multipart/form-data to handle file uploads
- The "inputs" field must be a JSON string defining the uploaded files and their roles
- Multiple files can be uploaded in a single request
- Files should be referenced by their filename in the inputs JSON




## OpenAPI

````yaml /api-reference/openapi.yml post /verifications/{verificationId}/send-inputs
openapi: 3.0.0
info:
  title: Urtentic API
  version: '1.0'
  description: >
    # Introduction

    The Urtentic API provides comprehensive identity verification and workflow
    management capabilities. 

    It enables organizations to create customized verification workflows,
    perform identity checks, 

    and manage verification processes with features including liveness
    detection, 

    location intelligence, and document verification.


    ## Authentication

    All authenticated endpoints require two headers:

    - `Authorization: Bearer {API_KEY}` - Your API key

    - `X-CLIENT-ID: {CLIENT_ID}` - Your client ID


    API credentials can be generated from your Urtentic Dashboard under Settings
    > API Keys.


    ## Webhook Notifications

    Configure webhook URLs in your Urtentic Dashboard to receive real-time
    notifications

    about verification status changes. Webhooks include the verification ID and
    current status,

    allowing your system to react to verification completions or failures.


    ## Key Features

    - User and organization management

    - Customizable verification workflows

    - Multiple verification processes (Liveness, Location, Document, Watchlist
    Check, Email)

    - Analytics and reporting

    - Webhook notifications for verification results
  contact:
    name: Urtentic Support Team
    email: support@urtentic.com
    url: https://urtentic.com/support
  termsOfService: https://urtentic.com/terms
  license:
    name: Urtentic License
    url: https://urtentic.com/license
servers:
  - url: https://api.urtentic.com/api/v1
    description: Urtentic API
security: []
tags:
  - name: Identity
    description: >
      Management of verified identity data, including retrieval and validation
      of identity information.


      Endpoints in this category allow you to:

      - Retrieve verified identity details

      - Check identity verification status

      - Update identity information

      - Link identities across verification sessions
  - name: Processes
    description: >
      Configuration and management of individual verification process types that
      can be used in workflows.


      The Urtentic platform supports these verification processes:

      - **Document Verification**: OCR and authenticity checks for identity
      documents

      - **Liveness Detection**: Confirms a person is physically present and not
      using photos/videos

      - **Location Intelligence**: Verifies geographic location and environments

      - **Email Verification**: Validates email ownership through OTP

      - **Watchlist Check**: Screens identities against compliance databases
  - name: Verification
    description: >
      Core verification operations including starting verifications, submitting
      verification data, and retrieving results.


      Key operations include:

      - Starting new verification sessions

      - Submitting identity data for verification

      - Retrieving verification results

      - Validating inputs before submission

      - Tracking verification status
  - name: Webhook
    description: >
      Configuration and management of webhook endpoints for receiving real-time
      event notifications.


      The webhook system allows you to:

      - Receive real-time notifications about verification status changes

      - Configure multiple webhook endpoints for different environments

      - Specify which events trigger notifications

      - Verify webhook signature to ensure authenticity

      - Track webhook delivery and retry failed deliveries
  - name: Workflow
    description: >
      Creation and management of verification workflows, combining multiple
      verification processes into customized sequences.


      Workflows allow you to:

      - Define multi-step verification sequences

      - Configure country-specific document requirements

      - Set custom verification rules and thresholds

      - Create specialized flows for different use cases

      - Manage verification process order and dependencies
paths:
  /verifications/{verificationId}/send-inputs:
    parameters:
      - schema:
          type: string
          format: uuid
        name: verificationId
        in: path
        required: true
        description: |
          Unique identifier of the verification.
          This is the verificationId returned when starting a verification.
        example: 85c94e71-6e3f-4a19-b15c-781d8a876542
    post:
      tags:
        - Workflow
      summary: Send verification inputs
      description: >
        Submits verification inputs (documents, selfie, etc.) for processing.

        Supports multipart form data for file uploads.


        ### Use Cases

        - Uploading document images for verification

        - Submitting selfie videos for liveness detection

        - Providing user information for verification processes


        ### Notes

        - This endpoint accepts multipart/form-data to handle file uploads

        - The "inputs" field must be a JSON string defining the uploaded files
        and their roles

        - Multiple files can be uploaded in a single request

        - Files should be referenced by their filename in the inputs JSON
      operationId: post-send-verification-inputs
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              properties:
                inputs:
                  type: string
                  format: json
                  description: >
                    JSON array of input definitions that map files to specific
                    field types.

                    Each object in the array should define:

                    - fieldName: The type of input (e.g., SELFIE_VIDEO,
                    FRONT_IMAGE)

                    - value: The filename or value for the field

                    - fileName: The filename for file uploads (should match the
                    uploaded file name)
                  example: |
                    [
                      {
                        "fileName": "selfie.mp4",
                        "fieldName": "SELFIE_VIDEO",
                        "value": "selfie.mp4"
                      },
                      {
                        "fieldName": "DOCUMENT_TYPE",
                        "value": "PASSPORT"
                      },
                      {
                        "fileName": "passport_front.jpg",
                        "fieldName": "FRONT_IMAGE",
                        "value": "passport_front.jpg"
                      }
                    ]
                documents:
                  type: array
                  items:
                    type: string
                    format: binary
                  description: >
                    Document files to be processed. Multiple files can be
                    uploaded with this field.

                    The filenames should match the values in the "inputs" JSON.
            encoding:
              documents:
                contentType: application/octet-stream
              inputs:
                contentType: application/json
            examples:
              multipart_request:
                value:
                  inputs: |
                    [
                      {
                        "fileName": "selfie.mp4",
                        "fieldName": "SELFIE_VIDEO",
                        "value": "selfie.mp4"
                      },
                      {
                        "fieldName": "DOCUMENT_TYPE",
                        "value": "PASSPORT"
                      },
                      {
                        "fileName": "passport_front.jpg",
                        "fieldName": "FRONT_IMAGE",
                        "value": "passport_front.jpg"
                      }
                    ]
                  documents:
                    - (binary file data)
      responses:
        '200':
          description: Inputs received and processing started
          content:
            application/json:
              schema:
                type: object
                properties:
                  message:
                    type: string
                    description: Confirmation message
                    example: Inputs received and processing started
                  status:
                    type: string
                    description: Current status of the verification
                    example: PROCESSING
                  inputsAccepted:
                    type: array
                    description: List of accepted input fields
                    items:
                      type: string
                    example:
                      - SELFIE_VIDEO
                      - DOCUMENT_TYPE
                      - FRONT_IMAGE
              examples:
                success:
                  value:
                    message: Inputs received and processing started
                    status: PROCESSING
                    inputsAccepted:
                      - SELFIE_VIDEO
                      - DOCUMENT_TYPE
                      - FRONT_IMAGE
        '400':
          description: Invalid inputs or missing required files
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                  message:
                    type: string
                  missingInputs:
                    type: array
                    items:
                      type: string
              examples:
                missing_files:
                  value:
                    error: MISSING_REQUIRED_FILES
                    message: One or more required files are missing
                    missingInputs:
                      - BACK_IMAGE
        '404':
          description: Verification not found
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                  message:
                    type: string
              examples:
                verification_not_found:
                  value:
                    error: VERIFICATION_NOT_FOUND
                    message: The specified verification ID was not found
      security: []

````