Bem vs Unstructured: which is better for turning PDFs into strict JSON with field-level confidence and auditability?

Most teams can get a PDF “demo parser” working in an afternoon. The problem shows up two weeks later—when you’re debugging silent failures, reconciling totals that don’t add up, and trying to explain to auditors why a model “probably” got the right answer. That’s the line between a convenient extraction library and a production layer for unstructured data.

Quick Answer: If you just need to crack PDFs into text and basic elements inside your own custom pipeline, Unstructured is a solid, flexible toolkit. If you need schema-enforced JSON, field-level confidence, hallucination detection, exception routing, and an auditable workflow that your ERP and compliance team can trust, Bem is the better choice. Unstructured is a parsing library; Bem is a production system for strict, observable outputs.

Why This Matters

Parsing PDFs is cheap. Running a business on the outputs is not.

If your invoices, contracts, statements, claims packets, or onboarding documents feed real money movement or customer decisions, you cannot ship on vibes. You need:

• Strict types and enums, not “close enough” strings.
• Field-level confidence, not a single fuzzy score.
• Explicit exceptions instead of silent failures.
• Versioned workflows and evals, not one-off scripts.

This is exactly where Bem and Unstructured diverge. Both help you move from PDFs to JSON, but they sit at different layers of the stack. One is a pre-processing and parsing toolkit; the other is an opinionated, event-driven pipeline that treats accuracy and auditability as first-class concerns.

Key Benefits:

• Predictable, schema-valid output: Bem enforces your JSON Schema at the architecture level—outputs are either valid or surfaced as exceptions, with no “best-effort” surprises downstream.
• Field-level confidence & hallucination detection: Every important field comes with confidence scores and hallucination checks, making it easy to route edge cases to humans instead of guessing.
• Production-ready workflows and governance: Versioned functions, idempotent workflows, webhooks, and review surfaces give you the observability and control that raw parsing libraries and ad-hoc glue code can’t.

Core Concepts & Key Points

Concept	Definition	Why it's important
Strict JSON Schema	A predefined, enforced structure (types, enums, required fields) that every output must conform to.	Stops bad data at the gate. No half-baked JSON flowing into your ERP or product—either it’s valid, or you see the exception.
Field-Level Confidence & Hallucination Detection	Per-field scores and checks indicating how reliable a value is, and whether it might be fabricated.	Lets you route low-confidence or suspect fields to review, instead of trusting a single aggregate score or eyeballing CSVs.
Auditable, Idempotent Workflows	Deterministic pipelines with versioning, trace logs, and safe re-runs that produce the same result for the same input.	Critical for regulated workflows, debugging, and regression testing—especially when your PDFs drive payments, claims, or compliance.

Bem vs Unstructured: Where They Sit in Your Stack

Before we go step-by-step, it’s useful to be clear about the category difference.

• Unstructured (the library) focuses on:

  • Parsing: segmenting documents into elements (text, tables, headers, images).
  • Normalization: cleaning and standardizing content for downstream models.
  • Flexibility: you own the pipeline—LLM prompts, schemas, retries, evals, UI, everything.

• Bem focuses on:

  • End-to-end workflows: Route → Split → Transform → Join → Enrich → Validate → Sync.
  • Schema-enforced outputs: JSON Schema as contract; explicit exceptions when violated.
  • Production controls: evals, F1 scores, regression testing, versioned functions, idempotent execution, review surfaces, and enterprise deployments (SOC 2, HIPAA, GDPR, on-prem).

If you think in terms of “what code do I still need to write?”:

• With Unstructured, you still need to:

  • Manage LLM calls and prompts.
  • Define and enforce your JSON schema.
  • Handle confidence scoring and hallucinations.
  • Build exception handling, review UIs, and reprocessing flows.
  • Add observability, evals, and versioned rollbacks.

• With Bem, you:

  • Define your schema and workflow once.
  • Send PDFs (or emails, images, audio, threads) to a single endpoint/function.
  • Get schema-valid JSON or structured exceptions, with confidence and audit trails.

How It Works (Step-by-Step)

Let’s walk through the concrete path from “raw PDF” to “strict JSON with field-level confidence and auditability” in both worlds.

1. Ingestion & Parsing

Unstructured:

• You choose an ingestion pattern: local file system, S3, web, etc.
• Run the document through partition_pdf or similar functions.
• Get back a list of elements (paragraphs, tables, titles, etc.) with metadata.
• From there, you must:
  • Decide which elements map to which fields.
  • Handle edge cases (multi-page tables, rotated text, headers/footers).
  • Feed these into an LLM or rules engine.

Bem:

• You send a REST call to a Bem function or workflow with your PDF as input:
  • POST /v1/functions/invoice_extraction:run
  • Body: file upload, URL, or base64.
• Bem’s internals Route and Split the document as needed:
  • Multi-page PDFs, mixed packets, attachments, scans—they’re all handled by primitives, not bespoke scripts.
• You don’t interact with elements directly unless you want to; you interact with the final schema.

Key difference: Unstructured exposes parsing primitives; Bem exposes production outcomes. You’re not in the loop on page boundaries unless your workflow needs it.

2. Structuring Into Strict JSON

Unstructured:

• You design your target data model.
• You orchestrate LLM calls (or custom rules) to:
  • Extract values from the parsed elements.
  • Validate types and formats.
  • Normalize vendor names, dates, currencies, etc.
• You implement your own schema checks:
  • If it fails, you decide whether to block, repair, or log and continue.
• Responsibility for correctness is on your code and prompts.

Bem:

• You define your JSON Schema (or use a prebuilt template) for the output:
  • Example: invoice { header, vendor, line_items[], totals, tax, payment_terms }.
  • Types, enums, required fields, constraints—fully defined.
• Bem’s workflow uses Transform and Enrich steps to map unstructured content into that schema:
  • LLMs are orchestration details inside Bem, not your problem to wire.
• Schema enforcement is architectural:
  • If output is not schema-valid, it is not “quietly accepted.”
  • The workflow flags an exception with structured error details (which field failed, why).

Key difference: With Unstructured, schema validation is whatever you bolt on. With Bem, schema validity is the contract—no valid JSON, no “success.”

3. Field-Level Confidence and Hallucination Detection

Unstructured:

• The core library doesn’t provide field-level model confidence out of the box because it doesn’t own your extraction logic.
• You must:
  • Implement your own scoring or use LLM probability tooling.
  • Decide what thresholds route to human review.
  • Detect hallucinations by comparing extracted values against sources or reference data.

Bem:

• Every field can carry per-field confidence:
  • E.g., vendor_name: { value: "Acme Corp", confidence: 0.97 }.
• Bem performs hallucination detection:
  • Compares fields to source spans and patterns.
  • Flags values that don’t appear in the document or conflict with constraints.
• Workflows can use thresholds:
  • If total_amount.confidence < 0.9 → route to human review surface.
  • If hallucination risk is high → mark as exception.

Key difference: Field-level confidence and hallucination checks are first-class primitives in Bem, not DIY add-ons. That’s what enables safe automation at scale.

4. Auditing, Versioning, and Idempotency

Unstructured:

• You build the pipeline:
  • Orchestrator (Airflow, Prefect, custom queue).
  • Logging and tracing (Datadog, OpenTelemetry).
  • Versioning for prompts and model settings.
• Idempotency is manual:
  • You decide how to deduplicate and safely re-run documents.
• Auditability depends on how much instrumentation you add:
  • Inputs, outputs, and intermediate states must be logged and linked to document IDs.

Bem:

• Every function and workflow is versioned:
  • You can roll forward/back, run A/B comparisons, and track changes over time.
• Idempotent execution:
  • Safe re-runs for the same input (e.g., reprocess a document with a new workflow version) without double-posting to downstream systems.
• Audit trails:
  • Every call is traceable: input artifacts, intermediate steps, outputs, exceptions.
  • Ideal for regulated industries and internal investigations.
• Evals and regression testing:
  • You can run golden datasets through new versions, measure F1 scores, and see exactly where accuracy changed.

Key difference: Unstructured gives you building blocks; Bem gives you a governed, observable, rollbackable system.

5. Syncing to ERP / Downstream Systems

Unstructured:

• After extraction, you:
  • Write the code to transform data into your ERP schema.
  • Build retry logic, dead-letter queues, and reconciliation scripts.
  • Maintain custom integrations for each downstream system.

Bem:

• You get ERP-ready JSON:
  • Fields, types, and constraints already aligned with your ERP or internal API.
• Delivery options:
  • REST responses, webhooks/subscriptions, polling.
• Idempotent sync:
  • Safe, exactly-once semantics when pushing into systems like SAP, NetSuite, or Dynamics.
• Collections-based enrichment:
  • Enrich output with vendor master lists, GL codes, customer DBs, with match confidence.
  • Turn “Acme Corp” in the PDF into vendor_id: 58231, match_confidence: 0.99.

Key difference: With Unstructured you build the sync layer; Bem assumes “system-ready” as part of the job.

Common Mistakes to Avoid

• Treating parsing as the same problem as production.
  Parsing the PDF correctly is maybe 20% of the work. The rest is schema enforcement, edge-case handling, review flows, and making sure nothing silently breaks on page 17 of a 50-page packet. Don’t select tooling on parsing alone.

• Ignoring confidence, hallucinations, and evals.
  If you ship extraction without per-field confidence and evals, you will eventually get burned—usually when volumes are high and a subtle change slips into production. Set thresholds, run golden datasets, and treat accuracy like code coverage.

Real-World Example

A finance team needs to process tens of thousands of multi-page invoices per week across hundreds of vendors. The requirements are blunt:

• Totals, including line items, must be correct.
• Every output must conform to an internal JSON Schema the ERP team owns.
• Low-confidence or unusual invoices must go to human review, not slip through.
• Auditors must be able to reconstruct “what happened” for any invoice ID.

With Unstructured, the team might:

1. Use partition_pdf to break invoices into elements.
2. Write custom mapping logic: regexes + LLM prompts to detect vendors, dates, and line items.
3. Implement ad-hoc schema checks in application code.
4. Bolt on a simple admin UI to review “failed” invoices.
5. Add logging and metrics over time as issues arise.

They get flexibility—but also a long tail of maintenance. When a large vendor changes their invoice layout, suddenly line items misalign. No one notices until reconciliations go off. Fixing requires code changes, re-deploys, and backfills.

With Bem, the same team:

1. Defines a strict invoice schema, with field types, enums, and required fields.
2. Stitches a workflow: Route invoices, Transform content, Enrich with vendor master data, Validate against schema, Sync to ERP.
3. Sets confidence thresholds:
   • Totals and line items must be ≥ 0.95 confidence.
   • Anything lower auto-routes to a Bem Surface for human review.
4. Uses golden datasets to evaluate new workflow versions and track F1 scores before rollouts.
5. Lets Bem push validated invoices into the ERP via an idempotent sync.

Result: “Totals including line items were 100% accurate” in production conditions, not just a sandbox demo. Millions of documents can be processed weekly, and every decision is auditable.

Pro Tip: If your PDF pipeline touches money, compliance, or critical customer data, start by writing your JSON Schema and evaluation plan—then choose the platform that makes schema enforcement, confidence thresholds, and regression testing first-class, not bolt-ons.

Summary

Unstructured and Bem are not interchangeable tools; they solve different layers of the problem.

• Choose Unstructured if:

  • You want a flexible parsing toolkit.
  • You’re comfortable building and owning the entire extraction pipeline, from LLM prompts to safety checks and review UIs.
  • “Library + lots of custom code” fits your team’s bandwidth and risk profile.

• Choose Bem if:

  • You need strict, schema-enforced JSON with field-level confidence out of the box.
  • You care about hallucination detection, explicit exceptions, and human-in-the-loop review.
  • You want versioned, auditable workflows with evals, regression testing, and safe rollbacks.
  • Your PDFs feed real operations—AP, claims, logistics, onboarding—and you can’t afford silent failures.

Agents guess. Parsing libraries parse. Production systems need to do more: enforce schemas, expose confidence, route exceptions, and keep your workflows running cleanly at scale. That’s the gap Bem is built to fill.

Next Step

Get Started