Document Intelligence

Document Intelligence is a workflow pattern in Atlas that lets users upload receipts or documents, automatically extract structured data from them using OCR, and then pre-populate an Item List with the extracted items — so users only have to review and confirm, rather than type everything by hand.

This pattern is ideal for claim flows where users need to report multiple expense items (medical receipts, travel costs, purchase invoices, etc.) that they already have as physical or digital documents.

What you get out of the box

Automatic extraction — Atlas reads uploaded images and pulls out item descriptions, prices, merchant names, and transaction dates.
AI-suggested table — Before the user starts adding items manually, the Item List shows a pre-populated table of suggested rows — one row per extracted receipt line.
One-click pre-fill — The user clicks a row in the suggested table and an item form opens with all fields already filled in. They can accept the values or edit them.
Confidence filtering — Only results with at least 80 % OCR confidence are shown, keeping noise out of the suggestions.
Multiple receipts — Items from all uploaded files are merged into a single list.

The three building blocks

The workflow consists of three nodes wired together in sequence:

┌─────────────────────┐
│  FileUpload Node    │  ① User uploads receipt image(s)
└────────┬────────────┘
         │  [fileUpload.UploadedFileData]
         ▼
┌─────────────────────┐
│  OCR Logic Item     │  ② Atlas extracts items, prices, dates, merchant
└────────┬────────────┘
         │  [ocr.Items]
         ▼
┌─────────────────────┐
│  Item List Node     │  ③ AI-suggested table + manual item entry
│  (ListFromCarousel) │
└─────────────────────┘

Node	Role
File Upload Node	Collects the receipt files from the user and exposes them as structured upload data.
OCR Logic Item (backend)	Reads the uploaded files, calls the OCR service, and writes the extracted items to the conversation value bag.
Item List Node (`ListFromCarousel`)	Displays the extracted items as a prefill suggestion table and manages the user's confirmed item list.

How the data flows

1 — User uploads files

The File Upload node stores the uploaded receipts in its UploadedFileData output property. Give the node a variable name — for example fileUpload — so that the OCR node can reference it.

2 — OCR extracts the data

The OCR Logic Item receives the file paths from [fileUpload.UploadedFileData], sends each file to the OCR service, and writes the results to the conversation value bag:

Value bag key	Content
`Items`	JSON array — one entry per receipt line item
`MerchantName`	Name of the merchant (from the first receipt)
`TransactionDate`	Transaction date (from the first receipt)
`Total`	Total amount (from the first receipt)
`Result`	Status: `Ok`, `NoDataFound`, `SearchDataNotProvided`, or `Exception`

Each item in the Items array looks like this:

{
  "Description": "Wireless Mouse",
  "TotalPrice": "29.90",
  "MerchantName": "Demo Store",
  "TransactionDate": "2026-05-07"
}

Items from multiple uploaded receipts are merged into one list. Each item carries the merchant name and date from its own receipt file, so the provenance is always correct.

3 — Item List shows the suggestions

The Item List node receives the Items array via its PrefillData input — set this to [ocr.Items]. It renders a preliminary table above the standard item list. The user can:

Review each suggested row (description, amount, date, merchant).
Click a row to open the regular Add Item form — with all fields pre-filled from that row.
Edit any pre-filled value before confirming.
Skip rows they do not want to include.

Once a row has been used to create an iteration it is marked as used and greyed out in the suggestion table.

How to build it in Atlas Editor

A complete reference flow is available in the Atlas Editor:
RT_HP_OCR_W_ItemList

Step 1 — File Upload node

Add a File Upload Node to your canvas.
Give it a variable name, e.g. receiptUpload.

Step 2 — OCR Logic Item

Add an OCR Logic Item after the File Upload node.
Set FullUploadedFilePaths to [receiptUpload.UploadedFileData].
Give it a variable name, e.g. ocr. Its Items output will be available as [ocr.Items].

Step 3 — Container node (item form)

Add a Container Node linked to a sub-flow with your item questions.
Inside the sub-flow, make sure there is a Start Node — pre-fill values land here.
On any input field you want pre-filled, set its Default value to the matching Start.* variable:

Field	Default value
Description	`[Start.Description]`
Amount	`[Start.TotalPrice]`
Date	`[Start.TransactionDate]`
Merchant	`[Start.MerchantName]`

You don't have to use all of them — pick whichever make sense for your form.

Step 4 — Item List node

Add a List From Carousel Node after the OCR Logic Item.
Set Carousel variable to the Container node from Step 3.
Set Prefill data to [ocr.Items].
Set Prefill table definition using the Data Source Composer, or paste JSON directly:

[
  { "title": "Description", "value": "Description", "isSummable": false },
  { "title": "Amount", "value": "TotalPrice", "isSummable": true },
  { "title": "Date", "value": "TransactionDate", "isSummable": false },
  { "title": "Merchant", "value": "MerchantName", "isSummable": false }
]

Optionally set Show total sum, Total sum label, and Total sum units if you want a sum row at the bottom of the suggestion table.

End-to-end example — health claim with receipt

This is what a complete health insurance claim flow looks like with Document Intelligence.

Flow structure

Start
  └─ Section: "Upload your receipts"
       └─ FileUpload Node [receiptUpload]
            └─ OCR Logic Item [ocr]
                 └─ Section: "Your expense items"
                      └─ Container Node [itemCarousel]  ← item sub-flow
                      └─ Item List Node                 ← prefill from [ocr.Items]
                           └─ Section: "Summary"

What the user sees

Upload step — User drops in one or more receipt photos.
Expense items step — The Item List opens with a "AI-suggested items" table at the top, showing all extracted receipt lines. Below that is the regular, currently empty item list.
User clicks a row — The Add Item form opens with Description, Amount, Date, and Merchant already filled in.
User confirms or edits — User submits the form. The row in the suggestion table is greyed out.
User adds remaining items — They work through the suggestion table or add items manually.
Done — The completed item list is saved and the flow continues.

OCR node input

FullUploadedFilePaths = [receiptUpload.UploadedFileData]

Item List prefill configuration

PrefillData              = "[ocr.Items]"
PrefillTableDefinition   = "[{\"title\":\"Description\",\"value\":\"Description\",\"isSummable\":false},{\"title\":\"Amount\",\"value\":\"TotalPrice\",\"isSummable\":true}]"
ShowTotalSum             = "true"
TotalSumLabel            = "Total"
TotalSumUnits            = "EUR"

Item sub-flow Start node variables used as defaults

Question in form	Default value	Prefill source
What was purchased?	`[Start.Description]`	OCR description
Amount (EUR)	`[Start.TotalPrice]`	OCR line price
Date of purchase	`[Start.TransactionDate]`	OCR transaction date
Store / merchant	`[Start.MerchantName]`	OCR merchant

Tips and good practices

Keep the suggestion table focused
Only include the columns that are relevant to your claim form. A shorter suggestion table is easier to scan. Three to four columns is usually the sweet spot.

Always test with real receipt photos
OCR confidence varies by image quality. Test with the kinds of receipts your users will actually upload — phone photos of crumpled receipts, scanned PDFs, etc. — to make sure the extraction rate meets your expectations.

Confidence threshold is fixed at 80 %
Items below this threshold are silently discarded. If certain fields consistently fail to appear, check whether the receipt format is clearly legible.

Pre-fill values are defaults, not locked values
Users can always edit any pre-filled field. The [Start.*] values are just defaults — the user remains in control. Make sure your form validates the final user-submitted value, not the pre-filled suggestion.

You can use any subset of Start variables
If your form does not ask for merchant name, simply do not add [Start.MerchantName] anywhere. Unused Start properties are silently ignored.

Multiple receipts work automatically
You do not need to do anything special to support multiple uploaded files. Items from all receipts are merged and presented together in the suggestion table.

OCR Extraction Node — details on the extraction process, supported fields, and confidence filtering.
Item List Prefill — deep-dive on how the prefill table and candidate IDs work.
Variables — how [variableName.property] references work across nodes.

What you get out of the box​

The three building blocks​

How the data flows​

1 — User uploads files​

2 — OCR extracts the data​

3 — Item List shows the suggestions​

How to build it in Atlas Editor​

Step 1 — File Upload node​

Step 2 — OCR Logic Item​

Step 3 — Container node (item form)​

Step 4 — Item List node​

End-to-end example — health claim with receipt​

Flow structure​

What the user sees​

OCR node input​

Item List prefill configuration​

Item sub-flow Start node variables used as defaults​

Tips and good practices​

Related concepts​