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

Most teams don’t need another AI demo. They need a way to push real packets—PDFs, emails, images, audio—through a deterministic pipeline and get clean JSON out the other side. That’s what Bem is built for. And you can start doing that with 100 free function calls every month, no credit card, no platform fees, no minimums.

Quick Answer: You sign up for Bem by creating an account, generating an API key, and calling your first function via REST. Every account automatically gets 100 free function calls per month, so you can send real unstructured inputs (PDFs, images, audio, threads) and get schema-enforced JSON back without entering payment details.

Why This Matters

If you’re evaluating unstructured-to-structured infrastructure, you don’t want sales decks—you want to hit an API with your real documents and see what comes back.

Bem’s free 100 calls/month exists for exactly that: to let you wire Bem into your stack, define schemas, and run end-to-end workflows before you argue with procurement. No per-page pricing. No token math. Just “does this pipeline actually handle our invoices, claims packets, contracts, and mixed attachments?”

Key Benefits:

Real workloads, not toy examples: Use the free calls on the messy PDFs, email threads, and mixed uploads your current stack is failing on.
No-risk integration: No credit card, no platform fees, no minimum commitments—just generate an API key and start calling functions.
Production-shaped evaluation: Test schema validation, confidence thresholds, exception handling, and Surfaces exactly how you’d run them in production.

Core Concepts & Key Points

Concept	Definition	Why it's important
Function Call	A single Bem execution that takes unstructured input (PDF, image, audio, thread) and returns structured, schema-enforced JSON.	Your 100 free calls/month are measured per function call, not per page or token, so you can test real documents without worrying about micro-billing.
Workflow	A composable pipeline of steps—Route, Split, Transform, Join, Enrich, Validate, Sync—applied to your input.	Lets you evaluate how Bem handles branching logic, edge cases, and downstream rules, not just one-off extraction.
Schema-Enforced Output	JSON responses strictly validated against your JSON Schema, with per-field confidence and hallucination detection.	You either get schema-valid data or an explicit exception, which is what production systems need to trust automated ingestion.

How It Works (Step-by-Step)

The path from “I’ve heard of Bem” to “My first packet just auto-ingested itself” is short and deterministic.

1. Create Your Bem Account

Go to https://bem.ai.
Click Get API key or Book a demo if you want a walkthrough first, but for hands-on use you’ll head straight to the app.
Sign up with your work email and basic details.
Confirm your email if prompted and log into the Bem console.

As soon as your account is created, the free tier is active. No billing config required to unlock the 100 free calls/month.

2. Generate an API Key

In the Bem console, navigate to the section where you manage API keys.
Click Create API key.
Name it something that maps to a service or environment (e.g., dev-ingestion-service, staging-ap-pipeline).
Copy the key and store it in your secrets manager (e.g., AWS Secrets Manager, Vault, Doppler). Treat it like any other production credential.

You now have everything you need to hit Bem’s REST API.

3. Understand What “100 Free Calls/Month” Covers

Bem bills per function call, regardless of:

Input size (1-page invoice or 50-page contract)
Input type (PDF, image, audio, video, email, WhatsApp/SMS thread)
Number of pages or tokens

So:

A 50-page contract that would cost $2–$4.50 with per-page tools is a single call—$0.09 at on-demand pricing, and free while you’re within the 100-call monthly allowance.
A 30-minute audio file is the same: one call.
A messy email thread with attachments is still a single call.

Your first 100 calls each month are free. After that, you slide into the graduated per-call pricing (e.g., $0.09/call for 1–10,000), but only if you’ve set up billing. If you never add billing, you simply won’t be able to exceed the free quota.

4. Create or Use a Function / Workflow

You have two options to start:

Use a prebuilt function (e.g., for invoices, receipts, IDs, generic forms).
Define your own schema and workflow for your specific packet type.

At a high level:

In the console, create a Function:
- Define the input type(s) (PDF, image, audio, email, etc.).
- Attach or define a JSON Schema for the output (e.g., invoice_number, vendor_name, line_items[].total, gl_code).
Optionally compose a Workflow:
- Route by document type or vendor layout.
- Split packets into sub-documents.
- Transform and normalize fields (dates, currencies).
- Enrich against Collections (vendor master, GL codes, customer DB).
- Validate output against your schema.
- Sync downstream (ERP, TMS, claims system) or trigger webhooks.

Bem will enforce your schema at the workflow boundary: schema-valid JSON or explicit exception.

5. Call the API With Real Inputs

From here, it’s just a REST call. For example, in Node.js using fetch:

const fs = require('fs');
const fetch = require('node-fetch');

const BEM_API_KEY = process.env.BEM_API_KEY;
const BEM_FUNCTION_ID = 'invoice-v1'; // your function or workflow name/id

async function processInvoice(filePath) {
  const fileBuffer = fs.readFileSync(filePath);

  const res = await fetch('https://api.bem.ai/functions/execute', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${BEM_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      function_id: BEM_FUNCTION_ID,
      input: {
        file_name: 'invoice.pdf',
        file_bytes_base64: fileBuffer.toString('base64'),
      },
    }),
  });

  if (!res.ok) {
    console.error('Bem error', await res.text());
    return;
  }

  const data = await res.json();
  console.log('Schema-valid JSON:', data);
}

processInvoice('./samples/invoice.pdf');

Each functions/execute call:

Consumes 1 free call out of your 100/month.
Returns structured, schema-validated JSON (or a flagged exception).
Includes per-field confidence and hallucination detection metadata when configured.

Use webhooks/subscriptions if you want asynchronous results for large batches.

6. Inspect Outputs, Confidence, and Exceptions

In the console, you can:

Inspect each call’s trace.
See per-field confidence and hallucination detection.
See how workflows routed, split, joined, and enriched your packet.
View exceptions (low-confidence or schema-violating outputs) that got routed to human review.

This is where you validate that the pipeline is doing what your production constraints require—totals correct including line items, GL codes normalized, vendors correctly matched.

7. Add Surfaces for Human Review (Optional but Recommended)

For low-confidence fields or edge cases, you can:

Define review rules (e.g., “if total confidence < 0.9, send to human review”).
Generate a Surface—an operator UI automatically derived from your schema.
Let humans correct fields; Bem stores corrections and can feed them back into evals and model training.

The 100 free calls cover the function/workflow executions themselves. Surfaces are part of the same operational stack; you’re not paying extra per screen or per user.

Common Mistakes to Avoid

Treating 100 calls as “toy-only” capacity:
Use them on real packets—multi-attachment emails, weird scans, noisy photos. The pricing model is per call, not per page, so you can test heavy documents without burning budget.
Skipping schema design and just “trying an LLM”:
Bem isn’t a generic LLM sandbox. Start by defining a JSON Schema that matches your system of record. That’s how you get enforceable guarantees and detect regressions over time.
Not tracking which calls are free vs paid:
In the console, monitor usage so you know when you’re approaching 100 calls/month. If you plan to go beyond that in a test, set up billing proactively to avoid hitting a hard stop.

Real-World Example

Imagine you’re running AP for a mid-size logistics company. Right now, invoices arrive as:

Scanned PDFs in email attachments
Photos from drivers
Multi-page statements with summaries plus line-item detail

You sign up for Bem, generate an API key, and:

Create a function ap_invoice_v1 with a schema that includes:
- invoice_number, vendor_id, invoice_date
- line_items[].description, line_items[].amount
- totals.subtotal, totals.tax, totals.total
Add enrichment against your vendor Collections to automatically match vendor names to canonical IDs with match confidence.
Wire a simple ingestion service that:
- Listens to your email inbox or S3 bucket
- Sends each inbound PDF or image to ap_invoice_v1
- Receives schema-enforced JSON and posts it directly to your ERP, unless confidence is low.
Configure a Surface so that any invoice where totals.total_confidence < 0.9 goes to a human for review.

Over the first month, you run 60–70 invoices through Bem as a “shadow pipeline.” All of that fits in the free 100 calls/month. You compare outputs to your golden set, compute F1 scores on key fields, and confirm that line-item totals match your ERP. Once you’re satisfied, you flip traffic from “shadow” to “write-through” and let Bem push approved packets directly into your system.

Pro Tip: Use your 100 free calls to build a proper eval harness, not just eyeball tests. Take a golden dataset of 50–100 documents, run them through Bem, and compute field-level F1, regression deltas, and failure modes. That’s how you know you’re production-ready, not just “AI-looking.”

Summary

Signing up for Bem and using the free 100 calls/month is straightforward:

Create an account at bem.ai and generate an API key.
Define at least one function/workflow with a real JSON Schema that mirrors your downstream system.
Start sending real-world inputs—PDFs, images, audio, threads—via the REST API, and inspect the schema-enforced JSON you get back.
Use the free quota to build an eval harness, explore Surfaces, and prove that Bem can replace manual entry or brittle OCR scripts for your actual packets.

No platform fees. No minimums. 100 free function calls each month to test real pipelines, not demos.

Next Step

Get Started