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...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
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.).
3 minutes pour extraire les informations clés de votre 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.




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.





Koncile propose une bibliothèque de plus de 100 modèles de document prêts à l'emploi.
Vous pouvez créer un modèle de document vide pour ajouter les champs que vous souhaitez.
Vous pouvez aussi , en vous appuyant sur le contenu du document test.
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.
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.


Test rapide
Découvrez Koncile en 3 minutes

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












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.
Dans la liste des documents d'un modèle, sélectionnez les fichiers à relancer, puis cliquez sur "Actions", puis "Relancer".
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é.
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".
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.
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.
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.
The swagger of the Koncile API is available at the following address:
Instructions : 5 maximum (champs généraux et tableaux ensemble)
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.

pip install koncile

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






Pour importer une pièce jointe par email dans l’application Koncile, utilisez votre adresse de transfert unique.
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 .
Après avoir créé votre modèle de document, importez un document pour qu'il soit extrait selon ce modèle.
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 :
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
Lorsque vous créez un champ à extraire, utilisez le menu déroulant à droite de "Nom".
Pour chaque modèle de document, vous pouvez ajouter des 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 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.
Pour des champs généraux :
Les documents traités sont des factures d'énergie.
Prends bien en compte toutes les informations des annexes.
Pour des champs de tableau :
Ignore les lignes de total
Prends en compte uniquement les lignes qui concernent les produits achetés, ignore les lignes de transport.
Formate tous les pays extraits selon le format international en trois lettres. Ex: FRA
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.
This example demonstrates how to use the Python requests library to integrate the Koncile API. The script illustrates the following steps:
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.
Retrieval of the Task ID: Once the file is processed, the task ID generated by the API is used to track its status.
Task Processing Monitoring: A polling function periodically checks whether the task is completed before extracting the returned information.
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.
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.
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


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.

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"])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
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.
Sélectionnez plusieurs modèles. Pour chaque document chargé, l'outil sélectionnera le modèle le plus pertinent.
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.
Si un fichier chargé ne correspond à aucun des modèles dans votre interface, le document apparaitra dans les alertes.

Chaque modèle de document peut être modifié. Vous pouvez ajouter, modifier ou supprimer des champs généraux ou des 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".
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
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.
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.
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.
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.
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:
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.
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.)



POSThttps://api.koncile.ai/v1/upload_file
Upload a list of files to the koncile API
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
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.
files files Required The list of File object (not file name) to be uploaded.
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)
Retrieve detailed line-level data for more precise and granular processing.
GEThttps://api.koncile.ai/v1/fetch_tasks_results
Fetch the results from the file upload
task_id Integer Required The id of the task to retrieve
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.
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:
General_fields: Groups the global data extracted from the document, such as the date, total price, and supplier.
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}]
}
}The message sent by the webhook follows the same output as the task retrieval and document fetching
npm init -y
npm install express body-parserThen 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.
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.
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!



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).
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
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
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).
Chaque abonnement inclut 2 utilisateurs
Utilisateurs additionnels : 5 €/mois (hors 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 are created and managed within folders.
POSThttps://api.openai.com/v1/create_template/
Creates a template
template_id Integer Optional Logic for copying another template, using their template_id
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
The created object
GEThttps://api.openai.com/v1/fetch_template/{template_id}
Fetches all informations about a template, using the template_id
template_id Integer Required The id of the template to fetch
The object
PUThttps://api.openai.com/v1/update_template/{template_id}
Updates a template, using the template_id
template_id Integer Required The id of the template to update
name String
desc String
type String Spend accounts only
Can be invoice, regular, or grid
The object
DELETEhttps://api.openai.com/v1/delete_template/{template_id}
Deletes a template, using the template_id
template_id Integer Required The id of the template to update
override Boolean
If True forces deletion. Default False
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
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.jspip install fastapi uvicornfrom 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 €
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);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
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);
GEThttps://api.openai.com/v1/fetch_field/{field_id}
Fetches all the informations about a field, using the field_id
field_id Integer Required The id of the field to fetch
The field object
PUThttps://api.openai.com/v1/update_field/{field_id}
Updates a field, using the field
field_id Integer Required The id of the field to update
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
The field object
DELETEhttps://api.openai.com/v1/delete_field/{field_id}
Deletes a field, using the field_id
field_id Integer Required The id of the field to update
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 are taken into account by Koncile to extract the general fields of the line fields.
POSThttps://api.openai.com/v1/create_instruction
Creates an instruction
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)
The created object
GEThttps://api.openai.com/v1/fetch_instruction/{instruction_id}
Fetches all information about an instruction, using the instruction_id
instruction_id Integer Required The id of the instruction to fetch
The object
PUThttps://api.openai.com/v1/update_instruction/{instruction_id}
Updates an instruction, using the instruction_id
instruction_id Integer Required The id of the instruction to update
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)
The object
DELETEhttps://api.openai.com/v1/delete_instruction/{instruction_id}
Deletes an instruction, using the instruction_id
Instruction_id Integer Required The id of the instruction to update
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 hold the different types of documents and templates.
POSThttps://api.openai.com/v1/create_folder
Creates a folder
Name String Required The name of the folder to create
Desc String A detailed description of the folder's purpose or content
The created object
GEThttps://api.openai.com/v1/fetch_folder/{folder_id}
Fetches all information about a folder, using the folder_id
Folder_id Integer Required The id of the folder to fetch
The object
PUThttps://api.openai.com/v1/update_folder/{folder_id}
Updates a folder, using the folder_id
Folder_id Integer Required The id of the folder to update
name String The name of the folder to update
desc String A detailed description of the folder's purpose or content to update
The object
DELETEhttps://api.openai.com/v1/delete_folder/{folder_id}
Deletes a folder, using the folder_id
folder_id Integer Required The id of the folder to delete
override Boolean
If True forces deletion. Default False
id Integer
name String
The name of the folder
desc String
A detailed description of the folder's purpose or content
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é.
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.
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.
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
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
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
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.
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.
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);
, etc. Fournir le libellé complet, y compris les mesures et montants.
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);
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);
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
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
Avis d’opération
Carte vitale
Chèque bancaire
Chèques bancaires (liasse)
Confirmation de transaction
Relevé de compte
Relevé d’identité bancaire (RIB)
Attestation d’assurance décennale
Permis de construire
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
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
Facture EDF
Facture Orange
Facture SFR
Facture TotalEnergies Electricité
Facture d’énergie
Comptes d’entreprise
Extrait Kbis
Liasse fiscale 2065 - Millésime 2024 - Régime réel normal
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)
Acte de vente notarié
Attestation de loyer
Bail d’habitation
Compromis de vente
DPE
Etat de situation
Quittance de loyer
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
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
CMR (Lettre de voiture internationale)
Facture transport express
Facture transport maritime
Facture transport routier
Lettre de voiture
Liste de colisage
Déclaration en douane
Catalogue produit
Devis
Facture
Facture hospitalière
Facture transport express
Reçu (ticket de caisse)
Grille tarifaire
Attestation d’assurance voyage
Carte européenne d’assurance maladie (CEAM)
Document d’Information Clé (DIC)
Valeur nutritive
Certificate of Entitlement
Certificate of Incorporation
Custom Declaration
European Health Insurance Card
Identity document
IRS notice
Passport
Residence Permit
Single Administrative Document (SAD)
Bank Account Details
Bank check
Bank Statement
Checks (bundle)
Merchant statement
Payment confirmation
Transaction notice
Employment contract
Non-Disclosure Agreement (NDA)
Procurement Contract
Purchase order
Reservation Agreement
Residential lease
Sales agreement
Energy bill
Energy Performance Certificate (EPC)
Vodafone invoice
Employee’s statement of sickness
Home insurance certificate
Insurance Claim
Prescription
Rental liability insurance certificate
Treatment form
Birth Certificate
Certificate of Live Birth
Driving license
European Health Insurance Card
Identity document
Passport
Residence Permit
Express transport invoice
Invoice
Maritime transport invoice
Quote
Receipt
Road transport invoice
Air Waybill (AWB)
Bill of Lading
Delivery Note
Packing list
Product catalog
Property Status Report
Business card
Business card (bundle)
Payslip
Resume
ALTA Settlement Statement
Building Permit Statement
Property Status Report
Rent Receipt
Reservation Agreement
Residential lease
Property Tax Notice
U.S. Corporation Income Tax Return (Form 1120)
VAT return (Form VAT100)







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.



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



