Snowflake Document AI: visão geral, preços e monitoramento de custos

O Document AI do Snowflake usa IA para transformar documentos não estruturados em dados estruturados e consultáveis, processando faturas, contratos e formulários direto dentro do Snowflake. O serviço utiliza o modelo proprietário Arctic-TILT para extrair texto, tabelas e entidades de PDFs e imagens com 90% de precisão no benchmark ANLS, superando o GPT-4. O Arctic-TILT roda em uma única GPU, o que garante eficiência de custo. Com preços a partir de cerca de US$ 0,012 a US$ 0,018 por página na Standard Edition, o Document AI ataca o problema de que 80% a 90% dos dados corporativos são não estruturados. Ele consegue extrair informações de novos tipos de documento sem treinamento prévio (zero-shot) e também suporta fine-tuning com apenas 5 a 20 exemplos.

O Document AI transforma documentos não estruturados em dados estruturados e consultáveis por meio de um fluxo em duas fases: criação do modelo e inferência.

Fase 1: criando os modelos de extração

Crie os modelos pela interface do Snowsight em AI & ML → Document AI. Você vai precisar da role de banco de dados 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;

Faça upload de 10 a 20 documentos de amostra que representem seus tipos de documento. Defina o que quer extrair usando perguntas em linguagem natural, como "Qual é o número da fatura?", "Qual é o nome do fornecedor?" ou "Quais são os itens de linha listados?". Revise os valores extraídos, corrija eventuais erros, treine o modelo (opcional, mas recomendado a partir de 20 documentos) e publique para uso em produção.

O modelo aprende os padrões de extração a partir das suas correções. Não é preciso ser especialista em ML — basta responder a perguntas sobre onde os dados aparecem nos documentos.

Fase 2: configurando a infraestrutura

Crie um warehouse, um banco de dados, um schema e um stage para o processamento dos documentos:

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;

-- CRÍTICO: é obrigatório incluir a criptografia SNOWFLAKE_SSE
CREATE STAGE doc_ai_stage
  DIRECTORY = (ENABLE = TRUE)
  ENCRYPTION = (TYPE = 'SNOWFLAKE_SSE');

Suba os documentos para o stage com comandos PUT ou usando integrações de stage externo com S3, Azure Blob ou GCS.

Fase 3: executando as queries de extração

Extraia os dados com o método 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);

A saída devolve um JSON com os valores extraídos e os scores de confiança:

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

Convertendo os resultados em tabelas estruturadas

Transforme a saída JSON em colunas prontas para uso:

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;

Daria para ir bem além daqui — por exemplo, desmembrar os resultados em várias linhas e automatizar tudo com Streams e Tasks —, mas queremos manter o exemplo enxuto.

O Snowflake cobra o Document AI pelo compute de AI Services gerenciado pelo Snowflake, que escala automaticamente conforme os workloads. Os créditos são consumidos com base no tempo de compute, a uma taxa de 8 créditos por hora (em setembro de 2025), e o consumo é influenciado pelo número de páginas, pela densidade do documento e pela quantidade de valores extraídos. Esse modelo é bem diferente do preço por token usado em outros recursos de LLM do Cortex.

Consumo de créditos por 1.000 páginas

Os custos variam conforme a densidade dos documentos e a complexidade da extração. Veja as faixas oficiais da documentação de preços do Snowflake:

Documentos de baixa densidade (faturas, slides) — 100 documentos com 10 páginas cada:

• 10 valores extraídos: 4 a 7 créditos por 1.000 páginas
• 20 valores extraídos: 6 a 11 créditos por 1.000 páginas
• 40 valores extraídos: 10 a 24 créditos por 1.000 páginas

Documentos de alta densidade (artigos acadêmicos, contratos jurídicos):

• 10 valores extraídos: 7 a 10 créditos por 1.000 páginas
• 20 valores extraídos: 11 a 15 créditos por 1.000 páginas
• 40 valores extraídos: 21 a 35 créditos por 1.000 páginas

Extração de tabelas (recurso em preview) — 1.000 documentos com 2 a 10 páginas cada:

• Tabelas minúsculas (<10 células): 5 a 37 créditos
• Tabelas pequenas (11 a 25 células): 14 a 52 créditos
• Tabelas médias (26 a 50 células): 24 a 86 créditos
• Tabelas grandes (51 a 400 células): 37 a 369 créditos

Exemplo prático

Processamento de pedidos de compra:

Imagine que você processe 10.000 pedidos de compra por ano. Cada PO tem uma única página e baixa densidade (formato típico de PO). Você quer extrair Nome do Cliente, Endereço do Cliente, Número do PO, Data do PO, Itens de Linha (tabela) e Valor Total. Isso dá 10.000 páginas no total, com cerca de 10 valores extraídos por documento. Usando a estimativa de baixa densidade para 1.000 documentos com 1 página cada, o consumo ficaria entre 9 e 12 créditos por 1.000 páginas, totalizando 90 a 120 créditos por ano.

Considerando US$ 3 por crédito, valor comum na Enterprise Edition, dá para estimar o custo entre US$ 270 e US$ 360 por ano. O valor real depende da quantidade de compute consumida.

O exemplo mostra como o Document AI consegue processar milhares de documentos por ano por algumas centenas de dólares, sendo uma opção econômica para automatizar entradas manuais de dados que, de outra forma, exigiriam horas de trabalho da equipe.

Custos adicionais

Custo do Virtual Warehouse

O Document AI precisa de um Virtual warehouse para disparar o job. A IA em si não roda nos seus warehouses, mas o job que inicia o processo, sim. Recomendamos sempre usar um x-small, já que o tamanho do warehouse não afeta a velocidade de execução das tarefas de IA.

Custo de armazenamento

O armazenamento dos documentos nos stages e nas tabelas de resultado é cobrado pela tarifa padrão. Por exemplo, US$ 23/TB/mês é o valor comum para clientes da Enterprise Edition.

O Snowflake oferece views dedicadas no ACCOUNT_USAGE para acompanhar o consumo do Document AI, com latência de cerca de 2 horas e retenção de 365 dias.

View principal de monitoramento

A view DOCUMENT_AI_USAGE_HISTORY traz o consumo de créditos por 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;

Consumo diário de créditos

Agrupe o uso por dia para enxergar a tendência de gastos:

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;

Custo por usuário e role

Veja quais usuários e roles estão consumindo créditos do 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;

Custo por warehouse

Identifique quais warehouses estão executando queries do 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;

Vale adaptar a query acima para detectar warehouses que não sejam x-small e disparar uma notificação quando isso acontecer.

Configure alertas, não só dashboards

As queries de monitoramento acima não valem de nada se ninguém as executa. Para qualquer métrica que você queira acompanhar no Snowflake, dá para embrulhar o SQL em uma task agendada com uma Notification Integration e criar um monitor customizado que envia alertas para o Slack ou para o Teams. Se você prefere uma solução de monitoramento bem simples de usar, dê uma olhada nos monitors do SELECT.

Use apenas warehouses X-Small ou Small

O Document AI roda em compute serverless gerenciado pelo Snowflake. Seu warehouse só executa a query SQL que invoca o método PREDICT. Warehouses maiores trazem zero ganho de velocidade para o Document AI e ainda elevam o custo de 1 crédito/hora (X-Small) para 4+ créditos/hora (Medium+).

Extraia só os valores de que você realmente precisa

Cada campo a mais aumenta o tempo de processamento e o custo. Extrair 10 valores consome de 4 a 7 créditos por 1.000 páginas (densidade média), enquanto extrair 40 valores consome de 16 a 30 créditos (um aumento de 2 a 3 vezes).

Modele as extrações mirando apenas os campos necessários para as aplicações downstream. Não tente extrair "tudo que pode ser útil um dia". Extraia o que você precisa agora. Você sempre pode criar uma nova versão do modelo com campos adicionais depois.

Agrupe os documentos por tipo antes de processar

A eficiência do processamento melhora quando os documentos são agrupados por tipo. Use primeiro um modelo de classificação para identificar o tipo do documento e depois encaminhe para modelos de extração especializados:

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

Expandir código

Essa abordagem também melhora a precisão, já que cada modelo se especializa em um formato de documento.

Implemente limites de confiança e fluxos de revisão humana

O Document AI devolve um score de confiança para cada valor extraído. Não confie cegamente em todas as extrações. Coloque controles de qualidade em prática:

-- Extrações com alta confiança vão direto para produção
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;

-- Extrações de baixa confiança exigem revisão humana
CREATE TABLE manual_review_queue AS
SELECT
  file_name,
  json as full_extraction

Expandir código

Defina os limites de acordo com a sua tolerância a risco. Dados financeiros podem exigir confiança de 0,95+, enquanto documentos internos podem aceitar 0,75+. Teste os limites com documentos de amostra para encontrar o equilíbrio ideal entre automação e precisão.

O Document AI torna viável automatizar o processamento de documentos em escala, normalmente por apenas alguns centavos no caso de documentos pouco densos. A chave para controlar os custos é entender o que os impulsiona: número de páginas, densidade dos documentos e quantidade de valores extraídos — tudo isso impacta o tempo de compute e o consumo de créditos. Use warehouses pequenos (X-Small ou Small) ao executar o método PREDICT, extraia só os campos de que você realmente precisa e adote limites de confiança como controle de qualidade. Mais importante: configure alertas nas queries de monitoramento acima para saber quando os custos disparam, em vez de descobrir só na fatura mensal. Comece com um lote pequeno de documentos, acompanhe os padrões de consumo de perto e vá escalando à medida que entender seus custos reais.

Conta pra gente como você está usando o Document AI! Adoraríamos ouvir mais casos reais sobre como os clientes estão utilizando o recurso e a sua opinião sobre a eficácia geral.

Jeff é Consultor de Dados e Analytics, com mais de 15 anos de experiência em automatizar insights e usar dados para conduzir processos de negócio. Do lado da tecnologia, é especialista em Snowflake + dbt + Tableau. Do lado do negócio, tem experiência em Utilities, Estudos Clínicos, Editoras, CPG e Manufatura. Fale com ele a qualquer momento: [email protected].