How do I sign up for Bem and start with the free 100 calls/month?

Most teams don’t need another demo. They need to see real, schema-valid JSON flowing into their stack in under an hour. That’s what the free 100 calls/month are for: you can point Bem at real PDFs, images, emails, or audio and watch them come back as clean, validated JSON without talking to sales or pulling out a credit card.

Quick Answer: You sign up for Bem by creating an account on bem.ai, generating an API key, and making your first function call via REST or your preferred SDK. Every account automatically gets 100 free function calls per month—no credit card, no platform fees, and the same capabilities you’ll use in production.

Why This Matters

Most “AI extraction” tools look great in a canned demo and then collapse under real inputs: multi-document packets, weird layouts, messy scans, and downstream business rules. You don’t find that out until you’ve sunk weeks into integration. Bem flips that: you get production-grade workflows, strict schema enforcement, and eval-ready outputs from day one—on a free tier that’s actually enough to build and ship something meaningful.

Key Benefits:

No-commitment, production-grade trial: 100 free calls/month with the same API, schema validation, confidence scoring, and workflows you’ll use in production.
Any input, one price: PDF, image, email threads, WhatsApp/SMS, audio, video—every function call counts once, not per page or per minute.
Built for real workloads, not demos: Versioned functions, idempotent workflows, and exception routing, so you can prove it works before you wire it into critical flows.

Core Concepts & Key Points

Concept	Definition	Why it's important
Function Call	A single API call to a Bem function that takes unstructured input and returns schema-enforced JSON.	This is what your 100 free calls/month are made of—any input type, one price, one outcome.
Workflow	A composed pipeline of primitives (Route, Split, Transform, Join, Enrich, Validate, Sync) with branching logic and state.	Lets you build real processes (AP, claims, onboarding) instead of one-off parsers or brittle scripts.
Schema-Enforced Output	JSON that must conform to a defined JSON Schema; invalid outputs are treated as exceptions, not “best effort.”	Guarantees your ERP, GL, or product never quietly ingests garbage. Failures are explicit and auditable.

How It Works (Step-by-Step)

At a high level, getting started is simple: create an account, grab an API key, make your first call, and then iterate into a workflow. Under the hood, you’re already operating in the same model you’ll use in production: function calls, strict schemas, and deterministic workflows.

1. Create Your Bem Account

Visit https://www.bem.ai
Click Get API key or Start building.
Sign up with your work email and basic details.
Verify your email if prompted and log into the console.

Once you’re in, you’re on the free tier by default:

100 free calls every month
No credit card required
No platform fees, no minimums

You can stay on pay-as-you-go indefinitely; if you ever want volume discounts or custom terms, that’s when we talk about commitments.

2. Generate an API Key

Inside the Bem console:

Go to the API keys or Settings section.
Click Create API key.
Give it a descriptive name (e.g., dev-local, staging-backend).
Copy the key and store it as a secret in your environment (e.g., BEM_API_KEY).

The API key is all you need to start using your 100 free calls/month via REST or SDKs. Treat it like any other production credential: keep it out of client-side code, don’t hardcode it in repos.

3. Make Your First Function Call

Bem is function-first. You call a function, pass an input, and get strict JSON back—no pages, no OCR gymnastics, no bespoke parser.

A typical REST call looks like this (pseudo-example):

curl https://api.bem.ai/v1/functions/invoice-extract/call \
  -H "Authorization: Bearer $BEM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "type": "file_url",
      "url": "https://example.com/sample-invoice.pdf"
    }
  }'

You’ll get:

Schema-enforced JSON (e.g., invoice_number, vendor_name, line_items[], totals)
Per-field confidence scores
Hallucination detection / flags where applicable

That call counts as 1 function call against your monthly 100—whether that PDF is 1 page or 50, pristine or messy.

4. Explore Different Inputs (All Covered by the Free Calls)

You can use your free calls to test across all supported unstructured formats:

PDFs / docs: contracts, invoices, claims, onboarding packets
Images: mobile captures, scans, logistics docs
Email threads: support tickets, order confirmations, approvals
WhatsApp/SMS: customer conversations, dispatch instructions
Audio / video: support calls, recorded walkthroughs, field videos

Every time you call a function with any of these, it’s a single billable unit—still just 1 of your 100 free monthly calls.

5. Move from Single Calls to a Workflow

Once you’ve proven extraction on a few documents, use your remaining free calls to simulate your real process:

Route: Detect doc type (invoice vs PO vs receipt) and send to the right function.
Split: Break apart multi-doc packets (e.g., a 30-page scan of mixed claims).
Transform: Normalize fields (date formats, currency, vendor codes).
Enrich: Match against your internal Collections (vendor master, GL codes, customer DB).
Validate: Enforce required fields, enums, and business rules; flag exceptions.
Sync: Push structured JSON into your system via webhook, queue, or API.

Every node in that workflow is backed by functions; each function call still draws from the same free 100 calls/month.

6. Observe, Evaluate, and Iterate

Use your free tier like you’d treat a test environment:

Upload a golden dataset (e.g., 50 invoices from different vendors).
Run them through the same function/workflow.
Measure F1 scores, pass/fail rates, and drift over time.
Tighten schemas, thresholds, and routing based on real failure modes.

The goal: by the time you’ve burned through those 100 free calls, you should know if Bem can handle your real workload, not just a demo.

Common Mistakes to Avoid

Burning all 100 calls on toy examples:
Use a mix: a few obvious “happy path” docs, then real production-like edge cases. The point is to test failure handling, not just extraction.
Treating Bem like a generic OCR or transcription API:
Don’t stop at “get text.” Define schemas, enforce types, and wire in validation logic. Use functions and workflows to get straight to business-ready JSON, not just bounding boxes.
Putting the API key in frontend code:
Keep the API key server-side and call Bem from your backend or worker layer. This is production infrastructure, not a browser widget.
Ignoring exception handling during the trial:
Configure thresholds and review surfaces early. Your production pain is rarely the 90% that works; it’s the 10% that needs human eyes and clean re-runs.

Real-World Example

A mid-market logistics platform wanted to replace manual entry for incoming freight docs—BOLs, packing lists, rate confirmations—all in different layouts, often scanned as a single multipage PDF.

In the first week, they:

Signed up on bem.ai and generated an API key (no contract, no calls with procurement).
Used their free 100 calls to run a mixed packet dataset: 40+ PDFs, each containing 3–7 documents.
Built a simple workflow:
- Split packets into individual docs.
- Route each doc to the right extraction function (BOL vs packing list).
- Transform carrier and lane codes into their internal formats.
- Validate required fields and totals.
Routed low-confidence results into a human review surface, where operators corrected fields; corrections fed back into training and future evals.

They didn’t pay a dollar to prove three things:

Bem could correctly split and route packets.
Totals—including line items—were accurate and schema-valid.
Exceptions were explicit, traceable, and easy to review.

Once they were confident (F1 scores across the dataset looked good, exception rates were predictable), they flipped from free tier into normal usage. Same functions, same workflows—just more volume.

Pro Tip: Use your first 20–30 free calls to establish a small golden dataset and eval harness. Don’t just eyeball responses in the console—write a simple script that checks fields against ground truth and prints pass/fail per document.

Summary

You don’t need a sales call or a credit card to see if Bem can handle your unstructured → structured pipeline. Sign up on bem.ai, generate an API key, and start burning your free 100 calls/month on real workloads: invoices, claims, packets, email threads, audio. Treat those calls as a test suite: enforce schemas, wire workflows, measure F1, and force exceptions to be explicit. If it survives your worst documents, it will survive production.

Next Step

Get Started