Confidence scores show how sure DigiParser is about each extracted value. They help you quickly see which values are safe to trust and which ones might need a human review.

When enabled, confidence scores appear:

• Next to fields in the document view
• In the data table and embed widget (when supported)
• In API responses as numeric values between 0.0 and 1.0

When you turn on Calculate confidence scores for extracted fields, DigiParser uses a consensus approach:

1. The document is processed multiple times using the same schema.
2. Each run suggests values for every field and table row.
3. DigiParser compares all runs field-by-field.
4. A final value is chosen for each field, and a confidence score is assigned based on how much the runs agree.

At a high level:

• If all runs agree, confidence is 1.0 (100%).
• If most runs agree, confidence is high but below 1.0.
• If the runs disagree a lot, confidence is lower.

Tables and arrays are handled row by row:

• Rows are aligned even if different runs return them in different orders.
• Each cell (e.g. Line Items → Quantity) gets its own confidence score.

You don’t need to configure any of this—just enable confidence scores in Parser Settings and DigiParser handles the rest.

Confidence scores always fall between 0.0 and 1.0. You’ll often see them as percentages in the UI (e.g. 82%).

In practice:

• Use 1.0 and high 0.9x values as “safe defaults” unless the field is business‑critical (e.g. payment amounts).
• Pay extra attention to fields in the 0.6–0.79 range.
• Treat anything below 0.6 as needing a human decision.

To turn on confidence scores for a parser:

1. Open your parser and go to Settings → Parser Settings.
2. Scroll to Parsing Configuration.
3. Find Calculate confidence scores for extracted fields.
4. Turn the toggle On.
5. Click Save Parser.

Once enabled, new documents processed by this parser will include confidence scores. Existing documents can be re-processed to add confidence scores.

Confidence scores use extra compute because DigiParser runs the extraction multiple times per page and compares the results.

However, enabling confidence scores does not use any additional credits beyond your normal document processing:

• Standard processing: 1 credit per page
• With confidence scores enabled: still 1 credit per page (no extra credits)

Other options like markdown parsing or using the accurate extraction model may increase credit usage. See Credits and Billing for full details.

Confidence scores are most useful when you’re deciding what to review first and what to send straight through.

When you open a document in the split view (original document on the left, extracted data on the right):

• Fields and table cells can show confidence visually (for example, as colors or tooltips).
• You can hover or click to see the exact percentage.

Use this to:

• Scan for low-confidence values and fix them directly.
• Focus on documents that have many low-confidence fields.

See Reviewing Extracted Data for the full review flow.

If you use Reviews & Approvals, you can build rules that look at confidence:

• Flag documents when overall confidence is low.
• Flag documents when a specific field has low confidence (e.g. Total Amount confidence < 80).

Example rules:

• Confidence < 80% – flag documents with low overall confidence.
• Line Items → Quantity confidence < 70% – flag when line item quantities don’t agree across runs.

See Setting Up Review Stages for how to add rules based on confidence.

When you call DigiParser’s APIs, confidence information is returned alongside your data.

In data responses, you’ll see a field_metadata object that mirrors your extracted data:

• Each simple field (e.g. email, total) has:
  • confidence_score: number between 0.0 and 1.0
• Each array or table has:
  • An array of metadata objects, one per item/row
  • Each nested field (e.g. education[0].degree, items[1].qty) includes its own confidence_score

This structure lets you:

• Decide which fields to trust automatically.
• Build your own review rules outside DigiParser.
• Store confidence scores in your own systems if needed.

In some exports and integrations, you’ll see confidence values:

• As a confidence field directly on each extracted field or table cell.
• As a flattened confidence_score object that follows the same shape as your flattened data.

The numeric meaning is always the same:

• 1.0 = all runs agreed exactly
• Lower values = more disagreement across runs

Confidence scores are especially helpful when:

• You process high‑value documents (e.g. invoices, contracts, payroll).
• You want to sample and review only risky documents instead of checking everything.
• You’re rolling out a new parser and want extra visibility into extraction quality.

They may be less critical when:

• You’re processing low‑risk documents.
• You already have a strong manual QA process and don’t need automated triage.

• Start with one parser: Enable confidence scores on a single parser first and see how they behave on real documents.
• Use rules, not just eyeballing: Combine confidence scores with Reviews & Approvals rules to automatically flag risky documents.
• Monitor performance: Confidence scores can increase processing time slightly—enable them where they provide the most value.
• Focus on key fields: Pay the most attention to confidence on critical fields like totals, dates, and identifiers.

• Parsing Configuration – Other parsing options (pages, file types, markdown)
• Reviewing Extracted Data – How to review and correct extracted values
• Setting Up Review Stages – Flag documents based on confidence and other rules
• Credits and Billing – How credits are calculated