.png)
UiPath Integration Guide
Integrate UiPath Automation Cloud and Orchestrator with enterprise systems through REST APIs, selected-event webhooks, queues, storage, and asynchronous job workflows.
UiPath integration options at a glance
UiPath's primary integration surface is its REST API coverage across Automation Cloud and Orchestrator, including processes, jobs, robots, queues, queue items, assets, folders, packages, and logs. Orchestrator also supports webhooks for selected event types, while storage, package, and queue-item attachment APIs support file-oriented workflows. Process execution and queue processing are asynchronous, so integrations may submit work, retain identifiers, poll for completion, or respond to applicable notifications. Martini can consume these APIs, receive webhook notifications, map and validate payloads, maintain synchronization watermarks, and expose controlled REST endpoints for downstream applications.
| Integration point | Supported by UiPath? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | UiPath's principal integration surface supports Automation Cloud and Orchestrator resources such as processes, jobs, robots, queues, queue items, assets, folders, packages, and logs. | Martini can consume the documented HTTP APIs from workflows, transform payloads, apply business rules, and expose its own REST API for controlled access. |
| Webhooks / outbound callbacks | Limited | Orchestrator supports notifications for selected event types and resources; coverage is not universal across all objects or state changes. | Martini can receive notifications through a secured API or webhook-started workflow, deduplicate them, and retrieve the authoritative resource through the REST API. |
| Bulk / async / batch APIs | Limited | Process execution and queue processing are asynchronous, and bulk operations vary by UiPath resource rather than forming one universal batch API. | Martini can submit work, retain job or queue identifiers, poll for terminal states, and apply controlled concurrency and retry policies. |
| File / attachment APIs | Limited | Package uploads, storage buckets, and queue-item attachments support resource-specific file and document workflows. | Martini can move files or references between systems, call the relevant UiPath resource API, and preserve correlation and error state. |
| Authentication | Yes | UiPath supports OAuth-based external applications and supported token mechanisms, with organization, tenant, scope, role, and folder permissions affecting access. | Martini stores client credentials, tokens, organization and tenant identifiers, and other environment values in secured configuration or secrets. |
| Incremental synchronization | Yes | OData-style filtering and ordering, timestamps, status fields, queue states, job states, and selected webhook events support incremental processing patterns. | Martini can persist watermarks or cursors, process paginated results, reconcile late changes, and combine notifications with scheduled API reads. |
| SDKs | Limited | UiPath provides API documentation and product-specific tooling, but an SDK is not required for the documented integration model. | Martini can use the documented HTTP APIs directly, avoiding a dependency on a product-specific SDK when orchestration and mapping are required. |
| Database access | Not confirmed | A general supported customer database integration for UiPath was not confirmed; documented service interfaces should be preferred. | Martini can use supported UiPath APIs and connect separately to approved enterprise databases when the integration architecture requires it. |
How UiPath exposes data and business events
UiPath REST APIs
UiPath exposes REST APIs across Automation Cloud and Orchestrator. Resource-oriented endpoints cover processes, jobs, robots, queues, queue items, assets, folders, packages, logs, and related services.
Martini implementation pattern
Martini implementation pattern: a scheduled or API-triggered workflow authenticates to UiPath, retrieves paginated resources, applies filters and mappings, writes to target systems, and stores a durable watermark or correlation state.
Implementation sequence
UiPath Webhooks
Orchestrator webhooks provide notifications for selected event types and resources. They are not a universal event stream and may not contain the complete current business object.
Martini implementation pattern
Martini implementation pattern: a secured Martini API receives the notification, validates and deduplicates it, acknowledges appropriately, then reads the authoritative UiPath resource before forwarding the business event.
Implementation sequence
Asynchronous Jobs and Queues
UiPath process execution and queue processing are asynchronous. API calls can start jobs or add Queue Items while processing continues later.
Martini implementation pattern
Martini implementation pattern: a workflow submits work, stores the job or queue correlation identifier, polls or consumes an applicable notification, and distinguishes successful, faulted, stopped, canceled, and business-exception outcomes.
Implementation sequence
Storage and Attachments
UiPath supports resource-specific package, storage bucket, and queue-item attachment capabilities. Endpoint behavior and permissions depend on the selected resource and deployment.
Martini implementation pattern
Martini implementation pattern: a workflow transfers a file or reference, calls the relevant UiPath storage or attachment API, associates it with business work, and records the resulting identifier for downstream processing.
Implementation sequence
Common UiPath integration patterns
Pattern 1: Submit enterprise transactions to UiPath queues
When to use this pattern
Use this pattern when an ERP, finance application, or other source produces transactions that require robotic processing. The flow validates required fields, submits a Queue Item, and returns the eventual outcome to the source system.
Integration direction
Example Mapping
| UiPath Field | Canonical Field | Target Field |
|---|---|---|
| invoiceNumber | transaction.reference | Queue Item Reference |
| supplierId | party.externalId | Queue Item SpecificContent.supplierId |
| grossAmount | transaction.amount | Queue Item SpecificContent.amount |
| documentUrl | document.location | Queue Item SpecificContent.documentUrl |
Martini implementation pattern
Martini receives or retrieves the source transaction, validates amount and supplier rules, maps it into UiPath Queue Item data, and stores the returned reference. A follow-up workflow reads queue and job status, distinguishes business exceptions from transient failures, and updates the source application with a controlled retry policy.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- asynchronous orchestration
- error handling
Pattern 2: Monitor UiPath jobs and route incidents
When to use this pattern
Use this pattern to give operations teams visibility into failed, stopped, or delayed UiPath executions. It combines selected webhook notifications with scheduled reconciliation so missed notifications do not become missed incidents.
Integration direction
Example Mapping
| UiPath Field | Canonical Field | Target Field |
|---|---|---|
| jobKey | automation.executionId | ServiceNow correlation_id |
| state | automation.status | ServiceNow incident state |
| releaseName | automation.process | ServiceNow configuration item |
| exceptionReason | automation.failureReason | ServiceNow description |
Martini implementation pattern
Martini receives a supported UiPath notification or queries jobs and queue items on a schedule, deduplicates by job key, classifies severity and retryability, and creates or updates a ServiceNow incident. It records the workflow outcome and avoids reopening incidents for repeated notifications.
Martini capabilities used
- webhook receiving
- scheduled workflows
- API consumption
- data mapping
- business rules
- idempotency
- monitoring
Pattern 3: Synchronize UiPath outcomes to Salesforce
When to use this pattern
Use this pattern when Salesforce customer, lead, or case work is processed by UiPath and the originating record needs a reliable automation status. The workflow supports asynchronous processing rather than treating submission as completion.
Integration direction
Example Mapping
| UiPath Field | Canonical Field | Target Field |
|---|---|---|
| Id | businessRecord.id | Queue Item SpecificContent.salesforceId |
| CaseNumber | businessRecord.reference | Queue Item Reference |
| Status | businessRecord.status | UiPath Queue Item priority or business status |
| jobKey | automation.executionId | Salesforce automation_job_key__c |
Martini implementation pattern
Martini retrieves Salesforce changes, applies eligibility rules, submits Queue Items, and stores correlation data. A second workflow checks the authoritative UiPath state, maps success or exception outcomes, and updates Salesforce. Retries are limited to transient API failures and safe-to-repeat updates.
Martini capabilities used
- API consumption
- workflows
- data mapping
- business rules
- correlation management
- retry handling
Pattern 4: Reconcile UiPath resources incrementally
When to use this pattern
Use this pattern when a downstream operational store needs reliable synchronization of jobs, queue items, folders, processes, or assets. It combines filtered API reads, pagination, durable watermarks, and periodic reconciliation.
Integration direction
Example Mapping
| UiPath Field | Canonical Field | Target Field |
|---|---|---|
| Id | resource.externalId | resource_id |
| CreationTime | resource.createdAt | created_at |
| State | resource.status | status |
| FolderName | resource.folder | folder_name |
Martini implementation pattern
A scheduled Martini workflow reads UiPath resources in stable order using supported filters and pagination, maps each object to the operational store, and advances the watermark only after successful writes. Overlapping windows and periodic full or bounded reconciliation account for late-arriving changes and missed notifications.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination
- data mapping
- state management
- error handling
Applications commonly integrated with UiPath
UiPath is commonly placed between enterprise applications and robotic processes. Martini can coordinate these flows using documented APIs, selected UiPath notifications, durable state, transformation rules, and downstream application interfaces; the specific objects and permissions depend on each implementation.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Submit customer, lead, case, or service work to UiPath and return processing status to Salesforce. | Salesforce → Martini → UiPath | Martini retrieves or receives Salesforce changes, validates and maps them into UiPath Queue Items, then tracks job or queue outcomes and updates Salesforce. Duplicate protection and retry rules protect both systems. |
| ServiceNow | Create or update incidents and requests when UiPath jobs or queues fail, or submit service work for robotic processing. | ServiceNow → Martini → UiPath | A Martini workflow queries UiPath jobs and queue items or receives supported notifications, classifies failures, and calls ServiceNow for incident management. Correlation identifiers link the incident to the UiPath execution. |
| SAP S/4HANA | Automate finance, procurement, master-data, and transaction workflows through UiPath processes. | SAP S/4HANA → Martini → UiPath | Martini receives SAP business data through the available SAP interface, applies validation and canonical mapping, and submits queue work to UiPath. Results and exceptions are routed back to SAP or an operational store. |
| Oracle NetSuite | Submit finance and order-processing work to UiPath and return automation outcomes. | Oracle NetSuite → Martini → UiPath | Martini orchestrates NetSuite API reads or events with UiPath queue submission, stores correlation keys, and writes completion or exception status back after asynchronous processing. |
| Microsoft Dynamics 365 | Automate sales, customer service, and finance-related tasks using UiPath queues and job execution. | Microsoft Dynamics 365 → Martini → UiPath | A scheduled or event-driven Martini workflow retrieves Dynamics 365 changes, transforms them into UiPath work items, and updates Dynamics 365 after the related job or queue item reaches a business outcome. |
| Jira | Create issues for failed jobs, queue exceptions, and operational follow-up. | UiPath → Martini → Jira | Martini receives supported UiPath notifications or performs reconciliation queries, applies severity and routing rules, and creates or updates Jira issues with the UiPath job, queue, and error context. |
| Workday | Automate selected HR and finance processes and synchronize processing outcomes. | Workday → Martini → UiPath | Martini retrieves approved Workday data, validates sensitive fields, submits controlled UiPath queue work, and returns status through the available Workday integration surface while minimizing sensitive logging. |
| Microsoft SharePoint | Exchange documents or metadata for document-driven UiPath processes. | Microsoft SharePoint → Martini → UiPath | Martini receives file or metadata references, coordinates storage and queue operations in UiPath, and writes classification or processing results back to SharePoint with idempotent file handling. |
How to build a UiPath integration in Martini
Objective
Configure the UiPath authentication and deployment context required by the selected API.
Instructions in Martini
- Select the relevant Automation Cloud or Orchestrator API surface
- Configure OAuth application credentials or a supported token mechanism
- Store secrets, organization, tenant, and folder identifiers securely
- Grant only the required scopes and permissions
Objective
Select an event-driven, API-led, or scheduled entry point based on the required latency and UiPath event coverage.
Instructions in Martini
- Use a Martini API or webhook workflow for supported UiPath notifications
- Use a scheduler for reconciliation and incremental synchronization
- Use an upstream API trigger when another application submits business work
Objective
Read the authoritative UiPath resource or source application data before applying business logic.
Instructions in Martini
- Call the documented UiPath REST API
- Handle pagination, filtering, ordering, and tenant or folder context
- Treat webhook payloads as notifications and retrieve the current resource when necessary
Objective
Coordinate submission, asynchronous execution, polling, and downstream updates in a maintainable workflow.
Instructions in Martini
- Submit jobs or Queue Items with correlation identifiers
- Persist job keys, queue references, and synchronization watermarks
- Poll or process supported notifications without excessive concurrency
- Separate API acknowledgement from long-running business processing
Objective
Transform UiPath objects and source payloads into canonical and target-system models.
Instructions in Martini
- Map processes, jobs, Queue Items, assets, folders, and statuses explicitly
- Validate required fields and normalize dates, identifiers, and status values
- Keep mappings versioned for important API or deployment changes
Objective
Apply routing, eligibility, retryability, and exception policies before committing changes.
Instructions in Martini
- Classify authentication, throttling, validation, business, and downstream errors
- Prevent duplicate submissions and duplicate event processing
- Route non-retryable failures to operational review
Common UiPath data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Folders | Organize UiPath resources and define logical security and administration boundaries. | Identity platforms, operational stores, governance systems, and enterprise administration tools | Martini retrieves folder metadata through the API, applies tenant and folder context, and maps it to governance or synchronization models. |
| Processes | Represent published automation definitions that can be executed by UiPath robots. | Deployment tooling, automation catalogs, monitoring systems, and operational dashboards | Martini can query process definitions, validate process references, and use them when starting jobs or routing work. |
| Jobs | Represent individual process executions, including state, timing, process, and robot context. | ServiceNow, Jira, monitoring platforms, data warehouses, and operational stores | Martini starts or queries jobs, tracks identifiers and terminal states, applies timeout and retry rules, and forwards outcomes. |
| Queues and Queue Items | Hold business work for attended or unattended automation, including references, priority, status, deadlines, exceptions, and business data. | SAP S/4HANA, Salesforce, ServiceNow, finance applications, and case-management systems | Martini maps source transactions into Queue Items, submits them through the API, persists correlation keys, and synchronizes results. |
| Robots | Represent execution identities or runtime associations used to run UiPath processes. | Operational dashboards, access governance systems, and automation management stores | Martini can retrieve robot information for routing, monitoring, reconciliation, and execution-context reporting. |
| Assets | Centrally manage reusable configuration values, credentials, or automation settings. | Configuration stores, governance systems, and operational reporting platforms | Martini handles asset metadata and approved values through secured API calls without exposing secrets in logs or mappings. |
Authentication and security considerations
Authentication and access control
UiPath access depends on the API, product, and deployment model. Automation Cloud supports OAuth-based external applications and supported token mechanisms, while organization, tenant, application scopes, roles, and modern folder permissions determine which resources are accessible.
- Store OAuth client credentials, tokens, organization identifiers, tenant identifiers, and folder identifiers in Martini secured configuration or secrets.
- Apply least-privilege scopes and Orchestrator permissions.
- Secure webhook receiving endpoints and validate authenticity using the mechanism supported by the UiPath webhook configuration.
- Do not log tokens, credentials, document contents, or sensitive Queue Item data.
Operational considerations for UiPath integrations
Reliability and operations
Confirm rate limits for the specific UiPath service and use controlled concurrency with exponential backoff for transient failures such as throttling or service unavailability.
- Implement pagination and stable filtering rather than assuming one API response contains all resources.
- Use job keys, Queue Item references, resource identifiers, or Martini-managed keys for idempotency.
- Track asynchronous states and define timeout, retry, cancellation, and manual-review behavior.
- Use selected webhooks together with scheduled reconciliation for synchronization completeness.
- Version mappings, avoid undocumented fields, and test in a non-production tenant when APIs, packages, storage, queues, or webhook configurations change.
- Classify authentication, authorization, validation, business, and downstream errors separately for useful monitoring and recovery.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini provides a maintainable integration layer between UiPath and enterprise applications without requiring point-to-point scripts for each process. Workflows can consume REST APIs, receive selected notifications, expose controlled APIs, and coordinate asynchronous execution.
- Reuse authentication, mapping, validation, correlation, and error-handling patterns across UiPath processes.
- Combine API-led, scheduled, webhook, and file-oriented flows in one integration design.
- Keep synchronization watermarks, retries, deduplication, and operational logging explicit.
- Apply business rules and canonical transformations before writing to downstream systems.
- Change target applications or UiPath processes without duplicating integration logic across scripts.
Frequently asked questions
UiPath can be integrated primarily through its Automation Cloud and Orchestrator REST APIs. Enterprise systems can submit Queue Items, start or monitor Jobs, retrieve Processes, Robots, Assets, Folders, and Logs, exchange storage or attachment data, and receive selected-event Orchestrator webhook notifications. Because execution is asynchronous, integrations should track identifiers and reconcile results.
Yes. Martini can consume UiPath REST APIs, submit jobs or Queue Items, retrieve execution and resource state, process supported webhook notifications, map data, and coordinate downstream updates. No native Martini UiPath connector is documented in the supplied sources.
No. A dedicated UiPath connector is not required. Martini can use UiPath's documented REST APIs, supported webhook notifications, authentication methods, and resource-specific file or attachment interfaces through workflows and APIs.
Lonti does not charge an additional per-connector or per-vendor fee to integrate UiPath. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from UiPath, infrastructure providers, or other third-party systems depending on subscriptions, usage, and deployment model.
REST APIs are UiPath's primary integration method. Use webhooks for selected supported events, asynchronous job and queue APIs for work submission, and resource-specific storage, package, or attachment APIs for file-oriented processes. GraphQL was not confirmed and SOAP is not a current supported Orchestrator mechanism in the supplied research.
UiPath Orchestrator supports webhooks for selected event types and resources, but not every object or state change. Martini can receive the notification through a secured API, deduplicate it, retrieve the current resource through REST when needed, and use scheduled reconciliation for completeness.
Synchronization can combine OData-style filtering and ordering, timestamps, status fields, queue and job states, selected webhook events, and a persisted watermark. Martini can paginate through results, transform objects, write target systems, and use overlapping windows and reconciliation to handle late changes or missed notifications.
Martini validates and transforms UiPath payloads in workflows, applies business rules, and routes results to target systems. It can distinguish authentication failures, throttling, invalid requests, missing resources, UiPath business exceptions, and downstream failures, applying bounded retries only where operations are safe to repeat and recording non-retryable exceptions for review.
Related Martini documentation
UiPath APIs
Workflows
Integrate UiPath with confidence
Use Martini to connect UiPath REST APIs, selected webhook events, queues, jobs, and storage workflows with the enterprise systems that depend on them.