Per-page OCR/IDP pricing vs per-document vs per-call: what’s cheapest for long PDFs and mixed packets at scale?

Most teams don’t realize how much money they’re lighting on fire with the wrong pricing model until the first “real” batch hits production: 40–80 page contracts, 200-page claim packets, PDFs glued together with emails and photos, and audio call logs that don’t fit into a neat “page” at all. That’s when per-page OCR/IDP pricing stops being a line item and starts being a blocker.

Quick Answer: For long PDFs and mixed packets at scale, per-call (per workflow/function call) pricing is usually cheapest and most predictable. Per-page OCR/IDP pricing almost always explodes with document length, and per-document pricing tends to either hide page caps/fair-use clauses or force you into vendor-specific document types. When you’re processing long, heterogeneous packets, outcome-based per-call pricing is the only model that stays sane.

Why This Matters

Your board wants you “AI-native.” Operations is buried under PDF sludge. And finance expects a clean cost curve—not a surprise 5–10x overrun when a new vendor sends 60-page invoices instead of 2-page ones.

Pricing isn’t just about cents per page. It shapes what you can afford to automate, which workflows you prioritize, and how much “weirdness” (long packets, embedded images, email chains, audio, chat logs) you can support without renegotiating a contract every quarter. If the unit of billing doesn’t match the unit of work your system actually performs, you get one of two outcomes: you stop automating the hard stuff, or you quietly accept margin erosion at scale.

Key Benefits of getting the model right:

• Predictable costs at scale: Your unit economics stay stable when vendors change layouts, packet sizes grow, or you add new channels (WhatsApp, calls, email).
• Freedom to handle real-world edge cases: You can process long PDFs, mixed packets, and non-document inputs without hitting page caps or “unsupported” fees.
• Cleaner architecture and less glue code: When you pay per outcome instead of per page, you can design deterministic workflows around functions and schemas instead of optimizing for billing quirks.

Core Concepts & Key Points

Concept	Definition	Why it's important
Per-page pricing (OCR/IDP)	You’re billed based on number of pages processed, often with separate charges for OCR vs extraction.	Costs scale linearly with length, which punishes long PDFs and multi-doc packets. Forces you to think about page counts, not outcomes.
Per-document pricing	You’re billed per “document” or “transaction,” regardless of pages, usually tied to specific document types (invoice, ID, receipt, etc.).	Looks simpler, but hides complexity: hard definitions of “document,” caps on length, or higher tiers for complex docs. Mixed packets become expensive or impossible.
Per-call (per function/workflow) pricing	You’re billed per API/function call—one price for any input (PDF, image, audio, thread) and any length.	Aligns cost with semantic work: one call → one structured output (or explicit exception). Long PDFs and mixed packets don’t explode your bill. Gives granular cost control at the workflow level.

How It Works (Step-by-Step)

Let’s walk the same 50-page contract packet through the three models and see what you actually pay and build.

1. Per-page OCR/IDP pricing

How it typically works:

1. OCR step: You’re charged for every page you digitize (e.g., $0.01–$0.05/page) just to get text and bounding boxes.
2. Extraction step: A second per-page fee to run the IDP/“AI extraction” layer (often another $0.03–$0.10/page).
3. Post-processing: You write the glue code to normalize fields, reconcile line items, handle edge cases, and check totals.

For a 50-page contract:

• OCR: 50 pages × $0.03 = $1.50
• Extraction: 50 pages × $0.05 = $2.50
• Total: $4.00 for one document. And that’s before any enrichment, validations, or custom business logic.

If you ingest 100k such packets/year, you’re at $400k/year just in per-page extraction. If the average page count creeps from 50 → 70, your cost jumps 40% with no change in value.

2. Per-document pricing

How it typically works:

1. Document type selection: You pay per “invoice,” “receipt,” “contract,” etc. The vendor uses heuristics/templates behind the scenes.
2. Length tiering: “Standard” docs up to N pages are included; longer docs push you into higher tiers or “enterprise” plans.
3. Scope creep: Mixed packets (contracts + annexes + exhibits) often count as multiple documents, or get rejected entirely.

For a 50-page contract:

• “Contract” doc type: Maybe $0.30–$1.00 per document at volume.
• But add supporting schedules, emails, and scans and you’re often forced to split the packet, meaning multiple “documents” billed—and more code to stitch them back together.

Costs are more predictable than pure per-page, but the model pressures you to:

• Pre-classify and split packets just to fit pricing rules.
• Avoid processing “non-core” attachments (emails, photos, call transcripts) because they don’t map to the vendor’s document taxonomy.
• Negotiate bespoke pricing as soon as your reality drifts from their assumptions.

3. Per-call pricing (Bem’s model)

Bem flips the unit of work:

• You pay per function call ($0.09 base tier).
• The input can be a 1-page invoice, a 50-page contract, a 200-page claim packet, a 5-minute phone call, or a WhatsApp thread. Same price.
• You define the schema and workflow; Bem returns schema-enforced JSON or flags an exception. No separate OCR fees, no page multipliers.

For a 50-page contract:

• Transform function call: 1 call × $0.09 = $0.09
• The call handles the entire contract: parse, classify, extract fields, line items, signatures, dates, clauses—whatever your schema defines.

Now compare:

Scenario	Per-page tools	Bem (per call)
10-page PDF — parse + extract	$0.40 – $0.90	$0.09
50-page contract — parse + extract	$2.00 – $4.50	$0.09
5-min phone call — transcribe + extract	Not supported / separate product	$0.09
WhatsApp thread — parse + extract	Not supported / priced per message/token	$0.09

One function. One semantic outcome. One price.

Workflow granularity and cost control

Because pricing is per function, you control granularity:

1. Route: Detect packet type and send to the right workflow. (1 call)
2. Split: Separate a mixed packet into constituent “logical” docs, if that serves your downstream systems. (1 call)
3. Transform: Extract fields into the right schema for each doc type. (1+ calls, one per schema)
4. Enrich: Look up vendor IDs, GL codes, policy numbers from your Collections. (1+ calls)
5. Join: Stitch enriched pieces into a final payload. (1 call)

Each of those is a priced call, so you get per-step cost visibility and can decide where determinism and enrichment are worth paying for.

You’re not paying for pages or tokens. You’re paying for specific workflow steps that produce production-ready JSON.

Common Mistakes to Avoid

• Optimizing your architecture for a pricing model instead of your data model.
  If you’re splitting PDFs into 5-page chunks just to keep per-page costs down, your billing model is driving your system design. Instead, design around schemas and workflows, then choose pricing that doesn’t penalize realistic packet sizes.

• Ignoring “unsupported” channels until it’s too late.
  Many OCR/IDP tools don’t support audio calls, WhatsApp threads, or email chains—or they bolt on separate products with separate pricing. If your pipeline will eventually ingest multi-modal inputs, pick a pricing model (per call) that treats “PDF vs audio vs chat” as just another input type, not another SKU.

Real-World Example

A customer in fleet management came to us with exactly this problem:

• They were ingesting maintenance packets that included:
  • Vendor invoices (2–10 pages)
  • Inspection reports (10–30 pages)
  • Photos of damage
  • Email threads with approvals
• Their prior IDP vendor charged per page, with separate tiers for OCR vs extraction. Their monthly invoice fluctuated wildly based on how many pictures and appended PDFs vendors decided to include.

Operationally:

• They built a fragile pre-processing layer to split packets into “billable” and “non-billable” pages.
• They skipped many attachments (photos, emails) entirely to avoid unpredictable costs.
• Finance couldn’t forecast spend, and product couldn’t expand the workflow without redoing the cost model.

With Bem:

1. They defined a Route workflow to identify packet type from the first few pages.
2. A Split function separated the invoice, inspection report, and “other” pages, but they treated the entire upload as a single packet for their business logic.
3. Two Transform functions mapped:
   • Invoices → AP schema (header + line items)
   • Inspection reports → maintenance schema (issues, severity, timestamps)
4. An Enrich function matched vendors to their master list and mapped cost centers from a GL Collection.
5. A Join function produced a single JSON object with everything their system needed.

Pricing:

• Packet length went from 15 pages to 60 pages for some vendors.
• Their Bem bill didn’t change per packet: they paid for the function calls, not the pages.
• They processed millions of documents weekly with 99.99% uptime, never once needing to “optimize for page count.”

The outcome: they stopped thinking about “expensive pages” and started thinking about “what else can we extract and automate?”

Pro Tip: When evaluating vendors, take your largest, ugliest packet—mixed PDFs, attachments, images, maybe an audio call—and ask for a per-packet, all-in price to get cleaned, schema-valid JSON with your business rules enforced. If the answer devolves into per-page math, separate modules, or “we don’t support that input,” you’re looking at compounding complexity and cost.

Summary

For long PDFs and mixed packets, per-page OCR/IDP pricing is fundamentally misaligned with how real data shows up:

• Costs grow linearly (or worse) with page count.
• You’re forced to design around pages instead of schemas and workflows.
• Multi-modal inputs (audio, chat, email) either aren’t supported or come with bolt-on pricing.

Per-document models look better, but they hide brittleness in how they define “document” and often punish complex packets.

Per-call pricing, when done correctly, aligns billing with semantic work:

• One function call handles any length and any input type for a fixed cost.
• Workflows become composable units (Route, Split, Transform, Enrich, Join), each with transparent cost.
• You can scale to long, messy, multi-modal packets without renegotiating or rewriting around billing artifacts.

That’s why Bem prices per function call ($0.09 base tier, any input type, any length) and focuses on outcome: schema-valid JSON or explicit exceptions, with evals, F1 scores, and regression tests to keep accuracy governed like software quality.

Next Step

Get Started