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

Quick Answer: At 50,000 function calls per month, your estimated Bem bill is $3,691, with a blended rate of about $0.0738 per call under our current published tiers. You get 100 free calls, then pay $0.09 for calls 101–10,000 and $0.07 for calls 10,001–50,000. Higher-volume tiers (e.g., $0.05 / $0.04) kick in above those ranges and via volume commitments.

Why This Matters

If you’re moving real workloads—AP packets, claims, onboarding docs, logistics packets—your board cares about two things: how much it will cost at production scale, and whether the system will hold up under edge cases. With Bem, you’re not guessing at token counts or page-based tiers. You’re paying per function call for an end-to-end pipeline that takes any unstructured input and returns schema-enforced JSON, or a flagged exception you can route.

Understanding how the $0.09 / $0.07 (and higher-volume $0.05 / $0.04) tiers apply at 50k+ calls/month lets you model real economics: what it costs to kill manual data entry, how fast you can expand use cases, and what your marginal cost is as volume grows.

Key Benefits:

Predictable, outcome-based pricing: You’re billed per function call, not per page, token, or minute of audio—whether it’s a one-page invoice or a 30-minute call transcript.
Automatic volume discounts: Graduated tiers drop your blended rate as you grow; you don’t have to renegotiate or “buy into” a higher plan to get a lower rate.
Aligned with production usage: Pricing maps directly to the unit you actually scale—workflows/functions in production—so finance and engineering can speak the same language.

Core Concepts & Key Points

Concept	Definition	Why it's important
Function call	A single execution of a Bem function or workflow that takes any unstructured input (PDF, image, email thread, audio, etc.) and returns structured, schema-valid JSON (or an exception).	This is the only billing unit. No per-page, per-token, or per-minute surprises; you can tie cost directly to business operations.
Graduated pricing	A tiered model where each block of usage is billed at its own rate (e.g., first 100 free, next 9,900 at $0.09, next 40,000 at $0.07), instead of all usage being billed at one flat tier rate.	Your blended rate decreases as volume grows; you always get the best price for the marginal calls in each band.
Blended rate	The effective average price per function call across all tiers for your total monthly volume.	Lets you compare Bem to per-page OCR or token-based APIs in one number, while still seeing how each tier contributes to your total.

How It Works (Step-by-Step)

Bem’s pricing is intentionally boring: no token math, no page counting. Just function calls. Here’s how the 50k/month scenario breaks down and how the $0.09 / $0.07 / $0.05 / $0.04 tiers fit into the picture.

1. Start with the free tier (0–100 calls)

Free calls applied:
- Monthly function calls 1–100 are free.
- At 50,000 calls/month, your first 100 calls cost $0.
No feature gating:
- Free calls are full-featured. Same pipeline, same schema validation, same exception handling.

2. Apply the first paid tier: $0.09 per call (101–10,000)

Next 9,900 calls:
- Calls 101 through 10,000 are billed at $0.09 each.
- That’s 9,900 calls × $0.09 = $890.91.
What you’re paying for:
- Each of these calls can process:
  - A mixed packet of PDFs and images.
  - An email thread with attachments.
  - A 30-minute support call transcript.
- Same price. Same function call.

3. Apply the second paid tier: $0.07 per call (10,001–50,000)

Remaining 40,000 calls:
- At 50,000 calls/month, after the first 10,000 are accounted for, you still have 40,000 calls.
- These fall into the $0.07 tier.
- 40,000 calls × $0.07 = $2,800.00.
Total for 50k calls:
- Free tier (0–100): $0.00
- $0.09 tier (101–10,000, 9,900 calls): $890.91
- $0.07 tier (10,001–50,000, 40,000 calls): $2,800.00
- Total estimated monthly cost: $890.91 + $2,800.00 = $3,690.91
- Rounded on the pricing calculator: $3,691 / month.
Blended rate calculation:
- Total paid calls: 50,000 (100 free calls are part of the volume, but $0 cost).
- Blended rate ≈ $3,691 ÷ 50,000 = $0.0738 per call.

4. Where the $0.05 / $0.04 tiers come in

Above the published $0.09 and $0.07 graduated tiers, there are higher-volume discounts (e.g., $0.05 and $0.04 per call) that typically apply when:

You’re consistently running hundreds of thousands to millions of calls per month, and/or
You’re able to commit to a monthly minimum volume.

Mechanics stay the same:

Graduated, not flat:
- You only pay $0.05 or $0.04 on calls above the thresholds you’ve agreed to.
- Calls below those thresholds still bill at the lower tiers (or free) as applicable.
Blended rate drops:
- As those discounts kick in on the marginal calls, your overall blended rate—across all 50k, 500k, or 5M calls—falls automatically.
Volume commitments:
- If you can commit to monthly minimums, Bem can lock in those lower per-call rates.
- This is how large teams get to $0.05 / $0.04 economics for critical workflows.

Common Mistakes to Avoid

Assuming “50k calls” means “50k pages”:
A single Bem function call can take an entire packet—multi-page PDF, attachments, emails, images—and output normalized JSON. Don’t equate function calls with pages; that’s how you under-estimate the value vs. per-page OCR tools.
Modeling cost on demo usage patterns:
A few test PDFs won’t resemble production: mixed sources, edge cases, re-runs. When you plan for 50k/month, plan around business events (invoices, claims, shipments), not lab tests. Then map each event to 1 or more function calls.

Real-World Example

Imagine you’re automating AP for a multi-entity company:

Each vendor packet is: a multi-page invoice, several attached receipts, and an email thread.
You design a Bem workflow with primitives like:
- Route: Detect packet type (AP invoice vs. expense report vs. credit memo).
- Split: Separate the invoice PDF from receipts and email body.
- Transform: Extract header, line items, tax, and currency into a strict JSON Schema.
- Enrich: Map vendor and GL codes against your “Collections” (vendor master, chart of accounts).
- Validate: Enforce schema validity; if any field violates type/enums, flag an exception.

You send each packet as one function call. At 50,000 packets/month:

Your finance team stops keying invoice totals, tax, and line items.
Your ERP receives schema-valid JSON or explicit exceptions via webhook.
Your monthly Bem bill lands around $3,691, with a $0.0738 blended rate—regardless of how many pages, images, or emails are in each packet.

Pro Tip: When modeling cost, start by counting business objects (packets, claims, orders) and define one function call per object. Then layer in exception flows (e.g., idempotent re-runs, human review surfaces) rather than breaking the problem into “pages.”

Summary

At 50,000 function calls per month, you’re looking at an estimated $3,691 on Bem under the current graduated tiers:

100 calls free.
9,900 calls at $0.09.
40,000 calls at $0.07.
A blended rate of about $0.0738 per call.

Higher-volume tiers like $0.05 / $0.04 apply to usage above these thresholds, typically when you can commit to larger monthly volumes. The key is that you’re paying per function call—for a complete unstructured → structured pipeline—not per page or token. That’s why teams use the 50k/month math to justify eliminating manual entry and shipping production workflows in weeks, not quarters.

Next Step

Get Started