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

# Téléverser des documents KYB via l'API

> Téléversez des documents d'entreprise dans une session de Vérification d'entreprise depuis votre serveur, avec l'OCR et les contrôles de Didit.



## OpenAPI

````yaml fr/openapi-25.json POST /v3/session/{sessionId}/kyb/documents/
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/session/{sessionId}/kyb/documents/:
    post:
      tags:
        - Sessions
      summary: Téléverser des documents KYB pour une session
      description: >-
        Téléversez un ou plusieurs documents d'entreprise (statuts, registre des
        actionnaires, extrait Kbis/certificat d'immatriculation, ...) vers
        l'étape Documents KYB d'une session de Vérification d'entreprise, depuis
        votre propre serveur au lieu de la page hébergée. Didit exécute le
        pipeline hébergé : compression, OCR, contrôles d'altération et de
        cohérence inter-documents, regroupement documentaire, et fait avancer la
        session lorsque les groupes de documents requis sont satisfaits. L'étape
        coûte un tarif forfaitaire unique, quel que soit le nombre de fichiers
        envoyés. La session doit être ouverte et à l'étape Documents KYB, et
        l'entreprise choisie à l'étape du registre doit exister. Consultez les
        personnes nommées dans les documents avec `GET
        /v3/session/{sessionId}/kyb/extracted-parties/`. Nécessite
        `write:businesses`.
      operationId: post_v3_session_kyb_documents
      parameters:
        - name: sessionId
          in: path
          required: true
          description: >-
            UUID de la session de Vérification d'entreprise (KYB). Il doit
            appartenir à l'application de la clé API.
          schema:
            type: string
            format: uuid
            example: 33333333-4444-5555-6666-777777777777
        - name: node_id
          in: query
          required: false
          description: >-
            Nœud de workflow de l'étape KYB. Nécessaire uniquement lorsque le
            workflow comporte plus d'un nœud KYB ; par défaut, Didit utilise le
            nœud propre à la session.
          schema:
            type: string
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              type: object
              required:
                - documents
              properties:
                documents:
                  type: array
                  items:
                    type: string
                    format: binary
                  description: >-
                    Fichiers à téléverser : JPG, JPEG, PNG, TIFF, WEBP, PDF ou
                    archives ZIP de ceux-ci. PDF jusqu'à 50 MB, photos jusqu'à 6
                    MB avant compression.
                document_passwords:
                  type: array
                  items:
                    type: string
                  description: >-
                    Une entrée par fichier dans `documents`, dans le même ordre
                    : le mot de passe d'un PDF protégé, vide pour tout autre
                    fichier.
                document_group:
                  type: string
                  enum:
                    - LEGAL_PRESENCE
                    - COMPANY_DETAILS
                    - OWNERSHIP_STRUCTURE
                    - REPRESENTATIVES_AUTHORIZATION
                  description: >-
                    Groupe de documents requis auquel correspond ce
                    téléversement.
                locale:
                  type: string
                  maxLength: 10
                  description: >-
                    Locale utilisée pour traduire la réponse de l'étape
                    suivante.
      responses:
        '200':
          description: "Documents traités. Lorsque chaque groupe requis est satisfait, la session avance et `next_step` indique l'étape suivante\_; sinon, elle reste à l'étape Documents et `document_groups` ainsi que `document_answer` indiquent ce qui manque encore."
          content:
            application/json:
              schema:
                type: object
                properties:
                  valid:
                    type: boolean
                  next_step:
                    type: string
                    nullable: true
                    description: Étape où se trouve la session après le téléversement.
                  kyb_status:
                    type: string
                    description: Statut de la vérification de l'entreprise.
                  document_answer:
                    type: object
                    additionalProperties: true
                    description: >-
                      Résultat pour chaque document téléversé et nombre de
                      téléversements restants.
                additionalProperties: true
              example:
                valid: true
                next_step: KYB_KEY_PEOPLE
                kyb_status: In Progress
        '400':
          description: >-
            Un document a été refusé (altération, illisible ou non pris en
            charge) ou la session n'a pas encore d'entreprise KYB. Réessayez
            avec un autre fichier tant qu'il reste des tentatives.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              example:
                message: No KYB company found. Submit company data first.
        '401':
          description: >-
            La clé API restreinte a expiré. C'est le seul cas qui renvoie `401`
            : une clé manquante, invalide ou révoquée renvoie `403`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              examples:
                Expired key:
                  summary: La date d'expiration de la clé est dépassée
                  value:
                    detail: This API key has expired.
        '402':
          description: L'organisation n'a plus de crédit pour l'étape des documents.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              example:
                detail: Insufficient credits.
        '403':
          description: >-
            Échec d'authentification ou d'autorisation. Une clé manquante
            renvoie `403`, tout comme la clé d'une autre application, une clé
            restreinte ne disposant pas de l'autorisation requise par cet
            endpoint, ou une requête provenant de l'extérieur de la liste
            d'adresses IP autorisées de la clé ; une clé incorrecte, révoquée ou
            expirée renvoie `401`. Distinguez-les grâce au champ `detail`.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              examples:
                Missing or invalid credentials:
                  summary: Aucun en-tête x-api-key, ou la validation de la clé a échoué
                  value:
                    detail: >-
                      Authentication credentials were not provided or are
                      invalid.
                Other application:
                  summary: >-
                    Une clé valide qui appartient à une application différente
                    de la session
                  value:
                    detail: You do not have permission to perform this action.
                Scoped key without decisions write:
                  summary: 'La clé restreinte ne dispose pas de decisions: write'
                  value:
                    detail: This API key has no write access to decisions.
                IP not allowed:
                  summary: >-
                    Requête provenant de l'extérieur de la liste d'adresses IP
                    autorisées de la clé
                  value:
                    detail: This API key can't be used from this IP address.
        '404':
          description: >-
            La session n'existe pas, a été supprimée, appartient à une autre
            application ou se trouve en dehors des limites d'une clé restreinte
            ; aucun détail ne permet de les distinguer.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              example:
                detail: Session not found.
        '409':
          description: >-
            La session est terminée (`kyb_session_not_writable`) ou n'est pas à
            l'étape des documents KYB (`kyb_step_mismatch`, avec `next_step`
            indiquant l'étape à laquelle elle se trouve).
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
                  code:
                    type: string
                  next_step:
                    type: string
              example:
                detail: The session is not on the step this operation completes.
                code: kyb_step_mismatch
                next_step: KYB_REGISTRY
        '429':
          description: >-
            Limite de débit dépassée : 300 requêtes d'écriture (POST, PATCH,
            DELETE) par minute par clé API. Attendez `Retry-After` secondes
            avant de réessayer ; les en-têtes `X-RateLimit-*` indiquent le
            budget.
          content:
            application/json:
              schema:
                type: object
                properties:
                  detail:
                    type: string
                    description: Message d'erreur lisible par l'humain.
              examples:
                Rate limited:
                  summary: Budget épuisé pour la minute en cours
                  value:
                    detail: >-
                      Write request rate limit exceeded. You can make up to 300
                      requests per minute.
          headers:
            Retry-After:
              description: Secondes à attendre avant de réessayer.
              schema:
                type: integer
                minimum: 1
                example: 30
        '503':
          $ref: '#/components/responses/DocumentProcessingBusy'
      security:
        - ApiKeyAuth: []
      x-codeSamples:
        - lang: python
          label: Python
          source: |-
            from didit import Didit

            # Reads DIDIT_API_KEY.
            client = Didit()

            result = client.sessions.upload_kyb_documents(
                "33333333-4444-5555-6666-777777777777",
                documents=[open("document.pdf", "rb")],
            )
            print(result)
        - lang: javascript
          label: Node.js
          source: >-
            import Didit, { fileFromPath } from "@didit-protocol/sdk-node";


            // Reads DIDIT_API_KEY.

            const didit = new Didit();


            const result = await
            didit.sessions.uploadKybDocuments("33333333-4444-5555-6666-777777777777",
            {
              documents: [await fileFromPath("document.pdf")],
            });

            console.log(result);
        - lang: go
          label: Go
          source: "ctx := context.Background()\n// Reads DIDIT_API_KEY.\nclient := didit.NewClient()\n\nresult, err := client.Sessions.UploadKYBDocuments(ctx, \"33333333-4444-5555-6666-777777777777\", didit.SessionsUploadKYBDocumentsParams{\n\tDocuments: []didit.File{didit.FileFromPath(\"document.pdf\")},\n})\nif err != nil {\n\tlog.Fatal(err)\n}\nfmt.Printf(\"%+v\\n\", result)"
        - lang: java
          label: Java
          source: >-
            import java.nio.file.Path;

            import java.util.List;

            import me.didit.Didit;

            import me.didit.types.SessionsUploadKybDocumentsParams;


            // Reads DIDIT_API_KEY.

            Didit client = new Didit();


            var result =
            client.sessions().uploadKybDocuments("33333333-4444-5555-6666-777777777777",
            SessionsUploadKybDocumentsParams.builder()
                    .documents(List.of(Path.of("document.pdf")))
                    .build());
            System.out.println(result);
        - lang: php
          label: PHP
          source: >-
            <?php


            require 'vendor/autoload.php';


            use Didit\DiditClient;

            use Didit\File;


            // Reads DIDIT_API_KEY.

            $didit = new DiditClient();


            $result =
            $didit->sessions->uploadKybDocuments('33333333-4444-5555-6666-777777777777',
            [
                'documents' => [File::fromPath('document.pdf')],
            ]);

            print_r($result->toArray());
        - lang: ruby
          label: Ruby
          source: |-
            require "didit"

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

            result = didit.sessions.upload_kyb_documents(
              "33333333-4444-5555-6666-777777777777",
              documents: [Pathname("document.pdf")]
            )
            puts result.to_h
        - lang: csharp
          label: .NET
          source: >-
            using System;

            using System.Text.Json;

            using Didit;


            // Reads DIDIT_API_KEY.

            using var client = new DiditClient();


            var result = await
            client.Sessions.UploadKybDocumentsAsync("33333333-4444-5555-6666-777777777777",
            new SessionsUploadKybDocumentsParams

            {
                Documents = new FileUpload[] { FileUpload.FromPath("document.pdf") },
            });

            Console.WriteLine(JsonSerializer.Serialize(result));
components:
  responses:
    DocumentProcessingBusy:
      description: >-
        Un nombre trop important de documents est actuellement en cours de
        traitement, cet envoi n'a donc pas été traité : rien n'a été stocké et
        aucune tentative n'a été utilisée. Renvoyez le même fichier après le
        nombre de secondes indiqué dans `Retry-After`. Effectuez le branchement
        en fonction de `code`, et non du texte du message.
      headers:
        Retry-After:
          description: >-
            Nombre de secondes à attendre avant d'envoyer à nouveau la même
            requête.
          schema:
            type: integer
            example: 10
      content:
        application/json:
          schema:
            type: object
            required:
              - detail
              - code
            properties:
              detail:
                type: string
              code:
                type: string
                enum:
                  - document_processing_busy
          example:
            detail: We are busy processing documents. Please try again in a moment.
            code: document_processing_busy
  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.

````

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