Snowflake Document AI: Überblick, Preise & Kostenkontrolle

Snowflake Document AI macht aus unstrukturierten Dokumenten per KI abfragbare, strukturierte Daten und verarbeitet Rechnungen, Verträge und Formulare direkt in Snowflake. Der Dienst setzt auf das proprietäre Arctic-TILT-Modell, das Text, Tabellen und Entitäten aus PDFs und Bildern mit einer ANLS-Benchmark-Genauigkeit von 90 % extrahiert – und dabei GPT-4 schlägt. Arctic-TILT läuft auf einer einzelnen GPU und ist dadurch besonders kosteneffizient. Mit Preisen ab rund 0,012–0,018 US-Dollar pro Seite in der Standard Edition adressiert Document AI ein zentrales Problem: 80–90 % der Unternehmensdaten liegen unstrukturiert vor. Das Modell extrahiert Informationen auch aus bisher unbekannten Dokumenttypen ohne vorheriges Training (Zero-Shot) und unterstützt Fine-Tuning bereits ab 5–20 Beispielen.

Document AI überführt unstrukturierte Dokumente in einem zweistufigen Workflow – Modellaufbau und Inferenz – in abfragbare, strukturierte Daten.

Phase 1: Extraktionsmodelle aufbauen

Modelle erstellen Sie in der Snowsight-Oberfläche unter AI & ML → Document AI. Dafür brauchen Sie die Datenbankrolle 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;

Laden Sie 10–20 Beispieldokumente hoch, die Ihre Dokumenttypen abbilden. Beschreiben Sie in natürlicher Sprache, was extrahiert werden soll – etwa "What is the invoice number?", "What is the vendor name?" oder "What line items are listed?". Prüfen Sie die extrahierten Werte, korrigieren Sie Fehler, trainieren Sie das Modell (optional, ab 20 Dokumenten aber empfohlen) und veröffentlichen Sie es für den produktiven Einsatz.

Das Modell lernt die Extraktionsmuster aus Ihren Korrekturen. ML-Know-how ist nicht nötig – Sie beantworten lediglich Fragen dazu, wo die Daten in Ihren Dokumenten stehen.

Phase 2: Infrastruktur einrichten

Legen Sie ein Warehouse, eine Datenbank, ein Schema und eine Stage für die Dokumentverarbeitung an:

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;

-- CRITICAL: Must include SNOWFLAKE_SSE encryption
CREATE STAGE doc_ai_stage
  DIRECTORY = (ENABLE = TRUE)
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

Dokumente laden Sie per PUT-Befehl oder über externe Stage-Integrationen aus S3, Azure Blob oder GCS in Ihre Stage.

Phase 3: Extraktions-Queries ausführen

Daten extrahieren Sie mit der model!PREDICT-Methode:

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);

Das Ergebnis ist ein JSON mit den extrahierten Werten und den zugehörigen Confidence Scores:

{
  "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}
}

Ergebnisse in strukturierte Tabellen überführen

So machen Sie aus der JSON-Ausgabe nutzbare Spalten:

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;

Hier ließe sich noch deutlich mehr machen – etwa Ergebnisse über mehrere Zeilen flatten oder den ganzen Ablauf mit Streams und Tasks automatisieren. Wir halten den Beispielteil aber bewusst kurz.

Snowflake rechnet Document AI über Snowflake-managed AI Services Compute ab, das automatisch mit dem Workload skaliert. Credits werden nach Compute-Zeit verbraucht – 8 Credits pro Stunde (Stand September 2025) –, wobei Seitenzahl, Dokumentdichte und Anzahl der extrahierten Werte den Verbrauch maßgeblich beeinflussen. Das unterscheidet sich grundlegend vom tokenbasierten Pricing der übrigen Cortex-LLM-Features.

Credit-Verbrauch pro 1.000 Seiten

Die Kosten skalieren mit Dokumentdichte und Extraktions-Komplexität. Hier die offiziellen Bandbreiten aus der Snowflake-Preisdokumentation:

Dokumente mit geringer Dichte (Rechnungen, Folien) – 100 Dokumente à 10 Seiten:

• 10 extrahierte Werte: 4–7 Credits pro 1.000 Seiten
• 20 extrahierte Werte: 6–11 Credits pro 1.000 Seiten
• 40 extrahierte Werte: 10–24 Credits pro 1.000 Seiten

Dokumente mit hoher Dichte (wissenschaftliche Arbeiten, Rechtsverträge):

• 10 extrahierte Werte: 7–10 Credits pro 1.000 Seiten
• 20 extrahierte Werte: 11–15 Credits pro 1.000 Seiten
• 40 extrahierte Werte: 21–35 Credits pro 1.000 Seiten

Tabellenextraktion (Preview-Feature) – 1.000 Dokumente à 2–10 Seiten:

• Sehr kleine Tabellen (<10 Zellen): 5–37 Credits
• Kleine Tabellen (11–25 Zellen): 14–52 Credits
• Mittelgroße Tabellen (26–50 Zellen): 24–86 Credits
• Große Tabellen (51–400 Zellen): 37–369 Credits

Praxisbeispiel:

Verarbeitung von Bestellungen:

Angenommen, Sie verarbeiten 10.000 Bestellungen pro Jahr. Jede Bestellung ist einseitig und hat eine geringe Dichte (typisches PO-Format). Extrahiert werden sollen Kundenname, Kundenadresse, Bestellnummer, Bestelldatum, Positionen (Tabelle) und Gesamtbetrag. Macht 10.000 Seiten mit jeweils rund 10 extrahierten Werten. Legt man den Schätzwert für geringe Dichte bei 1.000 Dokumenten zu je 1 Seite zugrunde, sind das 9–12 Credits pro 1.000 Seiten – also 90 bis 120 Credits pro Jahr.

Bei 3 US-Dollar pro Credit (in der Enterprise Edition üblich) liegen die geschätzten Kosten zwischen 270 und 360 US-Dollar pro Jahr. Die tatsächlichen Kosten hängen vom verbrauchten Compute ab.

Das Beispiel zeigt: Document AI kann Tausende Dokumente pro Jahr für wenige hundert Dollar verarbeiten – eine günstige Lösung, um manuelle Dateneingaben zu automatisieren, die sonst spürbar Personalkapazität binden würden.

Zusätzliche Kosten

Kosten für das Virtual Warehouse

Document AI braucht ein Virtual Warehouse, um den Document-AI-Job anzustoßen. Die KI selbst läuft nicht auf Ihren Warehouses – wohl aber der Job, der den Prozess startet. Wir empfehlen dafür durchgehend ein X-Small, denn die Warehouse-Größe hat keinerlei Einfluss darauf, wie schnell die KI-Tasks abgeschlossen werden.

Speicherkosten

Speicherkosten für Dokumente in Stages und Ergebnistabellen werden zu Ihrem regulären Speichertarif berechnet. Beispiel: 23 US-Dollar pro TB und Monat sind in der Enterprise Edition üblich.

Snowflake stellt in ACCOUNT_USAGE eigene Views bereit, mit denen Sie den Verbrauch von Document AI nachverfolgen – mit rund 2 Stunden Latenz und 365 Tagen Aufbewahrung.

Zentrale Monitoring-View

Die View DOCUMENT_AI_USAGE_HISTORY zeigt den Credit-Verbrauch pro Query:

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;

Täglicher Credit-Verbrauch

Aggregieren Sie die Nutzung tagesweise, um Ausgabentrends zu erkennen:

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;

Kosten nach User und Rolle

Verfolgen Sie nach, welche User und Rollen Document-AI-Credits verbrauchen:

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;

Kosten nach Warehouse

Finden Sie heraus, welche Warehouses Document-AI-Queries ausführen.

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;

Es lohnt sich, die obige Query so anzupassen, dass sie gezielt nach Warehouses sucht, die nicht X-Small sind, und in diesem Fall eine Benachrichtigung auslöst.

Alerts einrichten – nicht nur Dashboards

Die Monitoring-Queries von oben sind wertlos, wenn niemand sie ausführt. Alles, was Sie in Snowflake überwachen möchten, lässt sich als SQL in einen Scheduled Task mit Notification Integration verpacken – so entsteht ein eigener Monitor, der Alerts an Slack oder Teams sendet. Wer es besonders unkompliziert mag, sollte einen Blick auf die Monitors in SELECT werfen.

Ausschließlich X-Small- oder Small-Warehouses verwenden

Document AI läuft auf Snowflake-managed Serverless Compute. Ihr Warehouse führt lediglich die SQL-Query aus, die die PREDICT-Methode aufruft. Größere Warehouses bringen für die Document-AI-Verarbeitung keinerlei Geschwindigkeitsvorteil, treiben die Kosten aber von 1 Credit/Stunde (X-Small) auf 4+ Credits/Stunde (Medium+).

Nur die Werte extrahieren, die Sie wirklich brauchen

Jedes zusätzliche Feld erhöht Verarbeitungszeit und Kosten. 10 Werte zu extrahieren kostet 4–7 Credits pro 1.000 Seiten (mittlere Dichte), bei 40 Werten sind es 16–30 Credits – Faktor 2 bis 3.

Bauen Sie Extraktionsmodelle, die genau die Felder erfassen, die nachgelagerte Anwendungen tatsächlich benötigen. Extrahieren Sie nicht "alles, was irgendwann einmal nützlich sein könnte". Extrahieren Sie das, was Sie jetzt brauchen. Einen neuen Model-Build mit zusätzlichen Feldern können Sie jederzeit nachschieben.

Dokumente vor der Verarbeitung nach Typ batchen

Die Verarbeitung wird effizienter, wenn Dokumente nach Typ gruppiert sind. Setzen Sie zuerst ein Klassifikationsmodell ein, um den Dokumenttyp zu bestimmen, und leiten Sie die Dokumente dann an spezialisierte Extraktionsmodelle weiter:

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

Code erweitern

Dieser Ansatz verbessert nebenbei die Genauigkeit, da sich jedes Modell auf genau ein Dokumentformat spezialisiert.

Confidence-Schwellenwerte und manuelle Review-Workflows etablieren

Document AI liefert für jeden extrahierten Wert einen Confidence Score. Vertrauen Sie nicht blind allen Extraktionen – bauen Sie Qualitätskontrollen ein:

-- High confidence extractions go straight to 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;

-- Low confidence extractions require human review
CREATE TABLE manual_review_queue AS
SELECT
  file_name,
  json as full_extraction

Code erweitern

Legen Sie die Schwellenwerte nach Ihrer Risikobereitschaft fest. Für Finanzdaten sind 0,95+ Confidence sinnvoll, für interne Dokumente reichen oft 0,75+. Testen Sie die Schwellenwerte mit Beispieldokumenten, um die richtige Balance zwischen Automatisierung und Genauigkeit zu finden.

Document AI macht die automatisierte Dokumentenverarbeitung in großem Maßstab erschwinglich – bei Dokumenten mit geringer Dichte oft für nur wenige Cent pro Stück. Der Schlüssel zur Kostenkontrolle ist, die Treiber zu kennen: Seitenzahl, Dokumentdichte und Anzahl der extrahierten Werte wirken alle auf Compute-Zeit und Credit-Verbrauch. Setzen Sie für den Aufruf der PREDICT-Methode kleine Warehouses ein (X-Small oder Small), extrahieren Sie nur die Felder, die Sie wirklich brauchen, und arbeiten Sie mit Confidence-Schwellenwerten zur Qualitätssicherung. Noch wichtiger: Hinterlegen Sie auf den oben gezeigten Monitoring-Queries Alerts, damit Sie Kostenspitzen sofort sehen – und nicht erst auf der Monatsrechnung. Starten Sie mit einer kleinen Charge Dokumente, beobachten Sie Ihre Verbrauchsmuster genau und skalieren Sie hoch, sobald Sie Ihre tatsächlichen Kosten einschätzen können.

Erzählen Sie uns, wie Sie Document AI einsetzen! Wir freuen uns auf Praxisberichte von Kunden und auf Ihre Einschätzung, wie gut die Funktion insgesamt funktioniert.

Jeff ist Data- und Analytics-Consultant mit über 15 Jahren Erfahrung darin, Insights zu automatisieren und Geschäftsprozesse datenbasiert zu steuern. Technologisch ist er auf Snowflake + dbt + Tableau spezialisiert. Inhaltlich bringt er Erfahrung aus den Bereichen Versorgungswirtschaft, klinische Studien, Verlagswesen, CPG und Fertigung mit. Melden Sie sich jederzeit gerne: [email protected].