> ## 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.

# API de vérification MitID personnel

> Intégrez la vérification d'identité MitID à votre application avec Didit : couverture par pays, étapes d'authentification, résultats et tarifs.

Démarrez la vérification personnelle MitID depuis votre backend à l'aide de la clé API de votre application.
Vous n'avez pas besoin de workflow ni de `workflow_id`.
La réponse au démarrage décrit la prochaine action d'authentification ; elle ne constitue pas un résultat d'identité approuvé.

## Couverture et activation

| Propriété | Valeur |
| - | - |
| Portefeuille | MitID personnel |
| ID du portefeuille | `mitid` |
| Pays | ![](https://didit-public-assets.s3.eu-west-1.amazonaws.com/flags/dk.svg)Danemark |
| Activation du portefeuille en production | ✅ Disponible |
| Prix publié du portefeuille | \$0.25 par vérification terminée |

L'activation du portefeuille est distincte du déploiement de l'API et de l'éligibilité de votre application.
Un endpoint documenté n'active pas un portefeuille marqué « Bientôt disponible ».
Pour les tarifs publiés actuels, consultez les [tarifs des portefeuilles d'identité numérique](https://docs.didit.me/fr/getting-started/pricing.md#tarifs-des-portefeuilles-d’identité-numérique).

## Ce que fait la personne

Suivez la prochaine action renvoyée par la requête de démarrage.
L'expérience d'authentification du portefeuille détermine si la personne utilise un navigateur, un autre appareil ou une application.

## Recevoir le résultat

Suivez le [guide de l'API des portefeuilles d'identité numérique](https://docs.didit.me/fr/standalone-apis/digital-id-wallets.md) pour suivre la vérification et récupérer son résultat.
Ne considérez qu'un résultat finalisé et vérifié comme une preuve que le portefeuille a authentifié la personne.
Les attributs d'identité renvoyés varient selon le portefeuille ; ne supposez pas qu'une adresse, un portrait ou l'ensemble des attributs demandés sont présents.

## Voir aussi

* [API des portefeuilles d'identité numérique](https://docs.didit.me/fr/standalone-apis/digital-id-wallets.md)
* [Couverture et attributs des portefeuilles](https://docs.didit.me/fr/core-technology/id-verification/digital-id-wallets.md)
* [Tarifs](https://docs.didit.me/fr/getting-started/pricing.md#tarifs-des-portefeuilles-d’identité-numérique)


## OpenAPI

````yaml fr/openapi-25.json POST /v3/id-verification/wallets/mitid/
openapi: 3.0.0
info:
  version: 3.0.0
  title: Didit Verification API
  description: API de vérification d'identité. Authentifiez-vous avec l'en-tête x-api-key.
servers:
  - url: https://verification.didit.me
security: []
tags: []
paths:
  /v3/id-verification/wallets/mitid/:
    post:
      tags:
        - Digital ID wallets
      summary: Démarrer la vérification MitID
      description: "Démarrez une connexion MitID (Danish Agency for Digital Government\_; DNK) sans aucun workflow. Facturé une seule fois, uniquement lorsque l'identité est vérifiée. La réponse contient next_action.type=redirect avec l'URL vers laquelle diriger le navigateur de l'utilisateur\_; l'utilisateur revient sur return_url avec request_id et result ajoutés. Consultez le résultat avec GET /v3/id-verification/wallets/verifications/{request_id}/ ou depuis le webhook, jamais depuis l'URL. Les applications en sandbox reçoivent une simulation déterministe (simulated: true) qui ne contacte jamais le fournisseur."
      operationId: start_mitid_wallet_verification
      parameters:
        - in: header
          name: Idempotency-Key
          schema:
            type: string
          description: >-
            Clé de sécurité pour les réessais optionnelle (255 caractères
            maximum). Réessayer avec la même clé, le même portefeuille et le
            même corps renvoie la vérification d'origine sans démarrer une
            deuxième connexion ; la même clé avec un autre portefeuille ou un
            autre corps renvoie 409 idempotency_key_reused.
      requestBody:
        content:
          application/json:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiMitidWalletVerificationStartRequest
            example:
              country: DNK
              vendor_data: your-customer-reference
              metadata:
                reference: example
              return_url: https://app.example.com/identity/complete
          application/x-www-form-urlencoded:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiMitidWalletVerificationStartRequest
          multipart/form-data:
            schema:
              $ref: >-
                #/components/schemas/DigitalIdWalletApiMitidWalletVerificationStartRequest
        required: true
      responses:
        '201':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationResponse
              example:
                request_id: 00000000-0000-4000-8000-000000000001
                wallet_verification:
                  wallet:
                    id: mitid
                    name: MitID
                    issuing_authority: Danish Agency for Digital Government
                  country: DNK
                  status: Not Finished
                  outcome: pending
                  error: null
                  interaction: redirect
                  simulated: false
                  expires_at: '2026-01-01T10:10:00Z'
                  next_action:
                    type: redirect
                    url: https://wallet.example.com/authorize
                  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: ''
        '400':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationStartBadRequest
          description: >-
            Erreurs de validation de champ ({field: [messages]}), ou erreur
            return_url_invalid, return_url_not_allowed, invalid_personal_code,
            invalid_phone_number ou idempotency_key_invalid.
        '403':
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/DigitalIdWalletApiWalletVerificationStartForbidden
          description: >-
            Identifiants manquants ({detail}), ou erreur wallet_unavailable,
            insufficient_credits ou contract_rate_missing.
        '409':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: >-
            erreur idempotency_key_reused ou idempotency_key_in_progress (avec
            Retry-After).
        '502':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: "erreur wallet_provider_unavailable\_: le fournisseur n'a pas pu démarrer\_; rien n'a été créé."
        '503':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
          description: "erreur wallet_not_configured\_: cet environnement ne peut pas joindre le portefeuille."
      security:
        - ApiKeyAuth: []
        - BearerAuth: []
      x-codeSamples:
        - lang: curl
          label: cURL
          source: |-
            curl --request POST \
              --url https://verification.didit.me/v3/id-verification/wallets/mitid/ \
              --header 'x-api-key: YOUR_API_KEY' \
              --header 'Idempotency-Key: your-unique-attempt-key' \
              --header 'Content-Type: application/json' \
              --data '{
              "country": "DNK",
              "vendor_data": "your-customer-reference",
              "metadata": {
                "reference": "example"
              },
              "return_url": "https://app.example.com/identity/complete"
            }'
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.id_wallets.start_mitid(
                vendor_data="your-customer-reference",
                metadata={"reference": "example"},
                country="DNK",
                return_url="https://app.example.com/identity/complete",
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: |-
            import Didit from "@didit-protocol/sdk-node";

            // Reads DIDIT_API_KEY.
            const didit = new Didit();

            const result = await didit.idWallets.startMitid({
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "DNK",
              return_url: "https://app.example.com/identity/complete",
            });
            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.IDWallets.StartMitid(ctx, didit.IDWalletsStartMitidParams{\n\tBody: didit.DigitalIDWalletAPIMitidWalletVerificationStartRequest{\n\t\tVendorData: didit.String(\"your-customer-reference\"),\n\t\tMetadata:   didit.Some(map[string]any{\"reference\": \"example\"}),\n\t\tCountry:    didit.Some(didit.DigitalIDWalletAPIMitidWalletVerificationStartCountryEnum(\"DNK\")),\n\t\tReturnURL:  \"https://app.example.com/identity/complete\",\n\t},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.util.Map;

            import me.didit.Didit;

            import
            me.didit.types.DigitalIdWalletApiMitidWalletVerificationStartCountryEnum;

            import
            me.didit.types.DigitalIdWalletApiMitidWalletVerificationStartRequest;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.idWallets().startMitid(DigitalIdWalletApiMitidWalletVerificationStartRequest.builder()
                    .vendorData("your-customer-reference")
                    .metadata(Map.of("reference", "example"))
                    .country(DigitalIdWalletApiMitidWalletVerificationStartCountryEnum.of("DNK"))
                    .returnUrl("https://app.example.com/identity/complete")
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: |-
            <?php

            require 'vendor/autoload.php';

            use Didit\DiditClient;

            // Reads DIDIT_API_KEY.
            $didit = new DiditClient();

            $result = $didit->idWallets->startMitid([
                'vendor_data' => 'your-customer-reference',
                'metadata' => ['reference' => 'example'],
                'country' => 'DNK',
                'return_url' => 'https://app.example.com/identity/complete',
            ]);
            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

            # Reads DIDIT_API_KEY.
            didit = Didit::Client.new

            result = didit.id_wallets.start_mitid(
              vendor_data: "your-customer-reference",
              metadata: { reference: "example" },
              country: "DNK",
              return_url: "https://app.example.com/identity/complete"
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Collections.Generic;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await client.IdWallets.StartMitidAsync(new
            DigitalIdWalletApiMitidWalletVerificationStartRequest

            {
                VendorData = "your-customer-reference",
                Metadata = new Dictionary<string, object> { ["reference"] = "example" },
                Country = new DigitalIdWalletApiMitidWalletVerificationStartCountryEnum("DNK"),
                ReturnUrl = "https://app.example.com/identity/complete",
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  schemas:
    DigitalIdWalletApiMitidWalletVerificationStartRequest:
      type: object
      description: Démarrer une vérification MitID (DNK).
      properties:
        vendor_data:
          type: string
          nullable: true
          description: >-
            Votre propre référence pour cette vérification (par exemple, votre
            identifiant d'utilisateur). Renvoyée dans les résultats et les
            webhooks.
        metadata:
          type: object
          additionalProperties: {}
          nullable: true
          description: >-
            Objet JSON optionnel stocké avec la vérification et retourné dans
            les résultats et les webhooks.
        sandbox_scenario:
          type: string
          minLength: 1
          description: "Applications en sandbox uniquement\_: le résultat simulé - 'wallet_cancelled', 'wallet_timeout' ou 'wallet_provider_error'\_; la vérification réussit pour tout autre scénario (ou en l'absence de scénario). Rejeté sur les applications en production. Le catalogue complet est disponible à GET /v1/sandbox/scenarios/."
        country:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiMitidWalletVerificationStartCountryEnum
          default: DNK
          description: >-
            Pays ISO 3166-1 alpha-3 de l'identité MitID. La valeur par défaut
            est DNK, le seul pays pris en charge.


            * `DNK` - DNK
        return_url:
          type: string
          format: uri
          minLength: 1
          description: "URL HTTPS vers laquelle le navigateur de l'utilisateur est redirigé après l'utilisation du portefeuille, avec request_id et result ajoutés. Son hôte doit être enregistré dans les allowed_return_hosts de l'application (ou être son domaine en marque blanche). Ne vous fiez jamais à result à lui seul\_: lisez le résultat avec GET .../verifications/{request_id}/ ou le webhook."
          maxLength: 2048
        device:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiDeviceEnum'
          default: same_device
          description: >-
            same_device lorsque l'utilisateur se connecte sur l'appareil
            affichant votre page, cross_device lorsqu'il en utilise un autre
            (par exemple le code QR de BankID).


            * `same_device` - same_device

            * `cross_device` - cross_device
      required:
        - return_url
    DigitalIdWalletApiWalletVerificationResponse:
      type: object
      description: >-
        Une vérification de portefeuille autonome, telle que renvoyée par chaque
        endpoint de portefeuille.
      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: L'objet de métadonnées envoyé au démarrage, ou null.
        created_at:
          type: string
          format: date-time
      required:
        - created_at
        - metadata
        - request_id
        - vendor_data
        - wallet_verification
    DigitalIdWalletApiWalletVerificationStartBadRequest:
      oneOf:
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationFieldErrors'
    DigitalIdWalletApiWalletVerificationStartForbidden:
      oneOf:
        - $ref: >-
            #/components/schemas/DigitalIdWalletApiClientCredentialsForbiddenErrorMessage
        - $ref: '#/components/schemas/DigitalIdWalletApiWalletVerificationError'
    DigitalIdWalletApiWalletVerificationError:
      type: object
      properties:
        error:
          type: string
          description: Code stable lisible par machine, par exemple wallet_unavailable.
        detail:
          type: string
      required:
        - detail
        - error
    DigitalIdWalletApiMitidWalletVerificationStartCountryEnum:
      enum:
        - DNK
      type: string
      description: '* `DNK` - DNK'
    DigitalIdWalletApiDeviceEnum:
      enum:
        - same_device
        - cross_device
      type: string
      description: |-
        * `same_device` - same_device
        * `cross_device` - cross_device
    DigitalIdWalletApiWalletVerificationResult:
      type: object
      properties:
        wallet:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWallet'
          readOnly: true
        country:
          type: string
        status:
          type: string
          description: >-
            Non terminé tant qu'il est en attente, puis Approuvé (vérifié) ou
            Refusé.
        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: >-
            Vrai dès que la signature de l'attestation a été vérifiée ; null
            pour une attestation simulée.
        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
    DigitalIdWalletApiWalletVerificationFieldErrors:
      type: object
      description: >-
        Erreurs de validation de la requête : chaque champ rejeté avec ses
        messages.
      additionalProperties:
        type: array
        items:
          type: string
    DigitalIdWalletApiClientCredentialsForbiddenErrorMessage:
      type: object
      properties:
        detail:
          type: string
          default: Forbidden - User doesn't have permission
    DigitalIdWalletApiWallet:
      type: object
      properties:
        id:
          type: string
          description: Identifiant de catalogue du portefeuille, par exemple 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` - En attente
        * `verified` - Vérifié
        * `cancelled` - Annulé par l'utilisateur
        * `timeout` - Délai d'attente dépassé
        * `failed` - Échoué
    DigitalIdWalletApiInteractionEnum:
      enum:
        - redirect
        - in_app
        - digital_credentials
      type: string
      description: |-
        * `redirect` - redirect
        * `in_app` - in_app
        * `digital_credentials` - digital_credentials
    DigitalIdWalletApiWalletNextAction:
      type: object
      properties:
        type:
          allOf:
            - $ref: '#/components/schemas/DigitalIdWalletApiWalletNextActionTypeEnum'
          description: >-
            redirect : redirigez le navigateur de l'utilisateur vers url.
            confirm_in_app : affichez verification_code à l'utilisateur, qui
            vérifie qu'il correspond au code dans son application de
            portefeuille et confirme là-bas ; puis interrogez.
            request_digital_credential : lors d'un geste utilisateur sur
            l'origine initiale, interrogez le portefeuille avec
            digital_credentials.request, puis envoyez ce qu'il renvoie à POST
            .../verifications/{request_id}/response/.


            * `redirect` - redirect

            * `confirm_in_app` - confirm_in_app

            * `request_digital_credential` - request_digital_credential
        url:
          type: string
          format: uri
          description: >-
            redirect uniquement : là où l'utilisateur se connecte avec le
            portefeuille.
        digital_credentials:
          allOf:
            - $ref: >-
                #/components/schemas/DigitalIdWalletApiWalletDigitalCredentialsRequest
          description: >-
            request_digital_credential uniquement : la requête à transmettre au
            portefeuille.
        verification_code:
          type: string
          description: "confirm_in_app uniquement\_: le code de comparaison à 4 chiffres que l'application de portefeuille affiche également."
        poll_interval_seconds:
          type: integer
          description: "confirm_in_app uniquement\_: fréquence d'appel de POST .../verifications/{request_id}/poll/ pour un retour rapide. Didit interroge également les connexions en attente en arrière-plan, de sorte que le webhook signale le résultat même si vous n'effectuez pas de scrutation."
      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: >-
            Nationalité ISO3, uniquement lorsque le portefeuille en atteste une
            (jamais déduite).
        issuing_state:
          type: string
          description: Pays ISO3 dont le système a délivré l'identité.
      required:
        - date_of_birth
        - first_name
        - full_name
        - issuing_state
        - last_name
        - nationality
    DigitalIdWalletApiWalletNextActionTypeEnum:
      enum:
        - redirect
        - confirm_in_app
        - request_digital_credential
      type: string
      description: |-
        * `redirect` - redirect
        * `confirm_in_app` - confirm_in_app
        * `request_digital_credential` - request_digital_credential
    DigitalIdWalletApiWalletDigitalCredentialsRequest:
      type: object
      properties:
        protocol:
          type: string
          description: openid4vp-v1-signed.
        request:
          type: object
          additionalProperties: {}
          description: "Transmettez tel quel\_: navigator.credentials.get({digital: request}) dans le navigateur, ou JSON.stringify(request) comme requestJson de GetDigitalCredentialOption sur Android. Signé par Didit pour votre application."
      required:
        - protocol
        - request
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: x-api-key
      description: >-
        La clé API de votre application, issue de Développeurs -> Clés API dans
        la Business Console. La clé principale dispose d'un accès complet. Une
        clé nommée peut être restreinte : aucun, lecture ou écriture par
        ressource, limitée à certains workflows ou aux sessions approuvées, à
        une liste d'adresses IP et à une date d'expiration. 401 signifie que la
        clé est incorrecte, révoquée ou expirée ; 403 signifie qu'aucune clé n'a
        été envoyée, que la clé n'a pas accès à cette ressource ou action, ou
        que la requête provient d'une adresse hors de sa liste d'IP ; 404 sur
        une route de session signifie que la session est hors des workflows ou
        des statuts de la clé. Une clé sans accès aux médias reçoit les URL
        d'images, de vidéos et de PDF à null, et une clé sans accès en écriture
        aux sessions reçoit les liens et tokens de session à null. Voir
        https://docs.didit.me/console/api-keys.
    BearerAuth:
      type: http
      scheme: bearer
      description: Le token d'accès client-credentials de l'application.

````

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