The same 1,000 pages costs $1.36 or $55.10 inside Snowflake depending on which function and model your SQL calls. Here is the whole table, computed from Snowflake's own Service Consumption Table, with the arithmetic shown.
Written for US data and finance-systems teams deciding whether to parse documents in the warehouse or send them to an extraction API. Every rate comes from Snowflake's published credit table and its own documentation, not from a cost blog. Last updated September 2026.
Upload a document to extract
Drop files here or click to upload
Up to 50 files
The free demo extracts the first 5 files, the rest unlock when you upgrade
Uploading...
Run a real document through before you model credit consumption on a spreadsheet.
Snowflake has two functions that read documents and they bill in two different units. AI_PARSE_DOCUMENT is quoted per 1,000 pages: 0.68 AI Credits in OCR mode and 3.66 in LAYOUT mode, which at the $2.00 global-routing credit rate is $1.36 and $7.32 per 1,000 pages. AI_EXTRACT is quoted per million tokens, at 5.55 credits on the current arctic-extract model. A page counts as 970 tokens, so 1,000 pages is 0.97 million tokens and the bill is $10.77 per 1,000 pages before output. The two legacy arctic-tilt models cost 9.50 and 28.40 credits per million tokens, which is $18.43 and $55.10. Same platform, same document, a 40.5x spread.
That last figure is the one worth carrying away. arctic-tilt-table sits in Snowflake's consumption table under a heading that reads "Legacy Cortex Features", and at $55.10 per 1,000 pages it is more expensive than Amazon Textract's FORMS operation. The current model does the same work for a fifth of that. If your pipeline was written when tilt was the recommended path, nobody sends you a notice; the credits just keep leaving.
And here is the part that cuts against us, said before anything else on this page: in OCR mode Snowflake is the cheapest published page rate of any major cloud, and in LAYOUT mode it is the cheapest layout rate too. $1.36 undercuts the $1.50 that AWS, Azure and Google all charge for plain text, and $7.32 undercuts Azure Layout, Bedrock Data Automation and Textract TABLES. If text or markdown is genuinely what you need and the files already land in a Snowflake stage, the arithmetic says stay.
Where this page is not neutral, said up front. DocuOCR sells a document extraction API, so on the AI_EXTRACT half of this comparison we are a competitor. We have still written the three cases where staying in the warehouse is the right call, including the one where Snowflake is simply the cheapest option available. Every figure comes from Snowflake's own Service Consumption Table and its own function documentation, so you can check all of it against the source. Our rates are on the pricing page and the full cross-vendor view sits on OCR pricing per 1,000 pages.
AI Credits converted at Snowflake's published $2.00 global-routing rate. If your account uses regional routing the credit is $2.20, so add 10% to every dollar figure below. AI_EXTRACT rows use Snowflake's own documented figure of 970 tokens per page and count input tokens only, so treat them as a floor: output tokens are billed as well.
| Function and model | What you get back | Published rate | USD / 1,000 pages | Multiple |
|---|---|---|---|---|
| AI_PARSE_DOCUMENT, OCR mode | Plain text off the page | 0.68 credits / 1,000 pages | $1.36 | 1x |
| AI_PARSE_DOCUMENT, LAYOUT mode | Markdown with tables and structure | 3.66 credits / 1,000 pages | $7.32 | 5.4x |
| AI_EXTRACT, arctic-extract | Named fields from questions you ask | 5.55 credits / 1M tokens | $10.77 | 7.9x |
| AI_EXTRACT, arctic-extract fine-tuned | Same, on your tuned model | 9.140 credits / 1M tokens | $17.73 | 13x |
| AI_EXTRACT, arctic-tilt-entity (legacy) | Fields, older model | 9.50 credits / 1M tokens | $18.43 | 13.6x |
| AI_EXTRACT, arctic-tilt-table (legacy) | Tables, older model | 28.40 credits / 1M tokens | $55.10 | 40.5x |
Source: Snowflake Service Consumption Table, Table 6(a) Cortex AI Functions and the Snowflake AI Features Table, Other, read September 10, 2026. The two arctic-tilt rows appear under the heading "Legacy Cortex Features".
Search for what Snowflake document extraction costs and you get four different answers from four different cost-tooling blogs, none of which agree with each other. That is not carelessness. It happens because Snowflake genuinely publishes its two document functions in incompatible units, and the conversion between them lives on a third documentation page that a pricing article has no particular reason to open.
AI_PARSE_DOCUMENT is billed per 1,000 pages. AI_EXTRACT is billed per million tokens. There is no way to line those up until you find the cost-considerations page, which says it outright: "Each page in a document is counted as 970 tokens." Once you have that, everything resolves. A thousand pages is 970,000 input tokens, so you multiply any per-million rate by 0.97 and you have the per-thousand-page cost. That is the entire trick, and it is why the table above exists and the blog estimates do not match it.
Two details keep the arithmetic honest. The responseFormat argument counts as input tokens, so a wide schema costs money before a single page is read. And Snowflake states that "For AI_EXTRACT, both input and output tokens are counted", with output capped at 512 tokens per entity question and 4,096 for a table. Extracting six fields adds very little. Extracting a forty-row table on every page adds a real amount, and it lands on top of the $10.77.
arctic-extract, 1,000 pages, global routing.
Output tokens are additional. A six-field invoice extraction adds a negligible amount. A table extraction returning up to 4,096 tokens a page does not.
All figures per 1,000 pages, US list, first-tier rates. This is the comparison that decides whether the warehouse is the right place to do this, and on the plain-OCR row Snowflake wins it.
| Service and mode | USD / 1,000 pages | What it returns | Worth knowing |
|---|---|---|---|
| Snowflake AI_PARSE_DOCUMENT, OCR | $1.36 | Text only | Cheapest published page rate anywhere |
| AWS Textract DetectDocumentText | $1.50 | Text and lines | Falls to $0.60 above 1M pages |
| Azure Document Intelligence Read | $1.50 | Text only, no tables collection | Read cannot return tables at all |
| Google Enterprise Document OCR | $1.50 | Text and layout | Falls to $0.60 above 5M pages |
| Snowflake AI_PARSE_DOCUMENT, LAYOUT | $7.32 | Markdown with tables | Cheapest layout rate of any major cloud |
| Azure Document Intelligence Layout | $10.00 | Tables, selection marks, markdown | Free when used with tables |
| Amazon Bedrock Data Automation | $10.00 | Structured document output | No volume tier, no confidence score |
| Snowflake AI_EXTRACT, arctic-extract | $10.77 | Named fields | Input tokens only, output billed on top |
| AWS Textract TABLES | $15.00 | Table cells and geometry | Falls to $10.00 above 1M pages |
| Google Document AI Form Parser | $30.00 | Key-value pairs and tables | Falls to $20.00 above 1M pages |
| AWS Textract FORMS | $50.00 | Key-value pairs | 33x the Textract text rate |
| Snowflake AI_EXTRACT, arctic-tilt-table (legacy) | $55.10 | Tables, legacy model | Dearer than Textract FORMS |
Two things stand out. Snowflake is genuinely the cheapest page rate on the board in both of its parse modes, which is not what most people expect from a warehouse feature billed in credits. And the gap between plain text and structured fields is far narrower in Snowflake than at AWS, where the same page runs from $1.50 to $50.00 once the FORMS flag goes on. The full AWS matrix sits on the AWS OCR page, and the Azure meters are broken down on Azure OCR pricing.
Price is rarely what stops a warehouse-native extraction project. Limits are. These are Snowflake's own words, not a summary of them.
| Limit | Value | Snowflake's wording |
|---|---|---|
| Maximum document length | 125 pages | "The documents must be no more than 125 pages long." |
| Maximum file size | Under 100 MB | "The files must be less than 100 MB in size." |
| Questions per entity call | 100 | "you can ask a maximum of 100 questions for entity extraction" |
| Questions per table call | 10 | "a maximum of 10 questions for table extraction" |
| Table question weighting | 10x an entity question | "A table extraction question is equal to 10 entity extraction questions." |
| Output cap, entity extraction | 512 tokens per question | "The maximum output length for entity extraction is 512 tokens per question." |
| Output cap, table extraction | 4,096 tokens | "For table extraction, the model returns answers that are a maximum of 4096 tokens." |
| Tokens charged per page | 970 | "Each page in a document is counted as 970 tokens." |
It sounds generous until you list what your team actually receives. A commercial loan package, a closing binder, a full patient chart and a deposition transcript all run past it routinely. Splitting the file first is not free either: a table that runs across the split loses its structure at the boundary, which is precisely the data you were extracting.
The cap is 100 entity questions or 10 table questions per call, because Snowflake weights a table question as ten. Teams discover this when a schema that worked in testing starts erroring in production after somebody adds one more table to it.
AI_PARSE_DOCUMENT returns NULL rather than error details unless return_error_details is TRUE. The batch completes, no error surfaces, and the row is simply blank. If a silently missing page is a compliance problem for you, turn error details on and build the reconciliation step yourself.
If you are evaluating warehouse-native extraction you are probably comparing Snowflake with Databricks, and the two price on completely different principles. Snowflake charges one rate per page regardless of what is on it. Databricks is the only vendor we are aware of, cloud or specialist, that charges more for a difficult page than an easy one.
| Page complexity tier | DBU per 1,000 pages | What lands in this tier |
|---|---|---|
| Low: simple text, no captions | 10 to 15 DBU | A clean typed page, a contract body, a text-only report |
| Low: simple images with captions | 20 to 25 DBU | A page with a logo or a photo and a caption under it |
| Medium: text, tables, images, captions | 60 to 65 DBU | A real invoice, a financial statement, a lab report |
| High: complex diagrams with captions | 85 to 90 DBU | Engineering drawings, schematics, dense multi-panel charts |
We publish the DBU figures rather than dollars on purpose. A DBU is not a fixed price: it varies by region, by compute type and by whatever promotion is running, so any dollar conversion we printed would be wrong for most readers within a quarter. What travels is the ratio, and the ratio is the interesting part. A real invoice with tables costs roughly six times a plain text page, and an engineering drawing costs about eight. If your document mix skews complex, a Databricks estimate built on simple-text pricing will be badly wrong in production, and it will be wrong in the expensive direction.
AI_PARSE_DOCUMENT in OCR mode is $1.36 per 1,000 pages and in LAYOUT mode $7.32. Both are the cheapest published rates in their class, and there is no egress, no new vendor and no data-movement review. If what you need is the text of the page and your documents are already in Snowflake, stay where you are. We are not going to pretend otherwise.
Stay in Snowflake
AI_PARSE_DOCUMENT and AI_EXTRACT are functions in a SELECT statement. No endpoint to secure, no key rotation, no separate IAM model, no retries to write. For a small data team that operational saving is worth more than a per-page difference measured in single dollars per thousand pages.
Stay in Snowflake
Inside those bounds AI_EXTRACT does the job at a competitive rate, and the scores parameter gives you a per-value confidence figure to route on. The limits only become a problem when the documents get long or the field list gets wide.
Stay in Snowflake
Snowflake states both limits plainly and neither is negotiable in the function. A 300-page loan file, a full medical record or a long deposition has to be split before it can be processed, and splitting a document before extraction is exactly the step that breaks tables running across page boundaries.
Compare an extraction API
Snowflake scores run 0 to 1 and are off unless you set the scores parameter. Textract runs 0 to 100. A threshold of 85 carried across from a Textract pipeline passes every field in Snowflake, because every score is below 1. This is a silent failure, not a loud one.
Compare an extraction API
AI_PARSE_DOCUMENT returns NULL rather than error details by default, so a failed page looks like an empty one and a batch can report success while being incomplete. If a missing page is a compliance problem rather than an inconvenience, you need error details on and a reconciliation step you write yourself.
Compare an extraction API
The pattern underneath those six boxes is simple enough to state in a sentence. Warehouse-native parsing is excellent at turning a file into text and poor at the parts that come after: long documents, wide field sets, confidence-routed review and failures you need to see. Teams that get burned are usually the ones that priced the first job and inherited the second. If you want the cross-vendor version of that argument, OCR confidence scores compared covers the review-routing half and the OCR API pricing comparison covers the rest of the market.
Between $1.36 and $55.10, inside Snowflake alone, for the same 1,000 pages. AI_PARSE_DOCUMENT in OCR mode is 0.68 AI Credits per 1,000 pages, which is $1.36 at the $2.00 global-routing credit rate. LAYOUT mode is 3.66 credits, so $7.32. AI_EXTRACT on the current arctic-extract model works out to $10.77, and the legacy table model reaches $55.10.
Because Snowflake bills its two document functions in two different units and the bridge between them lives on a third page. AI_PARSE_DOCUMENT is quoted per 1,000 pages. AI_EXTRACT is quoted per million tokens. The cost-considerations page supplies the missing conversion: "Each page in a document is counted as 970 tokens." Without that sentence you cannot compare the two, so people estimate instead.
For plain text, yes, and only just. AI_PARSE_DOCUMENT in OCR mode is $1.36 per 1,000 pages against $1.50 for Textract DetectDocumentText, Azure Document Intelligence Read and Google Enterprise Document OCR. The gap is wider on layout: Snowflake LAYOUT is $7.32 against Azure Layout at $10.00, Bedrock Data Automation at $10.00 and Textract TABLES at $15.00.
AI_PARSE_DOCUMENT turns a file into text. AI_EXTRACT answers questions about it. In OCR mode the parse function "extracts text only" and returns plain text; in LAYOUT mode it "extracts layout as well as text, including structural content such as tables" and returns markdown. AI_EXTRACT takes a list of questions and returns named values, which is the part that becomes a database row.
Yes, and it is low enough to end some evaluations. Snowflake states plainly: "The documents must be no more than 125 pages long." and "The files must be less than 100 MB in size." A 300-page loan file, a full medical record or a long deposition transcript cannot be sent through AI_EXTRACT as a single document, so you have to split it yourself first.
Yes, but it is off unless you ask for it, and the scale is not the one you are used to. "When you set the scores parameter to TRUE, AI_EXTRACT returns a scoring object alongside the standard response object." Those scores run 0 to 1. Amazon Textract runs 0 to 100. A review threshold copied across without rescaling approves everything silently.
A hundred, unless you want tables. Snowflake documents it exactly: "In a single AI_EXTRACT call, you can ask a maximum of 100 questions for entity extraction, and a maximum of 10 questions for table extraction. A table extraction question is equal to 10 entity extraction questions." So ten table questions consume the entire budget of the call.
Yes. "For AI_EXTRACT, both input and output tokens are counted", and the responseFormat argument counts as input too. Output is capped at 512 tokens per entity question and 4,096 tokens for table extraction. Every AI_EXTRACT figure on this page is input tokens only, so treat it as a floor rather than an estimate: your real bill lands above it.
arctic-extract, at 5.55 AI Credits per million tokens. The two arctic-tilt models are listed in Snowflake's consumption table under the heading "Legacy Cortex Features": arctic-tilt-entity at 9.50 and arctic-tilt-table at 28.40. A pipeline still pointed at the legacy table model is paying 5.1 times the current rate to do the same job.
It makes it more expensive to run. A fine-tuned arctic-extract bills at 9.140 AI Credits per million tokens against 5.55 for the standard model, a 65% premium on every page forever, before the cost of the tuning job itself. Fine-tuning is worth it when accuracy on your specific layouts pays for that premium, not as a cost-reduction move.
Nothing visible, which is the dangerous part. AI_PARSE_DOCUMENT returns NULL rather than error details unless you pass return_error_details as TRUE, so a batch can complete, report no errors and quietly be missing pages. Document metadata including pageCount only appears when you ask for error details as well.
Databricks is the only vendor on the market that prices a page by how hard the page is. Its published DBU rates per 1,000 pages run 10 to 15 for simple text, 20 to 25 for simple images with captions, 60 to 65 for text with tables and images, and 85 to 90 for complex diagrams. Everyone else charges the same for a blank page and an engineering drawing.
It adds 10%. Snowflake publishes two AI Credit rates: $2.00 with global routing and $2.20 with regional routing. Every dollar figure on this page uses the $2.00 rate, so if your account is pinned to regional routing for data residency reasons, add ten percent to all of it. That is a real cost of a compliance decision, and it is rarely modelled.
Often yes, and we will say when. If the files already land in a Snowflake stage, you need text or markdown rather than typed fields, your documents are comfortably under 125 pages, and the team lives in SQL, doing it in the warehouse is cheaper and simpler than moving data out. The case against is fields, long documents and confidence-routed review.
Not really. Snowflake's own Document AI overview now describes AI_PARSE_DOCUMENT, AI_EXTRACT, AI_CLASSIFY and AI_COMPLETE, which are Cortex AISQL functions rather than the earlier build-a-model-per-document-type product. That is why the pricing you find under the old product name does not match the pricing you get billed at.
DocuOCR takes the document at whatever length it arrives, returns named fields with a confidence figure on each one, and charges a single published per-page rate whether the page is plain text or a dense table. Upload something real above and compare the output against what an AI_EXTRACT response with the scores parameter on would need before it becomes a row you can trust. If your files already land in a Snowflake stage and text is all you need, stay there and spend the afternoon on something else.
