Exemples d'utilisation de base

Cette page présente des exemples pratiques d'utilisation de l'API ParseMyFile pour différents cas d'usage courants.

Exemple 1 : Traitement d'une facture simple

Configuration YAML

# facture-simple.yaml
schemas:
  data:
    type: object
    properties:
      numero_facture:
        type: string
        description: numéro de facture
      date_facture:
        type: string
        description: date d'émission de la facture (format YYYY-MM-DD)
      client_nom:
        type: string
        description: nom du client
      montant_total:
        type: double
        description: montant total TTC de la facture

Requête cURL

curl -X POST "https://api.parsemyfile.com/api/v1/generate" \
  -H "X-API-KEY: votre_cle_api_ici" \
  -F "file=@facture.pdf" \
  -F "yaml_file=@facture-simple.yaml"

Réponse attendue

{
  "status": "success",
  "data": {
    "numero_facture": "FAC-2024-001",
    "date_facture": "15/01/2024",
    "client_nom": "Entreprise ABC",
    "montant_total": "1250.00"
  },
  "execution_time": "2.1543",
}

Exemple 2 : Extraction de données de formulaire

Configuration YAML

# formulaire-inscription.yaml
schemas:
  data:
    type: object
    properties:
      titre_formulaire:
        type: string
        description: titre du formulaire
      nom:
        type: string
        description: nom de famille
      prenom:
        type: string
        description: prénom
      email:
        type: string
        description: adresse email
      telephone:
        type: string
        description: numéro de téléphone
      rue:
        type: string
        description: numéro et nom de rue
      code_postal:
        type: string
        description: code postal
      ville:
        type: string
        description: ville
      pays:
        type: string
        description: pays
      preferences:
        type: array<string>
        description: préférences de communication

Code JavaScript

async function processForm(formData, apiKey) {
  try {
    const response = await fetch('https://api.parsmyfile.com/api/v1/generate', {
      method: 'POST',
      headers: {
        'X-API-KEY': apiKey
      },
      body: formData
    });

    if (!response.ok) {
      throw new Error(`Erreur ${response.status}: ${response.statusText}`);
    }

    const result = await response.json();
    
    if (result.status === 'success') {
      console.log('Données extraites:', result.data.extracted_fields);
      return result.data;
    } else {
      console.warn('Extraction partielle:', result.warnings);
      return result.data;
    }
  } catch (error) {
    console.error('Erreur lors du traitement:', error);
    throw error;
  }
}

// Utilisation
const formData = new FormData();
formData.append('file', fileInput.files[0]);
formData.append('yaml_file', yamlFileInput.files[0]);

processForm(formData, 'votre_cle_api')
  .then(data => {
    console.log('Traitement réussi:', data);
  })
  .catch(error => {
    console.error('Erreur:', error);
  });

Exemple 3 : Traitement d'image avec OCR

Configuration YAML

# image-ocr.yaml
schemas:
  data:
    type: object
    properties:
      titre_document:
        type: string
        description: titre du document
      contenu_principal:
        type: string
        description: contenu principal du document
      date_document:
        type: string
        description: date du document (format YYYY-MM-DD)
      signature:
        type: string
        description: signature détectée

Code Python

import requests
import json
from pathlib import Path

def process_image_with_ocr(image_path, yaml_path, api_key):
    """
    Traite une image avec OCR et retourne les données extraites
    """
    url = "https://api.parsemyfile.com/api/v1/generate"
    headers = {"X-API-KEY": api_key}
    
    try:
        with open(image_path, 'rb') as image_file, open(yaml_path, 'rb') as yaml_file:
            files = {
                'file': ('image.jpg', image_file, 'image/jpeg'),
                'yaml_file': ('config.yaml', yaml_file, 'text/yaml')
            }
            
            response = requests.post(url, headers=headers, files=files)
            
            if response.status_code == 200:
                result = response.json()
                return result['data']['extracted_fields']
            else:
                print(f"Erreur {response.status_code}: {response.text}")
                return None
                
    except FileNotFoundError as e:
        print(f"Fichier non trouvé: {e}")
        return None
    except requests.exceptions.RequestException as e:
        print(f"Erreur de requête: {e}")
        return None

# Utilisation
image_path = "document.jpg"
yaml_path = "image-ocr.yaml"
api_key = "votre_cle_api"

result = process_image_with_ocr(image_path, yaml_path, api_key)
if result:
    print("Données extraites:")
    for field, value in result.items():
        print(f"  {field}: {value}")

Exemple 4 : Traitement de contrat

Configuration YAML

# contrat.yaml
schemas:
  data:
    type: object
    properties:
      titre_contrat:
        type: string
        description: titre du contrat
      parties_contractantes:
        type: string
        description: noms des parties contractantes
      date_debut:
        type: string
        description: date de début du contrat (format YYYY-MM-DD)
      date_fin:
        type: string
        description: date de fin du contrat (format YYYY-MM-DD)
      montant:
        type: double
        description: montant du contrat en euros
      signatures:
        type: array<string>
        description: zones de signature détectées

Code PHP

<?php
function processContract($filePath, $yamlPath, $apiKey) {
    $url = 'https://api.parsemyfile.com/api/v1/generate';
    
    $postData = [
        'file' => new CURLFile($filePath, 'application/pdf', 'contrat.pdf'),
        'yaml_file' => new CURLFile($yamlPath, 'text/yaml', 'contrat.yaml')
    ];
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, $postData);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-KEY: ' . $apiKey
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        $result = json_decode($response, true);
        return $result['data']['extracted_fields'];
    } else {
        throw new Exception("Erreur API: " . $response);
    }
}

// Utilisation
try {
    $extractedData = processContract('contrat.pdf', 'contrat.yaml', 'votre_cle_api');
    echo "Données extraites:\n";
    foreach ($extractedData as $field => $value) {
        echo "  $field: $value\n";
    }
} catch (Exception $e) {
    echo "Erreur: " . $e->getMessage() . "\n";
}
?>

Exemple 5 : Traitement par lot

Code Python pour traitement par lot

import os
import requests
import json
from pathlib import Path
import time

def process_batch(documents_dir, yaml_path, api_key, delay=1):
    """
    Traite plusieurs documents en lot
    """
    results = []
    documents = list(Path(documents_dir).glob('*.pdf'))
    
    print(f"Traitement de {len(documents)} documents...")
    
    for i, doc_path in enumerate(documents, 1):
        print(f"Traitement {i}/{len(documents)}: {doc_path.name}")
        
        try:
            with open(doc_path, 'rb') as doc_file, open(yaml_path, 'rb') as yaml_file:
                files = {
                    'file': (doc_path.name, doc_file, 'application/pdf'),
                    'yaml_file': ('config.yaml', yaml_file, 'text/yaml')
                }
                
                response = requests.post(
                    'https://api.parsemyfile.com/api/v1/generate',
                    headers={'X-API-KEY': api_key},
                    files=files
                )
                
                if response.status_code == 200:
                    result = response.json()
                    results.append({
                        'file': doc_path.name,
                        'status': 'success',
                        'data': result['data']
                    })
                    print(f"  ✓ Succès (confiance: {result['data']['metadata']['confidence_score']:.2f})")
                else:
                    results.append({
                        'file': doc_path.name,
                        'status': 'error',
                        'error': response.text
                    })
                    print(f"  ✗ Erreur {response.status_code}")
                
        except Exception as e:
            results.append({
                'file': doc_path.name,
                'status': 'error',
                'error': str(e)
            })
            print(f"  ✗ Exception: {e}")
        
        # Délai entre les requêtes pour respecter les limites
        if i < len(documents):
            time.sleep(delay)
    
    return results

# Utilisation
results = process_batch('./documents', 'config.yaml', 'votre_cle_api')

# Sauvegarde des résultats
with open('results.json', 'w', encoding='utf-8') as f:
    json.dump(results, f, ensure_ascii=False, indent=2)

print(f"\nTraitement terminé. {len([r for r in results if r['status'] == 'success'])}/{len(results)} documents traités avec succès.")

Conseils pour les exemples

1. Testez avec des documents simples

Commencez par des documents bien structurés et de bonne qualité avant de passer à des cas plus complexes.

2. Ajustez la configuration

Modifiez le seuil de confiance et les options de preprocessing selon vos besoins :

processing:
  confidence_threshold: 0.7  # Plus permissif
  preprocessing:
    - "enhance_contrast"      # Pour les images sombres
    - "deskew"               # Pour les documents inclinés

3. Gérez les erreurs

Implémentez toujours une gestion d'erreurs robuste :

try {
  const result = await processDocument(file, yaml, apiKey);
  // Traiter le succès
} catch (error) {
  if (error.status === 401) {
    // Problème d'authentification
  } else if (error.status === 422) {
    // Problème de validation
  } else {
    // Autre erreur
  }
}

4. Optimisez les performances

• Utilisez des configurations adaptées à vos documents
• Implémentez un cache pour les configurations récurrentes
• Traitez les documents par lot quand possible