Snowflake Document AI: Overview, Pricing & Cost Monitoring

What is Snowflake Document AI?

Snowflake Document AI transforms unstructured documents into queryable structured data using AI, processing invoices, contracts, and forms directly within Snowflake. The service uses the proprietary Arctic-TILT model to extract text, tables, and entities from PDFs and images with 90% ANLS benchmark accuracy, outperforming GPT-4. Arctic-TILT runs on a single GPU providing cost efficiency. With pricing starting at roughly $0.012–$0.018 per page on Standard Edition, Document AI tackles the fact that 80–90% of enterprise data is unstructured. It can extract information from new document types without prior training (zero-shot) and also supports fine-tuning with as few as 5–20 examples.

How does Document AI work?

Document AI transforms unstructured documents into queryable structured data through a two-phase workflow: model building and inference.

Phase 1: Building extraction models

Create models through the Snowsight UI at AI & ML → Document AI. You'll need the SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR database role:

1USE ROLE ACCOUNTADMIN;
2
3CREATE ROLE doc_ai_role;
4GRANT DATABASE ROLE SNOWFLAKE.DOCUMENT_INTELLIGENCE_CREATOR TO ROLE doc_ai_role;
5GRANT ROLE doc_ai_role TO USER your_username;

Upload 10-20 sample documents representing your document types. Define what you want to extract using natural language questions like "What is the invoice number?", "What is the vendor name?", or "What line items are listed?". Review the extracted values, correct any errors, train the model (optional but recommended for 20+ documents), and publish for production use.

The model learns extraction patterns from your corrections. You don't need ML expertise - just answer questions about where data appears in your documents.

Phase 2: Setting up infrastructure

Create a warehouse, database, schema, and stage for document processing:

1CREATE WAREHOUSE doc_ai_wh
2  WAREHOUSE_SIZE = 'X-SMALL'
3  AUTO_SUSPEND = 600
4  AUTO_RESUME = TRUE;
5
6CREATE DATABASE doc_ai_db;
7CREATE SCHEMA doc_ai_db.doc_ai_schema;
8
9-- CRITICAL: Must include SNOWFLAKE_SSE encryption
10CREATE STAGE doc_ai_stage
11  DIRECTORY = (ENABLE = TRUE)
12  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

Upload documents to your stage using PUT commands or external stage integrations to S3, Azure Blob, or GCS.

Phase 3: Running extraction queries

Extract data using the model!PREDICT method:

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

The output returns JSON with extracted values and confidence scores:

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

Parsing results into structured tables

Transform JSON output into usable columns:

1WITH extraction AS (
2  SELECT
3    RELATIVE_PATH as file_name,
4    invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as json
5  FROM DIRECTORY(@doc_ai_stage)
6)
7SELECT
8  file_name,
9  json:invoice_number[0]:value::STRING AS invoice_num,
10  json:invoice_number[0]:score::FLOAT AS invoice_confidence,
11  json:vendor_name[0]:value::STRING AS vendor,
12  json:total_amount[0]:value::STRING AS total,
13  json:__documentMetadata.ocrScore::FLOAT AS ocr_quality
14FROM extraction;

There’s a lot more we could do here such as flattening results into multiple rows and automating with Streams and Tasks, but we want to keep the example section short.

How does Snowflake Document AI Pricing work?

Snowflake charges Document AI using Snowflake-managed AI Services compute, which automatically scales based on workload. Credits are consumed based on compute time at 8 credits per hour (as of September 2025), with consumption influenced by page count, document density, and number of values extracted. This is fundamentally different from token-based pricing used for other Cortex LLM features.

Credit consumption per 1,000 pages

Costs scale with document density and extraction complexity. Here are the official ranges from Snowflake's pricing documentation:

Low density documents (invoices, slides) - 100 documents with 10 pages each:

• 10 values extracted: 4-7 credits per 1,000 pages
• 20 values extracted: 6-11 credits per 1,000 pages
• 40 values extracted: 10-24 credits per 1,000 pages

High density documents (research papers, legal contracts):

• 10 values extracted: 7-10 credits per 1,000 pages
• 20 values extracted: 11-15 credits per 1,000 pages
• 40 values extracted: 21-35 credits per 1,000 pages

Table extraction (preview feature) - 1,000 documents with 2-10 pages each:

• Tiny tables (<10 cells): 5-37 credits
• Small tables (11-25 cells): 14-52 credits
• Medium tables (26-50 cells): 24-86 credits
• Large tables (51-400 cells): 37-369 credits

Real World Example:

Purchase order processing example:

Let's say you process 10,000 purchase orders annually. Each PO is a single page with low density (typical PO format). You want to extract Customer Name, Customer Address, PO Number, PO Date, Line Items (table), and Total Amount. That's 10,000 total pages with approximately 10 values extracted per document. Using the low density estimate for 1,000 documents with 1 page each, you'd consume 9-12 credits per 1,000 pages, resulting in 90 to 120 credits annually.

Using $3 per credit which is common for Enterprise Edition, the cost can be estimated as $270 to $360 per year. The actual cost would depend on the amount of compute used.

This example shows how Document AI can process thousands of documents annually for a few hundred dollars, making it cost-effective for automating manual data entry that would otherwise require significant staff time.

Additional costs

Virtual Warehouse Cost

Document AI requires a Virtual warehouse to kick off the document AI job. The AI does not run on one of your Warehouses, but the job that starts the process does. We recommend to always use and x-small for this, as the size of the warehouse will have no bearing on the speed at which the AI tasks are completed.

Storage Cost

Storage cost for documents in stages and result tables are billed at your standard storage rate. Example, $23 / TB / Month is common for Enterprise Edition customers.

How to monitor Document AI costs & usage

Snowflake provides dedicated views in ACCOUNT_USAGE for tracking Document AI consumption with ~2 hour latency and 365-day retention.

Primary monitoring view

The DOCUMENT_AI_USAGE_HISTORY view contains per-query credit consumption:

1SELECT
2  START_TIME,
3  END_TIME,
4  CREDITS_USED,
5  QUERY_ID,
6  OPERATION_NAME,
7  PAGE_COUNT,
8  DOCUMENT_COUNT,
9  FEATURE_COUNT
10FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY
11WHERE START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
12ORDER BY START_TIME DESC;

Daily credit consumption

Aggregate usage by day to understand spending trends:

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

Cost by user and role

Track which users and roles consume Document AI credits:

1SELECT
2  qh.USER_NAME,
3  qh.ROLE_NAME,
4  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
5  SUM(dh.CREDITS_USED) AS total_credits,
6  SUM(dh.PAGE_COUNT) AS total_pages,
7  ROUND(SUM(dh.CREDITS_USED) / NULLIF(SUM(dh.PAGE_COUNT), 0), 4) AS credits_per_page
8FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
9JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
10  ON dh.QUERY_ID = qh.QUERY_ID
11WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
12GROUP BY qh.USER_NAME, qh.ROLE_NAME
13ORDER BY total_credits DESC;

Cost by warehouse

Identify which warehouses process Document AI queries.

1SELECT
2  qh.WAREHOUSE_NAME,
3  qh.WAREHOUSE_SIZE,
4  COUNT(DISTINCT dh.QUERY_ID) AS query_count,
5  SUM(dh.CREDITS_USED) AS docai_credits,
6  SUM(dh.PAGE_COUNT) AS total_pages,
7  SUM(dh.DOCUMENT_COUNT) AS total_documents
8FROM SNOWFLAKE.ACCOUNT_USAGE.DOCUMENT_AI_USAGE_HISTORY dh
9JOIN SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY qh
10  ON dh.QUERY_ID = qh.QUERY_ID
11WHERE dh.START_TIME >= DATEADD(day, -30, CURRENT_TIMESTAMP())
12  AND qh.WAREHOUSE_NAME IS NOT NULL
13GROUP BY qh.WAREHOUSE_NAME, qh.WAREHOUSE_SIZE
14ORDER BY docai_credits DESC;

It may be a good idea to modify the query above to search for warehouses that are not x-small and notify when that happens.

Best practices and recommendations when using Document AI

Set up alerts, not just dashboards

Those monitoring queries above are worthless if nobody runs them. For anything you want to monitor in Snowflake, you can wrap the SQL in a scheduled task with a Notification Integration to create a custom monitor that sends alerts to Slack or Teams. If you want extremely easy to use monitoring functionality, check out monitors in SELECT.

Use X-Small or Small warehouses exclusively

Document AI runs on Snowflake-managed serverless compute. Your warehouse only executes the SQL query wrapping the PREDICT method. Larger warehouses provide zero speed improvement for Document AI processing while increasing costs from 1 credit/hour (X-Small) to 4+ credits/hour (Medium+).

Extract only the values you actually need

Each additional extracted field increases processing time and cost. Extracting 10 values consumes 4-7 credits per 1,000 pages (medium density) while extracting 40 values consumes 16-30 credits (2-3x increase).

Design extraction models targeting only fields required for downstream applications. Don't extract "everything that might be useful someday." Extract what you need now. You can always create a new model build with additional fields later.

Batch documents by type before processing

Processing efficiency improves when documents are grouped by type. Use a classification model first to identify document types, then route to specialized extraction models:

1WITH classification AS (
2  SELECT
3    RELATIVE_PATH as file_name,
4    classifier!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, RELATIVE_PATH), 1) as doc_type_result
5  FROM DIRECTORY(@doc_ai_stage)
6)
7SELECT
8  file_name,
9  doc_type_result:document_type[0]:value::STRING as doc_type,
10  CASE
11    WHEN doc_type_result:document_type[0]:value::STRING = 'invoice'
12      THEN invoice_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
13    WHEN doc_type_result:document_type[0]:value::STRING = 'contract'
14      THEN contract_model!PREDICT(GET_PRESIGNED_URL(@doc_ai_stage, file_name), 1)
15  END as extraction

This approach also improves accuracy since each model specializes in one document format.

Implement confidence thresholds and human review workflows

Document AI provides confidence scores for every extracted value. Don't blindly trust all extractions. Implement quality controls:

1-- High confidence extractions go straight to production
2CREATE TABLE production_data AS
3SELECT
4  file_name,
5  json:invoice_number[0]:value::STRING as invoice_number,
6  json:total_amount[0]:value::STRING as total_amount
7FROM extraction_results
8WHERE json:invoice_number[0]:score::FLOAT > 0.90
9  AND json:total_amount[0]:score::FLOAT > 0.90;
10
11-- Low confidence extractions require human review
12CREATE TABLE manual_review_queue AS
13SELECT
14  file_name,
15  json as full_extraction

Set thresholds based on your risk tolerance. Financial data might require 0.95+ confidence while internal documents might accept 0.75+. Test thresholds with sample documents to find the right balance between automation and accuracy.

Wrap Up

Document AI makes it affordable to automate document processing at scale, typically just a few cents for non dense documents. The key to controlling costs is understanding what drives them: page count, document density, and number of extracted values all impact compute time and credit consumption. Use small warehouses (X-Small or Small) when running the PREDICT method, extract only the fields you actually need, and implement confidence thresholds for quality control. More importantly, set up alerts on those monitoring queries above so you know when costs spike rather than discovering it in your monthly bill. Start with a small batch of documents, monitor your consumption patterns closely, and scale up as you understand your actual costs.

Let us know how you’re using document AI! We’d love to hear more real world stories about how customers are using it, and your opinion on the overall effectiveness.