.png)
Temenos Integration Guide
Integrate Temenos banking products with enterprise systems through REST APIs, product-specific services, callbacks, files, and secure API-gateway authentication.
Temenos integration options at a glance
Temenos primarily exposes REST APIs for banking domains such as Customers, Accounts, Transactions, Payments, Loans, and Products, although availability depends on the licensed product, API catalog, deployment model, and version. Some environments may also provide product-specific SOAP services, event notifications, outbound callbacks, asynchronous processing, batch operations, or file exchanges. Authentication commonly uses OAuth 2.0 and API-gateway controls, with possible client credentials, scopes, certificates, or subscription headers. Martini can consume these interfaces, expose APIs for surrounding banking systems, orchestrate workflows, transform JSON or XML, apply validation and business rules, and manage secure environment-specific configuration.
| Integration point | Supported by Temenos? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Current Temenos developer APIs expose banking capabilities such as Customers, Accounts, Transactions, Payments, Loans, and Products, subject to the product and subscribed API catalog. | Martini can consume Temenos REST APIs from workflows, map request and response payloads, apply validation and business rules, and expose REST APIs for surrounding systems. |
| SOAP APIs | Limited | SOAP may be available in legacy or product-specific Temenos environments where a WSDL and applicable service are provided. | Martini can consume a confirmed Temenos SOAP service using its WSDL, configured authentication, XML mapping, and service-specific error handling. |
| Webhooks and outbound callbacks | Limited | Some Temenos products and deployments provide event or notification mechanisms for selected business events, but coverage varies by product and object. | Martini can expose an HTTP endpoint and trigger a workflow when a supported Temenos callback or webhook-style notification is received. |
| Bulk, asynchronous, and batch APIs | Limited | Specific banking processes may support batch submissions, asynchronous jobs, polling, or partial-failure reporting; no universal bulk model applies across Temenos products. | Martini can submit supported jobs, store job identifiers, poll status endpoints, process partial results, and reconcile final outcomes. |
| File and attachment APIs | Limited | Specific Temenos products may support statements, payment files, reports, documents, or other file exchanges, but a universal attachment API was not confirmed. | Martini can retrieve or submit documented files, transform supported formats, route files to other systems, and retain processing references. |
| Authentication | Yes | Temenos API gateways commonly use OAuth 2.0, with environment-specific client credentials, scopes, roles, certificates, subscription keys, or additional headers where configured. | Martini can store credentials and secrets securely, configure authenticated API consumption, separate environment settings, and apply least-privilege access patterns. |
| Database and analytics access | Not confirmed | Direct access to Temenos-managed production databases should not be assumed; supported APIs, reporting services, or customer-provided interfaces are preferred. | Martini can connect to an explicitly supported customer-managed database, but it should not bypass Temenos APIs or connect to application databases without authorization. |
| Scheduled synchronization | Yes | Scheduled retrieval is appropriate where event coverage is unavailable, including incremental synchronization of Customers, Accounts, Transactions, Products, or Loans. | Martini can start workflows on a schedule, preserve checkpoints, handle pagination, apply controlled concurrency, and retry recoverable failures. |
How Temenos exposes data and business events
Temenos REST APIs
REST is the principal publicly documented Temenos integration style for current developer APIs. Available resources and operations depend on the specific Temenos product, API version, licensed modules, tenant, and API catalog.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates through the configured Temenos gateway, calls the required REST resource, handles pagination or continuation state, transforms the response, applies business rules, and writes the result to a target application or data service.
Implementation sequence
Temenos SOAP services
SOAP may be available in legacy or product-specific Temenos environments. It should be confirmed against the target product, deployment, WSDL, and authentication configuration rather than assumed across the Temenos portfolio.
Martini implementation pattern
Martini implementation pattern: a workflow invokes the confirmed WSDL-defined operation, maps XML request and response structures, classifies transport and business faults, and routes successful results or failures according to the banking process.
Implementation sequence
Temenos webhook-style notifications
Some Temenos products and deployments provide event notifications or outbound callbacks for selected business events. Coverage, delivery guarantees, ordering, and payload detail must be confirmed for the target environment.
Martini implementation pattern
Martini implementation pattern: Martini exposes an authenticated API endpoint, validates the incoming notification, checks event identifiers for duplicates, retrieves the full Temenos resource when necessary, and routes the normalized event to downstream workflows.
Implementation sequence
Temenos asynchronous and batch processing
Specific Temenos banking processes may provide asynchronous jobs, batch submissions, polling endpoints, or file-based processing. There is no single universal batch model across the Temenos portfolio.
Martini implementation pattern
Martini implementation pattern: a workflow submits a documented batch or asynchronous request, stores the job or file reference, polls or receives status updates, processes successful and partial results, and reconciles the final outcome with the originating business request.
Implementation sequence
Temenos file exchanges
Some Temenos products support statements, payment files, reports, documents, or other file exchanges. Supported formats and transports are product- and deployment-specific.
Martini implementation pattern
Martini implementation pattern: Martini retrieves or submits a documented file interface, validates the file and business references, transforms the format where required, routes the result to the target system, and records processing status without exposing sensitive data in logs.
Implementation sequence
Common Temenos integration patterns
Pattern 1: Synchronize Customers and Accounts with a CRM
When to use this pattern
Use this pattern when relationship managers or service teams need current Temenos customer and account context in a CRM. It is suitable for scheduled incremental retrieval and, where supported, selected event notifications.
Integration direction
Example Mapping
| Temenos Field | Canonical Field | Target Field |
|---|---|---|
| Customer.customerId | party.externalId | Salesforce Contact.External_Id__c |
| Customer.name | party.displayName | Salesforce Contact.Name |
| Account.accountId | account.externalId | Salesforce Account.External_Id__c |
| Account.status | account.lifecycleStatus | Salesforce Account.Status__c |
Martini implementation pattern
A scheduler or supported Temenos notification starts the workflow. Martini retrieves the current Customers and Accounts, follows pagination and checkpoints, resolves Party and Account relationships, and maps the result to Salesforce. Business rules determine ownership, permitted fields, and whether an update is safe; idempotency keys and durable references prevent duplicate CRM updates, while failed items are retried or routed for review.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
- checkpointing
Pattern 2: Orchestrate payments or transactions
When to use this pattern
Use this pattern when an upstream application needs to submit a payment or transaction request to Temenos and receive a controlled processing, settlement, or rejection outcome.
Integration direction
Example Mapping
| Temenos Field | Canonical Field | Target Field |
|---|---|---|
| payment.amount | transaction.amount | Temenos payment amount |
| payment.currency | transaction.currency | Temenos payment currency |
| payment.reference | transaction.idempotencyReference | Temenos payment reference |
| payment.beneficiary | transaction.counterparty | Temenos beneficiary or counterparty |
Martini implementation pattern
A Martini API accepts the request, validates amount, currency, authorization, and required references, then invokes the applicable Temenos payment or transaction operation. The workflow distinguishes acceptance from posting and settlement, stores correlation and idempotency data, and performs status inquiry before retrying an uncertain timeout. Rejected, returned, or unreconciled items are routed to operational handling.
Martini capabilities used
- APIs
- workflows
- validation
- business rules
- API consumption
- idempotency
- reconciliation
- error handling
Pattern 3: Process Temenos account or transaction notifications
When to use this pattern
Use this pattern when the target Temenos product exposes supported event notifications or callbacks for the required Customer, Account, Payment, or Transaction events.
Integration direction
Example Mapping
| Temenos Field | Canonical Field | Target Field |
|---|---|---|
| event.id | notification.eventId | ServiceNow Correlation ID |
| event.type | notification.eventType | ServiceNow Category |
| resource.id | businessObject.externalId | ServiceNow Configuration or Reference |
| event.occurredAt | notification.occurredAt | ServiceNow Opened or Event Time |
Martini implementation pattern
Martini receives and authenticates the callback, verifies replay and duplicate conditions, and retrieves the full resource when the event contains only a reference. It enriches the notification with business context, creates or updates the operational task, and uses retry and failure routing for unavailable downstream services. The pattern is limited to event types actually supported by the Temenos deployment.
Martini capabilities used
- API exposure
- workflow triggers
- event processing
- data mapping
- business rules
- error handling
- monitoring
Pattern 4: Reconcile Temenos payments with finance data
When to use this pattern
Use this pattern when the institution must compare Temenos payment, transaction, or settlement results with SAP S/4HANA, Oracle NetSuite, or another finance process.
Integration direction
Example Mapping
| Temenos Field | Canonical Field | Target Field |
|---|---|---|
| Transaction.transactionId | reconciliation.externalReference | SAP S/4HANA Document Reference |
| Transaction.amount | reconciliation.amount | SAP S/4HANA Amount |
| Transaction.currency | reconciliation.currency | SAP S/4HANA Currency |
| Transaction.status | reconciliation.processingStatus | SAP S/4HANA Clearing or Settlement Status |
Martini implementation pattern
A scheduled workflow retrieves the documented Temenos transaction or payment results and compares them with finance-system references, amounts, currencies, dates, and statuses. Martini applies tolerance and matching rules, produces matched and exception outcomes, updates the finance system where authorized, and sends unmatched or partial results to a controlled review queue with retry and audit state.
Martini capabilities used
- scheduling
- API consumption
- data mapping
- business rules
- reconciliation
- workflow orchestration
- error handling
Applications commonly integrated with Temenos
Temenos commonly participates in banking architectures alongside customer, finance, service, workforce, engineering, and analytics applications. The exact integration direction depends on which Temenos product is the system of record and which APIs or data services the institution has licensed. Martini can coordinate these exchanges without assuming a prebuilt Temenos connector.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize Temenos Customers, Parties, Accounts, and selected payment or relationship information with relationship-management and service processes. | Temenos → Martini → Salesforce | A scheduled or event-triggered workflow retrieves changed Temenos resources, maps them to Salesforce objects, applies duplicate and ownership rules, and records correlation and retry state. Selected Salesforce updates can be validated and sent back through Temenos APIs where permitted. |
| ServiceNow | Create incidents, service requests, or operational tasks for failed payments, account issues, API exceptions, and reconciliation discrepancies. | Temenos → Martini → ServiceNow | Martini receives a Temenos notification or detects an exception during a banking workflow, enriches it with the relevant business reference and error details, and creates or updates a ServiceNow record. Status changes can be routed back to the operational workflow. |
| SAP S/4HANA | Exchange customer, payment, settlement, finance, and reconciliation information between banking operations and enterprise finance processes. | Temenos → Martini → SAP S/4HANA | Martini orchestrates REST or product-specific service calls, normalizes banking and finance payloads, applies amount, currency, and reference validation, and handles asynchronous acceptance and reconciliation outcomes. |
| Oracle NetSuite | Synchronize payment, settlement, customer, and reconciliation data for organizations using NetSuite for finance operations. | Temenos → Martini → Oracle NetSuite | A Martini workflow retrieves or receives Temenos payment results, maps them to NetSuite finance structures, prevents duplicate postings using business references, and routes rejected or unmatched items for review. |
| Workday | Support payroll, employee banking, treasury, or organization-related processes where banking services interact with Workday-managed data. | Workday → Martini → Temenos | Martini validates Workday-originated payment or banking instructions, applies authorization and idempotency rules, submits eligible requests to Temenos, and returns processing or reconciliation status to the appropriate downstream process. |
| Microsoft Dynamics 365 | Synchronize customer and financial relationship data with sales, service, or finance applications while Temenos remains the source for banking accounts and transactions. | Temenos → Martini → Microsoft Dynamics 365 | Martini performs incremental retrieval or event processing, maps Customers, Parties, Accounts, and Transactions to Dynamics 365 structures, applies system-of-record rules, and retries transient API failures without duplicating updates. |
| Jira | Create development or operational work items from integration failures, API incidents, or banking-process exceptions requiring investigation. | Martini → Jira | Error-handling branches classify Temenos failures, remove sensitive data from the diagnostic payload, attach correlation and business references, and create or update Jira issues with controlled retry behavior. |
| Microsoft Power BI | Deliver curated customer, account, transaction, payment, or product data for operational reporting and analytics. | Temenos → Martini → Microsoft Power BI | Martini retrieves supported Temenos API or reporting data, transforms it into an analytics-ready structure, applies privacy and reconciliation checks, and publishes or stages the result without direct access to Temenos application databases. |
How to build a Temenos integration in Martini
Objective
Identify the exact Temenos product, release, API catalog, environment, and licensed modules, then configure the applicable gateway authentication.
Instructions in Martini
- Confirm the Temenos product and API version
- Provision OAuth 2.0 client credentials, scopes, roles, certificates, or gateway headers as required
- Store secrets outside workflow payloads and logs
- Separate sandbox, test, and production configuration
Objective
Select the trigger that matches the Temenos capability and synchronization requirement.
Instructions in Martini
- Use a REST API or Martini API when another system initiates the process
- Use a scheduler for incremental synchronization where events are unavailable
- Receive a supported Temenos callback or notification through an API endpoint
- Use an asynchronous job or file trigger only when documented for the target product
Objective
Obtain the current Temenos resource or notification while preserving the references needed for reliable processing.
Instructions in Martini
- Call the relevant REST or confirmed SOAP operation
- Validate incoming callback authentication and event identifiers
- Handle pagination, continuation tokens, and job references
- Store the last successful checkpoint or processing position
Objective
Coordinate calls, lookups, transformations, business decisions, and downstream writes in a maintainable Martini workflow.
Instructions in Martini
- Separate request validation from business processing
- Retrieve full Customers, Accounts, Transactions, Products, Parties, or Loans when notifications are incomplete
- Use correlation IDs and durable business references
- Branch synchronous acceptance, asynchronous processing, rejection, and settlement outcomes
Objective
Convert product-specific Temenos payloads into a canonical model and target-system representation.
Instructions in Martini
- Use explicit field mappings rather than passing payloads through unchanged
- Transform JSON or XML structures as required
- Normalize dates, amounts, currencies, statuses, and identifiers
- Protect or omit sensitive banking data from diagnostic output
Objective
Apply banking-specific validation, authorization, idempotency, and reconciliation rules before committing changes.
Instructions in Martini
- Validate required identifiers, amounts, currencies, and statuses
- Check duplicate payment or event references before retrying
- Confirm system-of-record and permitted update directions
- Create reconciliation and exception outcomes for uncertain or unmatched processing
Common Temenos data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Customers | Synchronize customer or client profiles between Temenos and relationship-management, service, finance, or analytics applications. | Salesforce, Microsoft Dynamics 365, SAP S/4HANA, Microsoft Power BI | Martini retrieves or receives Customers, validates required identifiers, maps fields to a canonical model, applies duplicate and system-of-record rules, and stores synchronization checkpoints. |
| Accounts | Exchange deposit, current, savings, or other banking account information with customer, finance, service, and reporting systems. | Salesforce, Microsoft Dynamics 365, SAP S/4HANA, Microsoft Power BI | Martini processes paginated or event-driven Account data, protects sensitive fields, maps account status and ownership, and supports reconciliation using stable business references. |
| Transactions | Process account postings, transfers, payments, and other financial movements for downstream operations, reconciliation, and reporting. | SAP S/4HANA, Oracle NetSuite, Microsoft Power BI, ServiceNow | Martini applies amount, currency, date, status, and duplicate checks, distinguishes processing from settlement, and routes rejected or unmatched Transactions for controlled handling. |
| Products | Publish banking product and configuration information to customer-facing, decisioning, reporting, or catalog applications. | Microsoft Power BI, Salesforce, Microsoft Dynamics 365 | Martini retrieves supported Product resources, transforms product attributes and eligibility data, applies version and effective-date rules, and publishes validated results. |
| Parties | Represent individuals, organizations, or other parties associated with accounts and financial relationships. | Salesforce, Microsoft Dynamics 365, SAP S/4HANA | Martini maps Party roles and identifiers to target models, resolves relationships to Customers and Accounts, and applies privacy and duplicate-detection rules. |
| Loans | Exchange lending arrangements, loan applications, or loan accounts where the licensed Temenos module exposes those resources. | Salesforce, Microsoft Dynamics 365, Microsoft Power BI, SAP S/4HANA | Martini validates product-specific Loan structures, maps application or account statuses, handles asynchronous decisions where applicable, and records correlation and reconciliation references. |
Authentication and security considerations
Environment-specific authentication
Temenos authentication depends on the product, API gateway, deployment, and institution security policy. OAuth 2.0 is commonly used for developer APIs, while client credentials, scopes, roles, certificates, mutual TLS, subscription keys, or additional headers may also be required.
Protect banking data
- Store client secrets, tokens, certificates, and gateway credentials in secure configuration or secrets management.
- Use separate credentials and endpoints for sandbox, test, and production.
- Apply least-privilege scopes and roles for each workflow.
- Use TLS and avoid logging access tokens, full account numbers, payment details, or unnecessary customer attributes.
Operational considerations for Temenos integrations
Reliability and throughput
- Respect API gateway quotas, concurrency limits, and banking-core capacity with controlled concurrency and backoff.
- Handle pagination, continuation tokens, checkpoints, and partial failures explicitly.
- Distinguish request acceptance, posting, settlement, rejection, return, and final reconciliation.
- Use idempotency keys or durable references and check status before retrying uncertain financial operations.
Change management
Temenos resource names, fields, enumerations, event models, and authentication requirements can vary by product and version. Use explicit mappings, validation, sandbox testing, correlation IDs, and operational monitoring before promoting changes.
Why use Martini instead of scripts or point-to-point integrations?
Orchestrate complete integration flows
Scripts often combine authentication, pagination, transformation, retries, reconciliation, and monitoring in code that is difficult to govern. Martini organizes these concerns into reusable workflows and APIs that can coordinate Temenos with CRM, finance, service, and analytics systems.
Reduce point-to-point coupling
Martini provides a controlled integration layer for mapping Temenos-specific payloads to canonical and target models. This supports business rules, environment-specific configuration, controlled error handling, and reusable services without requiring direct database access to Temenos.
Support banking-grade controls
- Apply validation and idempotency before payment or transaction operations.
- Separate synchronous acceptance from asynchronous processing and settlement.
- Preserve checkpoints, correlation references, reconciliation results, and failure state.
- Expose APIs for surrounding systems while keeping Temenos credentials and implementation details controlled.
Frequently asked questions
Temenos can be integrated primarily through product-specific REST APIs for Customers, Accounts, Transactions, Payments, Products, Loans, and related banking capabilities. Depending on the deployment, integrations may also use legacy or product-specific SOAP services, supported event notifications or callbacks, asynchronous operations, batch processes, and documented file exchanges. Authentication commonly uses OAuth 2.0 and API-gateway security controls.
Yes. Martini can integrate with Temenos by consuming its confirmed REST APIs, invoking applicable SOAP services, receiving supported callbacks or event notifications, and orchestrating documented asynchronous or file-based processes. Martini can transform payloads, apply banking business rules, expose APIs, and route results to enterprise applications.
No. A dedicated Temenos connector is not required. Martini can use Temenos native REST APIs, product-specific SOAP services, supported callbacks or events, documented file interfaces, and the applicable authentication methods. The exact implementation depends on the Temenos product, API catalog, and deployment configuration.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Temenos. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Temenos, cloud infrastructure, or other third-party systems based on subscription, usage, licensing, and deployment model.
REST should generally be evaluated first for new integrations because it is the principal documented Temenos API style. SOAP may be appropriate for a confirmed legacy or product-specific service. Supported callbacks, asynchronous jobs, batch operations, and file exchanges can be used when the target Temenos product documents them. GraphQL was not confirmed as a general Temenos integration method.
Some Temenos products and deployments provide event notifications or outbound callbacks for selected business events, but coverage is not universal. Confirm the event types, delivery method, authentication, ordering, duplicate behavior, retry model, and whether the payload contains a complete resource or only a reference before designing the workflow.
Synchronization can use supported event notifications or scheduled incremental retrieval. Martini can process pagination, continuation tokens, modification timestamps, cursors, resource versions, or other documented change markers, while preserving checkpoints and correlation references. Financial data should also be reconciled using transaction references, amounts, currencies, dates, and processing or settlement statuses.
Martini can separate transport, authorization, gateway, validation, business, and downstream errors, then apply controlled retry and failure-routing rules. Payment and transaction workflows should use idempotency keys or durable business references, status inquiry after uncertain timeouts, duplicate event checks, correlation IDs, and reconciliation rather than blindly repeating a request.
Related Martini documentation
APIs
Workflows
Connect Temenos with your enterprise systems
Use Martini to build secure, maintainable Temenos integrations across banking APIs, callbacks, files, workflows, and downstream applications.