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

# Poll wallet verification

> Check whether a person has approved a standalone Smart-ID or Mobile-ID authentication request.

Use this operation for a Smart-ID or Mobile-ID phone approval started through the standalone wallet API.
Authenticate with the application API key that started the verification.

Keep the comparison code visible while the person checks the prompt on their phone.
Never ask them to enter their wallet PIN in your application.
Stop polling when the verification reaches a terminal outcome or expires.

Redirect-based wallets complete through their authentication return; use [Get wallet verification](/standalone-apis/digital-id-wallet-result) to retrieve their result.


## OpenAPI

````yaml POST /v3/id-verification/wallets/verifications/{request_id}/poll/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: Identity verification API. Authenticate with x-api-key header.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/id-verification/wallets/verifications/{request_id}/poll/:
    post:
      tags:
        - Digital ID wallets
      summary: Poll a wallet verification
      description: >-
        Smart-ID and Mobile-ID: ask the provider whether the user confirmed,
        refused or let the prompt lapse, and verify the signed identity when
        they confirmed. Redirect wallets complete through the user's browser, so
        for them this only reads the verification back. Answers the verification
        as it is afterwards.
      operationId: poll_wallet_verification
      parameters:
        - in: path
          name: request_id
          schema:
            type: string
            format: uuid
          description: The request_id the start endpoint returned.
          required: true
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationResponse
              example:
                request_id: 00000000-0000-4000-8000-000000000001
                wallet_verification:
                  wallet:
                    id: smart_id
                    name: Smart-ID
                    issuing_authority: SK ID Solutions
                  country: EST
                  status: Not Finished
                  outcome: pending
                  error: null
                  interaction: in_app
                  simulated: true
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action:
                    type: confirm_in_app
                    verification_code: '1234'
                    poll_interval_seconds: 2
                  identity: null
                  attributes: null
                  level_of_assurance: null
                  verified_at: null
                  signature_valid: null
                  credential_type: person_identification
                vendor_data: your-customer-reference
                metadata:
                  reference: example
                created_at: '2026-01-01T10:00:00Z'
          description: ''
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
          description: 'Missing or invalid credentials (x-api-key or Authorization: Bearer).'
        '404':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            error not_found: no wallet verification of this application has this
            request_id.
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            error wallet_not_configured: this environment cannot reach the
            wallet.
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request POST \
              --url https://verification.didit.me/v3/id-verification/wallets/verifications/REQUEST_ID/poll/ \
              --header 'x-api-key: YOUR_API_KEY'
        - lang: python
          label: Python
          source: |
            import os
            import requests

            headers = {
                "x-api-key": os.environ["DIDIT_API_KEY"]
            }

            response = requests.post(
                "https://verification.didit.me/v3/id-verification/wallets/verifications/REQUEST_ID/poll/",
                headers=headers,
                timeout=30,
            )
            response.raise_for_status()
            print(response.json())
components:
  schemas:
    DigitalIdWalletApiWalletVerificationResponse:
      type: object
      description: One standalone wallet verification, as every wallet endpoint answers it.
      properties:
        request_id:
          type: string
          format: uuid
        wallet_verification:
          $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationResult'
        vendor_data:
          type: string
          nullable: true
        metadata:
          type: object
          additionalProperties: {}
          nullable: true
          description: The metadata object sent at start, or null.
        created_at:
          type: string
          format: date-time
      required:
        - created_at
        - metadata
        - request_id
        - vendor_data
        - wallet_verification
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    DigitalIdWalletApiWalletVerificationError:
      type: object
      properties:
        error:
          type: string
          description: Stable machine-readable code, e.g. wallet_unavailable.
        detail:
          type: string
      required:
        - detail
        - error
    DigitalIdWalletApiWalletVerificationResult:
      type: object
      properties:
        wallet:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWallet'
          readOnly: true
        country:
          type: string
        status:
          type: string
          description: Not Finished while pending, then Approved (verified) or Declined.
        outcome:
          $ref: >-
            #/components/schemas/DigitalIdWalletApiWalletVerificationResultOutcomeEnum
        error:
          type: string
          nullable: true
          readOnly: true
        interaction:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiInteractionEnum'
          readOnly: true
        simulated:
          type: boolean
          readOnly: true
        expires_at:
          type: string
          format: date-time
        next_action:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletNextAction'
          nullable: true
          readOnly: true
        identity:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletIdentity'
          nullable: true
          readOnly: true
        attributes:
          type: object
          additionalProperties: {}
          nullable: true
          readOnly: true
        level_of_assurance:
          type: string
          nullable: true
        verified_at:
          type: string
          format: date-time
          nullable: true
        signature_valid:
          type: boolean
          nullable: true
          description: >-
            True once the credential's signature was verified; null for a
            simulated one.
        credential_type:
          type: string
          nullable: true
      required:
        - attributes
        - country
        - credential_type
        - error
        - expires_at
        - identity
        - interaction
        - level_of_assurance
        - next_action
        - outcome
        - signature_valid
        - simulated
        - status
        - verified_at
        - wallet
    DigitalIdWalletApiWallet:
      type: object
      properties:
        id:
          type: string
          description: Catalog id of the wallet, e.g. bankid_se.
        name:
          type: string
        issuing_authority:
          type: string
          nullable: true
      required:
        - id
        - issuing_authority
        - name
    DigitalIdWalletApiWalletVerificationResultOutcomeEnum:
      enum:
        - pending
        - verified
        - cancelled
        - timeout
        - failed
      type: string
      description: |-
        * `pending` - Pending
        * `verified` - Verified
        * `cancelled` - Cancelled by the user
        * `timeout` - Timed out
        * `failed` - Failed
    DigitalIdWalletApiInteractionEnum:
      enum:
        - redirect
        - in_app
      type: string
      description: |-
        * `redirect` - redirect
        * `in_app` - in_app
    DigitalIdWalletApiWalletNextAction:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletNextActionTypeEnum'
          description: >-
            redirect: send the user's browser to url. confirm_in_app: show
            verification_code to the user, who checks it matches the code in
            their wallet app and confirms there; then poll.


            * `redirect` - redirect

            * `confirm_in_app` - confirm_in_app
        url:
          type: string
          format: uri
          description: 'redirect only: where the user signs in with the wallet.'
        verification_code:
          type: string
          description: >-
            confirm_in_app only: the 4-digit comparison code the wallet app
            shows too.
        poll_interval_seconds:
          type: integer
          description: >-
            confirm_in_app only: how often to call POST
            .../verifications/{request_id}/poll/ for prompt feedback. Didit also
            polls pending sign-ins in the background, so the webhook reports the
            outcome even when you do not poll.
      required:
        - type
    DigitalIdWalletApiWalletIdentity:
      type: object
      properties:
        full_name:
          type: string
          nullable: true
        first_name:
          type: string
          nullable: true
        last_name:
          type: string
          nullable: true
        date_of_birth:
          type: string
          format: date
          nullable: true
        nationality:
          type: string
          nullable: true
          description: ISO3 nationality, only when the wallet asserts one (never inferred).
        issuing_state:
          type: string
          description: ISO3 country whose scheme issued the identity.
      required:
        - date_of_birth
        - first_name
        - full_name
        - issuing_state
        - last_name
        - nationality
    DigitalIdWalletApiWalletNextActionTypeEnum:
      enum:
        - redirect
        - confirm_in_app
      type: string
      description: |-
        * `redirect` - redirect
        * `confirm_in_app` - confirm_in_app
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        Your application's API key, from Developers -> API keys in the Business
        Console. The primary key has full access. A named key can be scoped:
        none, read or write per resource, limited to some workflows or to
        approved sessions, to a list of IP addresses, and to an expiry date. 401
        means the key is missing, wrong, revoked or expired; 403 means the key
        has no access to this resource or action, or the request came from an
        address outside its IP list; 404 on a session route means the session is
        outside the key's workflows or statuses. A key without media access
        receives image, video and PDF URLs as null, and a key without sessions
        write receives session links and tokens as null. See
        https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: The application's client-credentials access token.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.