Snowflake Document AI : présentation, tarifs et suivi des coûts

Snowflake Document AI transforme les documents non structurés en données structurées interrogeables grâce à l'IA, en traitant factures, contrats et formulaires directement dans Snowflake. Le service s'appuie sur le modèle propriétaire Arctic-TILT pour extraire texte, tableaux et entités à partir de PDF et d'images avec une précision de 90 % au benchmark ANLS, surpassant GPT-4. Arctic-TILT s'exécute sur un seul GPU, gage d'efficacité économique. Avec des tarifs débutant autour de 0,012 à 0,018 $ par page sur l'édition Standard, Document AI répond à une réalité : 80 à 90 % des données d'entreprise sont non structurées. Il extrait des informations de nouveaux types de documents sans entraînement préalable (zero-shot) et prend également en charge le fine-tuning à partir de seulement 5 à 20 exemples.

Document AI transforme les documents non structurés en données structurées interrogeables via un workflow en deux phases : construction du modèle et inférence.

Phase 1 : construction des modèles d'extraction

Créez vos modèles depuis l'interface Snowsight via AI & ML → Document AI. Vous aurez besoin du rôle de base de données SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR :

USE ROLE ACCOUNTADMIN;

CREATE ROLE doc_ai_role;
GRANT DATABASE ROLE SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR TO ROLE doc_ai_role;
GRANT ROLE doc_ai_role TO USER your_username;

Téléversez 10 à 20 documents d'exemple représentatifs de vos types de documents. Définissez ensuite les éléments à extraire à l'aide de questions en langage naturel, par exemple : Quel est le numéro de facture ?, Quel est le nom du fournisseur ? ou Quels articles figurent sur la facture ?. Vérifiez les valeurs extraites, corrigez les éventuelles erreurs, entraînez le modèle (étape optionnelle mais recommandée au-delà de 20 documents), puis publiez-le pour une mise en production.

Le modèle apprend ses schémas d'extraction à partir de vos corrections. Aucune expertise en machine learning n'est requise : il suffit de répondre aux questions sur l'emplacement des données dans vos documents.

Phase 2 : mise en place de l'infrastructure

Créez un warehouse, une base de données, un schéma et un stage pour le traitement des documents :

CREATE WAREHOUSE doc_ai_wh
  WAREHOUSE_SIZE = 'X-SMALL'
  AUTO_SUSPEND = 600
  AUTO_RESUME = TRUE;

CREATE DATABASE doc_ai_db;
CREATE SCHEMA doc_ai_db.doc_ai_schema;

-- CRITIQUE : doit inclure le chiffrement SNOWFLAKE_SSE
CREATE STAGE doc_ai_stage
  DIRECTORY = (ENABLE = TRUE)
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

Téléversez vos documents vers le stage à l'aide de commandes PUT ou via une intégration avec un stage externe (S3, Azure Blob ou GCS).

Phase 3 : exécution des requêtes d'extraction

Extrayez les données via la méthode model!PREDICT :

SELECT
  RELATIVE_PATH as file_name,
  invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as extracted_data
FROM DIRECTORY(@doc_ai_stage);

La sortie renvoie un JSON contenant les valeurs extraites et leurs scores de confiance :

{
  "invoice_number": [{"value": "INV-2024-001", "score": 0.95}],
  "vendor_name": [{"value": "Acme Corp", "score": 0.92}],
  "total_amount": [{"value": "1250.00", "score": 0.98}],
  "__documentMetadata": {"ocrScore": 0.89}
}

Parser les résultats vers des tables structurées

Transformez la sortie JSON en colonnes exploitables :

WITH extraction AS (
  SELECT
    RELATIVE_PATH as file_name,
    invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as json
  FROM DIRECTORY(@doc_ai_stage)
)
SELECT
  file_name,
  json:invoice_number[0]:value::STRING AS invoice_num,
  json:invoice_number[0]:score::FLOAT AS invoice_confidence,
  json:vendor_name[0]:value::STRING AS vendor,
  json:total_amount[0]:value::STRING AS total,
  json:__documentMetadata.ocrScore::FLOAT AS ocr_quality
FROM extraction;

On pourrait aller bien plus loin, par exemple aplatir les résultats sur plusieurs lignes ou automatiser le tout avec des Streams et des Tasks, mais nous préférons garder cette section concise.

Snowflake facture Document AI via le compute des AI Services managés par Snowflake, qui s'adapte automatiquement à la charge. Les crédits sont consommés selon le temps de compute, à raison de 8 crédits par heure (à compter de septembre 2025). La consommation dépend du nombre de pages, de la densité des documents et du nombre de valeurs extraites. Cette logique diffère fondamentalement de la tarification au token utilisée pour les autres fonctionnalités Cortex LLM.

Consommation de crédits pour 1 000 pages

Les coûts évoluent en fonction de la densité des documents et de la complexité de l'extraction. Voici les fourchettes officielles issues de la documentation tarifaire de Snowflake :

Documents à faible densité (factures, diapositives) – 100 documents de 10 pages chacun :

• 10 valeurs extraites : 4 à 7 crédits pour 1 000 pages
• 20 valeurs extraites : 6 à 11 crédits pour 1 000 pages
• 40 valeurs extraites : 10 à 24 crédits pour 1 000 pages

Documents à forte densité (articles de recherche, contrats juridiques) :

• 10 valeurs extraites : 7 à 10 crédits pour 1 000 pages
• 20 valeurs extraites : 11 à 15 crédits pour 1 000 pages
• 40 valeurs extraites : 21 à 35 crédits pour 1 000 pages

Extraction de tableaux (fonctionnalité en preview) – 1 000 documents de 2 à 10 pages chacun :

• Très petits tableaux (<10 cellules) : 5 à 37 crédits
• Petits tableaux (11 à 25 cellules) : 14 à 52 crédits
• Tableaux moyens (26 à 50 cellules) : 24 à 86 crédits
• Grands tableaux (51 à 400 cellules) : 37 à 369 crédits

Exemple concret :

Traitement de bons de commande :

Imaginons que vous traitiez 10 000 bons de commande par an. Chaque PO tient sur une page, en faible densité (format classique). Vous souhaitez extraire le nom du client, son adresse, le numéro de PO, la date, les lignes d'articles (tableau) et le montant total. Cela représente 10 000 pages au total, avec environ 10 valeurs extraites par document. En appliquant l'estimation faible densité pour 1 000 documents d'une page, vous consommez 9 à 12 crédits pour 1 000 pages, soit 90 à 120 crédits par an.

Sur la base de 3 $ par crédit, tarif courant pour l'édition Enterprise, le coût peut être estimé entre 270 $ et 360 $ par an. Le coût réel dépendra du compute effectivement consommé.

Cet exemple illustre comment Document AI peut traiter des milliers de documents par an pour quelques centaines de dollars seulement, ce qui en fait une solution économique pour automatiser des saisies manuelles qui mobiliseraient autrement un temps important de vos équipes.

Coûts supplémentaires

Coût du Virtual Warehouse

Document AI nécessite un Virtual Warehouse pour lancer le job. L'IA elle-même ne s'exécute pas sur l'un de vos warehouses, mais le job qui déclenche le processus, lui, oui. Nous recommandons d'utiliser systématiquement un X-Small : la taille du warehouse n'a aucune incidence sur la vitesse d'exécution des tâches d'IA.

Coût de stockage

Le stockage des documents dans les stages et dans les tables de résultats est facturé au tarif de stockage standard. Par exemple, 23 $/To/mois est courant pour les clients de l'édition Enterprise.

Snowflake propose des vues dédiées dans ACCOUNT_USAGE pour suivre la consommation de Document AI, avec une latence d'environ 2 heures et une rétention de 365 jours.

Vue principale de monitoring

La vue DOCUMENT_AI_USAGE_HISTORY contient la consommation de crédits par requête :

SELECT
  START_TIME,
  END_TIME,
  CREDITS_USED,
  QUERY_ID,
  OPERATION_NAME,
  PAGE_COUNT,
  DOCUMENT_COUNT,
  FEATURE_COUNT
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY
WHERE START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
ORDER BY START_TIME DESC;

Consommation quotidienne de crédits

Agrégez l'utilisation par jour pour dégager les tendances de dépense :

SELECT
  DATE_TRUNC('DAY', START_TIME) AS usage_date,
  COUNT(*) AS total_queries,
  SUM(CREDITS_USED) AS total_credits,
  SUM(PAGE_COUNT) AS total_pages,
  SUM(DOCUMENT_COUNT) AS total_documents,
  ROUND(SUM(CREDITS_USED) / NULLIF(SUM(PAGE_COUNT), 0), 4) AS credits_per_page,
  ROUND(SUM(CREDITS_USED) / NULLIF(SUM(DOCUMENT_COUNT), 0), 4) AS credits_per_document
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY
WHERE START_TIME >= DATEADD(day, -90, CURRENT_TIMESTAMP())
GROUP BY DATE_TRUNC('DAY', START_TIME)
ORDER BY usage_date DESC;

Coût par utilisateur et par rôle

Identifiez les utilisateurs et les rôles qui consomment des crédits Document AI :

SELECT
  qh.USER_NAME,
  qh.ROLE_NAME,
  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
  SUM(dh.CREDITS_USED) AS total_credits,
  SUM(dh.PAGE_COUNT) AS total_pages,
  ROUND(SUM(dh.CREDITS_USED) / NULLIF(SUM(dh.PAGE_COUNT), 0), 4) AS credits_per_page
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
  ON dh.QUERY_ID = qh.QUERY_ID
WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
GROUP BY qh.USER_NAME, qh.ROLE_NAME
ORDER BY total_credits DESC;

Coût par warehouse

Identifiez les warehouses qui exécutent des requêtes Document AI.

SELECT
  qh.WAREHOUSE_NAME,
  qh.WAREHOUSE_SIZE,
  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
  SUM(dh.CREDITS_USED) AS docai_credits,
  SUM(dh.PAGE_COUNT) AS total_pages,
  SUM(dh.DOCUMENT_COUNT) AS total_documents
FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
  ON dh.QUERY_ID = qh.QUERY_ID
WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
  AND qh.WAREHOUSE_NAME IS NOT NULL
GROUP BY qh.WAREHOUSE_NAME, qh.WAREHOUSE_SIZE
ORDER BY docai_credits DESC;

Il peut être judicieux d'adapter la requête ci-dessus pour repérer les warehouses qui ne sont pas en X-Small et déclencher une notification le cas échéant.

Mettez en place des alertes, pas seulement des dashboards

Les requêtes de monitoring ci-dessus ne servent à rien si personne ne les exécute. Pour tout ce que vous souhaitez surveiller dans Snowflake, vous pouvez encapsuler le SQL dans une tâche planifiée associée à une Notification Integration pour créer un moniteur personnalisé qui envoie des alertes vers Slack ou Teams. Pour une solution de monitoring vraiment simple à prendre en main, jetez un œil aux moniteurs dans SELECT.

Utilisez exclusivement des warehouses X-Small ou Small

Document AI s'exécute sur du compute serverless managé par Snowflake. Votre warehouse se contente d'exécuter la requête SQL qui encapsule la méthode PREDICT. Des warehouses plus grands n'apportent aucun gain de vitesse sur le traitement Document AI, mais font grimper les coûts de 1 crédit/heure (X-Small) à plus de 4 crédits/heure (Medium et au-delà).

N'extrayez que les valeurs dont vous avez réellement besoin

Chaque champ extrait supplémentaire allonge le temps de traitement et augmente le coût. Extraire 10 valeurs consomme 4 à 7 crédits pour 1 000 pages (densité moyenne), contre 16 à 30 crédits pour 40 valeurs (soit 2 à 3 fois plus).

Concevez vos modèles d'extraction en ne ciblant que les champs réellement nécessaires aux applications en aval. N'extrayez pas tout ce qui pourrait servir un jour. Extrayez ce dont vous avez besoin aujourd'hui ; vous pourrez toujours créer un nouveau build du modèle avec des champs additionnels par la suite.

Regroupez les documents par type avant traitement

L'efficacité du traitement progresse lorsque les documents sont regroupés par type. Utilisez d'abord un modèle de classification pour identifier les types de documents, puis routez-les vers des modèles d'extraction spécialisés :

WITH classification AS (
  SELECT
    RELATIVE_PATH as file_name,
    classifier!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as doc_type_result
  FROM DIRECTORY(@doc_ai_stage)
)
SELECT
  file_name,
  doc_type_result:document_type[0]:value::STRING as doc_type,
  CASE
    WHEN doc_type_result:document_type[0]:value::STRING = 'invoice'
      THEN invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
    WHEN doc_type_result:document_type[0]:value::STRING = 'contract'
      THEN contract_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
  END as extraction

Développer le code

Cette approche améliore aussi la précision, chaque modèle se spécialisant sur un format de document.

Mettez en place des seuils de confiance et des workflows de revue humaine

Document AI fournit un score de confiance pour chaque valeur extraite. Ne faites pas aveuglément confiance à toutes les extractions. Mettez en place des contrôles qualité :

-- Les extractions à forte confiance passent directement en production
CREATE TABLE production_data AS
SELECT
  file_name,
  json:invoice_number[0]:value::STRING as invoice_number,
  json:total_amount[0]:value::STRING as total_amount
FROM extraction_results
WHERE json:invoice_number[0]:score::FLOAT > 0.90
  AND json:total_amount[0]:score::FLOAT > 0.90;

-- Les extractions à faible confiance nécessitent une revue humaine
CREATE TABLE manual_review_queue AS
SELECT
  file_name,
  json as full_extraction

Développer le code

Définissez vos seuils selon votre tolérance au risque. Les données financières peuvent exiger une confiance supérieure à 0,95, tandis que des documents internes pourront se contenter de 0,75. Testez vos seuils sur un échantillon de documents pour trouver le bon équilibre entre automatisation et précision.

Document AI rend l'automatisation du traitement documentaire à grande échelle abordable : quelques centimes seulement pour des documents peu denses. La clé pour maîtriser les coûts, c'est de comprendre ce qui les fait varier : nombre de pages, densité des documents et nombre de valeurs extraites ont tous un impact sur le temps de compute et la consommation de crédits. Utilisez de petits warehouses (X-Small ou Small) pour exécuter la méthode PREDICT, n'extrayez que les champs réellement utiles et mettez en place des seuils de confiance pour le contrôle qualité. Surtout, configurez des alertes sur les requêtes de monitoring ci-dessus pour être averti des pics de coûts plutôt que de les découvrir sur votre facture mensuelle. Commencez par un petit lot de documents, suivez de près vos schémas de consommation, puis montez en charge à mesure que vous cernez vos coûts réels.

Dites-nous comment vous utilisez Document AI ! Nous serions ravis d'avoir des retours concrets sur les usages de nos clients et votre avis sur son efficacité globale.

Jeff est consultant Data et Analytics, fort de plus de 15 ans d'expérience dans l'automatisation des insights et l'exploitation des données pour piloter les processus métiers. Côté technologie, il s'est spécialisé sur Snowflake + dbt + Tableau. Côté secteurs, il intervient dans les services publics, les essais cliniques, l'édition, les biens de grande consommation et l'industrie manufacturière. N'hésitez pas à le contacter à tout moment : [email protected].