Bem vs Extracta: how do they compare on long-document pricing (per-page vs per-call) at 100k and 1M+ volume?

Most teams don’t realize how much per-page pricing punishes long documents until they hit scale. At 100k or 1M+ documents, the difference between a per-page engine like Extracta and a per-call engine like Bem isn’t a rounding error—it’s the difference between a line item and a board conversation.

Quick Answer: Extracta’s per-page pricing scales linearly with length: every page of a 30–50 page packet is a new cost. Bem prices per function call, not per page or minute. A 50-page contract, a 10-page packet, or a 30-minute audio file all cost the same per call, with graduated discounts at 10k, 100k, and above. At 100k+ long-doc volume, that shift from “per-page” to “per-call” usually cuts total spend by multiples, not percentages—while also collapsing your pipeline from many page operations into a single, schema-enforced output.

Why This Matters

If you’re processing invoices, claims, contracts, or logistics packets, the median document is not one page. It’s 8. 30. 70+. That matters for two reasons:

Cost curves: With per-page tools like Extracta, every extra page is an extra billable unit. A 50-page contract costs ~5× a 10-page one, even if your workflow is the same.
Operational complexity: Per-page tools give you text and bounding boxes. You still have to join, normalize, apply business rules, and turn that into JSON your systems can trust.

Bem flips the model:

You pay per function call, regardless of page count, minutes, or media type.
You get structured, schema-enforced JSON in one shot—not N pages of OCR you have to glue back together.
At 100k and 1M+ documents, you care less about “price per page” and more about price per outcome and the cost to keep the pipeline from breaking.

Key Benefits:

Predictable cost for long documents: A 50-page or 5-page file has the same per-call price with Bem, so your COGS doesn’t explode as vendors send longer packets.
Outcome-based billing, not OCR fragments: Bem returns schema-valid JSON (or explicit exceptions), so you’re not paying to then build and maintain the missing 80% of the pipeline.
Scale economics at 100k+ volume: Graduated per-call pricing means your effective rate drops as you scale, instead of compounding per-page charges across long docs.

Core Concepts & Key Points

Concept	Definition	Why it's important
Per-page pricing (Extracta-style)	Charging based on page count (e.g., $X / page). A 50-page PDF costs ~50× a 1-page PDF.	Long contracts, claims packets, and multi-doc bundles get disproportionately expensive, especially at 100k+ volume.
Per-call pricing (Bem)	Charging per function call, independent of page count, minutes, or input type.	Aligns cost with “one input → one structured JSON output,” so long documents don’t blow up your bill.
Outcome-based pipeline	System that ingests any unstructured input and returns schema-enforced JSON, with validation, enrichment, and exception handling built in.	Eliminates the hidden cost of gluing together OCR, parsers, and business rules across pages and files.

How It Works (Step-by-Step)

At a high level, here’s how a long-document workflow looks in both worlds.

1. Extracta-style per-page pipeline

Upload & OCR per page:
Each page of a 50-page PDF is processed as its own unit. You’re billed for 50 pages.
Page-level parsing:
Models extract fields per page: line items, totals, dates, addresses, etc.
Custom glue code:
You stitch pages back together, reconcile totals, dedupe entities, apply business rules, and build JSON your ERP or claims system can accept.

Cost scales with pages. Ops cost scales with edge cases.

2. Bem’s per-call, full-pipeline approach

Single function call:
POST /functions/{function_id}/invoke with any input: a 10-page invoice packet, a 50-page contract, a 30-minute call, or a messy email thread with attachments. One call, one price.
Deterministic workflow execution:
Behind that call, you define a workflow composed of primitives:
- Route by document type/packet structure
- Split multi-doc packets
- Transform & Join across pages/sub-documents
- Enrich against internal Collections (vendor list, GL codes, plan definitions)
- Validate against JSON Schema with strict types, enums, and per-field confidence
- Surface low-confidence exceptions to a review UI
Schema-enforced output (or explicit exception):
Bem returns a single, schema-valid JSON payload—or an exception with fields flagged for review. No per-page operations. No manual post-processing to “make it production-grade.”

Pricing mechanics in practice

Using Bem’s published pricing as a baseline:

First 100 calls / month: Free
1 – 10,000 calls: $0.09 / call
10,001 – 100,000 calls: $0.07 / call
>100k: Additional volume commitments available (custom rates, but still per call, not per page or token)

Every call is priced the same whether the input is:

A 10-page PDF
A 50-page contract
A 5-minute phone call
A WhatsApp or SMS thread
An email with attachments

One API, one price, regardless of source. This isn’t OCR. It’s the whole pipeline.

Common Mistakes to Avoid

Treating “per-page” as neutral at scale:
A page-based quote looks fine at pilot size. At 100k long documents, it compounds. Always run the math using your actual page distribution (most teams discover their average packet is way longer than they assumed).
Ignoring the glue-code tax:
Even if per-page OCR looks cheaper on paper, you’ll spend months building and maintaining the join/normalize/validate pipeline yourself. When comparing Extracta to Bem, include:
- Engineering time to join pages and sub-documents
- Business rule implementation and testing
- Exception handling and review queues
- Ongoing maintenance as layouts and vendors change

Real-World Example

Assume you’re processing 100,000 multi-page documents per month, average length 30 pages (contracts, claims packets, invoice bundles).

With a per-page engine like Extracta

Let’s take a conservative fictional rate of $0.01 / page (many tools are higher, especially with “AI extraction” on top):

30 pages × $0.01 / page = $0.30 / document
100,000 documents × $0.30 = $30,000 / month

At 1M documents:

1,000,000 × $0.30 = $300,000 / month

And that’s just for per-page extraction. You still need:

Code to assemble packets and map fields across pages
Rules to reconcile totals and line items
Monitoring, evals, and exception handling
Infrastructure to run and scale it

With Bem’s per-call pricing

Same document set: 100,000 documents/month, average 30 pages. Each document—regardless of length—is processed as a single function call.

From Bem’s published tiers:

First 100 calls: free
Next 9,900 calls @ $0.09 = $891
Next 90,000 calls @ $0.07 = $6,300
Effective blended rate (from Bem’s own example): ~$0.0738 / call

Rough monthly cost at 100k calls:

100,000 × ~$0.0738 ≈ $7,380 / month

At 1M calls, with volume commitments, your per-call rate goes lower again. You’re still paying:

Per call, not per page
The same price for a 5-page or 50-page packet
One price for any input type (PDF, audio, email threads, WhatsApp, CCTV, etc.)

Side-by-side, long-doc economics

For 100k 30-page docs (fictional Extracta rate vs Bem published model):

Extracta-style per-page: ≈ $30,000 / month
Bem per-call: ≈ $7,380 / month (and trending down with higher volume)

Now add:

Engineering headcount to maintain a per-page, multi-step pipeline
The cost of bad data when something silently fails
The time to ship new layouts or rules

Bem’s model doesn’t just reduce raw compute costs. It collapses pipeline complexity into a deterministic, observable workflow you can version, test, and roll back.

Pro Tip: When you benchmark Bem vs Extracta, don’t just multiply pages × rate. Pull a real 1,000-document sample, measure average pages per document, and use that to model (a) monthly per-page spend, and (b) how often your current pipeline silently fails on edge-case packets. Accuracy and exception handling have a cost too.

Summary

If your workload is single-page PDFs at small volume, Extracta’s per-page economics might feel “good enough.” Once you’re dealing with long documents at 100k or 1M+ volume, the equation flips:

Extracta:
- Cost scales with pages.
- You pay per page, then pay again in engineering time to build the missing 80% of the pipeline.
- Long documents turn into a compounding COGS problem.
Bem:
- Cost scales with calls, not pages or minutes.
- Any unstructured input → schema-enforced JSON in one call, with per-field confidence, hallucination detection, and exception routing.
- Graduated per-call pricing means your effective rate drops as you grow, while pipeline complexity stays contained.

At long-document scale, you want pricing aligned with the unit that matters: a fully-processed document that your systems can safely ingest. That’s what Bem’s per-call, outcome-based model is designed for.

Next Step

Get Started