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

# Create Identity Verification Check

> Create an identity verification check for an individual identity.



## OpenAPI

````yaml /v2/openapi.yaml post /v2/identities/{identity_id}/id_verification
openapi: 3.1.0
info:
  title: Bastion APIs
  version: '2.0'
servers:
  - url: https://api.prod.bastion.com
    description: Production environment
  - url: https://api.sandbox.bastion.io
    description: Sandbox environment
security:
  - auth: []
tags:
  - name: Bastion APIs
paths:
  /v2/identities/{identity_id}/id_verification:
    post:
      tags:
        - Identity Verification
      summary: Create Identity Verification Check
      description: Create an identity verification check for an individual identity.
      operationId: bastion.api.v2.API.CreateIDVCheck
      parameters:
        - name: identity_id
          in: path
          description: Unique identifier of the identity to verify
          required: true
          schema:
            type: string
            title: identity_id
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                identity_id:
                  type: string
                  title: identity_id
                  description: Unique identifier of the identity to verify
                redirect_url:
                  type:
                    - string
                    - 'null'
                  title: redirect_url
                  description: >-
                    (OPTIONAL) URL to redirect the user to after completing
                    identity verification
                reason:
                  $ref: '#/components/schemas/bastion.common.IDVCheckReason'
                  title: reason
                  description: Reason for the identity verification check
                request_id:
                  type: string
                  title: request_id
                  description: Client-provided idempotency key
                labels:
                  type: array
                  items:
                    type: string
                    description: '(OPTIONAL) '
                  title: labels
                  description: >-
                    (OPTIONAL) Labels to associate with this identity
                    verification check
              title: CreateIDVCheckRequest
              additionalProperties: false
        required: true
      responses:
        '201':
          description: Success
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/bastion.api.v2.CreateIDVCheckResponse'
        '400':
          description: Bad request
        '500':
          description: Internal Server Error
components:
  schemas:
    bastion.common.IDVCheckReason:
      type: string
      title: IDVCheckReason
      enum:
        - IDV_CHECK_REASON_UNSPECIFIED
        - ONBOARDING
        - ACCOUNT_RECOVERY
        - RFI
      example: ONBOARDING
    bastion.api.v2.CreateIDVCheckResponse:
      type: object
      properties:
        id_verification_check:
          $ref: '#/components/schemas/bastion.api.v2.IDVCheck'
          title: id_verification_check
          description: The created identity verification check
      title: CreateIDVCheckResponse
      additionalProperties: false
    bastion.api.v2.IDVCheck:
      type: object
      properties:
        id:
          type: string
          title: id
          description: Unique identifier of the identity verification check
          readOnly: true
        identity_id:
          type: string
          title: identity_id
          description: Unique identifier of the identity associated with this check
          readOnly: true
        verification_url:
          type: string
          title: verification_url
          description: URL to redirect the user to for identity verification
          readOnly: true
        reason:
          $ref: '#/components/schemas/bastion.common.IDVCheckReason'
          title: reason
          description: Reason for the identity verification check
          readOnly: true
        request_id:
          type: string
          title: request_id
          description: Client-provided idempotency key
          readOnly: true
        redirect_url:
          type:
            - string
            - 'null'
          title: redirect_url
          description: URL to redirect the user to after completing identity verification
          readOnly: true
        status:
          $ref: '#/components/schemas/bastion.common.IDVCheckStatus'
          title: status
          description: Current status of the identity verification check
          readOnly: true
        created_at:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: created_at
          description: Timestamp when the check was created
          readOnly: true
        updated_at:
          $ref: '#/components/schemas/google.protobuf.Timestamp'
          title: updated_at
          description: Timestamp when the check was last updated
          readOnly: true
        labels:
          type: array
          items:
            type: string
            readOnly: true
          title: labels
          description: Labels associated with this identity verification check
          readOnly: true
      title: IDVCheck
      additionalProperties: false
    bastion.common.IDVCheckStatus:
      type: string
      title: IDVCheckStatus
      enum:
        - IDV_CHECK_STATUS_UNSPECIFIED
        - IN_PROGRESS
        - APPROVED
        - REJECTED
        - VERIFICATION_URL_EXPIRED
      example: IN_PROGRESS
    google.protobuf.Timestamp:
      type: string
      examples:
        - '2023-01-15T01:30:15.01Z'
        - '2024-12-25T12:00:00Z'
      format: date-time
      description: >-
        A Timestamp represents a point in time independent of any time zone or
        local
         calendar, encoded as a count of seconds and fractions of seconds at
         nanosecond resolution. The count is relative to an epoch at UTC midnight on
         January 1, 1970, in the proleptic Gregorian calendar which extends the
         Gregorian calendar backwards to year one.

         All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
         second table is needed for interpretation, using a [24-hour linear
         smear](https://developers.google.com/time/smear).

         The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
         restricting to that range, we ensure that we can convert to and from [RFC
         3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.

         # Examples

         Example 1: Compute Timestamp from POSIX `time()`.

             Timestamp timestamp;
             timestamp.set_seconds(time(NULL));
             timestamp.set_nanos(0);

         Example 2: Compute Timestamp from POSIX `gettimeofday()`.

             struct timeval tv;
             gettimeofday(&tv, NULL);

             Timestamp timestamp;
             timestamp.set_seconds(tv.tv_sec);
             timestamp.set_nanos(tv.tv_usec * 1000);

         Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.

             FILETIME ft;
             GetSystemTimeAsFileTime(&ft);
             UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;

             // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
             // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
             Timestamp timestamp;
             timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
             timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));

         Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.

             long millis = System.currentTimeMillis();

             Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
                 .setNanos((int) ((millis % 1000) * 1000000)).build();

         Example 5: Compute Timestamp from Java `Instant.now()`.

             Instant now = Instant.now();

             Timestamp timestamp =
                 Timestamp.newBuilder().setSeconds(now.getEpochSecond())
                     .setNanos(now.getNano()).build();

         Example 6: Compute Timestamp from current time in Python.

             timestamp = Timestamp()
             timestamp.GetCurrentTime()

         # JSON Mapping

         In JSON format, the Timestamp type is encoded as a string in the
         [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
         format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
         where {year} is always expressed using four digits while {month}, {day},
         {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
         seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
         are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
         is required. A ProtoJSON serializer should always use UTC (as indicated by
         "Z") when printing the Timestamp type and a ProtoJSON parser should be
         able to accept both UTC and other timezones (as indicated by an offset).

         For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
         01:30 UTC on January 15, 2017.

         In JavaScript, one can convert a Date object to this format using the
         standard
         [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
         method. In Python, a standard `datetime.datetime` object can be converted
         to this format using
         [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
         the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
         the Joda Time's [`ISODateTimeFormat.dateTime()`](
         http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
         ) to obtain a formatter capable of generating timestamps in this format.
  securitySchemes:
    auth:
      type: http
      description: Bearer authentication with an API token
      scheme: bearer

````

## Related topics

- [Get Identity Verification Check](/v2/api-reference/identity-verification/get-identity-verification-check.md)
- [List Identity Verification Checks](/v2/api-reference/identity-verification/list-identity-verification-checks.md)
- [Refresh Identity Verification Check URL](/v2/api-reference/identity-verification/refresh-identity-verification-check-url.md)
- [Identity verification API overview](/v2/api-reference/identity-verification/overview.md)
- [Onboard an individual customer](/guides/quickstarts/onboard-an-individual-customer.md)
