Only this pageAll pages
Powered by GitBook
1 of 52

French

Loading...

DÉBUTER

Loading...

Loading...

Loading...

APPLICATION

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

API

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Loading...

Miscellaneous

Loading...

Créer un modèle de document

Champs généraux et champs répétés

Koncile distingue deux types de champs à extraire :

  • Champs généraux : présents une seule fois dans le document, comme la date, le nom du fournisseur ou le montant total.

  • Champs répétés: apparaissent plusieurs fois, comme les lignes d’une facture (prix unitaire, description, champs en tableau, etc.).

Faire un test en 3 minutes

3 minutes pour extraire les informations clés de votre document

1

Cliquez sur "Importer mes documents"

Ce bouton permet d'importer tous vos documents dans l'application Koncile.

2

Choisissez "Classification Automatique"

Glissez-déposez votre document dans l'encadré.

Vous pouvez alors choisir :

  • de l'importer dans un qui existe déjà dans votre session, ou

3

Cliquez sur le nouveau modèle de document créé

Une fois le fichier traité, un nouveau modèle de document a été créé dans votre interface. Cliquez dessus pour accéder à la liste des documents du modèle.

4

Sélectionnez votre fichier

Dans la liste de documents de ce modèle, accédez à votre fichier. Ici "Facture.pdf".

Consultez la donnée extraite.

5

Téléchargez sous format CSV

Dans les options en haut à droite de votre écran, sélectionnez "Télécharger les données extraites du document".

Un dossier ZIP est téléchargé contenant 2 fichiers CSV :

Qu'est-ce qu'un modèle de document ?

Un modèle de document dans Koncile est une fiche qui indique quelles informations extraire automatiquement d’un type de document (facture, contrat, etc.).

L'application est organisée autour des modèles de documents qui sont visibles dans la barre latérale et sous forme de cartes lorsqu'on clique dans l'onglet Documents.

Un modèle de document peut être entièrement édité, modifié, complété et même généré par IA, dans l'interface Koncile.

En cliquant sur un modèle de document, vous retrouvez l'ensemble des fichiers que vous avez traités par ce modèle.

opter pour classification automatique, dans ce cas Koncile déterminera le bon modèle en fonction du document.

A noter que pour les comptes de démonstration, vous ne pouvez ajouter qu'un seul document à la fois.

Selon la taille du document, le traitement peut prendre entre 5 secondes et 20 secondes.

[Nom du modèle]_lines.csv qui contient les données de tableaux extraites
  • [Nom du modèle]_general.csv qui contient les données générales extraites

  • Vous pouvez également faire des téléchargements de données de plusieurs documents.

    modèle de document

    Utiliser un modèle prêt à l'emploi

    Koncile propose une bibliothèque de plus de 100 modèles de document prêts à l'emploi.

    1

    Cliquez sur "Nouveau modèle de document"

    Le bouton est accessible dans l'onglet "Documents".

    2

    Sélectionnez "Modèles prêts à l'emploi"

    Dans la liste déroulante, choisissez le modèle que vous souhaitez utiliser. Par exemple "facture".

    3

    Cliquez sur votre modèle puis "Modifier ce modèle de document"

    4

    Personnalisez le modèle

    Vous pouvez ajouter, modifier ou supprimer des champs généraux ou des champs de tableau.

    5

    Lancez l'extraction sur le fichier de test

    Les données extraites seront visibles directement sous les noms des champs.

    Créer un modèle à partir de zéro

    Vous pouvez créer un modèle de document vide pour ajouter les champs que vous souhaitez.

    1

    Cliquez sur "Nouveau modèle de document"

    Le bouton est accessible dans l'onglet "Documents".

    2

    Sélectionnez "A partir de zéro"

    Cette option permet de créer un modèle de document vide, que l'utilisateur pourra compléter.

    Renseigner ensuite le nom du modèle ainsi que des instructions de (optionnel).

    3

    Cliquez sur votre modèle puis "Modifier ce modèle de document"

    4

    Renseignez vos champs d'extraction et cliquez sur "Ajouter"

    5

    Importez un fichier de test

    6

    Lancez l'extraction sur le fichier de test

    Les données extraites seront visibles directement sous les noms des champs.

    Vous pouvez aussi , en vous appuyant sur le contenu du document test.

    Bienvenue sur Koncile

    Koncile est un outil de nouvelle génération pour l’extraction de données des documents. Nous allons au-delà de la technologie OCR traditionnelle. Il ne s’agit pas simplement de reconnaître des caractères, mais de transformer des données brutes et non structurées en contenus structurés et exploitables.

    Notre plateforme est conçue pour tous les secteurs d’activité, et ne nécessite aucune formation pour être prise en main. Voici quelques exemples concrets de l’usage de Koncile au quotidien :

    • Les comptables extraient automatiquement les montants hors taxes des factures. Découvrez notre OCR pour factures.

    • Les responsables conformité récupèrent les données clés des clients pour accélérer les vérifications KYC. Découvrez notre OCR pour documents d’identité ou OCR pour relevés bancaires.

    • Les acheteurs construisent des bases de données complètes à partir des articles listés dans les factures fournisseurs.

    • Les responsables logistiques extraient les codes essentiels des bons de livraison pour les rapprocher des factures.

    Découvrez notre de documents disponibles dans l'application.

    Vous pouvez créer ou personnaliser ce que nous appelons des “modèles d’extraction” : une liste flexible de champs à identifier dans n’importe quel type de document.

    Chaque document qui entre dans l'outil peut être classifié selon le bon modèle, découpé et extrait. La donnée peut également faire l'objet d'enrichissement, de correction et de rapprochement avec une base de données.

    Qu’est-ce qui fait la différence entre Koncile et les outils OCR classiques ?

    Vous ne vous limitez pas à l’extraction. L’outil vous permet aussi de définir des règles, transformer les données et les analyser directement depuis l’interface.

    Envie de découvrir le futur de l’extraction de données ? Essayez l’application et voyez par vous-même à quel point Koncile est puissant et simple d’utilisation.

    bibliothèque de modèles
    Cover

    Test rapide

    Découvrez Koncile en 3 minutes

    Cover

    Application

    Apprenez à extraire des données sans coder

    Cover

    API

    Accédez à la documentation complète

    Exporter la donnée

    Télécharger la donnée texte bruteExporter la donnée d'un documentExporter la donnée de plusieurs documents

    Importer et extraire des documents

    Importer des compléments ou amendements

    Koncile offre la possibilité d’enrichir un document existant en important un ou plusieurs fichiers complémentaires, puis en sélectionnant le document d’origine à compléter.

    Ces fichiers sont automatiquement fusionnés avec le document initial, qui est ensuite entièrement retraité par l’outil pour extraire les informations actualisées.

    Utilisation de l'API

    Lors de l’import d’un ou plusieurs fichiers, indiquez l’identifiant du document d’origine à compléter dans les paramètres de votre requête, via doc_id = the original document id.

    Organiser les documents

    classification automatique
    générer des champs grâce à l'IA

    Relancer l'extraction

    Relancer l'extraction d'un document

    Lorsque vous avez modifié un modèle de document, vous pouvez relancer l'extraction par l'IA en cliquant sur "Relancer".

    Tous les champs seront remis à jour.

    Relancer l'extraction de plusieurs documents

    Dans la liste des documents d'un modèle, sélectionnez les fichiers à relancer, puis cliquez sur "Actions", puis "Relancer".

    Crédits

    Les pages relancées seront comptabilisées dans les crédits de votre compte.

    Il n'est pas possible de relancer lorsque le modèle d'extraction n'a pas été modifié.

    Dupliquer un modèle de document

    1

    Cliquez sur les paramètres d'un modèle de document

    Les paramètres sont accessibles sur les trois points des cartes de chaque modèle.

    2

    Sélectionnez "Dupliquer"

    Supprimer des documents

    Par défaut, les documents sont conservés dans l'application. Si vous souhaitez les supprimer, sélectionnez les fichiers concernés dans la liste de documents d'un modèle, et cliquez sur "Actions", puis "Supprimer".

    Limites de contexte

    Chaque modèle de document comporte des limites techniques destinées à garantir des performances optimales lors de l’extraction des données.

    Champs et instructions

    • Champs généraux : 100 maximum

    Cas d'usage

    Extraire des données d'une facture PDF

    Extraire des données de notes de frais et reçus

    SDK Libraries

    Set up your development environment to use the Koncile API with an SDK in your preferred language. At the moment, only a python sdk is available.

    You can use the . Get started by installing the SDK using pip :

    Start uploading file, following the page.

    Déplacer un document de modèle

    Vous avez chargé un document dans un modèle, et vous souhaitez le déplacer dans un autre modèle ?

    Sélectionnez le fichier concerné, et cliquez sur "Attribuer à un autre modèle".

    L'extraction sera relancée selon votre autre modèle de document cible, et les données d'extraction initiales seront supprimées.

    Exporter la donnée d'un document

    Pour télécharger les données extraites structurées d'un document, cliquez sur ce document, puis sur les trois points en haut à droite de votre écran, puis "Télécharger les données extraites du document".

    Le dossier zip téléchargé contient deux fichiers CSV : "general" contient les données générales apparaissant une seule fois dans votre document, et "lines" contient les données du tableau.

    Swagger

    The swagger of the Koncile API is available at the following address:

    Champs de tableaux : 15 maximum
  • Instructions : 5 maximum (champs généraux et tableaux ensemble)

  • Taille du contenu

    • Champs généraux : jusqu’à 5 000 caractères

    • Champs de tableaux : jusqu’à 2 000 caractères

    • Instructions : jusqu’à 2 000 caractères

    Ces limites s’appliquent à chaque modèle de document indépendamment et permettent d’assurer la stabilité et la rapidité du traitement, y compris sur des volumes importants de données.

    Paramétrer un modèle de document

    Python guide

    Extraire des données de contrat
    Official Koncile SDK
    File Uploading
    pip install koncile

    API Key generation

    You can generate your API key in the user settings of the application by following the path: Settings > API. Please note, this feature is only accessible to admin users.

    Télécharger la donnée texte brute

    Vous pouvez télécharger les données texte brutes extraite du document.

    Cliquez sur un document, puis les trois points en haut à droite de l'écran, puis "Télécharger le contenu texte".

    Un fichier .txt sera généré avec l'ensemble du contenu textuel du document.

    Importer par email

    Pour importer une pièce jointe par email dans l’application Koncile, utilisez votre adresse de transfert unique.

    Veuillez noter que seules les pièces jointes envoyées depuis l’adresse email associée à votre compte seront acceptées.

    1

    Accédez aux paramètres de l'application

    2

    Ensuite, cliquez sur "Email d'intégration"

    Envoyez vos pièces jointes à Koncile en les adressant à cette adresse depuis l’email associé à votre compte.

    À noter

    Chaque pièce jointe envoyée par email sera traitée comme un fichier distinct.

    En revanche, si un PDF contient plusieurs documents, il sera tout de même traité comme un document unique.

    Les documents seront automatiquement organisés grâce aux fonctionnalités de .

    Importer dans un modèle

    Après avoir créé votre modèle de document, importez un document pour qu'il soit extrait selon ce modèle.

    1

    Cliquez sur "Importer mes documents"

    2

    Choisissez "Classification manuelle"

    Vous choisissez le modèle selon lequel votre document sera extrait. Par exemple, ci-dessous, vous choisissez le modèle "Facture".

    Ensuite, cliquez sur "Importer".

    3

    Consultez le statut de traitement du document

    Cliquez en bas de la barre latérale sur "Voir plus" pour consulter le statut de votre document.

    Il sera indiqué comme "Terminé" à la fin de l'extraction.

    Vous pouvez directement cliquer sur le lien pour accéder à la donnée extraite.

    4

    Cliquez sur le modèle de document

    Pour accéder à l'ensemble des fichiers dans le modèle de documents, sélectionnez le modèle dans votre barre latérale.

    Formatter les données extraites

    Vous pouvez appliquer un formatage automatique à tout champ extrait, qu’il soit général ou de tableau.

    Les formats pris en charge sont les suivants :

    Type
    Sortie formatée

    texte

    Format par défaut. Texte extrait sans post-traitement.

    Nombre

    Format numérique sans séparateurs de milliers. Par défaut, la virgule est utilisée comme séparateur décimal. Exemples : 1034045 ou 1,2. Vous pouvez changer le séparateur en point dans les paramètres.

    Date

    Format de date. Par défaut : JJ/MM/AAAA. Vous pouvez passer au format américain dans les paramètres.

    Vide

    Comment choisir le format d'un champ ?

    Lorsque vous créez un champ à extraire, utilisez le menu déroulant à droite de "Nom".

    Ajouter du contexte et des instructions

    Pour chaque modèle de document, vous pouvez ajouter des instructions.

    À quoi servent les instructions ?

    Les instructions ou le contexte sont des informations que vous souhaitez donner à l'outil pour mieux extraire les données de vos documents.

    Les instructions concernent-elles les champs généraux ou les champs de tableaux ?

    Les instructions peuvent être données soit pour les champs généraux, soit pour les champs répétés. L'option est dans le menu contexte.

    Des exemples d'instructions ?

    Pour des champs généraux :

    1. Les documents traités sont des factures d'énergie.

    2. Prends bien en compte toutes les informations des annexes.

    Pour des champs de tableau :

    1. Ignore les lignes de total

    2. Prends en compte uniquement les lignes qui concernent les produits achetés, ignore les lignes de transport.

    3. Formate tous les pays extraits selon le format international en trois lettres. Ex: FRA

    Organiser par dossiers

    Tous les modèles de documents sont affichés dans la barre latérale.

    Vous pouvez les organiser par dossier. La création de dossier est accessible via le bouton "Nouveau Dossier" dans la liste des modèles de documents.

    Vous pouvez ensuite déplacer un modèle de document dans un dossier, en cliquant sur les trois points sur la carte du modèle, puis "Déplacer le modèle".

    Vous choisissez ensuite le dossier dans lequel vous souhaitez déplacer le modèle.

    Polling task retrieval

    This example demonstrates how to use the Python requests library to integrate the Koncile API. The script illustrates the following steps:

    1. File Upload: The file is sent to the API via a dedicated endpoint, along with the necessary parameters such as the extraction template and the folder ID.

    2. Retrieval of the Task ID: Once the file is processed, the task ID generated by the API is used to track its status.

    3. Task Processing Monitoring: A polling function periodically checks whether the task is completed before extracting the returned information.

    API status codes

    Errors

    Koncile uses conventional HTTP response codes to indicate the success or failure of an API request. In general: Codes in the 2xx range indicate success. Codes in the 4xx range indicate an error that failed given the information provided (e.g., a required parameter was omitted, a charge failed, etc.). Codes in the 5xx range indicate an error with Koncile's servers (these are rare).

    Some 4xx errors that could be handled programmatically, with an error message that briefly explains the error reported.

    Classifier automatiquement

    Qu'est-ce que l'auto-classification ?

    L’application Koncile permet de trier automatiquement les documents chargés dans l'application vers le bon modèle de document.

    Limites de sécurité

    Depuis un compte administrateur, vous pouvez configurer les limites de sécurité quotidiennes et mensuelles. Une fois ces seuils atteints, l’extraction de nouvelles pages est automatiquement bloquée. L’application et l’API renverront alors un message d’erreur explicite.

    Accéder aux limites de sécurité

    Cliquez sur votre nom en bas à gauche de l'écran pour accéder aux paramètres de l'application.

    Puis dans "Factures & Usage".

    Modifiez ensuite vos limites par jour et par nombre de pages. Elles sont valables pour

    classification automatique

    Le champ restera vide.

    Choix multiple

    Les valeurs sont limitées à une liste prédéfinie par l’utilisateur. Seules les valeurs sélectionnées seront renvoyées. Exemple : Facture Devis ou Bon de commande

    Vrai/faux

    Limité aux valeurs vrai ou faux.

    tous les utilisateurs de votre société
    .

    Il existe des limites de sécurité par défaut qui sont visibles lorsque les limites sont désactivées.

    This script can serve as a starting point for integrating Koncile into your automated systems. Be sure to replace placeholder values (e.g., your-api-key, folder-id, template-id, path-to-file) with your own data.

    import requests
    import time
    
    api_key = "your-api-key"
    api_url = "https://api.koncile.ai"
    
    upload_url = f"{api_url}/v1/upload_file/"
    fetch_url = f"{api_url}/v1/fetch_tasks_results/"
    params = {"config_id": 'use-case-id', "class_id": 'file-type-id'}
    file_path = './path-to-file'
    headers = {
        "accept": "application/json",
        "Authorization": f"Bearer {api_key}"
    }
    files = [
        ('files', open(file_path, 'rb')),
    ]
    response = requests.post(upload_url, params=params, headers=headers, files=files)
    
    if response.status_code != 200:
        print(response.status_code)
        print(response.json())
        exit(1)
    
    task_id = response.json()["task_ids"][0]
    
    def poll_until_done(task_id, headers):
        while True:
            response = requests.get(f"{fetch_url}?task_id={task_id}/", headers=headers)
            status = response.json()["status"]
            if status != "IN PROGRESS":
                return response
            print("Task in progress")
            time.sleep(2)
    
    response = poll_until_done(task_id, headers)
    print(response.json()["status"])
    print(response.json()["status_message"])
    
    print(response.json()["General_fields"])
    print(response.json()["Line_fields"])

    Status codes

    Status code
    Details
    Definition

    200

    OK

    Everything worked as expected.

    307

    Temporary Redirect

    The request url is missing the final '/'

    400

    Bad Request

    The request was unacceptable, often due to missing a required parameter.

    401

    Unauthorized

    Comment activer l'auto-classification ?

    Méthode 1. Choisir l'option "Classification automatique" au moment du téléchargement.

    L'outil va alors sélectionner le bon modèle parmi les modèles de votre interface. Si aucun ne correspond, il sélectionnera un modèle pertinent dans la bibliothèque de modèles Koncile.

    Méthode 2. Choisir "Classification manuelle" et sélectionner plusieurs modèles

    Sélectionnez plusieurs modèles. Pour chaque document chargé, l'outil sélectionnera le modèle le plus pertinent.

    Comment fonctionne l'auto-classification ?

    L'outil analyse le contenu du document, son titre et ses métadonnées pour le rapprocher du bon modèle de document.

    Pour attribuer un document à un modèle, l'outil s'appuie également sur les instructions de classification.

    Que se passe-t-il si l'auto-classification échoue ?

    Si un fichier chargé ne correspond à aucun des modèles dans votre interface, le document apparaitra dans les alertes.

    Ajouter et modifier des champs

    Chaque modèle de document peut être modifié. Vous pouvez ajouter, modifier ou supprimer des champs généraux ou des champs de tableau.

    1

    Cliquez sur "Modifier modèle"

    2

    Sélectionnez "Champs généraux" ou "Champs de tableau"

    Si vous souhaitez extraire des champs unitaires de votre document, c'est-à-dire qui apparaissent une seule fois dans le document, choisissez "champs généraux".

    Si vous souhaitez extraire des champs répétés, dans des tableaux, des lignes ou tables, choisissez "champs de tableau".

    3

    Ajoutez ou mettez à jour des champs

    Ajoutez les champs que vous souhaitez extraire en donnant un nom, une description et un format.

    File Uploading

    File upload is a key step to initiate data processing in Koncile. This endpoint allows you to send files for analysis while specifying the necessary parameters, such as the folder identifier (folder_id) and the extraction template (template_id). Once the file is uploaded, the API returns a list of task IDs (task_ids), corresponding to the individual processes associated with your file.

    Auto-classification is applied when the folder id or template id are left empty. Auto-classification will select the folder and templates that fit best the uploaded document. When auto-classification fails, the files have to manually be classified on the platform. Only use this feature if you are using both the api and the platform. For more information, check out the

    Task Retrieval

    The Tasks Retrieval feature of the Koncile API allows you to monitor the real-time status of tasks related to the processing of submitted documents. This feature is essential for integrating automated tracking into your workflows, ensuring optimal management of documents and extracted information.

    When you submit a document to Koncile, it is processed in the background. Using the dedicated Tasks Retrieval endpoint, you can:

    • Check the status of a specific task, whether it is completed (DONE), in progress (IN PROGRESS), duplicate (DUPLICATE), or failed (FAILED).

    • Access general extracted information, such as dates, prices, and supplier names, through structured fields.

    FAQ

    Administration & Paramètres

    Quelles langues sont prises en charge par Koncile ?

    Koncile peut analyser des documents dans n'importe quelle langue. La plateforme est actuellement disponible en français et en anglais.

    Web-hook task retrieval

    As an option, you can chose instead of polling, to set up an endpoint that will automatically receive the document's extracted data whenever it is done parsing.

    Setting up

    The setting up of the webhook is made through the platform. You can only set up the web hook if you are a company administrator. This menu can be found in settings -> api.

    Insert the url from your webhook, and test out your path. Once you have a working webhook, the setup is complete on koncile's side. You can move to the Webhook call segment to set up your receival endpoint.

    Bubble Plugin

    You can use the Koncile API directly in your Bubble applications thanks to our plugin:

    You'll need to create a Koncile account to be able to use the Bubble Plugin.

    Step 1 - Post file

    The plugin gives you access to API actions. To send a file for extraction, select the “Post file” action:

    On your koncile app, you can access the koncile_ids of your folders and extraction templates:

    Puis-je créer un compte pour quelqu’un d’autre dans la même entreprise sur Koncile ?

    Nous proposons des comptes multi-utilisateurs dans le cadre de notre offre Enterprise. Tous les utilisateurs de l'entreprise auront accès aux fichiers partagés, aux modèles d’extraction et aux données extraites.

    Comment puis-je mettre à jour les informations de mon compte ?

    Pour actualiser les informations de votre compte :

    1. Allez dans le menu en bas à gauche de votre écran ;

    2. Cliquez sur "Paramètres" ;

    3. Vous pouvez y modifier vos informations générales, votre mot de passe, ainsi que la langue de la plateforme.

    Extraction de données

    Pourquoi devrais-je décrire chaque champ que je souhaite extraire ?

    Cela permet à l’outil de s’adapter au format du document. Par exemple, indiquez que la « description » doit inclure le sous-titre de la catégorie de produit ou de service, ou précisez que le poids doit être exprimé en kilogrammes plutôt qu’en tonnes.

    Quels formats de documents sont pris en charge ?

    Vous pouvez importer les types de documents suivants dans Koncile :

    • PDF (y compris PDF/A)

    • Images : PNG, JPEG et JPG

    Les champs extraits sur mes documents sont incorrects, que dois-je faire ?

    Vous pouvez vérifier que le document ne contient pas d’anomalies, telles que des lignes effacées, masquées ou illisibles, qui pourraient gêner l’extraction des informations. Dans certains cas, les modèles d’extraction peuvent nécessiter des ajustements pour tenir compte des spécificités de certains documents.

    Quel type de document puis-je importer dans Koncile ?

    Koncile prend en charge tous les types de documents pour l’analyse. Explorez notre bibliothèque de modèles pour découvrir la multitude de documents pouvant être traités. Si votre document n'y figure pas, vous pouvez facilement créer un modèle personnalisé à partir de zéro.

    Qu’est-ce que le temps de traitement ?

    Le traitement d’un document dans l’application prend généralement entre 10 secondes et 1 minute. Les documents plus volumineux ou plus complexes peuvent nécessiter un délai supplémentaire.

    Est-il possible de télécharger l’ensemble des données présentes sur la plateforme ?

    Sur la page des cas d’usage, vous pouvez sélectionner tous les cas d’usage, puis cliquer sur Télécharger, puis sur Données.

    No valid API key provided.

    402

    Request Failed

    The parameters were valid but the request failed.

    403

    Forbidden

    The API key doesn’t have permissions to perform the request.

    404

    Not Found

    The requested resource doesn’t exist.

    422

    Unprocessable Entity

    The request parameters are invalid.

    500, 502, 503, 504

    Server Errors

    Something went wrong on Koncile's end. (These are rare.)

    Upload file

    POSThttps://api.koncile.ai/v1/upload_file

    Upload a list of files to the koncile API

    Limitations

    Maximum number of pages per document: 150

    Supported file formats: PDF, JPEG & PNG

    Maximum file size in MB: 300MB for PDF | 10 MB for PNG/JPEG

    Rate limits: We don't enforce rate limits, but we ask that you use the API responsibly

    Path / Query parameters

    folder_id Integer The id of the folder in which the document will be stored

    template_id Integer The id of the template containing the fields to extract

    doc_id Integer Feature The id from the document the uploaded file will complete. For more informations check the Amendment logic.

    Request body

    files files Required The list of File object (not file name) to be uploaded.

    Returns

    task_ids Integer A list of task ids, used to retrieve the generated document

    The example below demonstrates how to make a cURL request to upload a file, including the essential information to be included in the headers and parameters.

    Detailed Response Schema (Returned Schemas)

    Classifier automatiquement

    Retrieve detailed line-level data for more precise and granular processing.

    Retrieve tasks

    GEThttps://api.koncile.ai/v1/fetch_tasks_results

    Fetch the results from the file upload

    Path parameters

    task_id Integer Required The id of the task to retrieve

    Returns

    document_id Integer The id from the extracted document

    status String The document extraction status, can be DONE | DUPLICATE | IN PROGRESS | FAILED

    status_message String More informations about the extraction

    General_Fields Dict The extracted fields present once in the document

    Line_Fields Dict The extracted fields present multiple time in the document lines

    To query a specific task via the Koncile API, use the following command. This cURL command allows you to retrieve the status and associated data of a given task using its `task_id`. Be sure to replace `{task_id}` with the task ID and `$API_KEY` with your personal authentication key.

    Detailed Response Schema (Returned Schemas)

    The API returns a JSON structure containing all the necessary information to analyze the status and extracted data of a task. The response is organized into two main sections:

    1. General_fields: Groups the global data extracted from the document, such as the date, total price, and supplier.

    2. Line_fields: Contains detailed line-level information, allowing for a more granular analysis of individual elements.

    Below, you will find the exact schema of the response, with the various available fields, their types, and examples of values. This structured format makes it easy to integrate the data into your systems or workflows.

    curl api.koncile.ai/v1/upload_file/ \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY" \
      -d '{
    	  "folder_id": $folder-id,
    	  "template_id": $template-id
       }' \
      -F "[email protected]"
    from koncile_sdk.client import KoncileAPIClient
    from koncile_sdk.clients.fields import FieldFormat
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    files = [
        "./files/invoice_2f05c4c2-ca00-441a-8efc-f6d0c5a86402.pdf", # exemple file path
        "./files/invoice_31462760-3070-4f7c-ba55-da3fdd6cddf6.pdf", # exemple file path
    ]
    
    response = client.files.upload(
        folder_id=folder_id,
        template_id=template_id,
        file_paths=files
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    files = [
        "./files/invoice_2f05c4c2-ca00-441a-8efc-f6d0c5a86402.pdf", # exemple file path
        "./files/invoice_31462760-3070-4f7c-ba55-da3fdd6cddf6.pdf", # exemple file path
    ]
    
    const response = await sdk.files.upload(
      folderId,
      templateId,
      files,
    );
    
    {
    	task_ids: ["EOBdOSUX4Uv57YWsLYc4JQ", "cUrsd2ClWXa8vzupWQ2zGQ"]
    }
    curl api.koncile.ai/v1/fetch_tasks_results/?task_id={task_id} \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    client = KoncileAPIClient(
        api_key=API_KEY,
    )
    
    response = client.tasks.fetch_tasks_results(task_id=task_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.tasks.fetchResults(taskId);
    
    
    {
    	"status": DONE | DUPLICATE | IN PROGRESS | FAILED,
    	"document_id": ID,
    	"document_name": "name",
    	"status_message": "",
    	"General_fields":
    		{
    			"Date" : {"value": "05/08/2022", "confidence_score": 0.99},
    			"Price" : {"value": "23$", "confidence_score": 0.98},
    			"Supplier name" : {"value": "Koncile", "confidence_score": 1}
    		}
    	,
    	"Line_fields":
    		{
    			"Date" : [{"value": "05/08/2022", "confidence_score": 0.97}, {"value" : "05/09/2022", "confidence_score": 0.98}, {"value": "03/02/2023", "confidence_score": 0.99}],
    			"Price" : [{"value": "23$", "confidence_score": 0.98}, {"value": "12$", "confidence_score": 0.97}, {"value": "5$", "confidence_score": 0.98}],
    			"Supplier name" : [{"value": "Koncile", "confidence_score": 0.97}, {"value": "Koncile", "confidence_score": 0.99}, {"value": "Koncile", "confidence_score": 1}]
    		}
    }
    Webhook call

    The message sent by the webhook follows the same output as the task retrieval and document fetching

    Example endpoint

    npm init -y
    npm install express body-parser

    Then go to Koncile, paste http://${your-url}:8000/web-hook/ as the webhook URL, and trigger a test document.

    Then go to Koncile, paste http://${your-url}:8000/web-hook/ as the webhook URL, and trigger a test document.

    Settings page for the web hook

    Use these IDs to fill out the config_id and class_id parameters of the call in the Bubble action:

    You can generate your API key in the user settings of the application by following the path: Settings > API. Please note, this feature is only accessible to admin users:

    Simply copy-paste your API key after “Bearer “ in the Authorization header.

    Note: You might need to trigger this call in a batch or in a loop to send multiple files at once. 1 file - 1 call.

    Step 2 - Fetch results

    Once the file has been sent, you can retrieve the results using the “fetch results” action:

    Trigger this action preferably once the Post file call returns a success code (200). You might need to trigger this call in a loop to make sure you get the full results once the task status is “DONE”. Take a look at the way it is implemented on the Bubble's plugin demo app, with a frontend workflow to post a file followed by a trigger of a backend looping workflow to fetch results.

    The API returns a JSON to exploit as you wish within your Bubble app: to create things for instance. Here is a typical output to exploit:

    Contact us at [email protected] if you have any questions about using the Bubble Koncile plugin!

    https://bubble.io/plugin/koncile-ai---advanced-ocr-1733836054037x247444812903219200

    Tarifs

    Vous pouvez à tout moment mettre à niveau votre compte de démonstration en cliquant sur S'abonner dans la barre de navigation.

    Tous les abonnements donnent accès aux deux modèles d'extraction : Koncile Pro (le plus puissant) et Koncile Lite (le plus économique).

    📅 Abonnement mensuel

    • Facturation mensuelle à la date de souscription

    • Résiliable à tout moment, sans engagement

    • Gérez votre abonnement dans Paramètres > Factures et Usage > Portail de facturation

    • Si vous dépassez votre quota mensuel, des crédits supplémentaires sont facturés au tarif indiqué dans le tableau ci-dessous

    # Crédits
    Prix mensuel
    Crédit supplémentaire

    📆 Abonnement annuel - faites des économies !

    • Facturation unique au début de la période d’abonnement

    • L’ensemble des crédits annuels est immédiatement disponible pour toute l’année

    • Si vous dépassez votre quota annuel, des crédits supplémentaires sont facturés au tarif indiqué dans le tableau ci-dessous

    • Les crédits sont valables uniquement pendant la durée de l’abonnement et ne peuvent pas être reportés au-delà du contrat

    # Crédits
    Prix mensuel
    Prix annuel
    Crédit supplémentaire

    🔑 Comment fonctionnent les crédits

    • 1 crédit = 1 page Koncile Pro

    • 1 crédit = 2 pages Koncile Lite

    • Rerun (relancer une page) : consomme le même nombre de crédits que l’extraction initiale

    • Les crédits ne peuvent pas être reportés d’un mois ou d’une année sur l’autre

    Exemple : avec la formule 500 crédits, vous pouvez traiter 500 pages Pro ou 1000 pages Lite (ou toute combinaison des deux).

    👥 Utilisateurs et gestion d’équipe

    • Chaque abonnement inclut 2 utilisateurs

    • Utilisateurs additionnels : 5 €/mois (hors TVA)

    💳 Facturation & TVA

    • Tous les prix s’entendent hors TVA ou taxes locales applicables

    • Les paiements sont effectués via notre partenaire Stripe, garantissant sécurité et fiabilité

    • L’ensemble de vos factures est disponible dans le Portail de facturation accessible via Paramètres > Factures et Usage

    Templates

    Templates are created and managed within folders.

    Create template

    POSThttps://api.openai.com/v1/create_template/

    Creates a template

    Path parameters

    template_id Integer Optional Logic for copying another template, using their template_id

    Request body

    folder_id Integer Required The id of the folder inside which the template is created

    name String Required The name of the template to create, unique

    desc String The description of the template to create

    type String Spend accounts only Can be invoice, regular, or grid

    Returns

    The created object

    Fetching template

    GEThttps://api.openai.com/v1/fetch_template/{template_id}

    Fetches all informations about a template, using the template_id

    Path parameters

    template_id Integer Required The id of the template to fetch

    Returns

    The object

    Update template

    PUThttps://api.openai.com/v1/update_template/{template_id}

    Updates a template, using the template_id

    Path parameters

    template_id Integer Required The id of the template to update

    Request body

    name String

    desc String

    type String Spend accounts only Can be invoice, regular, or grid

    Returns

    The object

    Delete template

    DELETEhttps://api.openai.com/v1/delete_template/{template_id}

    Deletes a template, using the template_id

    Path parameters

    template_id Integer Required The id of the template to update

    override Boolean If True forces deletion. Default False

    Template Object

    id Integer

    name String The name of the template

    desc String A more detailled description of the template. Informations can have an impact on the document output.

    type String Spend accounts only Can be invoice, regular, or grid

    folder_id Integer The id from the folder the template is linked to

    Fields

    Fields to be extracted

    Create field

    POSThttps://api.openai.com/v1/create_field Creates a field to extract

    webhookReceiver.js
    const express = require("express");
    const bodyParser = require("body-parser");
    
    const app = express();
    app.use(bodyParser.json());
    
    app.post("/web-hook/", (req, res) => {
      console.log("Webhook received:");
      console.log(JSON.stringify(req.body, null, 2));
      res.json({ message: "Webhook received successfully" });
    });
    
    const PORT = 8000;
    app.listen(PORT, () => {
      console.log(`Listening on http://localhost:${PORT}/web-hook/`);
    });
    node webhookReceiver.js
    pip install fastapi uvicorn
    main.py
    from fastapi import FastAPI, Request
    import uvicorn
    
    
    app = FastAPI()
    
    
    @app.post("/web-hook/")
    async def receive_webhook(request: Request):
        payload = await request.json()
        print("\n Webhook received:")
        print(payload)
        return {"message": "Webhook received successfully"}
    
    
    if name == "main":
        print("Listening on http://localhost:8000/web-hook/")
        uvicorn.run("webhook_receiver:app", host="0.0.0.0", port=8000, reload=True)
    
    python webhook_receiver.py
    {
    	"status": DONE | DUPLICATE | IN PROGRESS | FAILED,
    	"document_id": ID,
    	"document_name": str,
    	"status_message": str,
    	"General_fields":
    		{
    			"field_name" : {"value": str, "confidence_score": float},
    			"field_name" : {"value": str, "confidence_score": float}
    		}
    	,
    	"Line_fields":
    		{
    			"field_name" : [{"value": str, "confidence_score": float}, {"value": str, "confidence_score": float}, {"value": str, "confidence_score": float}],
    			"field_name" : [{"value": str, "confidence_score": float}, {"value": str, "confidence_score": float}, {"value": str, "confidence_score": float}]
    		}
    }
    {
    	"status": DONE | DUPLICATE | IN PROGRESS | FAILED,
    	"document_id": ID,
    	"status_message": "",
    	"General_fields":
    		{
    			"Date" : {"value": "05/08/2022", "confidence_score": 0.99},
    			"Price" : {"value": "23$", "confidence_score": 0.98},
    			"Supplier name" : {"value": "Koncile", "confidence_score": 1}
    		}
    	,
    	"Line_fields":
    		{
    			"Date" : [{"value": "05/08/2022", "confidence_score": 0.97}, {"value" : "05/09/2022", "confidence_score": 0.98}, {"value": "03/02/2023", "confidence_score": 0.99}],
    			"Price" : [{"value": "23$", "confidence_score": 0.98}, {"value": "12$", "confidence_score": 0.97}, {"value": "5$", "confidence_score": 0.98}],
    			"Supplier name" : [{"value": "Koncile", "confidence_score": 0.97}, {"value": "Koncile", "confidence_score": 0.99}, {"value": "Koncile", "confidence_score": 1}]
    		}
    }

    2500

    459.00 €

    0.18 €

    3000

    539.00 €

    0.18 €

    3500

    609.00 €

    0.17 €

    4000

    679.00 €

    0.17 €

    4500

    739.00 €

    0.17 €

    5000

    799.00 €

    0.16 €

    24000

    339.00 €

    4,068.00 €

    0.17 €

    30000

    409.00 €

    4,908.00 €

    0.16 €

    36000

    489.00 €

    5,868.00 €

    0.16 €

    42000

    549.00 €

    6,588.00 €

    0.16 €

    48000

    609.00 €

    7,308.00 €

    0.15 €

    54000

    669.00 €

    8,028.00 €

    0.15 €

    60000

    719.00 €

    8,628.00 €

    0.14 €

    500

    109.00 €

    0.22 €

    1000

    199.00 €

    0.20 €

    1500

    289.00 €

    0.19 €

    2000

    379.00 €

    6000

    99.00 €

    1,188.00 €

    0.20 €

    12000

    179.00 €

    2,148.00 €

    0.18 €

    18000

    259.00 €

    3,108.00 €

    0.19 €

    0.17 €

    template
    template
    template
    curl api.koncile.ai/v1/create_template/ \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY" \
      -d '{
      "name": string,
      "folder_id": int
    }'
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.templates.create(
        folder_id=folder_id,
        name=name
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.templates.create(folderId, name);
    
    curl api.koncile.ai/v1/fetch_template/?template_id=template_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.templates.get(template_id=template_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.templates.get(templateId);
    
    curl api.koncile.ai/v1/update_template/?template_id=template_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.templates.update(template_id=template_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.templates.update(templateId);
    
    curl api.koncile.ai/v1/delete_template/?template_id=template_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.templates.delete(template_id=template_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.templates.delete(templateId);
    Request body

    template_id Integer Required The id of the folder inside which the field is created

    name String Required The name of the field to create, unique

    type String Require Defines whether the field is extracted once (General fields) or for every line (Line fields)

    desc String The description of the field to create

    format String The kind of field to extract, with their custom formatting. By default "text". For all the field formats, please refer to this page.

    position Integer The field position in the output, relative to the other fields. Default: appended to the end

    Returns

    The created field object

    curl api.koncile.ai/v1/create_field/ \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY" \
      -d '{
        "template_id": integer,
    
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.fields.create(
        template_id=
    
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    

    Fetching field

    GEThttps://api.openai.com/v1/fetch_field/{field_id} Fetches all the informations about a field, using the field_id

    Path parameters

    field_id Integer Required The id of the field to fetch

    Returns

    The field object

    Update field

    PUThttps://api.openai.com/v1/update_field/{field_id} Updates a field, using the field

    Path parameters

    field_id Integer Required The id of the field to update

    Request body

    name String The name of the field to create, unique

    desc String The description of the field to create

    format String The kind of field to extract, with their custom formatting. By default "text". For all the field formats, please refer to this page.

    type String Defines whether the field is extracted once (General fields) or for every line (Line fields)

    position Integer The field position in the output, relative to the other fields. Default: appended to the end

    Returns

    The field object

    Delete field

    DELETEhttps://api.openai.com/v1/delete_field/{field_id} Deletes a field, using the field_id

    Path parameters

    field_id Integer Required The id of the field to update

    Field Object

    id Integer

    name String The name of the field, unique

    desc String The description of the field

    format String The kind of field to extract, with their custom formatting. By default "text". For all the field formats, please refer to this page.

    type String Defines whether the field is extracted once (General fields) or for every line (Line fields)

    position Integer The field position in the output, relative to the other fields. Default: appended to the end

    Template_id Integer The id from the template the field is linked to

    Instructions

    Instructions are taken into account by Koncile to extract the general fields of the line fields.

    Create instruction

    POSThttps://api.openai.com/v1/create_instruction

    Creates an instruction

    Request body

    template_id Integer Required The ID of the template to create the instruction in

    content String Required The instruction's text

    type String Required Defines whether instruction is targetting the fields extracted once (General fields) or for every line (Line fields)

    Returns

    The created object

    Fetching instruction

    GEThttps://api.openai.com/v1/fetch_instruction/{instruction_id}

    Fetches all information about an instruction, using the instruction_id

    Path parameters

    instruction_id Integer Required The id of the instruction to fetch

    Returns

    The object

    Update instruction

    PUThttps://api.openai.com/v1/update_instruction/{instruction_id}

    Updates an instruction, using the instruction_id

    Path parameters

    instruction_id Integer Required The id of the instruction to update

    Request body

    content String The instruction's text

    type String Defines whether instruction is targetting the fields extracted once (General fields) or for every line (Line fields)

    Returns

    The object

    Delete instruction

    DELETEhttps://api.openai.com/v1/delete_instruction/{instruction_id}

    Deletes an instruction, using the instruction_id

    Path parameters

    Instruction_id Integer Required The id of the instruction to update

    Instruction Object

    id Integer

    content String The instruction's text

    type String Whether the instruction has to be extracted once, or for every line. Can be "General fields" or "Line fields"

    template_id Integer The id from the template the instruction is linked to

    Folders

    Folders hold the different types of documents and templates.

    Create folder

    POSThttps://api.openai.com/v1/create_folder

    Creates a folder

    Request body

    Name String Required The name of the folder to create

    Desc String A detailed description of the folder's purpose or content

    Returns

    The created object

    Fetching folder

    GEThttps://api.openai.com/v1/fetch_folder/{folder_id}

    Fetches all information about a folder, using the folder_id

    Path parameters

    Folder_id Integer Required The id of the folder to fetch

    Returns

    The object

    Update folder

    PUThttps://api.openai.com/v1/update_folder/{folder_id}

    Updates a folder, using the folder_id

    Path parameters

    Folder_id Integer Required The id of the folder to update

    Request body

    name String The name of the folder to update

    desc String A detailed description of the folder's purpose or content to update

    Returns

    The object

    Delete folder

    DELETEhttps://api.openai.com/v1/delete_folder/{folder_id}

    Deletes a folder, using the folder_id

    Path parameters

    folder_id Integer Required The id of the folder to delete

    override Boolean If True forces deletion. Default False

    Folder Object

    id Integer

    name String The name of the folder

    desc String A detailed description of the folder's purpose or content

    Conseils de rédaction des prompts

    Pour obtenir la meilleure qualité d'extraction de champs, il peut être nécessaire d’ajouter vos propres champs personnalisés et/ou d’ajuster la description de certains champs.

    Notre interface est conçue pour vous permettre d’interagir avec l’outil de la manière la plus simple possible : vous expliquez ce que vous attendez, et l’outil appliquera vos consignes sur le modèle d’extraction concerné.

    Parlez à l’outil comme à un assistant

    Utilisez des phrases naturelles, complètes, plutôt que du langage télégraphique. Par exemple, au lieu d’écrire simplement "prix total", dites "Additionner les prix de toutes les lignes".

    N’hésitez pas à transmettre votre expertise métier : listes de fournisseurs, synonymes pour une même valeur, position habituelle des informations sur les documents, ou encore des règles spécifiques comme les codes commencent toujours par la lettre M, etc.

    Formulez aussi des consignes générales qui permettent à l’outil de gérer les cas ambigus

    Des lignes de service ou de produit peuvent apparaître deux fois de suite dans l’extrait. Il faut les extraire séparément, même si elles se ressemblent fortement. Toute ligne visible doit être extraite, y compris les doublons.

    Chaque ligne extraite doit contenir un prix. Ne pas extraire de lignes sans prix.

    Extraire uniquement les lignes de facturation. Ce sont des services facturés liés au transport international de marchandises. Chaque ligne doit toujours comporter un libellé et un prix. Ne pas inclure les en-têtes ni les totaux.

    Toujours utiliser les mêmes unités et devises pour les montants et les prix.

    Ajouter des exemples

    Les exemples renforcent considérablement la qualité de l’extraction et permettent de formater les résultats selon vos besoins.

    Nom : Description complète du service ou produit

    Description : Par exemple : “Pré-acheminement HT”, “Frais de déménagement”, “frais de manutention/documentation export”, “Fret maritime”, “frais de sécurité AMS/ACI”, “Surcharge carburant pré-acheminement”,

    Format : Texte


    Nom : Référence de transport

    Description : Pour les factures, il s’agit d’un numéro à 9 chiffres commençant par 61, situé tout à la fin. Pour les avoirs, c’est un code figurant après le numéro “page 1”, par exemple : “41A0234141”, “21A0620427”, “610156703”.

    Format : Texte

    Erreurs à éviter

    Si l’outil rencontre des ambiguïtés, fournissez des consignes précises.

    Nom : Montant net HT de la ligne

    Description : S’il y a plusieurs montants sur la ligne, extraire le plus élevé. S’il y a plusieurs devises, privilégier les euros (EUR, €).

    Format : Prix


    Nom : Adresse du destinataire

    Description : S’il y a plusieurs adresses, retenir celle liée à la référence de transport ayant la distance la plus élevée en km, ou sinon la dernière. Si une même adresse est valable pour plusieurs lignes, la répéter pour chaque sous-ligne. Ce champ est rarement vide.

    Format : Texte


    Nom : Date du document

    Description : Même si le document est en français, la date peut apparaître au format américain (MM/JJ/AAAA). Attention à ne pas inverser le mois et le jour.

    Format : Date

    Exploitez l’intelligence de l’outil

    L’outil peut enrichir, valider et reformater automatiquement les données extraites.

    Nom : Pays émetteur

    Description : Indiquez le code pays selon la norme ISO 3166.

    Format : Texte


    Nom : Catégorie de produit

    Description : Catégoriser le produit parmi les options suivantes : fruits et légumes, céréales et légumineuses, produits laitiers, viandes, poissons et fruits de mer, matières grasses, produits sucrés, sel, eau, autres.

    Format : Texte


    Nom : Classification comptable

    Description : Précisez s’il s’agit de dépenses fixes, variables, salaires, maintenance machines, frais bancaires, impôts, assurances, abonnements ou taxes locales.

    Format : Texte


    Nom : Code aéroport

    Description : Fournir le code ICAO correspondant à l’aéroport mentionné.

    Format : Texte


    Nom : Résumé des conditions de transfert du bail

    Description : Résumer en environ 20 mots les conditions de transfert du bail à un tiers, si applicable.

    Format : Texte

    Conseils supplémentaires

    L’IA déteste le vide

    Les modèles ont tendance à vouloir répondre à tout prix. Si vous souhaitez ignorer certaines lignes (comme celles d’une annexe), mieux vaut écrire une consigne du type Répondre “Annexe” plutôt que Ne pas extraire.

    Mieux vaut catégoriser qu’exclure

    Si une facture contient des lignes de détail, de résumé ou d’annexe que vous ne voulez pas exploiter, il est plus efficace de tout extraire et d’ajouter un champ de catégorisation multiple, avec des options comme : Ligne de facture, Ligne de sous-total, Ligne en annexe, Ligne de résumé, Ligne d’estimation, etc., afin de pouvoir trier les résultats facilement dans vos systèmes.

    GitHub - Koncile/koncile-python: The official Python SDK for Koncile, providing a seamless interface to interact with the Koncile API.GitHub
    Public API Documentationapi.koncile.ai
    curl api.koncile.ai/v1/fetch_field/?field_id=field_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.fields.get(field_id=field_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.fields.get(fieldId);
    
    curl api.koncile.ai/v1/update_field/?field_id=field_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.fields.update(field_id=field_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.fields.update(fieldId);
    curl api.koncile.ai/v1/delete_field/?field_id=field_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.fields.delete(field_id=field_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.fields.delete(fieldId);
    
    “BUC – Bunker charge”
    , etc. Fournir le libellé complet, y compris les mesures et montants.
    "name": "string",
    "type": "string"
    }'
    template_id,
    name=name,
    type=type
    )
    const response = await sdk.fields.create(templateId, name, type);
    instruction
    instruction
    instruction
    curl api.koncile.ai/v1/create_instruction/ \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY" \
      -d '{
        "content": string,
        "template_id": integer
      }'
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.instructions.create(
        template_id=template_id,
        content=content,
        type=type
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.instructions.create(templateId, content, type);
    
    folder
    folder
    folder
    curl api.koncile.ai/v1/create_folder/ \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY" \
      -d '{
        "name": "string",
        "desc": "string"
      }'
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.folders.create(
        name=name,
        desc=desc
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.folders.create(
      name,
      desc
    );
    
    curl api.koncile.ai/v1/fetch_instruction/?instruction_id=instruction_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.instructions.get(
        instruction_id=instruction_id
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.instructions.get(instructionId);
    curl api.koncile.ai/v1/update_instruction/?instruction_id=instruction_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.instructions.update(
        instruction_id=instruction_id
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.instructions.update(instructionId);
     curl api.koncile.ai/v1/delete_instruction/?instruction_id=instruction_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.instructions.delete(
        instruction_id=instruction_id
    )
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.instructions.delete(instructionId);
    curl api.koncile.ai/v1/fetch_folder/?folder_id=folder_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.folders.get(folder_id=folder_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.folders.get(folderId);
    
    
    curl api.koncile.ai/v1/update_folder/?folder_id=folder_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.folders.update(folder_id=folder_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.folders.update(folderId);
    curl api.koncile.ai/v1/delete_folder/?folder_id=folder_id \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $API_KEY"
    from koncile_sdk.client import KoncileAPIClient
    
    
    client = KoncileAPIClient(
        api_key=API_KEY
    )
    
    response = client.folders.delete(folder_id=folder_id)
    const { Koncile } = require('koncile-js');
    require('dotenv').config();
    
    const sdk = new Koncile(process.env.API_KEY);
    
    const response = await sdk.folders.delete(folderId);
    

    Bibliothèque de modèles

    Koncile propose des modèles de documents prêts à l'emploi. Partez de ces modèles pour ensuite les modifier selon vos besoins.

    Modèles en français

    Administratif général

  • Acte de naissance

  • Carte Nationale d’Identité (CNI)

  • Carte européenne d’assurance maladie (CEAM)

  • Document d’identité

  • Justificatif de domicile

  • Passeport

  • Permis de conduire

  • Titre de séjour

  • Assurance

    • Attestation d’assurance décennale

    • Attestation d’assurance habitation

    • Attestation d’assurance professionnelle

    • Attestation d’assurance responsabilité civile

    • Attestation d’assurance responsabilité locative

    • Attestation d’assurance scolaire

    • Attestation de tiers payant

    • Déclaration de sinistre

    • Feuille de soin

    • Certificat d’assurance automobile

    • Constat à l’amiable dégât des eaux

    • Constat amiable d’accident automobile

    Banque & finance

    • Avis d’opération

    • Carte vitale

    • Chèque bancaire

    • Chèques bancaires (liasse)

    • Confirmation de transaction

    • Relevé de compte

    • Relevé d’identité bancaire (RIB)

    Construction & BTP

    • Attestation d’assurance décennale

    • Permis de construire

    Contrats

    • Accord de confidentialité

    • Accord de confidentialité (NDA)

    • Bail d’habitation

    • Bon de commande

    • Bon de livraison

    • Conditions générales d’achat

    • Contrat d’achat

    • Contrat de travail

    • Lettre de mise en demeure

    • Procuration

    Douane & transport international

    • Certificat de circulation des marchandises

    • Connaissement maritime (Bill of Lading)

    • Déclaration en douane

    • Document Administratif Unique (DAU)

    • Lettre de transport aérien (Air Waybill)

    • License de transport

    Énergie & télécoms

    • Facture EDF

    • Facture Orange

    • Facture SFR

    • Facture TotalEnergies Electricité

    • Facture d’énergie

    Entreprise

    • Comptes d’entreprise

    • Extrait Kbis

    • Liasse fiscale 2065 - Millésime 2024 - Régime réel normal

    Fiscalité

    • Avis d’impôt de taxes foncières

    • Avis d’impôt sur le revenu

    • Déclaration TVA Formulaire CA3

    • Déclarations d’impôt sur les sociétés (2065)

    Immobilier

    • Acte de vente notarié

    • Attestation de loyer

    • Bail d’habitation

    • Compromis de vente

    • DPE

    • Etat de situation

    • Quittance de loyer

    RH & emploi

    • AEM (Attestation Employeur Mensuelle)

    • Attestation de salaire (indemnités)

    • Carte de visite

    • Carte de visite (lot)

    • Curriculum Vitae (CV)

    • Fiche de paie

    • Lettre de mise en demeure

    • Note de frais

    Santé

    • Attestation d’assurance scolaire

    • Attestation de droits à la sécurité sociale

    • Certificat d’aptitude physique

    • Certificat d’inaptitude au sport

    • Fiche d’admission hospitalière

    • Ordonnance

    Transport

    • CMR (Lettre de voiture internationale)

    • Facture transport express

    • Facture transport maritime

    • Facture transport routier

    • Lettre de voiture

    • Liste de colisage

    • Déclaration en douane

    Vente & commerce

    • Catalogue produit

    • Devis

    • Facture

    • Facture hospitalière

    • Facture transport express

    • Reçu (ticket de caisse)

    • Grille tarifaire

    Voyage

    • Attestation d’assurance voyage

    • Carte européenne d’assurance maladie (CEAM)

    Autres

    Document d’Information Clé (DIC)

    Valeur nutritive


    Modèles en anglais

    Administrative & Legal Documents

    • Certificate of Entitlement

    • Certificate of Incorporation

    • Custom Declaration

    • European Health Insurance Card

    • Identity document

    • IRS notice

    • Passport

    • Residence Permit

    • Single Administrative Document (SAD)

    Banking & Finance

    • Bank Account Details

    • Bank check

    • Bank Statement

    • Checks (bundle)

    • Merchant statement

    • Payment confirmation

    • Transaction notice

    Contracts & Agreements

    • Employment contract

    • Non-Disclosure Agreement (NDA)

    • Procurement Contract

    • Purchase order

    • Reservation Agreement

    • Residential lease

    • Sales agreement

    Energy & Utilities

    • Energy bill

    • Energy Performance Certificate (EPC)

    • Vodafone invoice

    Healthcare & Insurance

    • Employee’s statement of sickness

    • Home insurance certificate

    • Insurance Claim

    • Prescription

    • Rental liability insurance certificate

    • Treatment form

    Identification & Immigration

    • Birth Certificate

    • Certificate of Live Birth

    • Driving license

    • European Health Insurance Card

    • Identity document

    • Passport

    • Residence Permit

    Invoicing & Commercial Documents

    • Express transport invoice

    • Invoice

    • Maritime transport invoice

    • Quote

    • Receipt

    • Road transport invoice

    Logistics & Trade

    • Air Waybill (AWB)

    • Bill of Lading

    • Delivery Note

    • Packing list

    • Product catalog

    • Property Status Report

    Professional & HR

    • Business card

    • Business card (bundle)

    • Payslip

    • Resume

    Real Estate & Property

    • ALTA Settlement Statement

    • Building Permit Statement

    • Property Status Report

    • Rent Receipt

    • Reservation Agreement

    • Residential lease

    Tax & Compliance

    • Property Tax Notice

    • U.S. Corporation Income Tax Return (Form 1120)

    • VAT return (Form VAT100)

    Logo
    Logo

    Exporter la donnée de plusieurs documents

    Pour exporter les données de plusieurs documents, sélectionnez les documents, puis cliquez sur "Actions", puis "Télécharger".

    Ensuite, rendez-vous dans l'onglet Téléchargements de l'application.

    Dès que votre export est prêt, il apparaît en haut de la liste des téléchargements.

    Générer les champs extraits avec l'IA

    La fonctionnalité « Générer avec l’IA » de Koncile vous permet de générer automatiquement des suggestions de champs à partir d’un document exemple.

    L'outil va analyser le document de test et déduire les champs pertinents à extraire.

    1

    Créez un modèle de document vide

    Cliquez sur "Nouveau modèle de document", puis "À partir de zéro".

    Voir les détails dans la vidéo de.

    2

    Importez un document de test

    Le document importé sera utilisé par l'IA pour générer les champs à extraire.

    3

    Cliquez sur "Générer avec l'IA"

    L'outil analyse le contenu du document pour déduire des champs à extraire.

    Le temps de création peut varier entre 20 secondes et 1 minute.

    4

    Modifiez les champs extraits

    Personnalisez ensuite les champs créés par l'IA.

    Fonctionnement de la fonctionnalité "Générez avec l'IA"

    La fonctionnalité ne supprime pas de champs existants. Si vous avez déjà des champs existants, l'outil va créer de nouveaux champs complémentaires.

    Elle ne peut être activée que lorsqu'un fichier test a été ajouté.

    La fonctionnalité consomme 1 crédit de page.

    création de modèle