Landing AI sells credits rather than pages: $1 buys 100 credits, and a page burns between 0.5 and 3 of them depending on which API and which service tier you use. ADE v2 parses at 1 credit a page on the priority tier and half that on standard, then adds 0.5 credits for every 1,000 characters it writes back. For typed invoice fields you call Extract, which bills input and output characters separately and charges five times more for output, so the schema you ask for drives the bill more than the document does. This page shows every published credit rate, the per-page math behind it, and how the total compares with Textract, Azure and a flat-rate invoice tool.
Upload your invoices
Drop files here or click to upload
Up to 50 files
Uploading...
Landing AI publishes a clear credit price and then meters four different things against it. These are the gaps that turn a tidy per-page estimate into a surprise invoice.
The pricing page tells you $1 buys 100 credits and stops there. How many credits a page actually costs lives in separate credit-consumption documentation, split across one table for ADE v2 and another for ADE v1, so the number most buyers want is two clicks away from the number they are shown.
ADE v2 Parse charges 1 credit a page plus 0.5 credits for every 1,000 characters it returns. A dense page with a long line-item table can cost twice what a sparse one costs, at the identical page count, so page volume alone will not give you a budget.
On the priority tier it is 1 credit per 2,500 input characters against 1 credit per 500 output characters. Adding line items to an invoice schema can quadruple the cost of processing a document that never changed.
Twenty five thousand credits at one cent each is exactly $250, which is exactly what the Team plan costs. The monthly fee buys unlimited seats, higher rate limits, zero data retention and a BAA. It does not buy a cheaper page at any volume.
These are the published LandingAI rates as of August 2026, taken from the official pricing page and the ADE credit-consumption documentation. Confirm current figures with LandingAI before you commit, since API pricing changes.
One dollar buys 100 credits on both the Explore and Team plans, in the US and EU regions alike. Every dollar figure on this page is that rate multiplied by a documented credit cost, with no estimation in between.
The priority tier bills 1 credit per page plus 0.5 credits per 1,000 output characters. The standard tier, available on asynchronous jobs only, is exactly half: 0.5 credits a page plus 0.25 per 1,000 characters.
Priority charges 1 credit per 2,500 input characters and 1 credit per 500 output characters. Standard halves both. Because output costs five times more, the size of your JSON schema is the main cost driver.
An identical document costs exactly half on standard, and the only thing you trade away is a synchronous response. Sync calls always bill priority rates, so batch processing is worth fifty percent of the bill.
ADE v2 charges no extra credits for ZDR. ADE v1 charged an additional 1 credit per page for it, so a HIPAA workload moving from v1 to v2 standard drops roughly seventy percent on parsing alone.
The Explore plan opens with 1,000 credits, worth $10. On standard-tier parsing that covers roughly 800 to 1,100 invoice pages, which is enough to test extraction quality on your own documents before spending anything.
Four steps to a defensible monthly number, using only figures LandingAI publishes.
Count pages, not files, because a three page invoice bills three times on Parse. Then run twenty representative documents and read the credit consumption straight off the response instead of guessing at character counts.
Tip: Use your worst scans and your longest line-item tables, not the tidiest PDF you own. The messy ones set the average.
Standard tier costs exactly half and runs on asynchronous jobs only. If invoices arrive by email and get processed overnight, there is no reason to pay priority rates for a synchronous response nobody is waiting on.
Tip: This single decision is worth fifty percent of the bill, so make it before you write the integration.
Header fields only keeps output near 500 characters. Capturing 25 line items pushes output past 3,000, and on priority that is the difference between 1.8 credits and 7.2 credits for the same page.
Tip: Write the schema you will actually use in production, then price that. Pricing a header-only prototype will understate the real bill by several times.
Total credits times $0.01 gives the dollar figure. Compare it against the 25,000 credits included in the $250 Team plan, and remember that anything beyond the allowance bills at the same one cent rate with no discount.
Tip: Add engineering time for schema maintenance and a review path for low-confidence fields. Below a few hundred thousand pages a year, that usually costs more than the credits.
A developer-first document API and a finished invoice application are not really competing products. Here is the honest split.
If you are writing the integration anyway and want control over chunking, schemas and confidence handling, ADE is a strong API and the credit model is transparent once you find the rate tables.
Visual grounding returns a bounding box for every extracted value, so a reviewer can see exactly where a number came from. If somebody has to defend that in an audit, the premium is defensible.
Contracts, forms, spreadsheets and reports in one pipeline suit a general agentic parser far better than an invoice-specific API that only knows one document type.
If the goal is invoices in Excel and nobody on the team is going to define a JSON schema, a flat monthly plan is cheaper in practice and there is no per-page meter to model at all.
Last updated August 2026. Every credit rate below comes from LandingAI's own pricing page and the ADE credit-consumption documentation, checked on 15 August 2026. Rates change, so confirm with LandingAI before you commit budget.
Landing AI sells credits and a credit costs exactly one cent, so $1 buys 100 credits on both the Explore and Team plans, in the US and EU regions alike. The Agentic Document Extraction v2 Parse API bills 1 credit per page plus 0.5 credits for every 1,000 characters it returns, on the priority tier. The standard tier, which runs on asynchronous jobs only, is exactly half that. For a page of invoice markdown around 2,000 characters, parsing costs about $0.02 on priority and $0.01 on standard, so roughly $20 or $10 per 1,000 pages. Typed field extraction is billed on characters instead of pages and usually costs more.
| Plan | Price | Credits | Effective rate | What the fee buys |
|---|---|---|---|---|
| Explore | Pay as you go, $1 per 100 credits | 1,000 free credits to start | $0.01 per credit | Single seat, community support, standard rate limits |
| Team | $250 per month | 25,000 credits per month | $0.01 per credit | Unlimited seats, higher rate limits, enhanced email support, zero data retention and a HIPAA BAA available |
| Enterprise | Custom quote | Custom | Not published | SaaS, VPC and on-prem deployment, designated support, priority rate limits, Snowflake integration, SLAs |
Run the arithmetic on the Team plan and something stands out. Twenty five thousand credits at one cent each is exactly $250, which is exactly what the plan costs. There is no volume discount at all. The $250 buys unlimited seats, higher rate limits, zero data retention and the option of a BAA. It does not buy a cheaper page. That matters when you model growth, because the cost line rises in a straight line from your first document to your millionth.
| API | Priority tier (sync and jobs) | Standard tier (jobs only) |
|---|---|---|
| Parse | 1 credit per page, plus 0.5 credits per 1,000 output characters | 0.5 credits per page, plus 0.25 credits per 1,000 output characters |
| Extract | 1 credit per 2,500 input characters, plus 1 credit per 500 output characters | 1 credit per 5,000 input characters, plus 1 credit per 1,000 output characters |
Two rules apply on top. Every credit total is rounded up to the nearest 0.1 credit, which is noise at volume but visible on single test calls. And zero data retention on ADE v2 consumes no additional credits, which was not true of the older API.
LandingAI publishes a useful baseline: a typical business document uses a median of 1.5 credits on the standard tier. Work backwards through the standard Parse formula and 1.5 credits implies a single page returning roughly 4,000 characters. Their own worked example agrees: a 12 page document billing 36.1 credits on priority implies about 48,000 characters of output, or 4,010 per page. Invoices are lighter than that, because an invoice page is mostly a header block and a table rather than paragraphs of prose.
Because Parse charges for output length, the honest answer depends on how much text your pages produce. The table below applies the published formula across a realistic range. Invoice pages usually land between 1,000 and 3,000 characters.
| Output characters per page | Priority credits per page | Priority per 1,000 pages | Standard credits per page | Standard per 1,000 pages |
|---|---|---|---|---|
| 1,000 (sparse invoice) | 1.5 | $15.00 | 0.75 | $7.50 |
| 2,000 (typical invoice) | 2.0 | $20.00 | 1.00 | $10.00 |
| 3,000 (long line-item table) | 2.5 | $25.00 | 1.25 | $12.50 |
| 4,000 (LandingAI's median business document) | 3.0 | $30.00 | 1.50 | $15.00 |
The standard tier is the single biggest lever on this page. It is exactly half price for identical output, and the only thing you give up is a synchronous response. If your invoices arrive by email overnight and get processed in a batch, there is no reason to pay priority rates. If a user is waiting on a screen for the result, you have no choice. That one architectural decision is worth fifty percent of the bill.
Parsing returns markdown. It does not return an invoice number, a vendor name, a due date or a totals column as typed fields. For that you call Extract, and Extract is priced on characters in and characters out rather than pages. The asymmetry is the part people miss: on the priority tier, output characters cost five times what input characters cost, at 1 credit per 500 out against 1 credit per 2,500 in.
The practical consequence is that the same invoice page costs wildly different amounts depending on how much JSON you ask for. Here is the same document under three schemas.
| Schema you request | Input characters | Output characters | Priority credits | Priority per 1,000 | Standard credits | Standard per 1,000 |
|---|---|---|---|---|---|---|
| Header fields only | 2,000 | 500 | 1.8 | $18.00 | 0.9 | $9.00 |
| Header plus 10 line items | 2,500 | 1,500 | 4.0 | $40.00 | 2.0 | $20.00 |
| Header plus 25 line items | 3,000 | 3,000 | 7.2 | $72.00 | 3.6 | $36.00 |
Read that top to bottom. The document never changed. The page count never changed. The bill went up four times because the schema asked for line items. Anyone budgeting Landing AI from a page count alone will be wrong, and wrong in the expensive direction, because line-item capture is exactly what accounts payable teams need. If you only ever pull the header block, Extract is cheap. If you pull the table, model it properly before you sign anything.
LandingAI maintains two credit-consumption tables, one for each generation of the API, and the differences are not uniform. Parsing got cheaper. Priority extraction got dearer.
| Operation | ADE v1 | ADE v2 priority | ADE v2 standard |
|---|---|---|---|
| Parse a document page | 3 credits, flat | 1 credit plus 0.5 per 1,000 output characters | 0.5 credits plus 0.25 per 1,000 output characters |
| Zero data retention | Plus 1 credit per page | No extra charge | No extra charge |
| Extract | 1 credit per 5,000 input characters, 1 per 1,000 output | 1 credit per 2,500 input, 1 per 500 output | 1 credit per 5,000 input, 1 per 1,000 output |
| Classify | 0.5 credits per page | Not published separately | Not published separately |
| Parse a spreadsheet | 1 credit per sheet, 3 credits per embedded image | Not published separately | Not published separately |
Three things follow. First, v1 charged a flat 3 credits to parse a page regardless of content, so a sparse invoice subsidised a dense contract. Second, a regulated workload got much cheaper: v1 charged 4 credits per page with zero data retention turned on, while the same page on v2 standard costs around 1 credit, a cut of roughly seventy percent. Third, and least obvious, ADE v2's standard Extract rate is character for character identical to ADE v1's Extract rate, while v2's priority Extract is exactly double it. Extraction did not get cheaper. It got a faster tier that costs twice as much, and the old price survives as the async option.
The figures below are per 1,000 invoice pages for structured field output, each verified from the vendor's own documentation during 2026. Prices move, so treat this as a shape rather than a quote.
| Tool | Per 1,000 invoice pages | Returns invoice fields natively |
|---|---|---|
| Gemini 2.5 Flash | about $1.58 | No, you define fields in the prompt |
| Mistral OCR 4 | $4.00, or $2.00 via Batch | No, text and layout only |
| Claude Haiku 4.5 | $6.77 to $8.27 | No, you define fields in the prompt |
| OpenAI GPT-5 | about $9.12 | No, you define fields in the prompt |
| AWS Textract AnalyzeExpense | $10.00 | Yes, invoice fields returned natively |
| Azure Document Intelligence prebuilt invoice | $10.00 | Yes, invoice fields returned natively |
| InvoiceExtractor Plus plan | about $14.90 | Yes, header fields and full line items |
| Landing AI ADE v2 Extract, standard tier | about $20.00 | Yes, against a schema you define |
| LlamaParse Agentic Extract | $31.25 | Yes, against a schema you define |
| Landing AI ADE v2 Extract, priority tier | about $40.00 | Yes, against a schema you define |
Landing AI sits at the premium end for invoice work, and it is fair to say why that can still be the right call. ADE returns visual grounding, so every extracted value carries a bounding box back to the pixel it came from. For an audit trail, a human review queue, or a regulated process where somebody has to prove where a number came from, that is worth real money. Complex table handling and split classification are genuinely strong. What you are not buying is a cheaper invoice page than Textract or Azure, both of which return invoice fields natively at $10 per 1,000 with no schema work at all.
Take a real month of documents rather than an estimate. Count pages, not files, because a three page invoice bills three times on Parse. Run twenty representative documents through the API and read the credit consumption off the response rather than guessing at character counts, since that is the only number that settles the question. Decide next whether the workload tolerates asynchronous jobs, because standard tier halves everything. Then decide how large your extraction schema needs to be, since on priority every 500 characters of JSON costs a full credit. Multiply total credits by $0.01, compare against the 25,000 credits in the Team plan, and remember that anything past the allowance bills at the same one cent rate.
Add engineering time to whatever number you get. Defining and maintaining an extraction schema, handling low-confidence fields, and building a review path for the ones the model gets wrong are usually a larger annual cost than the credits themselves at anything under a few hundred thousand pages a year.
Landing AI costs one cent per credit, with $1 buying 100 credits. The Team plan is $250 a month for 25,000 credits and pay as you go is available on the Explore plan. In practice a typical invoice page costs about 1 to 2 credits to parse, so $10 to $20 per 1,000 pages, and more if you also call Extract for typed fields.
Not beyond a trial allowance. The Explore plan starts you with 1,000 free credits, worth $10, which covers roughly 800 to 1,100 invoice pages of standard-tier parsing. After that every API call and Playground run consumes paid credits at one cent each. There is no permanently free tier for production volume.
Agentic document extraction, shortened to ADE, is LandingAI's document processing API. Rather than returning raw OCR text, it parses the page into structured output with intelligent chunking, complex table extraction and visual grounding, so each value maps back to its location on the page. It also handles field extraction against a schema, split classification and multilingual documents.
No. ADE is metered in credits on every call, including runs in the Playground. You get 1,000 free credits when you sign up for the Explore plan, and after that parsing bills from 0.5 credits per page on the standard tier. The API itself is a paid commercial service, not an open-source library you can self-host.
ADE v2 Parse uses 1 credit per page on the priority tier plus 0.5 credits per 1,000 characters of output, and half of that on the standard tier. LandingAI's published baseline is that a typical business document consumes a median of 1.5 credits on standard. The older ADE v1 API charged a flat 3 credits per page instead.
Parsing got cheaper and zero data retention became free. ADE v1 billed a flat 3 credits per page plus 1 more per page for ZDR, while v2 bills 1 credit per page on priority, 0.5 on standard, and nothing extra for ZDR. Extraction is the exception: v2's standard rate matches v1 exactly, and v2 priority is double it.
No, not for structured invoice data. Textract AnalyzeExpense costs $10.00 per 1,000 pages and returns invoice fields natively with no schema to write. Landing AI parsing lands around $10 to $20 per 1,000 pages before extraction, and Extract with line items pushes the total to roughly $20 on standard or $40 on priority.
For general document parsing, LlamaParse and the OCR APIs from Mistral and Google are the closest substitutes. For invoices specifically, AWS Textract AnalyzeExpense and Azure Document Intelligence both return invoice fields natively at $10 per 1,000 pages. If you want a finished application rather than an API, a flat monthly plan removes per-page metering entirely.
Landing AI costs one cent per credit, with $1 buying 100 credits. The Team plan is $250 a month for 25,000 credits and pay as you go is available on the Explore plan. In practice a typical invoice page costs about 1 to 2 credits to parse, so $10 to $20 per 1,000 pages, and more if you also call Extract for typed fields.
Not beyond a trial allowance. The Explore plan starts you with 1,000 free credits, worth $10, which covers roughly 800 to 1,100 invoice pages of standard-tier parsing. After that every API call and Playground run consumes paid credits at one cent each. There is no permanently free tier for production volume.
Agentic document extraction, shortened to ADE, is LandingAI's document processing API. Rather than returning raw OCR text, it parses the page into structured output with intelligent chunking, complex table extraction and visual grounding, so each value maps back to its location on the page. It also handles field extraction against a schema, split classification and multilingual documents.
No. ADE is metered in credits on every call, including runs in the Playground. You get 1,000 free credits when you sign up for the Explore plan, and after that parsing bills from 0.5 credits per page on the standard tier. The API itself is a paid commercial service, not an open-source library you can self-host.
ADE v2 Parse uses 1 credit per page on the priority tier plus 0.5 credits per 1,000 characters of output, and half of that on the standard tier. LandingAI's published baseline is that a typical business document consumes a median of 1.5 credits on standard. The older ADE v1 API charged a flat 3 credits per page instead.
Parsing got cheaper and zero data retention became free. ADE v1 billed a flat 3 credits per page plus 1 more per page for ZDR, while v2 bills 1 credit per page on priority, 0.5 on standard, and nothing extra for ZDR. Extraction is the exception: v2 standard matches v1 exactly, and v2 priority is double it.
No, not for structured invoice data. Textract AnalyzeExpense costs $10.00 per 1,000 pages and returns invoice fields natively with no schema to write. Landing AI parsing lands around $10 to $20 per 1,000 pages before extraction, and Extract with line items pushes the total to roughly $20 on standard or $40 on priority.
For general document parsing, LlamaParse and the OCR APIs from Mistral and Google are the closest substitutes. For invoices specifically, AWS Textract AnalyzeExpense and Azure Document Intelligence both return invoice fields natively at $10 per 1,000 pages. If you want a finished application rather than an API, a flat monthly plan removes per-page metering entirely.
The other credit-metered parser: 1,000 credits for $1.25 and Agentic Extract at $31.25 per 1,000.
AnalyzeExpense returns invoice fields natively at $10 per 1,000 pages.
The prebuilt invoice model, also $10 per 1,000 pages, with strong line-item scores.
Flat $4 per 1,000 pages, or $2 through Batch, with no credit system to decode.
Token-metered GPT-4o and GPT-5 per-page math, from $0.47 per 1,000.
Claude bills tokens with no OCR product: 2,714 visual tokens a page, from $6.77 per 1,000.
A page counts as a flat 258 tokens, which makes Gemini the cheapest metered option.
Prefer an API? Pull invoice data to JSON without per-page metering.
Capture full line-item tables, not just the totals.
Compare the top invoice extraction tools on price and accuracy.
Start turning your invoices into clean, structured spreadsheet data.
USD
per month
billed as
$288 yearly
Choose speed vs accuracy when extracting
| Base AI Faster | 2,500 pages |
| Pro AI Best accuracy | 500 pages |
Scale invoice extraction across your whole team with automation.
USD
per month
billed as
$888 yearly
Choose speed vs accuracy when extracting
| Base AI Faster | 10,000 pages |
| Pro AI Best accuracy | 2,000 pages |
Enterprise‑grade invoice extraction, security, and controls.
USD
per month
billed as
$ yearly
Choose speed vs accuracy when extracting
| Base AI Faster | pages |
| Pro AI Best accuracy | pages |