Ellipse Gradient for Header

Modern Treasury Integration Guide

Connect Modern Treasury payment, banking, ledger, and reconciliation operations with enterprise systems through REST APIs, selected webhook events, and Martini workflows.

Modern Treasury integration options at a glance

Modern Treasury’s primary integration interface is its REST API, which supports payment orders, counterparties, external accounts, ledger accounts, ledger transactions, expected payments, and related resources. Selected webhook events notify systems about payment status changes, returns, reversals, and other documented events. Martini can consume these APIs, receive and validate webhook requests, retrieve the latest resource after an event, and orchestrate downstream updates. API-key authentication and the Modern Treasury organization identifier can be stored as environment-specific secrets. Document-related API resources can support selected supporting-document workflows, subject to confirmation of the required upload and file operations.

Integration pointSupported by Modern Treasury?Common use casesHow Martini supports it
REST APIsYesCreate, retrieve, update, and list Payment Orders, Counterparties, External Accounts, Ledger Accounts, Ledger Transactions, Expected Payments, and related resources.Martini can consume Modern Treasury REST endpoints from workflows, map request and response data, apply business rules, and expose controlled internal APIs for upstream applications.
Webhooks / outbound callbacksYesReceive selected notifications for Payment Order status changes, returns, reversals, counterparty or account changes, and documented ledger or reconciliation events.Martini can expose an endpoint or workflow trigger, validate the request, acknowledge promptly, retrieve the current resource, and process the event idempotently.
File / attachment APIsLimitedManage document-related resources and supporting documentation associated with financial objects where the required API operations are available.Martini can orchestrate document metadata and file-transfer steps, but the exact upload behavior, file types, and object relationships should be confirmed for the use case.
AuthenticationYesAuthenticate API requests with Modern Treasury API credentials and supply the organization identifier in the required request header.Martini can store credentials and organization identifiers as environment-specific secrets and apply them to outbound API calls; webhook authenticity should also be validated.
Pagination and synchronizationYesRetrieve complete lists incrementally and reconcile Payment Orders, Counterparties, External Accounts, Ledger Transactions, and Expected Payments using pagination and available filters.Martini workflows can maintain durable checkpoints, process pages, apply time or status filters where supported, and combine scheduled reconciliation with webhook processing.
Bulk / async / batch APIsNot confirmedPayment processing and webhook activity may be asynchronous, but a general-purpose Modern Treasury bulk or batch API was not confirmed.Martini can orchestrate asynchronous workflows and status polling without representing an unconfirmed bulk API as a vendor capability.
GraphQL APIsNot confirmedNo official Modern Treasury GraphQL API documentation was confirmed in the supplied research.Martini should use the confirmed REST API and webhook mechanisms rather than assuming a GraphQL interface.
SOAP APIsNot confirmedNo official Modern Treasury SOAP API documentation was confirmed.Martini should not design the Modern Treasury integration around SOAP unless the vendor separately confirms such an endpoint.

How Modern Treasury exposes data and business events

Modern Treasury REST APIs

Modern Treasury REST APIs are the principal integration interface for payment, counterparty, account, ledger, expected-payment, and supporting-resource operations. List endpoints support incremental retrieval through pagination and filtering where documented.

Martini implementation pattern

Martini implementation pattern: a workflow or Martini API receives a request, authenticates with environment-specific credentials, calls the required Modern Treasury endpoint, maps the response to a canonical model, applies business rules, and writes the result to the target system. Durable checkpoints and correlation identifiers support repeatable synchronization.

Implementation sequence

Receive an API request or start a scheduled synchronization
Authenticate with the Modern Treasury API credential and organization identifier
Call the required Modern Treasury REST endpoint
Process all required pages and persist a synchronization checkpoint
Map the response to the canonical data model
Apply validation, approval, currency, and duplicate-prevention rules

Modern Treasury Webhooks

Modern Treasury provides webhook notifications for selected events, including documented Payment Order status changes, returns, reversals, and certain counterparty, account, ledger, or reconciliation events. Coverage is event-specific and is not universal across every object or state transition.

Martini implementation pattern

Martini implementation pattern: expose a controlled endpoint or workflow trigger, validate webhook authenticity, acknowledge promptly, record the event identifier, retrieve the current Modern Treasury resource, and process the notification asynchronously. Scheduled REST reconciliation provides recovery for missed or rejected deliveries.

Implementation sequence

Receive the Modern Treasury webhook notification
Validate webhook authenticity and required event fields
Record the event identifier and related resource identifier
Return an appropriate HTTP response promptly
Retrieve the current resource through the REST API
Map the resource to the downstream model and apply idempotency checks

Modern Treasury Documents

Modern Treasury provides document-related API resources for supporting documentation associated with financial objects. The exact binary upload process, supported file types, and object relationships should be confirmed for the target workflow.

Martini implementation pattern

Martini implementation pattern: orchestrate document metadata and any confirmed file-transfer operations, associate the document with the relevant financial object, and preserve correlation and audit information. Martini should only implement binary operations confirmed for the selected Modern Treasury resource.

Implementation sequence

Identify the financial object and document relationship
Retrieve or create the required document metadata
Transfer the file using the confirmed Modern Treasury operation
Associate the document with the target financial object
Store the Modern Treasury document identifier
Handle upload or association errors without duplicating the document

Modern Treasury Scheduled Reconciliation

Scheduled REST retrieval complements webhook processing by identifying missed events, incomplete downstream updates, and reconciliation differences. Pagination, filtering, and durable checkpoints are important when processing payment and ledger collections.

Martini implementation pattern

Martini implementation pattern: a scheduler starts a workflow for a bounded time window, retrieves pages of relevant resources, compares them with stored correlation keys, and routes new, changed, or unmatched items to downstream systems or review queues.

Implementation sequence

Start the reconciliation workflow on a controlled schedule
Load the last successful synchronization checkpoint
Retrieve filtered Modern Treasury resources page by page
Compare resource and event identifiers with stored processing keys
Write new or changed records to the target system
Persist the checkpoint and report unresolved differences

Common Modern Treasury integration patterns

Pattern 1: Execute approved payments from finance systems

When to use this pattern

Use this pattern when an ERP, procurement, payroll, or finance application produces an approved payment instruction that must be created and tracked in Modern Treasury. The flow should distinguish request acceptance from later settlement and should prevent duplicate payment creation.

Integration direction
NetSuite or Workday
Martini
Modern Treasury
Example Mapping
Modern Treasury FieldCanonical FieldTarget Field
payment_order.amountpayment.amountPayment Order amount
payment_order.currencypayment.currencyPayment Order currency
counterparty_idbeneficiary.idCounterparty reference
payment_typepayment.methodPayment Order payment type
Martini implementation pattern

A Martini API or workflow receives the approved instruction, validates beneficiary, amount, currency, payment type, and approval status, and checks the source transaction and idempotency key before calling Modern Treasury. It persists the resulting Payment Order identifier and returns a normalized accepted status. Later webhook events update the source system; transient failures use bounded retries while validation or business-state failures are routed for correction.

Martini capabilities used
  • APIs
  • workflows
  • data mapping
  • business rules
  • secrets management
  • error handling

Pattern 2: Synchronize payment statuses and exceptions

When to use this pattern

Use this pattern when downstream finance or operations systems need current Payment Order status, return, reversal, or failure information. Webhooks provide timely notification for selected events, while REST retrieval ensures that downstream processing uses the current resource state.

Integration direction
Modern Treasury
Martini
NetSuite or ServiceNow
Example Mapping
Modern Treasury FieldCanonical FieldTarget Field
payment_order.idpayment.externalIdExternal payment ID
payment_order.statuspayment.statusPayment status
return.reasonpayment.exceptionReasonException reason
event.idevent.correlationIdIntegration event ID
Martini implementation pattern

Martini receives a selected Modern Treasury webhook, validates and records the event, retrieves the current Payment Order or related resource, and maps the vendor status to the target status model. Duplicate events are ignored using the event or business key. Returns, reversals, and failed states can create ServiceNow cases or finance exceptions, while temporary API failures are retried with bounded backoff.

Martini capabilities used
  • webhook consumption
  • workflow orchestration
  • data mapping
  • idempotency
  • error handling
  • monitoring

Pattern 3: Synchronize ledger activity to finance platforms

When to use this pattern

Use this pattern when finance systems need Modern Treasury Ledger Accounts and Ledger Transactions for accounting, reporting, or reconciliation. Scheduled retrieval is appropriate where the required ledger event coverage is not available through webhooks.

Integration direction
Modern Treasury
Martini
SAP S/4HANA or NetSuite
Example Mapping
Modern Treasury FieldCanonical FieldTarget Field
ledger_account.idaccount.externalIdLedger account ID
ledger_transaction.amountjournal.amountJournal amount
ledger_transaction.currencyjournal.currencyCurrency
ledger_transaction.effective_atjournal.effectiveDatePosting date
Martini implementation pattern

A scheduled Martini workflow loads a checkpoint, retrieves Ledger Accounts and Ledger Transactions page by page, preserves monetary precision, maps accounts to the target chart of accounts, and applies period and debit-credit rules. It stores source identifiers to prevent duplicate journal entries and routes unmapped accounts or reconciliation differences for review.

Martini capabilities used
  • scheduling
  • API consumption
  • pagination
  • data transformation
  • business rules
  • checkpointing

Pattern 4: Reconcile expected payments with payment activity

When to use this pattern

Use this pattern when finance teams need to compare Expected Payments with Payment Orders, incoming payment information, or related financial activity. It supports operational reconciliation and exception routing without assuming that every state change produces a webhook.

Integration direction
Modern Treasury
Martini
NetSuite or finance operations
Example Mapping
Modern Treasury FieldCanonical FieldTarget Field
expected_payment.idexpectedPayment.externalIdExpected payment ID
expected_payment.amountexpectedPayment.amountExpected amount
expected_payment.currencyexpectedPayment.currencyCurrency
payment_order.idmatchedPayment.externalIdMatched payment ID
Martini implementation pattern

Martini retrieves Expected Payments and relevant payment activity within a bounded time window, normalizes identifiers and monetary fields, and applies matching rules for amount, currency, counterparty, account, and timing. Matched results are written to the finance platform; unmatched, partial, or conflicting items are routed to review. Checkpoints and idempotency keys make reruns safe.

Martini capabilities used
  • scheduled workflows
  • data mapping
  • matching rules
  • API consumption
  • exception handling
  • audit logging

Applications commonly integrated with Modern Treasury

Modern Treasury commonly sits between payment, finance, banking, and operational systems. The following products represent practical integration counterparts; exact flows depend on each system’s APIs, account configuration, and business process.

Application Scenario Direction Martini Pattern
NetSuite Synchronize approved vendor payments, payment statuses, settlement results, and reconciliation data between finance operations and Modern Treasury. NetSuite → Martini → Modern Treasury Martini receives approved payment instructions, validates amount, currency, beneficiary, and approval state, creates a Modern Treasury Payment Order, and later processes webhook events or reconciliation results back into NetSuite.
Salesforce Connect customer, billing, or receivables processes to payment execution and payment-status visibility. Salesforce → Martini → Modern Treasury A Martini API or scheduled workflow accepts payment requests from Salesforce-related processes, calls Modern Treasury, persists the external identifier, and publishes normalized status or exception updates back to Salesforce.
Stripe Reconcile Stripe-originated collections or payouts with Modern Treasury payment and ledger activity. Stripe → Martini → Modern Treasury Martini consumes relevant Stripe and Modern Treasury API data, applies transaction and account matching rules, and writes reconciliation outcomes to the designated finance or ledger process.
Workday Send approved payroll, supplier, or reimbursement payment instructions to Modern Treasury and return processing results. Workday → Martini → Modern Treasury A workflow validates Workday payment batches or instructions, creates corresponding Payment Orders, stores correlation identifiers, and routes returned, failed, or completed outcomes back to Workday.
SAP S/4HANA Connect treasury payment execution with enterprise accounting, vendor payments, and reconciliation. SAP S/4HANA → Martini → Modern Treasury Martini maps SAP payment and accounting structures to Modern Treasury resources, applies approval and currency rules, and synchronizes payment outcomes and ledger activity back to SAP.
ServiceNow Create operational cases for payment exceptions, returns, failed payments, or manual review. Modern Treasury → Martini → ServiceNow Martini receives selected Modern Treasury webhook events, retrieves the current resource, classifies the exception, and creates or updates a ServiceNow case with correlation and audit details.
Jira Track payment integration incidents, reconciliation exceptions, and engineering remediation work. Modern Treasury → Martini → Jira Martini routes persistent API, webhook, or reconciliation failures to Jira with the event identifier, resource identifier, error category, and relevant diagnostic context.

How to build a Modern Treasury integration in Martini

Objective

Configure the Modern Treasury API credential, organization identifier, environment endpoints, and webhook verification settings without embedding secrets in workflow logic.

Instructions in Martini

  • Create environment-specific secret values for API credentials and organization identification
  • Configure the required Modern Treasury authentication headers
  • Separate sandbox and production configuration where applicable
  • Apply least-privilege access and protect webhook endpoints

Objective

Select the trigger that matches the integration’s latency and recovery requirements: a Modern Treasury webhook, an inbound Martini API request, or a scheduled synchronization.

Instructions in Martini

  • Use a webhook trigger for selected asynchronous Modern Treasury events
  • Use a Martini API for controlled payment or ledger requests from internal applications
  • Use a scheduler for pagination-based reconciliation and recovery
  • Define the event types, time windows, and checkpoint strategy

Objective

Receive the event or request and obtain the authoritative Modern Treasury resource before downstream processing.

Instructions in Martini

  • Validate inbound request structure and webhook authenticity
  • Record event and source transaction identifiers
  • Retrieve the current Payment Order, ledger resource, or related object through REST
  • Process paginated responses and retain the synchronization checkpoint

Objective

Coordinate validation, resource retrieval, transformation, target updates, and recovery logic in a maintainable Martini workflow.

Instructions in Martini

  • Separate acceptance of a request from later asynchronous status processing
  • Add correlation identifiers to each workflow execution
  • Route payment, ledger, reconciliation, and exception paths explicitly
  • Use reusable services or APIs for shared validation and normalization logic

Objective

Transform Modern Treasury payloads into canonical and target-specific models while preserving financial precision and required audit fields.

Instructions in Martini

  • Map Payment Orders, Counterparties, External Accounts, Ledger Accounts, Ledger Transactions, or Expected Payments explicitly
  • Preserve currency, amount precision, direction, and source identifiers
  • Validate required fields, account relationships, approval state, and supported business values
  • Ignore or retain additive fields safely as the external schema evolves

Objective

Update the target finance, operations, reconciliation, or case-management application and persist the Modern Treasury correlation state.

Instructions in Martini

  • Write normalized payment status or ledger data to the target system
  • Persist Modern Treasury identifiers and source transaction keys
  • Create operational cases for returns, reversals, failures, and unmatched items
  • Prevent duplicate downstream writes during retries or repeated events

Common Modern Treasury data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
Payment OrdersRepresent instructions to move money through supported payment types such as ACH, wire, or check where available.NetSuite, SAP S/4HANA, Workday, SalesforceMartini validates payment details and approval state, creates or retrieves Payment Orders through REST, stores identifiers, and processes later status, return, or reversal events.
CounterpartiesRepresent individuals or organizations participating in payment activity.NetSuite, SAP S/4HANA, Workday, SalesforceMartini maps identity and beneficiary information, applies validation rules, and synchronizes changes through REST API workflows.
External AccountsRepresent bank or financial accounts associated with counterparties or payment participants.NetSuite, Workday, SAP S/4HANA, PlaidMartini securely maps account references, validates relationships and permissions, and avoids exposing sensitive values in logs or downstream messages.
Ledger AccountsRepresent accounts used to model balances and accounting positions in Modern Treasury’s ledger.NetSuite, SAP S/4HANA, finance data storesMartini retrieves and maps ledger-account structures to a target chart of accounts, applying account and period rules.
Ledger TransactionsRecord movements between ledger accounts for financial tracking and reconciliation.NetSuite, SAP S/4HANA, finance platformsMartini paginates through transactions, preserves monetary precision and currency, prevents duplicates, and sends normalized entries to finance systems.
Expected PaymentsRepresent expected incoming or outgoing payment activity used for tracking and reconciliation.NetSuite, SAP S/4HANA, reconciliation applicationsMartini retrieves expected payments on a schedule, correlates them with payment activity, and routes unmatched or partially matched items for review.

Authentication and security considerations

API authentication

Modern Treasury uses API credentials for general API access, commonly through HTTP Basic Authentication, together with an organization identifier in the required request header. OAuth should not be assumed for standard server-to-server access.

Secrets and environments

Store API credentials, organization identifiers, webhook verification settings, and environment-specific endpoints as Martini secrets or protected configuration. Keep sandbox and production values separate and apply least-privilege access.

Webhook protection

Webhook consumers should validate the authenticity and integrity of incoming requests using the verification mechanism documented by Modern Treasury. Record event identifiers and avoid exposing credentials or sensitive financial data in logs.

Operational considerations for Modern Treasury integrations

Pagination and checkpoints

List responses may contain only a page of Payment Orders, Counterparties, External Accounts, Ledger Transactions, or Expected Payments. Use documented pagination and filters, retain durable checkpoints, and run periodic reconciliation to recover from missed webhook deliveries.

Idempotency and financial precision

Persist stable source transaction keys and idempotency keys before creating payment instructions. Preserve monetary values without binary floating-point rounding, map currencies explicitly, and distinguish accepted, pending, completed, failed, returned, and reversed states.

Retries and schema changes

Use bounded retries for transient network, service, and rate-limit failures. Route validation and business-state errors for correction rather than repeatedly retrying them. Treat webhook payloads and API responses as external contracts and tolerate additive fields.

Testing and monitoring

Test payment creation, status transitions, returns, reversals, webhook verification, duplicate delivery, timeouts, retries, ledger mappings, and reconciliation behavior in a controlled non-production environment. Monitor event identifiers, resource identifiers, workflow outcomes, and unresolved exceptions.

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

Orchestration beyond point-to-point calls

Martini separates inbound requests, Modern Treasury API calls, webhook processing, scheduled reconciliation, target-system updates, and exception handling into maintainable workflows rather than embedding all logic in scripts.

Reusable transformation and business rules

Mappings and validation rules can be reused across finance, payment, ledger, and operational flows. Martini can normalize Modern Treasury objects, preserve financial controls, and apply account, approval, currency, matching, and duplicate-prevention rules consistently.

Operational reliability

Martini provides workflow-based handling for retries, checkpoints, asynchronous processing, logging, and controlled deployment. It can also expose an internal API façade so applications interact with a governed interface instead of calling Modern Treasury directly.

Frequently asked questions

How can Modern Treasury be integrated with enterprise systems?

Modern Treasury can be integrated primarily through its REST API and selected webhook notifications. Enterprise systems can submit and monitor Payment Orders, maintain Counterparties and External Accounts, synchronize Ledger Accounts and Ledger Transactions, retrieve Expected Payments, and process documented payment or reconciliation events.

Can Martini integrate with Modern Treasury?

Yes. Martini can consume the Modern Treasury REST API, receive selected Modern Treasury webhook events, authenticate with API credentials and the organization identifier, and orchestrate validation, mapping, payment, ledger, reconciliation, and exception workflows.

Do I need a connector to integrate Modern Treasury with Martini?

No. A dedicated Modern Treasury connector is not required. Martini can integrate using Modern Treasury’s confirmed REST API, webhook notifications, authentication methods, and applicable document-related API resources.

Is there any extra Lonti cost to integrate Modern Treasury with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Modern Treasury. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Modern Treasury, cloud infrastructure, or other third-party systems based on subscription, usage, and deployment model.

Which Modern Treasury integration methods should be used?

Use the REST API as the primary interface for Payment Orders, Counterparties, External Accounts, ledger resources, Expected Payments, and related data. Use webhook notifications for documented asynchronous events, and supplement them with scheduled REST reconciliation for recovery and completeness. No official GraphQL or SOAP API was confirmed.

Are Modern Treasury webhooks available for every object and state change?

No. Modern Treasury supports webhook notifications for selected event types, but coverage is not universal for every object, field update, or internal processing step. Integrations should consume only documented events and use periodic REST reconciliation where necessary.

How does Martini handle Modern Treasury synchronization and data mapping?

Martini can combine webhook-driven processing with scheduled, paginated REST retrieval. Workflows map Modern Treasury objects to canonical and target models, preserve monetary precision and currency, apply account and status rules, store checkpoints and identifiers, and prevent duplicate processing.

How are Modern Treasury errors, retries, and duplicate events handled?

Martini can classify authentication, validation, rate-limit, network, duplicate, and business-state failures. Transient failures can use bounded retries and backoff, while business errors can be routed for correction. Event identifiers, source transaction keys, and idempotency controls help prevent duplicate payment creation and downstream updates.

Related Martini documentation

APIs

Workflows

Transformation

Security

Operations

Connect Modern Treasury with your enterprise systems

Use Martini to orchestrate Modern Treasury payment, ledger, webhook, and reconciliation integrations with controlled workflows, reusable mappings, and operational safeguards.

EXPLORE MARTINI
BOOK A DEMO