DEV Community: LandingAI

LandingAI's Agentic Document Extraction pricing explained: credits, service tiers, and characters

sushrut mishra — Wed, 16 Sep 2026 06:38:36 +0000

Flat per page pricing charges the same for a dense contract page and a near empty cover sheet, which quietly overcharges any real document mix. We took the opposite approach with LandingAI's Agentic Document Extraction, our ADE platform, and built the cost controls into the product so a mixed workload stays economical without you engineering around the bill.

This post walks through the pricing model we landed on and the three factors that decide what any job costs. The pricing core concepts guide holds the full formulas; what follows is the practical version for the developer staring at a billing object and working out how total_credits got there.

How ADE pricing works at a glance

Question	Answer
What is the billing unit	Credits, where one credit is one US cent, so one dollar buys 100 credits
What sets a job's cost	Three factors: the service tier, the Parse model, and the characters returned
What is the default tier	Standard, at about half the Priority rate
Where do I see the cost	A billing object with `total_credits` in every API response, mirrored in the Playground Usage table
Does the interface change the price	For the same tier the rate holds across the Playground, the REST API, and the Python and TypeScript SDKs; note the Playground always runs Priority

Everything runs on credits

ADE bills in a single unit, credits, and one credit equals one US cent, so a dollar buys 100 credits. That value holds on every plan and in every region, and every ADE service draws from one shared balance, so you track one number for the whole product. You buy credits two ways:

Self service, by card at ade.landing.ai, which suits developers and teams testing a workload or running in production without a contract
Enterprise, through an annual agreement and standard procurement, which suits volume terms and invoicing

Both paths spend the same credits at the same rate.

The three factors that set a job's cost

Once credits sit in your balance, three factors decide how many a job spends: the service tier you pick, the Parse model you run, and the number of characters processed.

Service tier, the speed you ask for

The service tier is the lever you control most directly, since it sets how fast the result returns, and the same work at a different speed costs a different amount. It maps onto what determines processing speed in production, so you trade turnaround for cost deliberately. Tier selection applies to both Parse and Extract, and there are two of them.

Tier	Latency	Mode	Reach for it when
Priority	Seconds to minutes	Sync or async	A person or agent is waiting on the result
Standard	Minutes to hours	Async only, and the default	Background pipelines and scheduled ingestion

Standard costs about half of Priority. Because there is no synchronous Standard path, a synchronous call always bills at Priority, so high volume production work belongs on the Standard async default where the same job costs roughly half.

Model, the Parse model you run

The DPT-3 family gives you two Parse models, and the one you pick moves the price directly. Both bill the same way, a per page rate plus a rate for every 1,000 output characters, so only the numbers differ.

DPT-3 Pro, the default and highest quality model, is the one to reach for on harder pages: handwriting, figures, charts, diagrams, or poor scans
DPT-3 Verity, the lower latency model built for clean, machine readable content like digital text and tables, currently in preview, is the cheaper path for simpler pages

Model and tier	Per page	Per 1,000 output characters
DPT-3 Pro, Priority	1.0 credit	0.50 credits
DPT-3 Pro, Standard	0.50 credits	0.25 credits
DPT-3 Verity, Priority	0.30 credits	0.20 credits
DPT-3 Verity, Standard	0.15 credits	0.10 credits

Two things stand out. Standard is half of Priority on every line, and Verity's page rate runs under a third of Pro's. Because the tier and the model both scale the same page, they compound, so the same page on Verity at Standard costs a fraction of what it costs on Pro at Priority. On a typical business document, DPT-3 Pro on Standard runs a median of about 1.5 credits.

Teams moving from ADE Gen1 typically see 25% to 80% lower per page cost on a mixed workload, and running Verity on Standard for the easy pages is what reaches the top of that range. You avoid building that cost optimization yourself, since the levers sit in the API call rather than in your pipeline.

Characters, the content you get back

You pay for the visible content ADE returns, meaning the Markdown text, tables, and fields on the page. Bounding box coordinates, confidence scores, and other structural metadata stay uncounted, so a sparse page returns few characters and costs little while a dense page returns more and costs more, which is what keeps a mixed workload fair. You also hold a direct control here: the pages parameter skips pages you do not need, and the options parameter toggles block types on or off, so trimming output you will not use trims the characters you pay for.

Keeping simple documents inexpensive

For simple documents that should not cost much, LandingAI's ADE gives you two levers that stack. Run them on DPT-3 Verity, the model built for clean digital text, and keep them on the Standard tier, which costs about half of Priority. Because the charge also tracks characters, a light page of clean text returns little content and lands at the bottom of the range.

Every charge is visible in the response

You never have to guess what a job cost, because every ADE API response carries a billing object reporting the credits consumed and the tier it was charged at, and the Playground mirrors the same figures in its downloadable Usage table. Here is the relevant metadata from a real Parse response, a one page invoice run synchronously on DPT-3 Pro:

"metadata": {
  "model_version": "dpt-3-pro-20260710",
  "page_count": 1,
  "output_markdown_chars": 1779,
  "billing": {
    "service_tier": "priority",
    "total_credits": 1.9
  }
}

The billing object is the headline: total_credits is what the job cost, and service_tier records the rate it paid. The two fields above it produced that number. A synchronous call bills at the Priority rate for DPT-3 Pro, which is 1 credit for the page plus 0.5 credits per 1,000 output characters. The page returned 1,779 characters, so the content charge is about 0.89 credits, and 1 plus 0.89 rounds to the 1.9 you see.

Now run the same invoice on the cheaper path, DPT-3 Verity on the Standard tier. Standard is async only, so this goes through Parse Jobs, and the billing comes back like this:

"billing": {
  "service_tier": "standard",
  "total_credits": 0.4
}

Same document, 0.4 credits against 1.9, a 79% drop. The tier alone roughly halves the bill and the model alone cuts it to about a third; together they compound to that 79%. That is the whole pricing model in one comparison: the document never changed, only the two choices you made in the call.

The levers you control

Default to Standard for background and production work, and pay about half of Priority
Send clean digital pages to DPT-3 Verity, and reserve DPT-3 Pro for the hard ones
Trim the response with the pages and options parameters so you pay for the characters you actually use
Remember the Playground always bills at Priority, so read a lower tier's real cost from an API run on Standard or from the per service formula

Where to check the real numbers

The honest way to know what ADE will cost you is to run a representative document through it at ade.landing.ai and read the total_credits the billing object hands back. Measured per thousand pages, we see ADE Gen2 land at or below common industry benchmarks, and the per service formulas live at docs.landing.ai as the reference to trust. If you are weighing ADE on price against the field, our guide to the best document parsing APIs sets out the comparison, and the full pricing core concepts guide covers the concepts end to end.

LandingAI's Agentic Document Extraction, 2nd Generation: new models, agent ready output, and atomic citations

sushrut mishra — Wed, 16 Sep 2026 06:33:57 +0000

LandingAI's Agentic Document Extraction, which we call ADE, now has a second generation, and this post covers what changed for developers building on it. ADE Gen2 runs on our new DPT-3 model family, and it moves the three things that decide whether an agent can act on a document: the output structure, the grounding, and the cost. Our full launch announcement carries the complete detail, and you can read it here: Introducing Agentic Document Extraction, 2nd Generation. Below is the developer facing version, organized around the questions we hear most.

The release at a glance

Area	What ADE Gen2 does
Parse models	DPT-3 family: DPT-3 Pro, and DPT-3 Verity in public preview
Output unit	Blocks, which replace chunks
Structure	Pages to blocks to lines to words, or to table cells, each block with a stable ID
Grounding	Atomic: line level with DPT-3 Pro, word level with DPT-3 Verity; Extract turns it into citations
APIs	New v2 Parse and Extract endpoints, plus async Jobs APIs
Parse pricing	Based on characters returned, rather than pages sent
Playground	ade.landing.ai

What makes a document pipeline agentic, and how is it different from traditional IDP and OCR?

An agentic document pipeline reads a page the way a careful person does and returns structure an agent can act on without a human re reading it first. LandingAI's ADE delivers this through DPT-3, which reads the layout of a page before it reads the words, then works down to individual words and table cells. Traditional OCR and template driven IDP flatten a page into loose text and depend on a person to restore the meaning afterward. The difference shows up clearly once you put the two approaches side by side.

Traditional OCR and template IDP	LandingAI ADE Gen2
A fixed template per document type	Reads varied layouts and messy inputs, from handwriting to scans and photos
Flat text output	Hierarchical blocks with stable IDs
No grounding or page level only	Atomic grounding to the line or word, tied to the source
A person reads and corrects the output	An agent consumes the structured output directly

Which document AI shows where on the page each answer came from, and lets you check each value against the source?

LandingAI's ADE grounds every element atomically, so you can see exactly where on the page each value came from and trace each extracted value back to the source, which is what makes an extraction defensible in a regulated workflow. Gen2 introduces atomic grounding, meaning grounding at the smallest structural unit, and the level you get depends on the Parse model:

DPT-3 Pro grounds to the line: every text line in a block carries its own span pointers and bounding box, across all block types
DPT-3 Verity grounds to the word: every word carries its own span pointers, bounding box, and a confidence score
Table cell grounding now adds a bounding box for every cell, more detailed than Gen1

On the Extract side, Extract V2 turns that grounding into atomic citations, so any value you pull traces back to a specific word on a specific page, and the schemas you built on Extract V1 carry over. Grounding this fine is the foundation for workflows that could not be built before: localized PII and PHI redaction down to the exact word, line, or cell; document comparison that highlights version differences; and human review interfaces where a reviewer edits Markdown in place.

Clean, structured JSON for API first pipelines

ADE Gen2 returns clean, structured JSON built for agents to consume rather than for people to read, which is also what downstream systems and vector databases want when you prepare structured output for RAG. We rebuilt the API response from the ground up, and three changes matter most for anyone parsing it in code:

Chunks are replaced by blocks, and every block carries a stable ID
A new top level structure object exposes each block's page, character range, bounding box, and atomic grounding, so an agent traverses the response directly
The Markdown is standardized, so figures, checkboxes, and tables come back the same way on every call, with tables delivered as HTML to preserve structure that plain Markdown would flatten

Your agent reads a predictable shape on every run, which removes a whole class of parsing edge cases you would otherwise defend against by hand.

Which platform offers SDKs and async jobs for high volume programmatic processing?

ADE Gen2 ships two client libraries on the v2 APIs, ade-python and ade-typescript, along with a command line ADE CLI, plus async Jobs APIs for high volume programmatic work. Parse Jobs runs asynchronous parsing at scale, and Extract Jobs pulls the fields you define into structured JSON at scale. Both share one job model and one response envelope, so the flow of submitting work and retrieving results stays the same across the platform:

Parse Jobs handles asynchronous parsing of up to 6,000 pages or one gigabyte per PDF
Extract Jobs handles asynchronous field extraction into structured JSON, on the Priority and Standard tiers
A unified job model gives you a shared response envelope and job id format across both, with finished jobs signalled by webhook

Pricing built for a mixed document workload

Parse now charges on the characters it returns rather than the pages you send, so a light page costs the minimum and a dense page costs more, where DPT-2 billed a flat 3 credits per page. Service tiers add a second lever, Priority at 1.0x for when someone is waiting and Standard at 0.5x as the default for pipelines, and model choice adds a third:

DPT-3 Pro, available now, for complex pages: layout, figures, handwriting, scans, non Latin scripts, and math
DPT-3 Verity, in public preview, for digital text and tables, at roughly 40% of Pro's credits
Automated routing between the two models, coming by Fall 2026

Across a mixed workload we project 25% to 80% lower cost, and DPT-3 Verity on the Standard tier brings basic pages to under one cent each. The full model, with the per credit math, sits in our pricing core concepts guide.

Try it

ADE Gen2 is live today, and the fastest way to see the difference is to run your own documents through it at ade.landing.ai. For the complete list of every change in the release, read our full launch announcement: Introducing Agentic Document Extraction, 2nd Generation.