New Era of Precision: Introducing Field Groups, Monetary Quantities, and Enhanced Validation

[Ioana_Gligan]

Processing documents isn’t just about reading text anymore; it’s about understanding the relationships between data points. We are excited to announce that these latest UiPath Document Understanding updates are now available in Public Preview, focusing on making your taxonomies more intuitive and your post-extraction logic more powerful.

Field Groups: Logic Meets Structure

Say goodbye to flat, messy lists of fields. You can now define Field Groups in your taxonomy.

• What it is: A logical container that bundles related “simple” fields together.
• Why it matters: This allows you to capture complex, hierarchical relationships. For instance, in a healthcare use case, you might need to capture a list of Patients, where each patient entry contains a Name, and a Date of Birth, along with a nested list of Doctor’s Visits. Each visit then holds its own specific fields like Date, Provider Name, and Diagnosis. This ensures your data maintains its real-world hierarchy throughout the automation.
• Supported in:
  • UiPath.IntelligentOCR.Activities: Field groups are currently supported for IXP extraction, and can be used interchangeably with Tables for DU Modern or Classic projects, where a table field defined in a model can be mapped, in your automation, to a field group.
  • UiPath.DocumentUnderstanding.Activities: if you opt to use the latest Public Preview package, starting with this release, ALL IXP extraction results will be reported as Field Groups instead of Tables, just like you define them in your IXP project.
  • UiPath Document Understanding APIs: Version 2.0 of the APIs reports IXP extraction results as field groups instead of tables.
  • UiPath.DocumentProcessing.Contracts: New field type, new related functionality.
    • Do check out how the ExportExtractionResults output structure changes, to accommodate for Field Groups and remain consistent
    • Also check out a few sections below on improvements on HOW to easily manipulate your extraction results!
  • Validation Station: yep, see for details.

The New “Monetary Quantity” Field Type

Handling currency has always been a multi-step headache—until now.

• The Upgrade: We’ve introduced the Monetary Quantity field type. It doesn’t just capture a number; it intelligently links the Value and the Currency into a single data object.
• The Benefit: No more building custom logic to “guess” which currency symbol belongs to which total. The model now treats them as a cohesive unit, streamlining financial workflows.
• Supported in:
  • UiPath.IntelligentOCR.Activities: Taxonomy Manager now allows you to define monetary quantity fields, and map them to extractor fields in ConfigureExtractors. Each such field will have a formatted value of the form <numericValue> <currency>, where the numeric value is captured and treated just like a Number field, and the Currency is a string.
  • UiPath.DocumentUnderstanding.Activities: if you opt to use the latest Public Preview package, starting with this release, ALL IXP extraction results will have the proper Field Type (Date, Number, Monetary Quantity), just like you define them in your IXP project.
  • UiPath Document Understanding APIs: Version 2.0 of the APIs reports IXP extraction results with all field types as defined in the IXP project, including Monetary Quantities, Dates, Numbers, as well as Field Groups.
  • UiPath.DocumentProcessing.Contracts: New field type, new related functionality.
    • Monetary Quantity field values contain two DerivedParts, a Value corresponding to the numeric part, and a Currency, corresponding to the associated coin (if any).
    • Also check out a few sections below on improvements on HOW to easily manipulate your extraction results!
  • Validation Station: yep, see for details.

Validation Station: A Face-Lift for Complex Data

To support these new types, the UiPath Validation Station has been upgraded with a more intuitive UI:

• Field Group Display: Field Groups offer visually nested placement of the child fields, making it clear to human validators how data points relate to one another.
• Currency-Aware Editing: Validating Monetary Quantities is now seamless, with dedicated inputs for both the amount and the currency code, reducing manual entry errors.
• Current Limitation: the Validation Control in Apps does not yet expose methods for manipulating field group and child values and value changes. This is a work in progress and will be coming a bit after this Public Preview release.

Before Field Group support, it was hard / next to impossible to structure any “table within table” needs. Starting with this update, you can use:

• simple fields
• table fields
• field groups with
  • simple fields
  • table fields
  • field groups with
    • simple fields
    • table fields

(this is the max depth supported by Validation Station: table within field group within field group).

For the Devs: Advanced Navigation in UiPath.DocumentProcessing.Contracts

We know that programmatically navigating the ExtractionResult object can be complex, especially with nested data. To solve this, we are publishing a new Navigator (Helper) Class within the UiPath.DocumentProcessing.Contracts package.

• Simplified CRUD Operations: This helper class provides a streamlined way to find, add, edit, or delete any value—including values for Tables, Field Groups, and child fields.
• Deep Access: Whether you are working with Tables (navigating through rows and specific cells) or the new Field Groups (drilling down into child fields and multiple values), the Navigator handles the heavy lifting.
• Cleaner Code: Developers can now manipulate complex document structures with fewer lines of code, ensuring that post-processing logic is both readable and maintainable.

Public APIs New Version

To support all this shiny new functionality , we are also releasing a V2.0 of the Document Understanding APIs. They contain a host of new features.

• new Predefined Non-Latin project available: a new Predefined project available, focused on centralizing out-of-the-box data extraction resources available for Non-Latin languages
• new IXP extraction features: field groups, monetary quantities along with ALL field types coming from IXP are now properly reported in the extraction result
• new (simplified) predefined projects usage: all predefined projects now also expose a tag and a version (default values) to ease the discovery and the use of the out-of-the-box resources for data extraction.
• new taxonomy input support for document validation task creation: you can now (optionally) send a taxonomy along with the extraction result to the validation endpoint, thus allowing you to take advantage of the taxonomy settings that govern Validation Station display: date and number display settings, confidence thresholds, validator notes, business rules etc.

---

How-To: Using the ExtractionResult Navigator

The new helper class acts as a “pointer” that allows you to traverse the hierarchy of your document results without manually iterating through nested ResultsDataPoints.

Sharing here a sample code that show how the Navigator is used in an out-of-this-world scenario , in which data from a multi-value Field Group containing a child multi-value repeating Field Group (like in the example), needs to be moved to a different multi-value Field Group that contains a child table instead of the child field group.

It would look like this:

var handler = new UiPath.DocumentProcessing.Contracts.Extensions.Navigator.V1.ExtractionResultHandler(extraction);

// navigate through all instances of the original field group that I want to move data from
foreach (var patient in handler.GetFieldGroup("Patient History With Field Group Child").Values) {
	// create a new empty value in the target field group
	var taxonomyFieldForMyNewStructure = taxonomy.DocumentTypes
		.Single(d => d.Name == "Medical Records of Middle Earth")
		.Fields.Single(f => f.FieldName == "Patient History With Table Child");
	var newPatient = handler.GetFieldGroup("Patient History With Table Child").AddEmptyValue(taxonomyFieldForMyNewStructure);
	
	// move general patient info to the new field group general patient info
	foreach (var simpleField in patient.GetSimpleFields()) {
		if (!simpleField.IsMissing) {
			newPatient.GetSimpleField(simpleField.FieldName).AddValue(simpleField.Value.GetRawResultsValue());
		}
	}
	
	// prepare the table data structure within my new field group value instance
	var taxonomyFieldForMyNewSubTable = taxonomyFieldForMyNewStructure.Components.Single(c => c.FieldName == "Medical Interventions");
	var newInterventions = newPatient.GetTable("Medical Interventions").InitializeIfMissing(taxonomyFieldForMyNewSubTable).Value;
	
	// move the data
	foreach (var intervention in patient.GetFieldGroup("Medical Interventions").Values) {
		var newRow = newInterventions.AddEmptyRow(taxonomyFieldForMyNewSubTable);
		foreach (var interventionFieldWithValue in intervention.GetSimpleFields().Where(f => !f.IsMissing)) {
			// I don't really care about the confidence or the reference, especially for the multi-value field, so here's a trick for adding a no reference value
			if (interventionFieldWithValue.Values.Length > 1) {
				newRow[interventionFieldWithValue.FieldName].AddValue(string.Concat(interventionFieldWithValue.Values.Select(v => v.Value+";")), 1);
			}
			// else I preserve everything
			else {
				newRow[interventionFieldWithValue.FieldName].AddValue(interventionFieldWithValue.Value.GetRawResultsValue()); 
				// need the .GetRawResultsValue() to make sure I preserve everything from the original field value, including references.
			}
		}
	}
}

To help you get started with some tests, here’s an input ExtractionResult and an input Taxonomy:
original lotr results.json
taxonomy.json
fileToUse.jpeg

Steps to recreate :

• read the results file using Read Text File
• create an ExtractionResult object by using ExtractionResult.Deserialize(fileContentReadPreviouslyString)
• read the taxonomy file using a Read Text File
• create a Taxonomy object by using DocumentTaxonomy.Deserialize(fileContentReadPreviouslyString)
• put the code above in an Invoke Code, C# flavor, having the extraction result and the loaded taxonomy as arguments.

Result:

---

Conclusion

These updates represent a shift toward object-oriented document processing. By allowing you to group fields and handle currency as a unified quantity, we’re making it easier to automate complex use cases like international trade, multi-entity invoicing, and detailed medical record processing.

Got Feedback or Questions?

You know we’re always listening - and very glad to get any feedback you have for us! Looking forward to hearing what you think about these new features.

[edevries (Peter Griffin)]

Good work fellas’, drinks on me at the clam tonight!

The ExtractionResult Navigator is something I will check out. I have wished this class was easier to work with/manipulate since I starting working with Document Understanding. Look forward to this update.