- Overview
- Document Processing Contracts
- Release notes
- About the Document Processing Contracts
- Box Class
- IPersistedActivity interface
- PrettyBoxConverter Class
- IClassifierActivity Interface
- IClassifierCapabilitiesProvider Interface
- ClassifierDocumentType Class
- ClassifierResult Class
- ClassifierCodeActivity Class
- ClassifierNativeActivity Class
- ClassifierAsyncCodeActivity Class
- ClassifierDocumentTypeCapability Class
- ContentValidationData Class
- EvaluatedBusinessRulesForFieldValue Class
- EvaluatedBusinessRuleDetails Class
- ExtractorAsyncCodeActivity Class
- ExtractorCodeActivity Class
- ExtractorDocumentType Class
- ExtractorDocumentTypeCapabilities Class
- ExtractorFieldCapability Class
- ExtractorNativeActivity Class
- ExtractorResult Class
- FieldValue Class
- FieldValueResult Class
- ICapabilitiesProvider Interface
- IExtractorActivity Interface
- ExtractorPayload Class
- DocumentActionPriority Enum
- DocumentActionData Class
- DocumentActionStatus Enum
- DocumentActionType Enum
- DocumentClassificationActionData Class
- DocumentValidationActionData Class
- UserData Class
- Document Class
- DocumentSplittingResult Class
- DomExtensions Class
- Page Class
- PageSection Class
- Polygon Class
- PolygonConverter Class
- Metadata Class
- WordGroup Class
- Word Class
- ProcessingSource Enum
- ResultsTableCell Class
- ResultsTableValue Class
- ResultsTableColumnInfo Class
- ResultsTable Class
- Rotation Enum
- Rule Class
- RuleResult Class
- RuleSet Class
- RuleSetResult Class
- SectionType Enum
- WordGroupType Enum
- IDocumentTextProjection Interface
- ClassificationResult Class
- ExtractionResult Class
- ResultsDocument Class
- ResultsDocumentBounds Class
- ResultsDataPoint Class
- ResultsValue Class
- ResultsContentReference Class
- ResultsValueTokens Class
- ResultsDerivedField Class
- ResultsDataSource Enum
- ResultConstants Class
- SimpleFieldValue Class
- TableFieldValue Class
- DocumentGroup Class
- DocumentTaxonomy Class
- DocumentType Class
- Field Class
- FieldType Enum
- FieldValueDetails Class
- LanguageInfo Class
- MetadataEntry Class
- TextType Enum
- TypeField Class
- ITrackingActivity Interface
- ITrainableActivity Interface
- ITrainableClassifierActivity Interface
- ITrainableExtractorActivity Interface
- TrainableClassifierAsyncCodeActivity Class
- TrainableClassifierCodeActivity Class
- TrainableClassifierNativeActivity Class
- TrainableExtractorAsyncCodeActivity Class
- TrainableExtractorCodeActivity Class
- TrainableExtractorNativeActivity Class
- Document Understanding Digitizer
- Document Understanding ML
- Document Understanding OCR Local Server
- Document Understanding
- Release notes
- About the Document Understanding activity package
- Project compatibility
- Configuring external connection
- Set PDF Password
- Merge PDFs
- Get PDF Page Count
- Extract PDF Text
- Extract PDF Images
- Extract PDF Page Range
- Create Validation Task and Wait
- Wait for Validation Task and Resume
- Create Validation Task
- Create Classification Validation Task
- Create Classification Validation Task and Wait
- Wait for Classification Validation Task and Resume
- Intelligent OCR
- Release notes
- About the IntelligentOCR activity package
- Project compatibility
- Configuring Authentication
- Load Taxonomy
- Digitize Document
- Classify Document Scope
- Keyword Based Classifier
- Document Understanding Project Classifier
- Intelligent Keyword Classifier
- Create Document Classification Action
- Create Document Validation Artifacts
- Retrieve Document Validation Artifacts
- Wait For Document Classification Action And Resume
- Train Classifiers Scope
- Keyword Based Classifier Trainer
- Intelligent Keyword Classifier Trainer
- Data Extraction Scope
- Document Understanding Project Extractor
- RegEx Based Extractor
- Form Extractor
- Intelligent Form Extractor
- Create Document Validation Action
- Wait For Document Validation Action And Resume
- Train Extractors Scope
- Export Extraction Results
- Validating documents with App actions
- Manual validation for digitize documents
- Anchor-based data extraction using Intelligent Form Extractor
- Validation station
- ML Services
- OCR
- OCR Contracts
- Release notes
- About the OCR Contracts
- Project compatibility
- IOCRActivity Interface
- OCRAsyncCodeActivity Class
- OCRCodeActivity Class
- OCRNativeActivity Class
- Character Class
- OCRResult Class
- Word Class
- FontStyles Enum
- OCRRotation Enum
- OCRCapabilities Class
- OCRScrapeBase Class
- OCRScrapeFactory Class
- ScrapeControlBase Class
- ScrapeEngineUsages Enum
- ScrapeEngineBase
- ScrapeEngineFactory Class
- ScrapeEngineProvider Class
- OmniPage
- PDF
- [Unlisted] Abbyy
- [Unlisted] Abbyy Embedded

Document Understanding Activities
Validating documents with App actions
This quickstart guide helps you start validating documents by adding the Validation Station within UiPath® Action apps, and then sending them out for validation through Action Center as App actions. The tutorial uses UiPath Studio to automate the document processing, UiPath Apps to for displaying the validation station, and Action Center for performing the validation. The document type that is used in the examples throughout this tutorial is a health insurance form, of type CMS 1500 claim form.
The overview steps of this quickstart guide are:
- Build the Action app that displays the Validation Control.
- Use a previously configured app to design the Studio automation that processes the document, and sends it out for validation in Action Center.
- Complete the action within Action Center.
Prerequisites
Make sure your tenant:
- Has sufficient Robot units since the app runs using Serverless robots.
- A Serverless robot template is created in Orchestrator and provisioned. For more information on serverless robots and adding them to a tenant, visit Executing unattended automations with Serverless robots.
1. Create an Action app
To create an Action app, follow these steps:
- Go to Studio Web.
- Select Create New > App to create a new project.
- Within the Project
Explorer of your app, select Add pages, workflows, controls,
integrations > Action.
This step adds an Action to your app, and lets you configure an action schema for it.
- Expand Action, and select
ActionSchema.
Configure the action schema with the In and Out arguments that you want for App actions in Action Center.
- For Outcomes, add
other custom outcomes that you want the action to have.
For example, you can add the a custom outcome, named "Approve".
- For Input
Properties, add properties for data that you want to pass into
the action.
These properties will appear in the Create App Task activity, when this app is selected from the Apps dropdown list. Input properties allow you to pass data from your Studio automation to your action.
- For Output
Properties, add properties for arguments that you want to
retrieve from the action.
These properties will be accessible from the Wait for App Task and Resume activity, through the Task Object (Output) variable.
- For Input/Output
properties, add properties that function as In/Out arguments in your
Studio automation.
These Input/Output properties first appear as properties in the Create App Task activity, that you pass to the action. And then, after the action is completed, you can access the same properties, that were updated, from the Wait for App Task and Resume activity, through the Task Object (Output) property.
- For Outcomes, add
other custom outcomes that you want the action to have.
2. Add and customize the Validation Control
A Validation Control incorporates the Validation Station, used in document processing workflows. To add and customize a Validation Control within an Action app, follow these steps:
- Open the desired Action app, where you want to incorporate the Validation Station.
- Select Open toolbox.
- Under Display, find the
Validation Control, and add it into your app.
Adding the Validation Control to your app automatically creates a
Var<ValidationControl_PageName>
variable under the App variables section from your app's Project Explorer.Note: You can use the Validation Control and the corresponding App Variable to read information from the Validation Control. Use theVar<ValidationControl_PageName>
App Variable to write information to it. - Prepare the action schema:
- In the Project Explorer, under Action, select ActionSchema.
- In the Input Properties, select Add property.
- In the property search bar, select More Options.
- Under Advanced,
select ContentValidationData.
This is the input property that will display in the Create App Task activity. The ContentValidationData input property requires a
ContentValidationData
object as input, which can be a single object or an array/list ofContentValidationData
instances.ContentValidationData
contains the artifacts of the Validation Station.ContentValidationData
is created using the Create Document Validation Artifacts activity.
- Configure the Validation Control:
- Go to the Validation Control properties.
- In the Source input, select the Action input that you have
defined as a
ContentValidationData
type.
- Configure the rest of the app with other Controls that you need.
3. Access Validation Control Data and its properties
VarValidationControl_PageName
). You
can change the values displayed in the Validation Control through the corresponding
app variable. Follow the steps outlined under Edit Validation Control data to
add, modify, or remove a field value.
The following table describes the properties that you can access from the Validation Control, their data type, and descriptions.
Property | Data Type | Description |
---|---|---|
Taxonomy | UiPath.DocumentProcessing.Contracts.Taxonomy.DocumentTaxonomy | The taxonomy object with which the content was prepared for display. It contains information about document types, fields, and display properties. |
ExtractionResult | UiPath.DocumentProcessing.Contracts.Results.ExtractionResult | The extraction results, as they are (with or without human changes), from the Validation Control. |
SelectedDocumentType | System.String | The name of the document type currently selected in the Validation Control. |
SelectedField | UiPath.DocumentProcessing.Contracts.Apps.FieldValueDetails | The field currently selected in the Validation Control along with its value. |
DataSource | UiPath.DocumentProcessing.Contracts.Actions.ContentValidationData | The content validation data that is currently the source of the Validation Control. |
Hidden | boolean | The state of the control property governing whether the control is visible or hidden. |
Disabled | boolan | The state of the control property governing whether the control is editable or not. |
IsValid | boolean | Checks validity of the Validation Control value. If true, indicates it is valid. |
4. Edit Validation Control data
You can change the values displayed in the Validation Control through the corresponding app variable. For example, you can change Extraction Result values displayed in the Validation Control through the corresponding app variable.
The following example shows how to update a regular field value:
- Select any Control in your app, and go to Events.
- Select Define automation.
This action opens Studio Web's designer panel, where you can build a trigger automation for a certain app control.
- In the context of the document's
Extraction Results, to add or change a field value for regular fields, add a
Set Variable Value activity in the automation.
- For the To
Variable field, use
AppVariable.VarValidationControl_PageName.Field("<field name>").Value
.This expression represents the field you want to change, accessed through theVarValidationControl_PageName
variable. - In the To field enter the desired value for the referenced field.
Apart from regular fields, theAppVariable.VarValidationControl_PageName
variable can also manipulate multi-value fields usingAppVariable.VarValidationControl_PageName.Field("<field name>", <index>)
, and interact with table cells usingAppVariable.VarValidationControl_PageName.Field("<table field name").Field("<column name>", <row index>)
.To delete values, select the target value similarly and use the.DeleteValue
flag set to True.The properties of values that you can update in the validation control include:
- Textual value (
.Value
) - Confirmed state (
.Confirmed
) - Confidence level of the value (
.Confidence
) - Deletion flag (
.DeleteValue
) - Flag to remove a value reference (
.KeepReference
)
- For the To
Variable field, use
AppVariable.ValidationControl.SelectedDocumentType
variable if
you want to update it with a different value.
5. Create events for the Validation Control
You can trigger various events specific to the Validation Control. In the Project Explorer, navigate to the Validation Control, and select it. The Events panel of the Validation Control allows you to define automations for specific events.
The following table describes the available Validation Control events:
Event | Description |
---|---|
On Ready | Triggers when the Validation Control is loaded. |
Document Type Changed | Triggers when the user changes the document type from the Validation Control. |
Field Selected | Triggers when the user selects one of the fields, or the value of a field, in the Validation Control. |
Field Value Changed | Triggers when the user adds, removes, or replaces a field value in the Validation Control. |
6. Use dedicated Validation Control activities
- Set Validation Control Field Focus: Allows you to focus on a field, based on a configured event.
- Save Validation Control State: Saves the state of the Validation Control. You can use this when you want to revisit and complete the validation later.
Common Validation Control expressions
When you are creating your app that contains a Validation Control, you can use the following expressions to access various data exposed by the Validation Control. The following table describes the most common expressions you can use when working with the Validation Control:
Purpose | Expression |
---|---|
Access Extraction Results displayed within the Validation Control |
|
Access the taxonomy loaded in the Validation Control |
|
Access the selected field in the Validation Control |
The properties of the selected field can be:
|
Access additional Validation Control properties | MainPage.ValidationControl.<PropertyName> |
Read Extraction Results data | Use the methods exposed by the Extraction Result class. |
Read taxonomy data | Use the methods exposed by the Taxonomy class. |
Access a field value to update it in the Validation Control | AppVariable.<ValidationControlVariable>.Field("<FieldName>").Value |
Retrieve the list of field names displayed in the Validation Control | AppVariable.<ValidationControlVariable>.ExtractionResult.GetFields().Select(Function(f)
f.FieldName) |
6. Publish and deploy the app
After you build your Action app and trigger automations for Controls inside of it, you can publish it. Publishing the app makes it available to use for creating App actions. For more information on publishing apps, visit Publishing, deploying, and upgrading app projects.
Prerequisites
- Install the following activity package versions:
- IntelligentOCR.Activities version 6.24.0
- Persistence.Activities version 1.5.5 or higher.
- AppEvents.Activities version 3.12.0 or higher.
- Create a storage bucket in
Orchestrator, in the same folder where you want to publish the document
processing automation.
Data required to load the Validation Control within apps is stored within an Orchestrator storage bucket.
- Add the document that you want to process inside the Studio project folder.
- Optionally, if you want to use generative extraction or validation capabilities, then you need AI units. For more information on Document Understanding generative features, visit Generative features.
1. Process a file using Document Understanding
Add activities that use Document Understanding to process a file. Prepare the document for validation in Action Center, through apps, using digitization and extraction.
After adding the activities for processing the file, the following variables should be available:
DocumentTaxonomy
(Taxonomy): Retrieved via the Load Taxonomy activity.Dom
(Document Object Model) andtext
(Document Text): Acquired through the Digitize Document activity.doc
(Document Path): Represents the path to the processed file.autoExtractionResults
(ExtractionResults): This is the output from the Data Extraction Scope activity, regardless of the extraction methods used.
2. Send out the validation information to the app
After the document is ready to be validated, you can prepare all the information to be sent out to the previously created and deployed app. Follow these steps:
- Add a Create Document
Validation Artifacts activity to create the
Content Validation Data
object which stores the information necessary for loading the Validation Control within the Action app.In this example, configure the activity using the previously created or outputted variables:- Bucket Folder Path: The name of the Orchestrator folder where the storage bucket was created.
- Bucket Name:
storageBucketName
- Bucket Directory Path: The directory path within the previously inputted storage bucket, where you want to store action data.
- DocumentPath:
doc
- Document Text:
text
- Document Object
Model:
dom
- Taxonomy:
taxonomy
- Automatic
Extraction Results:
autoExtractionResults
- Add a Create App Task activity, so you can
bind the
Content Validation Data
object to the previously designed app and then send it out to Action Center for validation.In this example, configure the activity as follows:
- Title:
CVD
- Priority:
Medium
- Apps:
Demo.Validation.Control.in.Apps
- App Version:
v2.0.0
After you select the App, and the corresponding version that you want to use for creating the action, the input properties of that app will be shown in the body of the activity.
- In this example,
one of the input properties is
Action_Content_Validation_Data, which requires the
document validation artifacts previously created:
contentValidationData
.
- In this example,
one of the input properties is
Action_Content_Validation_Data, which requires the
document validation artifacts previously created:
Figure 2. The Create App Task activity
- Title:
- Add a Wait for App Task and Resume activity
to return the information about the action, and resume the workflow.
In the Created App Task field, enter the output variable of the Create App Task activity.
- Add a Retrieve Document Validation Artifacts
activity, to return the document validation artifacts after the user performed
validation in Action Center.
Pass the output variable of the Create Document Validation Artifacts activity as the input of the Retrieve Document Validation Artifacts activity.
Tip: You can also create dedicated output variables for additional information stored in the validation artifacts, such as AutomaticExtractionResults, and ValidatedExtractionResults.
- Open Action Center, and go to My Actions or Manage Actions.
- In the Unassigned tab, find the action you just created using the previous Studio automation.
- If you want to assign the action to yourself, select the desired action, and then select Assign to self.
- If you want to assign the action to another user, select More options for the desired action. Then select Assign to user, and select a user from the dropdown list.
- Go to the Pending tab, and complete the action, so the Studio workflow can be resumed.