Bem pricing: what would 50k function calls/month cost, and how do the $0.09/$0.07/$0.05/$0.04 tiers apply?

Most teams evaluating Bem hit the same question fast: “If we run ~50,000 function calls per month, what does that actually cost — and how do the $0.09/$0.07/$0.05/$0.04 tiers kick in?” You don’t want surprises, and you don’t want to guess how graduated pricing behaves when you scale from a demo to a production pipeline.

Quick Answer: At 50,000 function calls per month, your Bem bill is calculated using graduated pricing. The first 100 calls are free, the next 9,900 are billed at $0.09, and the remaining 40,000 at $0.07 — for a total of $3,690.91 and a blended rate of ~$0.0738 per call. Higher-volume tiers ($0.05 / $0.04) apply only to calls above those thresholds.

Why This Matters

If you’re building a production layer for unstructured data, cost structure isn’t a footnote — it shapes your architecture. Per-page OCR tools force you to count pages and tokens and hack around pricing; Bem prices per function call so you can reason about cost in terms of outcomes: “How many packets/workflows are we processing?” not “How many pages did this random 84‑page PDF have?”

Knowing exactly how 50k calls land on the Bem invoice helps you:

Key Benefits:

• Plan production budgets realistically: Map your AP, claims, or onboarding volumes to a predictable per-call cost instead of guessing based on page counts.
• Design workflows with confidence: Split, route, and enrich freely, knowing each function call has a clear price attached — independent of file length or modality.
• Scale without renegotiation: As volume grows, your blended rate drops automatically via graduated pricing; you only talk to sales if you want additional savings via volume commitments.

Core Concepts & Key Points

Concept	Definition	Why it's important
Function call	A single invocation of a Bem function or workflow that turns arbitrary unstructured input (PDFs, images, audio, threads) into schema-enforced JSON.	This is the atomic billing unit — you pay for the outcome, not for pages, tokens, or minutes of audio.
Graduated pricing	A tiered model where each price applies only to the calls within that band (e.g., 1–10k @ $0.09, 10,001–100k @ $0.07), with the first 100 free.	Ensures your effective (blended) rate decreases naturally as volume grows — without suddenly paying the higher price for all calls.
Blended rate	The average price per call after applying all tiers and the free allowance.	Lets you benchmark “what we actually paid per function call” and compare it to alternatives that hide cost in per-page or per-token billing.

How It Works (Step-by-Step)

Bem’s pricing is simple at the surface — $0.09 / $0.07 / $0.05 / $0.04 per function call — but the important detail is that it’s graduated, not flat. Here’s how the 50k example plays out and how the tiers behave in general.

1. Understand the per-call model

   One call. One price. Any input.

   • A 1‑page invoice and a 300‑page logistics packet cost the same if they go through the same function.
   • A 2‑minute voicemail and a 30‑minute support call recording are priced identically per function call.
   • Mixed packets (email threads + PDFs + images) are treated as a single unstructured input if you route them through one workflow step.

   Bem is not charging by:

   • Pages
   • Tokens
   • OCR lines
   • Minutes of audio or video

   You’re paying for the full pipeline from unstructured input → structured JSON in one deterministic call.

2. Apply the free tier and the first bands

   Every month, the first 100 function calls are free. After that, graduated pricing kicks in:

   • 0–100 calls: $0.00 (free tier)
   • 1–10,000 calls: $0.09 / call
   • 10,001–100,000 calls: $0.07 / call
   • 100,001–X calls: $0.05 / call (higher volume)
   • Above that: $0.04 / call (very high volume)

   Graduated means each band only applies to the calls in that band, not retroactively to all calls.

3. Walk through the 50,000-call calculation

   Let’s compute a realistic 50k-month bill using the bands we know from the official documentation. For 50,000 calls in a single month:

   1. First 100 calls: free

      • 100 calls @ $0.00
      • Cost: $0.00

   2. Next 9,900 calls (calls 101–10,000): $0.09

      • 9,900 calls @ $0.09
      • Cost: $890.91

   3. Remaining 40,000 calls (calls 10,001–50,000): $0.07

      • 50,000 total – 10,000 already accounted for = 40,000 calls
      • 40,000 calls @ $0.07
      • Cost: $2,800.00

   4. Total monthly cost

      • $0.00 + $890.91 + $2,800.00
      • Total: $3,690.91

   5. Blended effective rate

      • $3,690.91 / 50,000 calls ≈ $0.0738 per call

   So at 50k calls/month, you’re effectively paying about seven and a third cents per function call — for full unstructured→structured processing, including schema enforcement and validation.

   Note: The $0.05 / $0.04 tiers don’t apply yet at 50k. They come into play only once your monthly volume crosses those higher thresholds; when that happens, the lower price applies only to the incremental calls above the boundary.

Common Mistakes to Avoid

• Treating tiers as flat pricing:
  It’s easy to assume that once you cross, say, the 10,000-call mark, all calls are billed at $0.07. That’s not how Bem works.
  How to avoid it: Model cost with a simple “waterfall”:

  • First 100 @ $0
  • Next 9,900 @ $0.09
  • Next 90,000 @ $0.07
  • Next N @ $0.05 / $0.04

• Optimizing for pages, not outcomes:
  If you come from OCR/IDP tooling, you might try to game the system around page count, file splitting, or token usage. Bem doesn’t bill that way.
  How to avoid it: Design your workflows for correctness and operational simplicity: Route, Split, Transform, Join, and Enrich as needed. Then multiply the expected function calls by your blended rate — not your page counts.

Real-World Example

Imagine you’re a mid-size logistics platform processing carrier packets: contracts, rate sheets, COIs, invoices, and email threads with attachments. You build a Bem workflow that:

• Accepts any packet as a single unstructured input (PDFs, emails, images in one go).
• Routes by document type (contract vs invoice vs COI).
• Transforms each into a schema-enforced JSON payload (e.g., Invoice v3, COI v2).
• Enriches against your internal Collections (carrier master, GL codes).
• Surfaces low-confidence fields for human review.

That’s one function call per packet, regardless of the number of documents, pages, or modalities inside. At ~50,000 packets/month:

• Your total cost, as we calculated, is $3,690.91.
• Your effective rate is ~$0.0738 per packet for end-to-end processing.
• You’re not paying extra for a 200‑page rate sheet vs a 2‑page invoice; complexity is handled in the workflow, not in the billing.

The operational outcome: you can confidently say, “We can onboard any carrier packet, in any format, for around eight cents per run — with schema-valid output or explicit exceptions.”

Pro Tip: When you build your cost model, start from business events, not files: “invoice received,” “packet uploaded,” “claim submitted.” Map each event to a function call and apply the graduated tiers. If a workflow step feels “expensive,” it’s usually a signal to refactor the pipeline, not to micro-optimize pages.

Summary

At 50,000 function calls per month, Bem’s graduated pricing structure gives you a clear, predictable bill:

• First 100 calls are free.
• The next 9,900 calls are billed at $0.09.
• The remaining 40,000 calls are billed at $0.07.
• Total: $3,690.91, or a blended rate of ~$0.0738 per call.

You’re paying per function call — for the full unstructured-to-structured pipeline — not per page or per token. As your volume grows, your effective rate drops automatically, and higher tiers ($0.05 / $0.04) apply only to the incremental calls above those thresholds.

Next Step

Get Started