Extracting data from semi-structured documents: invoices
🎯 Learning objectives
- Navigate the Document Understanding service in UiPath Automation Cloud
- Differentiate between Classic and Modern projects and know when to use each
- Explain the Active Learning approach and how it speeds up model training by 80%
- Walk through the full Build → Measure → Publish → Monitor lifecycle in Modern Projects
- Annotate documents using Generative AI pre-annotation in Modern Experience
- Identify and use out-of-the-box ML Extractors for invoices and other document types
- Describe UiPath Helix Classifier and Helix Extractor and their key characteristics
- Migrate a trained project from a development environment to production
DU Service Platform in Automation Cloud
The Document Understanding service in UiPath Automation Cloud is your central hub for building, managing, and deploying AI extraction models. It eliminates the need for separate AI Center configuration for most use cases.
Accessing Document Understanding
- Log into cloud.uipath.com
- Select your tenant
- Navigate to Document Understanding service in the left menu
- Click on Create Project and you will see 2 options - Classic or Modern projects
Classic Projects — What You Should Know
Classic DU projects are the traditional framework for UiPath Document Understanding. They offer compatibility with OCR engines and rely on AI Center for model hosting.
- Cost-effective for OCR-heavy tasks — free OCR usage that does not consume AI units; first 25 pages per document are processed free.
- Established capabilities — well-suited for regex-based extraction and Intelligent Keyword Classifier (IKC) classification.
- Broader infrastructure support — works on Automation Cloud, Suite, and Standalone deployments.
⚠️ Important
Important: UiPath recommends creating all new projects using Modern Projects. Classic activities remain available and supported, but are no longer being enhanced. Transitioning to Modern is strongly encouraged for access to active learning, generative AI pre-annotation, and ongoing feature updates.
💡 Tip
Recommendation: Use Modern Projects for new implementations on Automation Cloud. They offer faster model development (80% faster), no AI Center setup, and guided training experience.
Modern Projects
Modern Projects is the next-generation AI-powered model training experience within UiPath Document Understanding. It uses an iterative process between annotators and an ML model to minimize the amount of labeled data needed.
Key Benefits of Active Learning
- 🚀 80% faster model training — from a week down to a day
- 👥 No ML expertise required — anyone can train AI models
- 🤝 Human + AI collaboration — guidance on model optimization
- 📊 Built-in performance analytics — instant model evaluation
- 🔄 Background training — model improves as you annotate
Modern Experience: Build → Measure → Publish → Monitor
🔨 Build
- Upload & classify your documents (automatic AI classification)
- Generative AI pre-annotates fields — you validate/correct
- Follow recommendations on how many samples to add
- Model trains in the background as you annotate
- Minimum recommended: 30 documents per document type
📊 Measure
- Evaluate model readiness with performance metrics (F1, precision, recall per field)
- Field-level performance shows which fields need more attention
- Distribution of annotated vs unannotated documents
- Guided recommendations on where to improve
🚀 Publish
- Choose the model version to deploy
- One-click deployment — model becomes available as a service
- Click the deployed toggle button
- Edit the published model to add the deployment tag as Production
- Consume from Studio, Studio Web, or via APIs
👁 Monitor
- Insights dashboard shows live automation performance
- Drill down into individual document processing status
- Visibility into human-in-the-loop events and corrections
- Search through historical document processing records
Out-of-the-Box ML Extractors
UiPath provides pre-trained, ready-to-use ML extractors that work immediately — no training required. These are called out-of-the-box (OOTB) ML extractors.
Available Out-of-the-Box Models
| Category | Model |
|---|---|
| Invoices | Invoices ML Extractor — English, Spanish, Portuguese, German, Romanian (PDF, PNG, JPEG, TIFF) |
| Receipts | Receipts ML Extractor — English, Spanish, German, French, Norwegian, Finnish, Romanian (PDF, PNG, JPEG, TIFF) |
| Finance / Accounting | Purchase Orders, Remittance Advices |
| Tax | IRS Form 1040, Schedule C / D / E, W-2, W-9 |
| Insurance | ACORD 25 / 125 / 126 / 131 / 140, CMS 1500, UB04 |
| HR / Onboarding | I-9, Payslips, W-2, W-9 |
| Supply Chain | Bills of Lading, Packing Lists, Certificates of Origin |
| Know Your Customer (KYC) | ID Cards, Passports, Bank Statements, Utility Bills |
| Regional Invoice Variants | Invoices China, Invoices India, Invoices Japan, Invoices Hebrew |
📖 For the full list of all available out-of-the-box models and their supported fields, refer to the UiPath Documentation — Out-of-the-Box Pre-Trained ML Packages →
Limitations
| Limit Type | Community Edition | Enterprise Edition |
|---|---|---|
| Document size | Max 2 pages, 4MB | Max 20 megapixels per page, 10MB in JSON-Base64 |
| Rate limit | 50 requests/hour | Higher limits (license-dependent) |
| Data storage | Stored by UiPath for QA | Not stored by UiPath |
💡 Tip
Customization: You can customize all OOTB ML extractors using transfer learning — add new fields or improve accuracy for your specific use case with as few as 30 labeled documents.
UiPath Helix — Classifier & Extractor
UiPath Helix is UiPath's next-generation LLM-based AI framework for Document Understanding. It includes two distinct models: the Helix Classifier (for identifying document types) and the Helix Extractor (for extracting field data). Both are available in Modern Projects and significantly reduce the annotation effort needed to build high-accuracy automations.
Helix Classifier
The Helix Classifier is an LLM-based document classification model that automatically identifies document types with minimal training data.
Key Characteristics
- Classifies documents into defined document types using generative AI
- Requires significantly fewer training samples compared to the Intelligent Keyword Classifier
- Works within Modern Projects — no separate AI Center configuration needed
- Background model training as you annotate and validate classification results
- Supports splitting of multi-document PDFs into individual document types
Helix Extractor
The Helix Extractor 1.0 is an LLM-based data extraction model built into Document Understanding. It leverages a wide variety of training documents to handle common document types with minimal annotation requirements.
Key Characteristics
- 🎯 ~15% fewer false positives and ~17% fewer false negatives compared to previous models
- ✏️ Reduced annotation effort — only one annotation per document required, not per field instance
- 📊 Better confidence scores — stronger correlation between confidence values and actual extraction accuracy
- Text matching only — does not support summarisation or other types of text analysis
- Latin script languages only (non-Latin scripts not supported in v1.0)
- Field names must use natural language and proper grammar for optimal performance
Supported Document Types
- ✅ Invoices, Receipts, Purchase Orders, and semi-structured documents
📌 Note
For full details, refer to the UiPath Helix Extractor 1.0 documentation → and Helix Extractor 2.0 (Public Preview) →
Annotation in Modern Experience
Annotation is the process of labeling document examples to tell the model what to extract. In Modern Experience, annotation is guided and accelerated by Generative AI pre-annotation.
- Upload documents to your Modern project (minimum 30 per document type)
- Automatic classification: AI assigns document types; review and correct any mistakes
- AI pre-annotation: Generative AI suggests field values for each document
- Validate predictions: Review each suggestion — accept if correct, correct if wrong
- Background training: Model retrains automatically as you validate
- Check recommendations: Platform guides you on which documents to annotate next
📌 Note
Annotation Best Practices: Annotate a diverse set of document samples covering different vendors, layouts, and edge cases. The more diversity in your training set, the more robust your model will be.
Migrating a Project from Dev to Production
When your model is ready, you can migrate it from your development environment to production by exporting the annotated dataset and importing it into the target project. UiPath provides a structured process for this within Modern Projects.
Step 1: Export Data
- Open your project and navigate to the Publish section.
- Go to the Export tab.
- Select Export data (ensure a project version exists first).
- Choose the desired document type from the dropdown menu.
- Select the project version to export from its dropdown.
- Click Export to initiate the process.
- When ready, a popup appears with a download option. Download immediately or retrieve it later via the three-dot menu.
📌 Note
Only annotated and confirmed items (marked with a green shield icon) are exported. Datasets from project versions created prior to May 2024 (GA date) are not supported for export.
Step 2: Import Datasets
- Open the target project (e.g. your production environment).
- Select Add document type to create a new custom document type.
- In the newly created document type, select Upload.
- Choose the exported .zip file and wait for the upload to complete.
- Once the upload finishes, training starts automatically.
📌 Note
You can only import zip datasets directly into a document type — not at the project level.
📖 For the full migration guide, refer to: Migrating Existing Modern Projects — docs.uipath.com →
Consuming DU Modern Project in Studio
Once your model is published, consume it in UiPath Studio using the DocumentUnderstanding.Activities package.
DU Activities Package vs Intelligent OCR
| DocumentUnderstanding.Activities | IntelligentOCR.Activities | |
|---|---|---|
| Best for | Teams starting their DU journey; Modern Projects with generative capabilities | Complex scenarios requiring high flexibility and full pipeline control |
| Target users | RPA professionals and citizen developers across Studio Web, StudioX, and Studio Desktop | RPA developers using Studio Desktop seeking advanced control |
| Configuration | Single input/output object (DocumentData) — no repeated argument passing; no setup needed for OOTB models | Requires explicitly passing taxonomy, DOM, text, and classification/extraction results between activities |
| Flexibility | Simplified, opinionated flow; leverages cloud APIs for faster updates | Full control — modify taxonomy and extraction results at runtime; supports custom classifiers, extractors, and OCR engines |
| Human in the loop | Built-in Action Center integration | Manual Validate Document Action |
| Deployment | Automation Cloud & Test Cloud, Automation Suite | Automation Cloud & Test Cloud, Automation Suite and Standalone |
📖 Source: Automations in Document Understanding — docs.uipath.com →
Best Practices – Modern Projects
🏗️ Build: Best Practices
- Upload at least 30 documents for each document type — ensure these are a representative sample of all documents
- Uploaded documents are automatically processed (uploaded, digitized, classified and annotated) — ensure you validate all classifications & pre-annotations and correct any mistakes
- Mark the fields that are not present in a document as 'missing'
- Do not attempt to modify the incorrectly digitized fields — OCR outputs cannot be edited in Active Learning UI
- Use the default UiPath Document OCR for Latin script languages, Hebrew or Arabic
- Use the Extended Languages OCR for Chinese, Japanese, Korean or other languages that the default OCR doesn't support
📊 Measure: Best Practices
- You need to upload at least 10 documents to get a project score
- You need to upload at least 10 documents within the same document type to get a document type score
- You should stop training your model when it reaches your desired performance — this will vary per each use case and your business objectives
- Follow the recommended actions to fine-tune model's performance
🚀 Publish: Best Practices
- Each published version is referenced in your automations which consume the respective document types or classifier — if you wish to update the version used, make sure to update your automations
- Make sure to select the required resources (classifier or document types) when creating a project version
- Follow the recommended actions to build a good performing model
🖥️ Monitor: Best Practices
- Orchestrator data is ingested approximately every 20 minutes
- Robot logs are ingested every 10–15 minutes, but due to latency, this can take up to 2 hours to be displayed in Insights
- All robot logs are ingested (not only the last records and errors)
- Metrics in the Project Performance dashboard may change — especially the Consumption metrics, as they will be made available on a platform level
- To disable the monitoring of data, switch the corresponding setting in the Tenant Profile
- Data is displayed as per the following RBAC policies:
- Document Understanding Administrator, Document Understanding Contributor — full access
- Document Understanding Viewer — access to the Project Performance dashboard only
- Document Understanding Data Labeler — no access to Monitor
✅ Knowledge check
1. What is the key advantage of Active Learning in Modern Document Understanding Experience?
2. Why can an out-of-the-box ML extractor be customized with only a small number of labeled documents, rather than needing a full training set like a brand-new model?
3. What is the purpose of the 'Measure' phase in the Modern DU experience?