Picking the Right Model in Snowflake Cortex: A Cost per Task Table

Last updated: August 2026

Snowflake documents every Cortex function and publishes every rate, then stops. Nowhere does it say which model to call for which job. So teams reach for the name they recognize from a keynote, wire it into a pipeline running a hundred thousand rows a night, and meet the number six weeks later.

Every rate here comes from the Snowflake Service Consumption Table, Table 6(a), effective August 10, 2026, in AI credits per million tokens. AI credits are a separate purchasable currency from platform credits, flat-priced regardless of edition and region, and the platform credit discount on your order form explicitly does not apply to them. On demand they run $2.00 each on global routing and $2.20 on regional routing. Dollar figures below use $2.00. For what the functions do rather than which to call, the Snowflake Cortex AI Guide covers that ground.

Get one thing straight before the tables. Input and output are priced on separate lines, and the gap between them varies enormously by model, so a model's rank on your bill depends on the shape of your workload.

A per million token price is not a number any more

Table 6(a) gives every model two rates. llama3.1-8b bills 0.132 in and 0.132 out, identical. openai-gpt-5-nano bills 0.033 and 0.24, a sevenfold skew. claude-opus-5 bills 3.00 and 15.00. Quote any of these as one number and you have quoted the wrong one.

Work out your blended rate instead. A classification job reading 250 tokens and writing one label is about 97 percent input, so claude-opus-5 blends to roughly 3.4 credits per million. A drafting job that reads and writes equally blends to 9.0 on the same model. llama3.1-8b costs 0.132 either way, the underrated property of the symmetric open models: indifferent to workload shape, so you size them once.

Rates as published in the Snowflake Service Consumption Table effective August 10, 2026. Preview status is Snowflake's own footnote marker, not our judgment of maturity.

The task to model table

This is the table the docs will not print. The last column matters most: it names the specific accuracy failure that justifies paying more, rather than a feeling that a bigger model would be safer.

The shape is deliberate. Most rows sit under half a credit per million, because most production AI work is short classification and extraction over structured-ish text, and small models have been good enough at that for a year. The frontier tier earns its price in one row.

One hundred thousand reviews, priced eight ways

Same job, same prompt, same output: classify 100,000 product reviews into one of six topics. Budget 250 input tokens per row (review, instruction and label list) and 8 output tokens for the label. That is 25M input and 0.8M output. Dollars at $2.00 per AI credit.

Nobody downstream can tell those eight runs apart on a taxonomy this coarse. The gap between $6.81 and $174.00 buys nothing here; the gap between $6.81 and $22.29 buys a little stability on the two labels that overlap. Warehouse compute sits on top and is not in the table, though Snowflake's own guidance is to use nothing larger than a MEDIUM warehouse for Cortex calls, since the bottleneck is the model.

What we deploy is two tier. Run llama3.1-8b, have it emit a confidence with the label, re-run the bottom decile on claude-sonnet-4-6. At a 10 percent escalation rate that costs $17.25 against $104.40 for all-sonnet, and the rows getting the expensive model are the ones that were going to be wrong.

AI_CLASSIFY is a convenience price, not a floor price

The task-specific functions take no model argument. You get Snowflake's choice at Snowflake's rate, billed on total tokens with no input and output split:

• AI_SENTIMENT 1.60, AI_CLASSIFY 1.62, AI_FILTER 1.62, AI_TRANSLATE 1.63. Roughly 12x the blended rate of llama3.1-8b doing the same work through AI_COMPLETE.
• AI_AGG and AI_SUMMARIZE_AGG at 1.85. These aggregate across rows, so there is no clean AI_COMPLETE comparison.
• AI_EXTRACT at 5.55, on arctic-extract. The dearest of the flat-rate functions, and on input it is beaten only by claude-fable-5 and openai-gpt-5.5-long-context, both 6.00. Budget it like a frontier model, not like a utility.
• AI_REDACT 0.69, AI_GUARDRAILS 0.35, AI_TRANSCRIBE 0.97. No sensible alternative, so the rate is the rate.

That premium is not a rip-off, it is a real product. AI_CLASSIFY takes up to 100 categories per call, does multi-label output through output_mode, reads documents up to 200,000 tokens (capped at 100 pages and 22 MB per file) and returns structured errors rather than confidently malformed text. AI_EXTRACT takes files under 100 MB and 125 pages, a document pipeline you did not build.

Our rule: prototype on the task functions, then move anything above roughly a million rows a month onto AI_COMPLETE with a pinned model and a response_format schema. Below that, the engineering time costs more than the credits. One trap: every label, description and example you hand AI_CLASSIFY counts as input tokens on each call, and one row is one call, so a four-line description per category taxes every row forever.

Where a frontier model earns its 26x

Change the unit of work and the arithmetic inverts. Take 2,000 supplier contracts at 40,000 input tokens each and 1,200 tokens of structured analysis out: 80M input, 2.4M output.

The whole spread between the cheapest workable option and the dearest is $481, about 24 cents a contract. One indemnity cap read wrong costs more than the entire run. That is the test: when the unit of work is rare and consequential, buy the best model available and stop optimizing. When it is common and cheap, buy the cheapest model that passes an agreement test.

Context window is a hard gate before it is a quality question, and chunking to fit a small one is not free: you re-send the shared context with every chunk and lose the cross-reference that made the frontier model worth buying.

Region gating kills more Cortex projects than model quality

Here is the one that actually derails delivery. Native model availability in any given Snowflake region is short. The open models (llama3.1-8b, llama3.3-70b, mistral-large2, mixtral-8x7b, mistral-7b) and the embedding models are broadly available, and claude-sonnet-4-6 is native across the AWS US regions, most Azure US regions, AWS Europe Central 1, AWS Europe West 1 and Azure West Europe. Past that the list thins fast. claude-opus-5 and claude-haiku-4-5 are natively available in very few places, and most of the OpenAI and Google entries are worse. Snowflake's line is blunt: if your region is not listed for a function, use cross-region inference. That setting is account-level and ACCOUNTADMIN only, with no session or user override, so it is a platform decision, not something an engineer routes around.

-- 1. Where does this account live, and is cross-region routing on?
SELECT CURRENT_REGION() AS home_region;

SHOW PARAMETERS LIKE 'CORTEX_ENABLED_CROSS_REGION' IN ACCOUNT;
-- DISABLED               -> home region only, shortest model list
-- AWS_US / AWS_EU / ...  -> geography-constrained routing
-- AWS_GLOBAL / ANY_REGION-> widest model list

-- 2. Smoke test every model your design assumes, one row each.
--    A model that is not reachable errors here, not in UAT.
SELECT
    m.model_name,
    AI_COMPLETE(m.model_name, 'Reply with the single word: ok',
                {'temperature': 0, 'max_tokens': 5}) AS response
FROM (
    SELECT 'llama3.1-8b'       AS model_name UNION ALL
    SELECT 'llama3.3-70b'                    UNION ALL
    SELECT 'claude-haiku-4-5'                UNION ALL
    SELECT 'claude-sonnet-4-6'               UNION ALL
    SELECT 'claude-opus-5'
) m;

-- 3. Only ACCOUNTADMIN can change it, and it applies account-wide.
-- ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'ANY_REGION';

Now the part that surprises people. Turning cross-region routing on makes AI credits cheaper. Snowflake prices them at $2.00 on global routing (ANY_REGION, AWS_GLOBAL, AZURE_GLOBAL, GCP_GLOBAL) and $2.20 on regional routing, which includes DISABLED and geography-scoped values such as AWS_EU. The residency-conservative setting costs 10 percent more per credit and gives you fewer models. No egress charge either way.

On residency, Snowflake's position is that customer data stays stored only in your home region, while the prompt and response transit encrypted and are not persisted in the processing region. Whether that satisfies your client's policy belongs in week one, in writing. Not in UAT, after you built the pipeline around claude-opus-5.

Preview tiers, and one price that expires in three weeks

Read the footnote markers on Table 6(a) before you commit. Preview covers most of the interesting column: claude-opus-5, claude-opus-4-7 and 4-8, claude-fable-5 at 6.00 and 30.00, the openai-gpt-5, 5.5 and 5.6 families plus the 5.4-mini and 5.4-nano variants, every Gemini and Grok entry, mistral-large3 and the Qwen models. The generally available list is shorter and is where a production SLA belongs: claude-sonnet-4-5 and 4-6, claude-haiku-4-5, claude-opus-4-5 and 4-6, openai-gpt-4.1, 5.1, 5.2 and 5.4, and the llama, mistral and gemma models. Note the split inside a single family: claude-opus-4-6 is GA, claude-opus-4-7 is not.

The dated one. claude-sonnet-5 is listed at 1.20 input and 6.00 output with a footnote saying the pricing is promotional and increases by 50 percent on September 1, 2026, or such other date as Snowflake determines. That lands it on 1.80 and 9.00, level with claude-sonnet-4-6. A business case built on a July benchmark at the promotional rate is about to run 50 percent over. Pin exact model strings, never a moving alias.

The same model costs more inside an agent

Cortex Agents do not bill at the AI function rate. Table 6(d) prices the identical model higher: claude-sonnet-4-6 is 1.80 / 9.00 through AI_COMPLETE and 1.95 / 9.76 through an agent, claude-opus-5 3.00 / 15.00 against 3.25 / 16.26. A consistent 8 percent premium, before the tools the agent invokes.

It runs the other way too. Snowflake CoCo has its own table roughly 8 percent below the function rate, with claude-sonnet-4-6 at 1.65 / 8.25. Cortex Analyst changes unit entirely: 67 platform credits per 1,000 messages when you call its own API, token-metered AI credits when it runs inside an agent. Three prices for one model is not a misreading, it is the table.

Find out which model is actually eating the bill

Use SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY. Two dates govern it: usage is included from January 5, 2026, and the user, role and query tag columns are populated only for data acquired after February 16, 2026. Older tutorials send you to CORTEX_FUNCTIONS_USAGE_HISTORY, which is frozen. Its deprecation note redirects to CORTEX_AISQL_USAGE_HISTORY, a narrower view with a different column set that leaves out AI_PARSE_DOCUMENT, so take the AI functions view instead.

Token detail lives in a METRICS array of {key: {metric, unit}, value} objects, so input and output separate only after a FLATTEN. The trap: flattening multiplies each row, so credits must be summed before the flatten, never after.

WITH usage AS (
    SELECT
        COALESCE(NULLIF(model_name, ''), '(function default)') AS model,
        function_name,
        query_id,
        credits,
        metrics
    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY
    WHERE start_time >= DATEADD('day', -30, CURRENT_TIMESTAMP())
      AND is_completed
),
-- Credits aggregated BEFORE the flatten, or you multiply the bill.
spend AS (
    SELECT model, function_name,
           COUNT(DISTINCT query_id) AS calls,
           SUM(credits)             AS ai_credits
    FROM usage
    GROUP BY 1, 2
),
tok AS (
    SELECT
        u.model,
        u.function_name,
        SUM(IFF(f.value['key']['metric']::STRING = 'input',
                f.value['value']::NUMBER, 0)) AS input_tokens,
        SUM(IFF(f.value['key']['metric']::STRING = 'output',
                f.value['value']::NUMBER, 0)) AS output_tokens,
        SUM(IFF(f.value['key']['metric']::STRING = 'total',
                f.value['value']::NUMBER, 0)) AS undivided_tokens
    FROM usage u,
         LATERAL FLATTEN(input => u.metrics) f
    WHERE f.value['key']['unit']::STRING = 'tokens'
    GROUP BY 1, 2
)
SELECT
    s.model,
    s.function_name,
    s.calls,
    t.input_tokens,
    t.output_tokens,
    ROUND(t.output_tokens / NULLIF(t.input_tokens, 0), 3) AS out_in_ratio,
    ROUND(s.ai_credits, 2)                                AS ai_credits,
    ROUND(s.ai_credits * 2.00, 2)                         AS usd_global_rate,
    ROUND(s.ai_credits / NULLIF(
        (t.input_tokens + t.output_tokens + t.undivided_tokens) / 1000000.0, 0
    ), 3)                                                 AS blended_credits_per_million
FROM spend s
JOIN tok   t
  ON t.model = s.model
 AND t.function_name = s.function_name
ORDER BY s.ai_credits DESC;

Read blended_credits_per_million against Table 6(a) and the picture resolves fast. A model landing near its input rate is classifying or extracting. One landing near its output rate is generating, which is where a cheaper model saves real money.

Downgrade candidates, and proving the downgrade

The waste worth hunting is a frontier model producing tiny outputs at volume. Twenty output tokens per call on claude-opus-5 means somebody wired a classifier to a reasoning model.

WITH calls AS (
    SELECT model_name, query_id, credits, metrics
    FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AI_FUNCTIONS_USAGE_HISTORY
    WHERE function_name = 'AI_COMPLETE'
      AND start_time >= DATEADD('day', -30, CURRENT_TIMESTAMP())
      AND is_completed
      AND model_name IN (
            'claude-opus-5', 'claude-opus-4-6', 'claude-opus-4-5',
            'claude-sonnet-4-6', 'claude-sonnet-4-5', 'claude-sonnet-5',
            'openai-gpt-5.4', 'openai-gpt-5.5', 'gemini-3.1-pro')
),
shaped AS (
    SELECT
        c.model_name,
        c.query_id,
        ANY_VALUE(c.credits) AS credits,
        SUM(IFF(f.value['key']['metric']::STRING = 'input',
                f.value['value']::NUMBER, 0)) AS input_tokens,
        SUM(IFF(f.value['key']['metric']::STRING = 'output',
                f.value['value']::NUMBER, 0)) AS output_tokens
    FROM calls c, LATERAL FLATTEN(input => c.metrics) f
    GROUP BY 1, 2
)
SELECT
    model_name,
    COUNT(*)                                       AS billing_rows,
    SUM(input_tokens)                              AS input_tokens,
    SUM(output_tokens)                             AS output_tokens,
    ROUND(SUM(output_tokens) / COUNT(*), 1)        AS avg_output_tokens,
    ROUND(SUM(credits), 2)                         AS ai_credits,
    ROUND(SUM(credits) * 2.00, 2)                  AS usd_global_rate
FROM shaped
GROUP BY 1
HAVING SUM(output_tokens) / COUNT(*) < 40   -- a label, not an answer
ORDER BY ai_credits DESC;

Then prove it. Run both models over a real sample and compare, rather than reading a leaderboard. On the 250-token budget above, 2,000 rows costs about 14 cents on llama3.1-8b and about $2.09 on claude-sonnet-4-6. That is not a number anyone needs to approve.

CREATE OR REPLACE TEMPORARY TABLE model_bakeoff AS
WITH sample_rows AS (
    SELECT review_id, body
    FROM analytics.reviews
    SAMPLE (2000 ROWS)
),
prompted AS (
    SELECT
        review_id,
        'Classify this review into exactly one of: billing, shipping, '
        || 'product_defect, agent_conduct, praise, other. '
        || 'Reply with the label only.' || CHAR(10) || CHAR(10) || body AS p
    FROM sample_rows
)
SELECT
    review_id,
    LOWER(TRIM(AI_COMPLETE('claude-sonnet-4-6', p,
        {'temperature': 0, 'max_tokens': 8}))) AS incumbent_label,
    LOWER(TRIM(AI_COMPLETE('llama3.1-8b', p,
        {'temperature': 0, 'max_tokens': 8}))) AS candidate_label
FROM prompted;

-- Headline agreement, then the breakdown that actually decides it.
SELECT
    incumbent_label,
    COUNT(*)                                                   AS rows_seen,
    SUM(IFF(incumbent_label = candidate_label, 1, 0))          AS agreed,
    ROUND(100 * AVG(IFF(incumbent_label = candidate_label, 1, 0)), 1)
                                                               AS agreement_pct
FROM model_bakeoff
GROUP BY 1
ORDER BY rows_seen DESC;

Read the per-label breakdown, not the headline. 96 percent agreement that collapses on your smallest and highest-value label is worse than 88 percent spread evenly. When disagreements cluster on two labels, the fix is usually a sharper prompt on the cheap model, not a dearer model.

What we deploy

• Classification, routing, sentiment: llama3.1-8b through AI_COMPLETE, temperature 0, max_tokens capped hard, low-confidence decile escalated to claude-sonnet-4-6.
• Structured extraction: claude-haiku-4-5 with a response_format schema. Move to AI_EXTRACT only when the input is a real document file.
• Long-document reasoning: claude-sonnet-4-6 by default, claude-opus-5 where the answer carries legal or financial weight. Do not optimize this line.
• Before any of it: settle CORTEX_ENABLED_CROSS_REGION and the residency policy in week one. Model choice is downstream of that answer.
• Every quarter: re-run the blended-rate query, re-read Table 6(a) for repricing, and re-run the agreement test on anything above half a credit per million.

The consistent finding across client accounts is that model selection beats any warehouse tuning on the same workload, and it takes an afternoon. The bill is usually one pipeline, on one model, chosen once by whoever wrote the prototype.