Ellipse Gradient for Header

SS&C Blue Prism Integration Guide

Integrate SS&C Blue Prism with enterprise applications through REST APIs, OAuth 2.0, process and session orchestration, work queues, and controlled status polling.

SS&C Blue Prism integration options at a glance

SS&C Blue Prism provides REST APIs for administering and managing processes, sessions, resources, environments, and work queues in current platform versions. Modern deployments generally use OAuth 2.0 through configured Blue Prism identity services, while older interfaces may expose legacy authentication or SOAP-based patterns that require release-specific validation. Selected components and versions may support notifications or callbacks, but webhook coverage is not universal. Martini can authenticate securely, invoke Blue Prism APIs, start or monitor automation sessions, process queue items in controlled batches, poll unsupported event types, transform JSON payloads, and expose a standardized API for downstream applications.

Integration pointSupported by SS&C Blue Prism?Common use casesHow Martini supports it
REST APIsYesAdminister and manage Blue Prism processes, sessions, resources, environments, and work queues where exposed by the target API version. REST is the preferred approach for new platform integrations when the required operation is available.Martini can consume the Blue Prism REST API from workflows, authenticate with OAuth 2.0, transform JSON payloads, and expose a separate REST API that abstracts Blue Prism operations.
AuthenticationYesModern Blue Prism API deployments use OAuth 2.0 through configured identity services, commonly with registered client credentials, scopes, and permissions.Martini can store client secrets and environment-specific endpoints securely, obtain or refresh tokens, and send bearer tokens to Blue Prism endpoints.
Webhooks / outbound callbacksLimitedSelected Blue Prism components and releases may provide notifications, callbacks, or event-related capabilities, but coverage across processes, sessions, resources, and work queues is not universal.Where a documented callback exists, Martini can receive it through a REST API or webhook-triggered workflow. Otherwise, Martini can use scheduled polling.
Bulk, asynchronous, and batch processingLimitedBlue Prism sessions and work queues are inherently asynchronous, but a universal bulk API for all objects was not verified. Queue-oriented batching, pagination, and controlled concurrency are appropriate for larger workloads.Martini can process pages or batches, limit concurrent requests, persist checkpoints, and monitor multiple sessions with retry and timeout branches.
SOAP APIsLegacySOAP-based interfaces and older web-service patterns exist in parts of the Blue Prism ecosystem, but their availability depends on the release and installed components.Martini can consume SOAP services where the target deployment documents and enables them, while keeping REST as the preferred new-integration mechanism.
Database / analytics accessLimitedBlue Prism deployments commonly use Microsoft SQL Server. Approved read-only access may support reporting or analytics, but direct writes to Blue Prism system tables are not recommended.Martini can use approved SQL connectivity for reporting workflows, while operational changes should be performed through supported Blue Prism APIs.
File / attachment APIsNot confirmedBlue Prism processes can interact with files, but a general-purpose platform file or attachment API was not verified.Martini can process files or use an external file-transfer endpoint when separately documented, but should not assume file support in the core Blue Prism REST API.

How SS&C Blue Prism exposes data and business events

SS&C Blue Prism REST APIs

Blue Prism provides REST APIs for platform administration and automation management in current product versions. Depending on the release and enabled components, the APIs can expose processes, sessions, resources, environments, and work queues. Exact resources, fields, and paths must be confirmed for the target deployment.

Martini implementation pattern

Martini implementation pattern: a workflow or Martini API authenticates with the configured Blue Prism identity service, calls the required REST endpoint, validates the response, maps Blue Prism JSON into a canonical model, and invokes downstream systems or returns a controlled response.

Implementation sequence

Receive a business request or scheduled trigger
Obtain or refresh an OAuth 2.0 access token
Call the documented Blue Prism REST endpoint
Validate the response and capture correlation identifiers
Map Blue Prism JSON to the target data model
Write the result or return a normalized API response

Process and session orchestration

Blue Prism processes can be started or managed through supported API operations, while sessions represent their asynchronous runtime execution. A process-start response may be accepted before the automation completes, so status must be handled as a separate lifecycle.

Martini implementation pattern

Martini implementation pattern: receive a request, validate the process and resource context, submit the operation, persist the session identifier, and use an asynchronous workflow or status endpoint to monitor completion. Martini reconciles uncertain outcomes before repeating a process start.

Implementation sequence

Validate the process, resource, and business correlation ID
Submit the documented process or session operation
Persist the returned session identifier
Poll session status or receive a documented callback
Map the lifecycle state to a normalized status
Publish completion, failure, or pending-reconciliation results

Work Queues and batch processing

Blue Prism work queues distribute cases and work items to automation processes. The platform is naturally asynchronous, but a universal bulk API was not verified, so larger synchronizations should use documented pagination, queue-oriented batches, and controlled concurrency.

Martini implementation pattern

Martini implementation pattern: a scheduled workflow retrieves queue pages, transforms Work Queue Items, submits downstream operations, and updates queue state only after successful completion. Checkpoints and stable identifiers make the workflow restartable and reduce duplicate processing.

Implementation sequence

Start the scheduled queue synchronization
Retrieve a page of Work Queues or Work Queue Items
Persist the page checkpoint and stable item identifiers
Map and validate each item
Execute downstream work with controlled concurrency
Update the item after downstream commit and record the outcome

Notifications and callbacks

Selected Blue Prism components and releases may provide notifications, callbacks, or event-related capabilities. Broad webhook coverage for every process, session, resource, or queue event was not verified, so callback availability must be confirmed for the deployment.

Martini implementation pattern

Martini implementation pattern: expose a secured Martini REST endpoint or webhook-triggered workflow only when the Blue Prism component documents the callback contract. The workflow validates the notification, retrieves the current Blue Prism resource when necessary, and uses polling for unsupported event types.

Implementation sequence

Confirm the callback capability and event contract for the deployment
Receive the notification at a secured Martini endpoint
Validate the event and deduplicate its correlation data
Retrieve the current Blue Prism resource when required
Map the event to a downstream status or action
Use scheduled polling for event types without callback support

Legacy SOAP services

SOAP-based interfaces and older web-service patterns exist in parts of the Blue Prism ecosystem, but support depends on the installed components and release. REST should generally be preferred for new platform integrations where the required operation is available.

Martini implementation pattern

Martini implementation pattern: where a target deployment documents a required SOAP operation, Martini consumes the service using its SOAP integration capabilities, applies the documented authentication and XML mapping, and routes transport or service faults through workflow error handling.

Implementation sequence

Confirm the SOAP interface and target Blue Prism release
Configure the documented endpoint and authentication
Send the validated SOAP request
Parse and validate the XML response
Map the response to the canonical model
Handle SOAP faults and retry only safe operations

Common SS&C Blue Prism integration patterns

Pattern 1: Start and monitor Blue Prism processes

When to use this pattern

Use this pattern when an enterprise application needs to request a Blue Prism automation and receive a reliable business outcome. It separates process initiation from asynchronous session monitoring and prevents an ambiguous timeout from creating a duplicate run.

Integration direction
Enterprise application
Martini
SS&C Blue Prism
Example Mapping
SS&C Blue Prism FieldCanonical FieldTarget Field
processNameautomationProcessProcess name
businessReferencecorrelationIdQueue or session reference
inputDataprocessParametersProcess input
sessionStatusexecutionStatusSession status
Martini implementation pattern

Martini receives and validates the request, authenticates with Blue Prism, starts the documented process or session operation, and persists the returned identifier. An asynchronous workflow polls status, applies timeout and retry rules, and returns a normalized result. Before repeating a timed-out start, it reconciles whether a session was created.

Martini capabilities used
  • API exposure
  • API consumption
  • workflows
  • data mapping
  • business rules
  • error handling

Pattern 2: Synchronize Blue Prism Work Queue Items

When to use this pattern

Use this pattern when Blue Prism queues contain cases that must be synchronized with a business application or data store. It is suitable for scheduled, incremental processing with checkpointing and downstream commit control.

Integration direction
SS&C Blue Prism
Martini
Business application
Example Mapping
SS&C Blue Prism FieldCanonical FieldTarget Field
itemIdworkItemIdExternal reference
prioritypriorityCase priority
itemDatabusinessPayloadCase or transaction data
itemStatusprocessingStatusCase status
Martini implementation pattern

A scheduled Martini workflow retrieves queue pages, records a checkpoint, maps Work Queue Items to the target model, and applies validation and routing rules. It updates Blue Prism only after the target transaction commits, uses stable identifiers to avoid duplicates, and routes abandoned or exception items for reconciliation.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • pagination handling
  • data mapping
  • business rules
  • checkpointing
  • error handling

Pattern 3: Expose a controlled automation API

When to use this pattern

Use this pattern when multiple applications need a stable enterprise interface instead of direct access to Blue Prism authentication, endpoint details, and payload formats. Martini becomes the governed boundary for validation and orchestration.

Integration direction
Enterprise applications
Martini
SS&C Blue Prism
Example Mapping
SS&C Blue Prism FieldCanonical FieldTarget Field
requestTypeautomationRequestProcess selection
requesterIdrequestingPrincipalCorrelation or audit data
parametersvalidatedInputsProcess parameters
statusnormalizedStatusAPI response status
Martini implementation pattern

Martini exposes a REST API, authenticates and authorizes callers, validates the requested process and parameters, and applies business rules before invoking Blue Prism. It hides vendor-specific credentials and payloads, returns an accepted response for long-running work, and exposes or publishes a status result with correlation data.

Martini capabilities used
  • API exposure
  • API security
  • workflows
  • validation
  • data transformation
  • business rules
  • monitoring

Pattern 4: Publish Blue Prism execution status

When to use this pattern

Use this pattern when operations teams or business applications need visibility into process, session, and resource status. It supports scheduled polling where a documented Blue Prism callback is unavailable or incomplete.

Integration direction
SS&C Blue Prism
Martini
ServiceNow
Example Mapping
SS&C Blue Prism FieldCanonical FieldTarget Field
sessionIdexecutionIdExternal task reference
statusnormalizedStatusTask state
resourceNameruntimeResourceAssignment or diagnostic field
errorDetailsfailureReasonWork note or incident detail
Martini implementation pattern

A scheduled Martini workflow queries the relevant Blue Prism resources, compares the result with the last checkpoint, and publishes only meaningful changes. It creates or updates operational records, suppresses duplicate notifications, and distinguishes transient API failures from actual process failures.

Martini capabilities used
  • scheduled workflows
  • API consumption
  • checkpointing
  • data mapping
  • conditional routing
  • error handling
  • monitoring

Applications commonly integrated with SS&C Blue Prism

Blue Prism is commonly used alongside business applications whose transactions, exceptions, or operational work can be handled by digital workers. The exact interface depends on the application and Blue Prism process design; Martini can orchestrate the interaction, apply business rules, and normalize status and error handling across systems.

Application Scenario Direction Martini Pattern
Salesforce Automate customer, account, case, or opportunity updates and synchronize Blue Prism execution outcomes with CRM records. Salesforce → Martini → SS&C Blue Prism Martini receives a Salesforce request or scheduled extract, maps the business payload to a Blue Prism process request, invokes the relevant REST API, and stores the session identifier. A follow-up workflow polls execution status and updates Salesforce with a normalized result.
ServiceNow Use incidents, requests, or tasks to initiate automation and record Blue Prism results, exceptions, and completion details. ServiceNow → Martini → SS&C Blue Prism A Martini API or workflow receives a ServiceNow request, validates the process and business parameters, invokes Blue Prism, and correlates the resulting session with the ServiceNow task. Failed or timed-out runs are routed to an exception path rather than blindly retried.
SAP S/4HANA Automate operational transactions, master-data updates, and exception processing where Blue Prism workers interact with SAP business processes. SAP S/4HANA → Martini → SS&C Blue Prism Martini coordinates the transaction request, transforms SAP data into the input contract expected by the Blue Prism process, and records process and session status. Reconciliation logic prevents duplicate process starts after ambiguous network failures.
Microsoft Dynamics 365 Coordinate customer, case, order, and finance-related activities with Blue Prism automation processes. Microsoft Dynamics 365 → Martini → SS&C Blue Prism Martini consumes or exposes the required application API, maps Dynamics payloads to Blue Prism process inputs, and publishes normalized completion or exception statuses back to Dynamics 365.
Jira Create or update issues for automation exceptions, approvals, operational work items, and remediation activities. Jira → Martini → SS&C Blue Prism A scheduled or event-triggered Martini workflow identifies Blue Prism failures or queue exceptions, applies severity rules, and creates or updates Jira issues with correlation and session identifiers while avoiding duplicate issue creation.
Workday Automate selected HR and finance processes involving worker, payroll, or business-process data. Workday → Martini → SS&C Blue Prism Martini validates the Workday event or request, invokes the appropriate Blue Prism process through its configured API, and records the asynchronous session lifecycle. Sensitive fields and credentials remain in secure configuration.
NetSuite Automate finance and order-management operations that require coordination with NetSuite processes. NetSuite → Martini → SS&C Blue Prism Martini maps NetSuite transactions into a Blue Prism work request, submits or monitors the associated process, and returns a business-level outcome. Retry rules distinguish safe status retrieval from non-idempotent process initiation.
UiPath Coordinate or coexist with automation estates during migration, workload division, or centralized operational orchestration. UiPath → Martini → SS&C Blue Prism Martini provides the orchestration boundary between automation platforms, normalizing requests, statuses, and errors through APIs. This is an architecture pattern rather than a claim of a standard Blue Prism native integration.

How to build a SS&C Blue Prism integration in Martini

Objective

Capture the Blue Prism API version, base URL, deployment topology, identity service, and required permissions before building the workflow.

Instructions in Martini

  • Confirm the target Blue Prism release and enabled API components.
  • Configure HTTPS endpoints and OAuth 2.0 client credentials as environment-specific settings.
  • Store client secrets, tokens, and endpoint values in Martini secrets or secure configuration.
  • Grant the integration identity only the permissions required for its operations.

Objective

Select the trigger that matches the business requirement and the confirmed Blue Prism capabilities.

Instructions in Martini

  • Use a Martini API for synchronous business requests or a controlled asynchronous submission.
  • Use a scheduler for session, resource, or queue polling when callbacks are unavailable.
  • Use a webhook-triggered workflow only for a documented Blue Prism callback contract.
  • Avoid treating Blue Prism as a universal webhook source.

Objective

Call the appropriate Blue Prism API and retrieve complete, version-appropriate data without assuming that one response contains every result.

Instructions in Martini

  • Authenticate and refresh the OAuth 2.0 token when required.
  • Call the documented process, session, resource, environment, or queue endpoint.
  • Implement the pagination model documented for the target API version.
  • Capture session identifiers, item identifiers, timestamps, and correlation references.

Objective

Coordinate Blue Prism operations and downstream actions as an explicit Martini workflow with separate branches for synchronous and long-running work.

Instructions in Martini

  • Separate process initiation from session monitoring.
  • Use asynchronous execution for long-running automations where appropriate.
  • Apply controlled concurrency to process starts and queue processing.
  • Persist checkpoints so interrupted synchronizations can resume safely.

Objective

Convert Blue Prism JSON or documented SOAP responses into canonical enterprise models and target-specific payloads.

Instructions in Martini

  • Map Processes, Sessions, Resources, Work Queues, and Work Queue Items using stable identifiers.
  • Normalize Blue Prism lifecycle states for downstream applications.
  • Validate required fields and tolerate additive response fields where safe.
  • Keep version-specific mappings isolated from shared business models.

Objective

Protect automation operations from invalid requests, duplicate starts, unsafe retries, and inconsistent downstream updates.

Instructions in Martini

  • Validate process names, resources, queue references, and business parameters.
  • Use correlation IDs and reconciliation checks before retrying process initiation.
  • Update queue items only after downstream transactions commit.
  • Route invalid, abandoned, deferred, and exception items according to defined policies.

Common SS&C Blue Prism data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
ProcessesRepresent Blue Prism automations that can be scheduled, started, stopped, and monitored.Salesforce, ServiceNow, SAP S/4HANA, Microsoft Dynamics 365, operational data storesMartini validates the process reference and input parameters, invokes documented process operations, records correlation data, and applies reconciliation before retrying a potentially non-idempotent start.
SessionsRepresent runtime executions of Blue Prism processes, including status and associated resources.ServiceNow, Jira, monitoring platforms, operational data storesMartini stores session identifiers, polls or receives supported status notifications, maps lifecycle states to a canonical model, and routes failures or timeouts to exception handling.
ResourcesRepresent digital workers, runtime resources, or execution environments used to run processes.Monitoring platforms, capacity dashboards, service-management applicationsMartini retrieves resource information for validation, capacity-aware routing, and operational reporting without assuming that every deployment exposes identical fields.
Work QueuesOrganize and distribute automation work across Blue Prism processes and runtime resources.Salesforce, ServiceNow, SAP S/4HANA, business applications, reporting storesMartini reads queue collections using the documented pagination model, checkpoints progress, applies controlled concurrency, and reconciles queue states.
Work Queue ItemsRepresent individual cases or work items with status, priority, item data, and stable references.Business applications, case-management systems, data warehousesMartini maps item data to target schemas, uses stable identifiers or unique references for idempotency, and updates item state only after downstream transactions commit.
EnvironmentsRepresent configured Blue Prism environments or deployment contexts used to organize automation resources and execution.Configuration stores, monitoring platforms, operational data storesMartini treats environment identifiers and API base URLs as version- and deployment-specific configuration, using them to select the correct target context.

Authentication and security considerations

OAuth 2.0 and least privilege

Modern SS&C Blue Prism API deployments generally use OAuth 2.0 through configured identity services. Service integrations commonly use registered client credentials, scopes, and Blue Prism permissions. Confirm the authentication behavior for the target release and API components rather than assuming that all installations use the same method.

Secrets and transport

Use HTTPS for API communication. Store client secrets, access tokens, endpoint URLs, and environment-specific settings in Martini secure configuration or secrets management. Do not place credentials in workflow payloads or operational logs.

Access boundaries

  • Use a dedicated integration identity.
  • Separate monitoring permissions from permissions that can start, stop, or administer processes.
  • Grant access only to the processes, sessions, resources, and queues required by the integration.
  • Review permissions when Blue Prism versions or API components change.

Operational considerations for SS&C Blue Prism integrations

Versioning and deployment topology

API availability, endpoint paths, schemas, authentication, and network access depend on the Blue Prism version, API version, identity configuration, installed components, and hosted or on-premises topology. Keep the base URL and version-specific mappings in environment configuration.

Polling, pagination, and capacity

Do not assume that collection responses contain all results or that a universal public rate limit exists. Implement documented pagination, moderate polling intervals, exponential backoff for transient failures, controlled concurrency, and checkpoints. Coordinate Martini schedules with Blue Prism runtime-resource capacity.

Idempotency and session lifecycle

Starting a process can create a new session, so an unknown timeout must be reconciled before retrying. Model accepted, created, running, completed, stopped, failed, and timed-out states separately. For Work Queue Items, use stable identifiers and update Blue Prism only after the downstream transaction commits.

Testing and change management

  • Maintain contract tests for key endpoints and version-specific mappings.
  • Tolerate additional response fields where safe and detect missing or renamed fields.
  • Test authentication failures, invalid references, throttling, service unavailability, runtime failures, and duplicate notifications.
  • Review integration behavior before upgrading Blue Prism or its API components.
  • Do not write directly to Blue Prism system tables; isolate approved read-only SQL reporting from operational API workflows.

Why use Martini instead of scripts or point-to-point integrations?

Centralized orchestration

Martini provides a governed workflow and API layer between SS&C Blue Prism and enterprise applications. It can coordinate requests, asynchronous sessions, queue processing, status polling, and downstream updates without duplicating integration logic in multiple scripts.

Reusable transformation and rules

Martini maps Blue Prism objects into canonical and target-specific models, validates inputs, applies business rules, and normalizes statuses and errors. Version-specific API details can be isolated from reusable business workflows.

Operational reliability

Workflows can include checkpoints, correlation identifiers, controlled concurrency, timeout handling, reconciliation, and targeted retries. This is especially important when process initiation is non-idempotent or when callback coverage is incomplete.

Controlled enterprise interfaces

Martini can expose a secured REST API that hides Blue Prism credentials and deployment-specific payloads from downstream applications. It can also support monitoring, logging, testing, and environment-specific deployment configuration as the integration evolves.

Frequently asked questions

How can SS&C Blue Prism be integrated with enterprise systems?

SS&C Blue Prism can be integrated through its documented REST APIs, typically secured with OAuth 2.0, to manage processes, sessions, resources, environments, and work queues. Selected components and releases may also provide callbacks or notifications, while scheduled polling can cover unsupported event types. Legacy SOAP interfaces and approved read-only SQL reporting may be relevant for specific deployments but require release-specific validation.

Can Martini integrate with SS&C Blue Prism?

Yes. Martini can consume documented SS&C Blue Prism REST APIs, authenticate through the configured OAuth 2.0 identity services, orchestrate process and session workflows, synchronize Work Queue Items, transform payloads, and expose an API façade. Where a supported callback is documented, Martini can receive it; otherwise it can poll Blue Prism on a schedule.

Do I need a connector to integrate SS&C Blue Prism with Martini?

No dedicated SS&C Blue Prism connector is required. Martini can integrate using Blue Prism's confirmed native REST APIs, OAuth 2.0 authentication, supported callback or webhook-style notifications, and documented legacy SOAP or approved database interfaces where appropriate. No native Martini Blue Prism connector was verified in the supplied context.

Is there any extra Lonti cost to integrate SS&C Blue Prism with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate SS&C Blue Prism. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from SS&C Blue Prism, cloud infrastructure, hosting, or other third-party systems depending on licensing, usage, and deployment model.

Which SS&C Blue Prism integration methods should be used for new integrations?

Use the Blue Prism REST API with OAuth 2.0 when the required operation is available. Use queue-oriented batching and documented pagination for larger workloads, and use scheduled polling for status or event types without a documented callback. SOAP is a legacy option that should be validated against the target release, and no official Blue Prism GraphQL API was verified.

Does SS&C Blue Prism provide webhooks or event notifications?

Selected Blue Prism components and releases may provide notifications, callbacks, or event-related capabilities, but universal webhook coverage for every process, session, resource, or work queue event should not be assumed. Martini can receive a documented callback through a secured API; for unsupported events, it can poll Blue Prism with checkpoints and deduplication.

How does Martini synchronize Blue Prism data and handle transformation?

Martini retrieves Blue Prism JSON through workflows, follows the target API's pagination model, maps actual objects such as Sessions and Work Queue Items into canonical models, and transforms them for downstream applications. Checkpoints, stable identifiers, and status comparisons support incremental synchronization and reduce duplicate processing.

How are errors, retries, and duplicate Blue Prism process starts handled?

Martini can classify authentication, validation, network, capacity, throttling, and runtime failures, then apply targeted retry and timeout policies. Process initiation is potentially non-idempotent, so a timed-out request should be reconciled using correlation or session data before another start is submitted. Queue synchronization should use stable identifiers, checkpoints, and downstream commit rules.

Related Martini documentation

APIs

Workflows

Data

Security

Operations

Integrate SS&C Blue Prism with confidence

Use Martini to connect SS&C Blue Prism APIs and automation workflows with enterprise applications through secure authentication, reusable orchestration, controlled synchronization, and operationally reliable error handling.

EXPLORE MARTINI
BOOK A DEMO