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

# Confirm Card Binding

> **Completes the Card Binding Process**

This endpoint finalizes the card binding process by validating the verification code sent to the cardholder.

Submit the **`verificationId`** (received from the initial binding request) and the **`code`** (verification code received by the cardholder) in the request payload.

Upon successful validation, the assigned **`cardId`** will be returned. This ID should be stored securely for all future transactions with this card.

**Note:** The verification code must be submitted before the `codeExpiry` timestamp from the initial binding request.




## OpenAPI

````yaml /merchant/partner-connect/partner-connect.yaml post /partner-connect/card-binding/confirm
openapi: 3.0.2
info:
  title: Partner Connect API Reference
  description: >
    # Partner Connect API Documentation


    Welcome to the Partner Connect API documentation. This API allows external
    partners (merchants, service providers) to integrate with our card services
    for binding customer cards and processing transactions.


    ## Key Features:

    - Secure Card Binding: Link customer payment cards to your system securely.

    - Transaction Processing: Authorize, capture, void, and refund payments
    using bound cards.


    ## Notes for API Integration

    - **Authentication:** Requests must be authenticated using either HTTP Basic
    Auth or Bearer Token (JWT), as specified in the `securitySchemes`.

    - **Error Handling:** The API uses standard HTTP status codes. Specific
    error details are provided in the response body with `code` and `message`
    fields. Refer to the `components/schemas/ErrorPartnerConnect...` definitions
    and the specific endpoint `responses` for details on possible errors.

    - **Idempotency:** Where applicable (e.g., transaction initiation), consider
    implementing idempotency checks on your side using unique request
    identifiers if needed, although the API itself may handle idempotency for
    certain operations like binding initiation.
  version: '1.0'
servers:
  - url: tbc
security:
  - Basic: []
  - Bearer: []
tags:
  - name: Partner Connect
    description: >-
      Endpoints for integrating partner systems with card services, including
      card binding and transaction processing.
paths:
  /partner-connect/card-binding/confirm:
    post:
      tags:
        - Card Binding
      summary: Confirm Card Binding
      description: >
        **Completes the Card Binding Process**


        This endpoint finalizes the card binding process by validating the
        verification code sent to the cardholder.


        Submit the **`verificationId`** (received from the initial binding
        request) and the **`code`** (verification code received by the
        cardholder) in the request payload.


        Upon successful validation, the assigned **`cardId`** will be returned.
        This ID should be stored securely for all future transactions with this
        card.


        **Note:** The verification code must be submitted before the
        `codeExpiry` timestamp from the initial binding request.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - verificationId
                - code
              properties:
                verificationId:
                  type: string
                  format: uuid
                  description: Verification ID from the initial card binding request.
                  example: 123e4567-e89b-12d3-a456-426614174000
                code:
                  type: string
                  description: The verification code entered by the user.
                  example: '123456'
      responses:
        '200':
          description: >-
            Card binding confirmed successfully. The card is now bound and ready
            for transactions.
          content:
            application/json:
              schema:
                type: object
                properties:
                  cardId:
                    description: >-
                      The unique identifier (UUID) assigned to the successfully
                      bound card. **Store this `cardId` securely**, as it is
                      required to reference this card in all subsequent
                      transaction requests (`/verify`, `/purchase`, etc.).
                    type: string
                    format: uuid
                  bindingStatus:
                    description: >-
                      The final status of the card binding request (will be
                      `success` on successful confirmation).
                    type: string
                    enum:
                      - success
                  cardFace:
                    description: A URL pointing to an image representing the card's brand.
                    type: string
                    format: uri
                  expirationDate:
                    description: The expiration date of the bound card in MM/YYYY format.
                    type: string
                    pattern: ^\d{2}\/\d{4}$
                    example: 12/2028
                  cardType:
                    description: >-
                      The product tier of the card (e.g., Platinum, Gold, World
                      Elite).
                    type: string
                    example: Platinum
                required:
                  - cardId
                  - bindingStatus
                  - cardFace
                  - expirationDate
                  - cardType
        '400':
          description: >-
            Bad Request. The provided `code` is invalid or expired
            (`INVALID_CODE`), or the request payload is malformed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorPartnerConnectInvalidCode'
        '404':
          description: >-
            Not Found. The provided `verificationId` does not match an active,
            pending binding request (`VERIFICATION_ID_NOT_FOUND`). It might be
            expired, already used, or incorrect.
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/ErrorPartnerConnectCardBindingRequestNotFound
        '409':
          description: >-
            Conflict. The card associated with this `verificationId` is already
            bound (`ALREADY_BOUND`).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorPartnerConnectCardAlreadyBound'
        '500':
          $ref: '#/components/responses/InternalServerError'
components:
  schemas:
    ErrorPartnerConnectInvalidCode:
      description: |
        The provided **verification code** is incorrect or has expired.
        Reinitiate the process or verify the entered code.
      type: object
      properties:
        code:
          type: string
          default: INVALID_CODE
          description: Error code, i.e. `INVALID_CODE`.
        message:
          type: string
          default: >-
            The verification code provided is incorrect or has expired. Please
            check the code or re-initiate the process (binding or purchase
            verification) to receive a new code.
          description: Human-readable error explanation.
    ErrorPartnerConnectCardBindingRequestNotFound:
      description: >
        No active binding request was found for the provided
        **`verificationId`**.

        It may have already been used or expired. Please initiate a new binding
        process if necessary.
      type: object
      properties:
        code:
          type: string
          default: VERIFICATION_ID_NOT_FOUND
          description: Error code, i.e. `VERIFICATION_ID_NOT_FOUND`.
        message:
          type: string
          default: >-
            The provided verification ID was not found. It may correspond to an
            expired, completed, or non-existent binding request. Please initiate
            the binding process again if needed.
          description: Human-readable error explanation.
    ErrorPartnerConnectCardAlreadyBound:
      description: |
        The card is already bound to an account.
        **Binding confirmation cannot be performed again.**
      type: object
      properties:
        code:
          type: string
          default: ALREADY_BOUND
          description: Error code, i.e. `ALREADY_BOUND`.
        message:
          type: string
          default: >-
            This card is already bound and associated with an account. Binding
            confirmation cannot be performed again.
          description: Human-readable error explanation.
  responses:
    InternalServerError:
      description: >-
        Internal Server Error. A server error occurred. Please try again later;
        if the problem persists, contact support.
      content:
        application/json:
          schema:
            type: object
            properties:
              code:
                type: string
                description: Error code, i.e. `INTERNAL_SERVER_ERROR`.
                default: INTERNAL_SERVER_ERROR
              message:
                type: string
                description: A brief message indicating a server-side error.
                default: Your request could not be processed due to a server error.
  securitySchemes:
    Basic:
      type: http
      scheme: basic
    Bearer:
      type: http
      scheme: bearer
      bearerFormat: JWT

````