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

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.