Meilleurs moteurs OCR : IronOCR contre la concurrence

Modèle d'intégration de l'API REST

Parce que Klippa ne publie pas de SDK .NET, toute l'intégration est en HTTP manuel. La source .cs pour Klippa montre à quoi ressemble une véritable intégration :

// Klippa: manual HttpClient integration — no NuGet, no SDK
public class KlippaService
{
    private readonly HttpClient _client;
    private readonly string _apiKey;

    public KlippaService(string apiKey)
    {
        _apiKey = apiKey;
        _client = new HttpClient();
        _client.DefaultRequestHeaders.Add("X-Auth-Key", apiKey); // custom auth header
    }

    // Document upload to Klippa cloud — simplified, see Klippa documentation for full API
    // public async Task<ReceiptData> ProcessReceiptAsync(string imagePath)
    // {
    //     var content = new MultipartFormDataContent();
    //     content.Add(new ByteArrayContent(File.ReadAllBytes(imagePath)), "document", "receipt.jpg");
    //     var response = await _client.PostAsync(
    //         "https://custom-ocr.klippa.com/api/v1/parseDocument", content);
    //     // deserialize structured JSON response...
    // }
}

// Klippa: manual HttpClient integration — no NuGet, no SDK
public class KlippaService
{
    private readonly HttpClient _client;
    private readonly string _apiKey;

    public KlippaService(string apiKey)
    {
        _apiKey = apiKey;
        _client = new HttpClient();
        _client.DefaultRequestHeaders.Add("X-Auth-Key", apiKey); // custom auth header
    }

    // Document upload to Klippa cloud — simplified, see Klippa documentation for full API
    // public async Task<ReceiptData> ProcessReceiptAsync(string imagePath)
    // {
    //     var content = new MultipartFormDataContent();
    //     content.Add(new ByteArrayContent(File.ReadAllBytes(imagePath)), "document", "receipt.jpg");
    //     var response = await _client.PostAsync(
    //         "https://custom-ocr.klippa.com/api/v1/parseDocument", content);
    //     // deserialize structured JSON response...
    // }
}

Imports System.Net.Http

Public Class KlippaService
    Private ReadOnly _client As HttpClient
    Private ReadOnly _apiKey As String

    Public Sub New(apiKey As String)
        _apiKey = apiKey
        _client = New HttpClient()
        _client.DefaultRequestHeaders.Add("X-Auth-Key", apiKey) ' custom auth header
    End Sub

    ' Document upload to Klippa cloud — simplified, see Klippa documentation for full API
    ' Public Async Function ProcessReceiptAsync(imagePath As String) As Task(Of ReceiptData)
    '     Dim content = New MultipartFormDataContent()
    '     content.Add(New ByteArrayContent(File.ReadAllBytes(imagePath)), "document", "receipt.jpg")
    '     Dim response = Await _client.PostAsync("https://custom-ocr.klippa.com/api/v1/parseDocument", content)
    '     ' deserialize structured JSON response...
    ' End Function
End Class

Il n'existe aucune classe typée à instancier. Il n'y a pas d'objet d'entrée à configurer. Chaque aspect de l'authentification, de la logique de nouvelle tentative, de la gestion des erreurs et de l'analyse des réponses est à votre charge, tant pour la mise en œuvre que pour la maintenance.

Comparaison détaillée des fonctionnalités

L'approche de Klippa

Klippa renvoie des données structurées pré-analysées pour les types de documents qu'elle connaît. Soumettez un reçu et vous obtenez vendor, amount, date, vat_amount en retour sous forme de champs typés. Aucun code d'analyse syntaxique n'est requis de votre côté. Pour une intégration simple de gestion des dépenses où vous traitez les reçus d'un ensemble connu de fournisseurs, c'est vraiment utile.

La limitation est la limite. Soumettez un contrat de travail scanné, un dessin technique, un formulaire médical ou une capture d'écran, et le modèle spécialisé de Klippa n'aura rien à vous offrir. La plateforme ne dispose pas d'un mode OCR général permettant de renvoyer du texte brut à partir de documents quelconques. Si votre application traite plusieurs types de documents — ou si les exigences dépassent le cas d'utilisation initial de gestion des dépenses — vous aurez besoin d'un deuxième système.

Approche d'IronOCR

IronOCR traite tout document contenant du texte. En contrepartie, l'extraction de champs structurés (nom du fournisseur, montant total, date d'échéance) nécessite que vous écriviez vous-même le code. L'objet OcrResult vous donne la matière première : texte complet, coordonnées au niveau des mots, segmentation en lignes et paragraphes, et scores de confiance par mot.

// IronOCR: extract text from any document type, then parse
var ocr = new IronTesseract();
var result = ocr.Read("invoice.jpg");

// Word coordinates and confidence — build any extraction logic on top
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence: {word.Confidence}%");
}

// Or use region-based OCR to target specific fields
var totalRegion = new CropRectangle(400, 600, 200, 50); // bottom-right area
using var input = new OcrInput();
input.LoadImage("invoice.jpg", totalRegion);
var totalText = new IronTesseract().Read(input).Text;

// IronOCR: extract text from any document type, then parse
var ocr = new IronTesseract();
var result = ocr.Read("invoice.jpg");

// Word coordinates and confidence — build any extraction logic on top
foreach (var word in result.Words)
{
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence: {word.Confidence}%");
}

// Or use region-based OCR to target specific fields
var totalRegion = new CropRectangle(400, 600, 200, 50); // bottom-right area
using var input = new OcrInput();
input.LoadImage("invoice.jpg", totalRegion);
var totalText = new IronTesseract().Read(input).Text;

Imports IronOcr

' IronOCR: extract text from any document type, then parse
Dim ocr As New IronTesseract()
Dim result = ocr.Read("invoice.jpg")

' Word coordinates and confidence — build any extraction logic on top
For Each word In result.Words
    Console.WriteLine($"'{word.Text}' at ({word.X},{word.Y}) confidence: {word.Confidence}%")
Next

' Or use region-based OCR to target specific fields
Dim totalRegion As New CropRectangle(400, 600, 200, 50) ' bottom-right area
Using input As New OcrInput()
    input.LoadImage("invoice.jpg", totalRegion)
    Dim totalText = New IronTesseract().Read(input).Text
End Using

Le guide OCR basé sur les régions explique comment extraire des champs spécifiques de documents à mise en page fixe. Pour les modèles OCR de factures, le tutoriel OCR de factures couvre la logique d'extraction de bout en bout, et le tutoriel de numérisation de reçus traite spécifiquement du cas des reçus.

Cela représente plus de travail que Klippa pour les cas de reçus et de factures. C'est la seule option pour tout le reste.

L'approche de Klippa

Chaque document soumis à Klippa transite par l'internet public et est traité sur des serveurs que vous ne contrôlez pas. Le fichier README et le code source le confirment explicitement : " Les documents sont traités sur l'infrastructure cloud européenne de Klippa " et " Les documents sont envoyés à des centres de données de l'UE ". Le traitement européen répond à certaines exigences du RGPD — notamment le mécanisme de transfert de données prévu au chapitre V — mais n'en couvre pas toutes.

Les problèmes qui subsistent sont bien réels :

• Les données relatives aux dépenses des employés (montants, commerçants, habitudes de voyage) sont visibles par un prestataire de services de paiement tiers.
• Les données des états financiers, les détails des factures et les numérisations des pièces d'identité sont transmises à chaque appel.
• Les conditions d'utilisation et les politiques de conservation des données de Klippa régissent le traitement des données stockées sur leurs serveurs.
• Le périmètre d'audit couvrant le traitement de vos documents doit désormais inclure l'infrastructure de Klippa.

Pour les organisations soumises à des exigences strictes en matière de traitement des données — services financiers, santé, entreprises sous contrat avec le gouvernement, cabinets d'avocats — l'hébergement européen ne résout pas le problème fondamental de la sortie des données de l'organisation.

// Klippa: document data leaves your network on every call
// Non configuration option changes this — it is the service's architecture
public class KlippaService
{
    public void ShowConsiderations()
    {
        Console.WriteLine("Klippa Considerations:");
        Console.WriteLine("1. Cloud-only - no on-premise option");
        Console.WriteLine("2. Per-document pricing");
        Console.WriteLine("3. Specialized for receipts/invoices");
        Console.WriteLine("4. Requires internet connection");
        Console.WriteLine("5. Documents sent to EU data centers");
    }
}

// Klippa: document data leaves your network on every call
// Non configuration option changes this — it is the service's architecture
public class KlippaService
{
    public void ShowConsiderations()
    {
        Console.WriteLine("Klippa Considerations:");
        Console.WriteLine("1. Cloud-only - no on-premise option");
        Console.WriteLine("2. Per-document pricing");
        Console.WriteLine("3. Specialized for receipts/invoices");
        Console.WriteLine("4. Requires internet connection");
        Console.WriteLine("5. Documents sent to EU data centers");
    }
}

' Klippa: document data leaves your network on every call
' Non configuration option changes this — it is the service's architecture
Public Class KlippaService
    Public Sub ShowConsiderations()
        Console.WriteLine("Klippa Considerations:")
        Console.WriteLine("1. Cloud-only - no on-premise option")
        Console.WriteLine("2. Per-document pricing")
        Console.WriteLine("3. Specialized for receipts/invoices")
        Console.WriteLine("4. Requires internet connection")
        Console.WriteLine("5. Documents sent to EU data centers")
    End Sub
End Class

Approche d'IronOCR

IronOCR traite les documents intégralement au sein de votre infrastructure. La bibliothèque exécute le moteur OCR en interne — sans appels HTTP, sans accès réseau, sans dépendance à un service externe d'aucune sorte.

// IronOCR: all processing stays on your server
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();
var result = ocr.Read("financial-statement.pdf"); // stays on your machine

// Build extraction logic on top of the raw result
var text = result.Text;
Console.WriteLine($"Processed {result.Pages.Count()} pages locally");
Console.WriteLine($"Confidence: {result.Confidence}%");

// IronOCR: all processing stays on your server
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";

var ocr = new IronTesseract();
var result = ocr.Read("financial-statement.pdf"); // stays on your machine

// Build extraction logic on top of the raw result
var text = result.Text;
Console.WriteLine($"Processed {result.Pages.Count()} pages locally");
Console.WriteLine($"Confidence: {result.Confidence}%");

Imports IronOcr

' IronOCR: all processing stays on your server
IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"

Dim ocr As New IronTesseract()
Dim result = ocr.Read("financial-statement.pdf") ' stays on your machine

' Build extraction logic on top of the raw result
Dim text = result.Text
Console.WriteLine($"Processed {result.Pages.Count()} pages locally")
Console.WriteLine($"Confidence: {result.Confidence}%")

Les conséquences en matière de conformité sont directes : les exigences HIPAA, ITAR, CMMC et FedRAMP qui interdisent la transmission de données sensibles à des sous-traitants externes sont satisfaites par défaut. Les environnements isolés fonctionnent sans modification. La documentation IronOCR couvre le déploiement dans les environnements Docker, AWS, Azure et Linux, le tout fonctionnant intégralement sur votre propre infrastructure.

Concernant plus spécifiquement le traitement des documents d'identité, le guide OCR pour les documents d'identité et le tutoriel OCR pour les passeports expliquent comment extraire les données des passeports et des cartes d'identité sans transmettre le document à un service externe.

L'approche de Klippa

En fonction de son architecture et de son positionnement public, Klippa facture par document ou par niveau d'abonnement. Chaque reçu, facture et document d'identité traité s'ajoute à la facture. À une échelle modérée — un système de gestion des dépenses traitant 5 000 documents par mois, ou une application financière scannant 500 factures par jour — la tarification par document s'accumule rapidement. L'évolution des coûts est illimitée : plus de documents, plus de coûts, indéfiniment.

Il n'existe aucun concept de réduction des coûts de traitement par lots au niveau de l'API. Le traitement hors ligne ou la mise en cache ne sont pas possibles. Chaque document nécessite un appel API en direct et engendre des frais.

Approche d'IronOCR

IronOCR utilise une licence perpétuelle sans frais par document. La licence $999 Lite est un paiement unique qui couvre le traitement illimité de documents — pas de comptage, pas de suivi de l'utilisation, pas de surprises de facturation en fin de mois.

Pour une équipe traitant 5 000 documents par mois :

• Année 1 avec IronOCR Lite : $999 total
• Année 3 avec IronOCR Lite : $999 total (perpétuel, même licence)
• Troisième année avec Klippa : trois ans d'abonnement facturés à des tarifs par document non divulgués.

La page de licences IronOCR détaille tous les niveaux. La licence Professional à $2,999 couvre 10 développeurs et 10 projets — une équipe complète pour un coût unique qui s'adapte à des documents illimités.

Le traitement par lots avec IronOCR n'entraîne aucune pénalité financière :

// IronOCR: process 10,000 documents — same cost as processing 10
var ocr = new IronTesseract();

Parallel.ForEach(Directory.GetFiles("receipts", "*.jpg"), filePath =>
{
    var result = new IronTesseract().Read(filePath);
    SaveResult(filePath, result.Text);
    // Each document: $0 marginal cost
});

// IronOCR: process 10,000 documents — same cost as processing 10
var ocr = new IronTesseract();

Parallel.ForEach(Directory.GetFiles("receipts", "*.jpg"), filePath =>
{
    var result = new IronTesseract().Read(filePath);
    SaveResult(filePath, result.Text);
    // Each document: $0 marginal cost
});

Imports System.IO
Imports System.Threading.Tasks

' IronOCR: process 10,000 documents — same cost as processing 10
Dim ocr As New IronTesseract()

Parallel.ForEach(Directory.GetFiles("receipts", "*.jpg"), Sub(filePath)
    Dim result = (New IronTesseract()).Read(filePath)
    SaveResult(filePath, result.Text)
    ' Each document: $0 marginal cost
End Sub)

L'approche de Klippa

En l'absence de package NuGet , l'intégration de Klippa nécessite un client HTTP personnalisé que votre équipe conçoit et maintient. Le code dans le fichier de comparaison montre le modèle : instancier HttpClient, ajouter X-Auth-Key aux en-têtes de requête par défaut, construire MultipartFormDataContent, envoyer par POST à https://custom-ocr.klippa.com/api/v1/parseDocument, lire et désérialiser la réponse. Chacune de ces étapes est à votre charge.

Au-delà de la mise en œuvre initiale, vous possédez désormais :

• Logique de nouvelle tentative pour les pannes transitoires et les limites de débit
• Gestion des délais d'expiration et propagation des jetons d'annulation
• Gestion des versions du schéma de réponse lors de la mise à jour de l'API de Klippa
• Rotation et stockage sécurisé des clés d'authentification
• Correspondance entre les codes d'erreur HTTP et les exceptions d'application
• Infrastructure de tests d'intégration pouvant fonctionner sans appels cloud en direct

Ce n'est pas un projet de week-end. Pour les équipes travaillant sur une intégration de production, prévoyez 2 à 4 jours de travail d'ingénierie avant que le premier document ne soit traité de manière fiable.

Approche d'IronOCR

dotnet add package IronOcr et vous avez terminé avec l'installation. Le guide d'installation d'IronTesseract couvre l'installation en moins de cinq minutes. Aucun client HTTP personnalisé. Pas de système d'authentification. Aucune réponse lors de la désérialisation.

// IronOCR: installation is one command, first read is three lines
dotnet add package IronOcr

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("receipt.jpg").Text;

// IronOCR: installation is one command, first read is three lines
dotnet add package IronOcr

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY";
var text = new IronTesseract().Read("receipt.jpg").Text;

' IronOCR: installation is one command, first read is three lines
' dotnet add package IronOcr

IronOcr.License.LicenseKey = "YOUR-LICENSE-KEY"
Dim text As String = New IronTesseract().Read("receipt.jpg").Text

L'API est synchrone par défaut, avec un support asynchrone disponible via ReadAsync pour l'intégration d'applications web. Les modèles OCR asynchrones couvrent le chemin d'intégration ASP.NET Core . La bibliothèque est thread-safe : plusieurs instances IronTesseract fonctionnent en parallèle sans contention.

Pour les sources d'entrée, IronOCR accepte les chemins de fichiers, les tableaux d'octets, les flux, les URLs, et les objets System.Drawing.Bitmap sans configuration supplémentaire. Le guide d'entrée d'image et le guide d'entrée de flux couvrent tous les modèles d'entrée.

Des exigences de résidence des données émergent

Une équipe qui a adopté Klippa pour une simple intégration de notes de frais découvre souvent plus tard le problème de la résidence des données — lorsqu'un audit de conformité demande où les données des documents sont traitées, ou lorsqu'un nouveau contrat client inclut des dispositions relatives au traitement des données qui interdisent la transmission à des sous-traitants tiers. Une fois cette conversation engagée, le traitement des données effectué par Klippa au sein de l'UE ne satisfait pas à l'exigence, car les données quittent tout de même l'organisation. La voie de la conformité passe par le traitement sur site, et IronOCR est un remplacement direct via NuGet . La page produit IronOCR détaille le modèle de déploiement local complet qui répond aux exigences d'audit sans refonte architecturale.

Le champ d'application du document s'étend au-delà du domaine des spécialistes.

Les systèmes de gestion des dépenses restent rarement des systèmes de gestion des dépenses. Un produit qui commence par traiter les reçus des employés évolue pour gérer les factures des fournisseurs, puis les bons de commande, puis les contrats numérisés, puis les documents d'identité d'intégration, puis les formulaires techniques avec des champs de texte libre. Chaque type de document qui ne correspond pas aux catégories pré-enregistrées de Klippa nécessite un système différent. Les équipes qui atteignent ce stade — utilisant Klippa pour les dépenses, un autre logiciel pour les contrats, un autre encore pour la reconnaissance optique de caractères (OCR) des documents en général — constatent IronOCR consolide l'ensemble de leurs solutions. Une seule bibliothèque gère tous les types de documents, et la logique d'extraction réside dans votre code source où vous pouvez la versionner, la tester et la modifier.

Les coûts par document dépassent le budget.

Les organisations qui traitent des milliers de documents par mois ressentent fortement la tarification au document. Ce qui semble gérable à 500 reçus par mois lors d'un projet pilote se transforme en un poste budgétaire imprévu à 50 000 documents par mois en production. La dynamique cumulative est prévisible mais facile à sous-estimer : plus d'utilisateurs, plus de documents, plus de coûts, sans limite naturelle. La licence perpétuelle d'IronOCR élimine complètement cette dynamique. Le traitement de 500 ou de 500 000 documents coûte la même chose.

Environnements hors ligne ou à réseau restreint

Les applications de traitement financier fonctionnent parfois dans des environnements où l'accès Internet sortant est restreint : réseaux bancaires, systèmes gouvernementaux, environnements Enterprise avec des contrôles de sortie stricts ou déploiements en périphérie où la connectivité est intermittente. Klippa ne peut fonctionner dans aucun de ces contextes. IronOCR fonctionne entièrement hors ligne, sans aucun appel réseau sortant. Les guides de déploiement Docker et Linux couvrent le processus de déploiement conteneurisé pour ces environnements.

La logique d'extraction nécessite une personnalisation

Le schéma de champs prédéfini de Klippa convient aux reçus standard. Dès que vos documents présentent des mises en page non standard (formats de date spécifiques à une région, factures multidevises, champs combinés, structures de tableau), la sortie structurée est soit mal classée, soit renvoie des valeurs nulles pour les champs non reconnus par Klippa. La sortie texte brut d'IronOCR, avec ses coordonnées au niveau des mots, vous permet de concevoir une logique d'extraction ciblant précisément les régions et les modèles présents dans vos documents.

Création de votre propre couche d'extraction

Le principal Shift entre Klippa et IronOCR réside dans la prise en charge de l'extraction sur le terrain. Klippa fournit vendor et amount en tant que propriétés typées. IronOCR fournit le texte brut et les coordonnées des mots. Pour l'analyse standard des reçus, le tutoriel de numérisation des reçus fournit des modèles d'extraction complets. Pour les factures, l'extraction de données PDF couvre le chemin d'entrée du PDF. Les données structurées OcrResult fournissent les blocs de construction — result.Lines, result.Words, scores de confiance par mot — qui rendent l'extraction basée sur les regex et les coordonnées fiable.

// IronOCR: build structured extraction from OcrResult
var result = new IronTesseract().Read("receipt.jpg");

// Use word positions to locate fields in known layout areas
var totalRegion = new CropRectangle(300, 500, 250, 60);
using var input = new OcrInput();
input.LoadImage("receipt.jpg", totalRegion);
var totalText = new IronTesseract().Read(input).Text;

// Line-based extraction for sequential field parsing
foreach (var line in result.Lines)
{
    if (line.Text.StartsWith("Total", StringComparison.OrdinalIgnoreCase))
        Console.WriteLine($"Total line: {line.Text}");
}

// IronOCR: build structured extraction from OcrResult
var result = new IronTesseract().Read("receipt.jpg");

// Use word positions to locate fields in known layout areas
var totalRegion = new CropRectangle(300, 500, 250, 60);
using var input = new OcrInput();
input.LoadImage("receipt.jpg", totalRegion);
var totalText = new IronTesseract().Read(input).Text;

// Line-based extraction for sequential field parsing
foreach (var line in result.Lines)
{
    if (line.Text.StartsWith("Total", StringComparison.OrdinalIgnoreCase))
        Console.WriteLine($"Total line: {line.Text}");
}

Imports IronOcr

' IronOCR: build structured extraction from OcrResult
Dim result = New IronTesseract().Read("receipt.jpg")

' Use word positions to locate fields in known layout areas
Dim totalRegion = New CropRectangle(300, 500, 250, 60)
Using input As New OcrInput()
    input.LoadImage("receipt.jpg", totalRegion)
    Dim totalText = New IronTesseract().Read(input).Text
End Using

' Line-based extraction for sequential field parsing
For Each line In result.Lines
    If line.Text.StartsWith("Total", StringComparison.OrdinalIgnoreCase) Then
        Console.WriteLine($"Total line: {line.Text}")
    End If
Next

Prétraitement des images de documents de faible qualité

Le traitement cloud de Klippa applique l'amélioration d'image côté serveur avant la reconnaissance. Cette étape est invisible. Avec IronOCR, cette même fonctionnalité est explicite et contrôlable. Les documents reçus sous forme de photos prises avec un téléphone portable, de numérisations basse résolution ou de captures déformées nécessitent un prétraitement avant d'être reconnus. Le prétraitement automatique d'IronOCR gère la plupart des cas, et l'API de filtrage explicite prend en charge les autres. Le guide de correction de la qualité d'image couvre l'ensemble des filtres.

// IronOCR: explicit preprocessing for phone-captured receipts
using var input = new OcrInput();
input.LoadImage("phone-photo-receipt.jpg");
input.Deskew();          // correct the camera angle
input.DeNoise();         // remove compression artifacts
input.Contrast();        // boost faded ink
input.EnhanceResolution(300); // normalize DPI

var result = new IronTesseract().Read(input);

// IronOCR: explicit preprocessing for phone-captured receipts
using var input = new OcrInput();
input.LoadImage("phone-photo-receipt.jpg");
input.Deskew();          // correct the camera angle
input.DeNoise();         // remove compression artifacts
input.Contrast();        // boost faded ink
input.EnhanceResolution(300); // normalize DPI

var result = new IronTesseract().Read(input);

Imports IronOcr

Dim result As OcrResult
Using input As New OcrInput()
    input.LoadImage("phone-photo-receipt.jpg")
    input.Deskew()          ' correct the camera angle
    input.DeNoise()         ' remove compression artifacts
    input.Contrast()        ' boost faded ink
    input.EnhanceResolution(300) ' normalize DPI

    result = New IronTesseract().Read(input)
End Using

Remplacement du client HTTP par des appels locaux

L'intégration de Klippa est nécessairement asynchrone — les appels REST prennent entre 500 ms et 2000 ms sur le réseau. IronOCR fonctionne de manière synchrone par défaut, et un seul appel OCR d'image s'effectue en 100 à 400 ms en local. Le wrapper asynchrone est disponible pour les contrôleurs ASP.NET Core qui ne doivent pas bloquer les threads de requêtes, mais le modèle de programmation est plus simple. Retirez le HttpClient, le MultipartFormDataContent, et la désérialisation JSON. Remplacez par IronTesseract.Read(). La logique de nouvelle tentative disparaît puisqu'il n'y a plus de réseau susceptible de tomber en panne.

Gestion des documents d'identité

L'analyse des documents d'identité de Klippa renvoie des champs pré-structurés pour les passeports et les cartes d'identité. L'équivalent d'IronOCR consiste en une extraction de texte brut Plus' une reconnaissance optique de caractères (OCR) basée sur les régions, ciblant la zone de lecture machine (MRZ) ou des champs spécifiques du document. Le guide OCR pour passeport couvre directement les modèles d'extraction MRZ.