We’re excited to announce a new Preview release of the Document Understanding activity packages, alongside the Public Preview of IXP models in Solutions. This release is all about meeting developers where they work: whether you build visually on the canvas, write C# in coded workflows, or orchestrate everything as a solution, your document processing tools now follow you there.
Here’s what’s new.
Document Understanding and PDF Activities in Coded Workflows
You can now call Document Understanding and PDF capabilities directly from coded workflows — no XAML required.
Coded workflows give you the full power of C# — loops, LINQ, exception handling, unit-testable logic — while staying fully integrated with the UiPath platform. With this release, UiPath.DocumentUnderstanding.Activities and UiPath.PDF.Activities now expose coded workflow capabilities as services you can call directly in coded workflows:
- The
duservice (fromUiPath.DocumentUnderstanding.Activities) exposes document classification, data extraction, and the human-in-the-loop validation artifacts operations. - The
pdfservice (fromUiPath.PDF.Activities) exposes the PDF toolbox: reading text, counting pages, merging and splitting PDFs, extracting page ranges and attachments, creating PDFs from images, and the new document-to-PDF conversions.
A complete classify-then-extract flow now looks like this:
public class ProcessInvoice : CodedWorkflow
{
[Workflow]
public void Execute(string documentPath)
{
// Classify the document against your Document Understanding project
var classified = du.ClassifyDocument(
documentPath,
projectName: "AccountsPayable",
projectVersionOrTag: "Production");
// Extract structured data — the document type is picked up
// from the classification result, and the file isn't re-digitized
var extractionResults = du.ExtractDocumentData(
classified,
projectName: "AccountsPayable",
projectVersionOrTag: "Production");
// Work with the extracted fields in plain C#
var total = extractionResults.Data.GetFieldValue("Total Amount");
}
}
Need a human in the loop? The du service also covers the validation flow: CreateDocumentValidationArtifacts uploads extraction results and returns a handle you can attach to a Validation Station task, and RetrieveDocumentValidationArtifacts picks up the validated results once the task completes.
PDF manipulation is just as direct:
// Read, inspect, and reshape PDFs with one-line calls
var text = pdf.ReadPdfText(@"C:\input\contract.pdf", range: "1-3");
var pageCount = pdf.GetPdfPageCount(@"C:\input\contract.pdf");
var merged = pdf.JoinPdf(new[] { @"C:\input\cover.pdf", @"C:\input\body.pdf" });
The full API references, including every method signature and more end-to-end examples, are available in the docs: Document Understanding coded automation APIs and PDF coded automation APIs.
Three New PDF Conversion Activities: Email, HTML, and Text to PDF
Real-world documents come in various formats. Invoices arrive as email bodies, reports as HTML, confirmations as plain text. Three new activities in UiPath.PDF.Activities normalize all of these into PDF — the format the rest of your document processing pipeline expects:
- Convert Email to PDF — turn an email message into a PDF document, preserving its visual layout.
- Convert HTML to PDF — render HTML content straight to PDF.
- Convert Text to PDF — produce a formatted PDF from plain text, with configurable font size and alignment.
All three are available on both Windows and cross-platform projects, and all three share a common set of rendering options: standard paper sizes (A4, Letter, Legal, and more), custom margins, a rendering scale from 0.1 to 2.0, optional HTML header and footer templates, and background colors and graphics preserved by default.
A typical pattern this unlocks: an email trigger fires, you convert the email (and its HTML body) to PDF, then feed it directly into Extract Document Data — a complete mailbox-to-structured-data pipeline with no intermediate manual steps. And yes, these conversions are available from coded workflows too.
E-Invoicing Building Blocks: Extract Attachments from PDFs new Activity
Processing PDFs with attached structured XMLs is now one activity away! Literally. The UiPath.PDF.Activities pack now holds the Extract Attachments From PDF activity, allowing you to save the XMLs from your PDF and process them as structured data.
Here’s a little something I did with my coding agent:
IXP models as solution resources (Public Preview)
If you build with UiPath Solutions, model management just got significantly simpler. IXP models can now be added to a solution as resources — packaged, versioned, and deployed together with everything else in the solution.
Here’s how it works: when you add an IXP model as a solution resource, it appears in the Resource Explorer in Studio Web and becomes part of the solution package. Deploy the solution, and the model travels with it — no separate model deployment step, no environment-by-environment reconfiguration.
You can use solution-deployed IXP models in:
- the Extract Document Data activity
- the Document Understanding Project Extractor activity
Both activities gain a new Use Solution Resource toggle. Switch it on (available when your workflow is part of a solution), pick your model, and you’re done.
This closes a long-standing gap between automation lifecycle management and model lifecycle management: your extraction model is now just another resource that moves through dev, test, and production alongside the workflows that depend on it.
Document Redaction - Field Level Settings and Redaction Codes
Redact Document gains a new public RedactionOptions argument for per-field redaction settings, giving you granular control over exactly how each field gets redacted.
Building the RedactionOptions input in an Invoke Code would look as simple as:
redactionOptions = new RedactionOptions
{
Fields = new List<FieldRedactionSettings>
{
new FieldRedactionSettings
{
FieldId = "NoGroup.NoCategory.UtilityBills.BillingName",
RedactionType = RedactionType.Fill,
FillColor = "#00FF00",
FillOpacity = 1,
RedactionCode = "FILL PII-01",
RedactionCodeFontColor = "#FF00FF",
RedactionCodeFontSize = 30
},
new FieldRedactionSettings
{
FieldId = "NoGroup.NoCategory.UtilityBills.BillingAddress",
RedactionType = RedactionType.StrikeThrough,
FillColor = "#FF0000",
FillOpacity = 0.6,
BorderColor = "#FF0000",
BorderSize = 1,
RedactionCode = "STRK PII-02",
RedactionCodeFontColor = "#000000",
RedactionCodeFontSize = 30
},
new FieldRedactionSettings
{
FieldId = "",
RedactionType = RedactionType.Fill,
FillColor = "#FFFF00",
FillOpacity = 0.6,
BorderColor = "#FF0000",
BorderSize = 1,
RedactionCode = "WTR PII-03",
RedactionCodeFontColor = "#000000",
RedactionCodeFontSize = 30
}
}
};
Notice you can choose between a Fill and a Strikethrough redaction type, and you can define redaction codes (that get written over the redacted areas) for each field individually.
The one entry with an empty FieldID will be applied to every redaction performed from the “Words To Redact” string array.
Try it out
The new capabilities ship in the following Preview package versions, available now:
| Package | Version | Release notes |
|---|---|---|
| UiPath.IntelligentOCR.Activities | 7.4.0-preview | Release notes |
| UiPath.DocumentUnderstanding.Activities | 3.4.0-preview | Release notes |
| UiPath.PDF.Activities | 4.4.0-preview | Release notes |
For IXP models in Solutions, see the IXP release notes.
As always with Preview releases, we recommend evaluating these features in non-production environments first — and we’d love to hear your feedback. Happy automating!
