.png)
Sage Intacct Integration Guide
Integrate Sage Intacct with enterprise systems through XML Web Services, selected REST APIs, scheduled synchronization, batch requests, and supported event-oriented capabilities.
Sage Intacct integration options at a glance
Sage Intacct’s primary integration mechanism is its XML Web Services API, which provides broad coverage for financial and operational objects through XML requests and responses. Selected resources are also available through REST APIs with JSON payloads and OAuth 2.0, although coverage varies by object. XML Web Services supports filtered queries, multiple operations, and batch-oriented processing. Sage Intacct also provides selected event-oriented capabilities and object-specific attachment and file features. Martini can authenticate securely, orchestrate scheduled or API-led workflows, transform XML and JSON, maintain synchronization checkpoints, validate financial dimensions, and route errors for retry or exception handling.
| Integration point | Supported by Sage Intacct? | Common use cases | How Martini supports it |
|---|---|---|---|
| XML Web Services API | Yes | Broad object coverage for Customers, Vendors, Invoices, Bills, Journal Entries, dimensions, custom fields, queries, updates, and accounting operations. | Martini can construct XML requests, consume XML responses, map payloads, invoke operations, and orchestrate multi-step financial workflows. |
| REST APIs | Limited | Selected Sage Intacct resources using RESTful endpoints, JSON payloads, and OAuth 2.0 authentication. | Martini can consume REST endpoints, manage OAuth configuration, transform JSON, and use REST where the required object and operation are available. |
| Authentication | Yes | XML Web Services uses sender and company or user credentials; REST integrations use OAuth 2.0 with required scopes or permissions. | Martini stores credentials and tokens in protected environment configuration and separates authentication failures from business validation errors. |
| Batch and asynchronous processing | Limited | XML Web Services supports multiple operations in a request and batch-oriented processing for suitable synchronization and posting workloads. | Martini can control batch sizes, process individual results, checkpoint successful work, and route partial or failed responses for review. |
| Event notifications and outbound callbacks | Limited | Selected platform and application features provide event-oriented capabilities, but coverage depends on the object, event, account, and delivery model. | Martini can receive supported notifications where configured and use scheduled polling when event coverage is unavailable or insufficient. |
| File and attachment APIs | Limited | Attachment and file capabilities are available for supported objects, with object-specific file references, metadata, upload, or download behavior. | Martini can coordinate file or attachment operations, preserve external and Sage Intacct identifiers, and separate file failures from accounting transactions when appropriate. |
| Queries and incremental synchronization | Yes | Filtered and ordered queries can retrieve changed Customers, Vendors, Invoices, Bills, Journal Entries, and related objects using supported criteria. | Martini can maintain durable timestamps, identifiers, cursors, or pagination checkpoints and process overlap windows safely. |
| Database access | No | Direct SQL access to the Sage Intacct production database is not a standard integration method. | Martini should use Sage Intacct APIs, reports, exports, or supported files rather than direct database access. |
How Sage Intacct exposes data and business events
Sage Intacct XML Web Services
Sage Intacct XML Web Services is the principal integration mechanism for broad financial and operational object coverage. It supports reads, filtered queries, creates, updates, supported deletes, functions, business operations, dimensions, custom fields, and multiple operations in a request.
Martini implementation pattern
Martini implementation pattern: a workflow builds an authenticated XML request, sends it to the Sage Intacct Web Services gateway, parses the XML response, maps business results, and records control IDs, object IDs, and errors for reconciliation.
Implementation sequence
Sage Intacct REST APIs
Sage Intacct REST APIs expose selected resources through RESTful endpoints and JSON payloads. Coverage varies by object, so REST suitability must be verified before selecting it as the primary interface.
Martini implementation pattern
Martini implementation pattern: a workflow obtains or refreshes an OAuth 2.0 access token, calls the supported REST resource, transforms JSON into a canonical model, and applies object-specific validation and error handling.
Implementation sequence
Queries and incremental synchronization
Sage Intacct APIs support filtered and ordered queries for synchronization scenarios. Modified-date or other supported criteria can be used for selected Customers, Vendors, Invoices, Bills, Journal Entries, and related objects.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow reads a durable checkpoint, queries within a bounded time window, processes pages or continuation results, writes downstream changes, and advances the checkpoint only after successful completion.
Implementation sequence
Batch and attachment processing
XML Web Services supports multiple operations in a request, while Sage Intacct provides object-specific attachment and file capabilities. Batch transaction behavior and attachment support must be verified for each use case.
Martini implementation pattern
Martini implementation pattern: Martini groups compatible operations or coordinates file transfers, records each result independently where required, and keeps accounting transaction status separate from attachment status when business rules permit.
Implementation sequence
Event-oriented capabilities
Sage Intacct provides selected event-oriented capabilities through platform and application features, but event coverage is not universal across objects and business events. Account configuration and delivery behavior must be confirmed.
Martini implementation pattern
Martini implementation pattern: where supported, Martini receives the notification, retrieves the current Sage Intacct object, applies the same mapping and idempotency rules used by polling workflows, and falls back to scheduled synchronization for uncovered events.
Implementation sequence
Common Sage Intacct integration patterns
Pattern 1: Synchronize Sage Intacct customers and vendors
When to use this pattern
Use this pattern when CRM, procurement, expense, or supplier applications need reliable master-data synchronization. It supports incremental reads, normalization, identifier matching, and controlled updates without repeatedly transferring complete collections.
Integration direction
Example Mapping
| Sage Intacct Field | Canonical Field | Target Field |
|---|---|---|
| CUSTOMER.CUSTOMERID | customer.externalId | Account.ExternalId |
| CUSTOMER.NAME | customer.name | Account.Name |
| VENDOR.VENDORID | vendor.externalId | Supplier.ExternalId |
Martini implementation pattern
A scheduled Martini workflow queries changed Customers and Vendors using supported filters, maps XML or JSON into a canonical model, resolves matching target records, applies create-or-update rules, and stores a checkpoint only after successful downstream processing. Duplicate identifiers and validation failures are routed to an exception path.
Martini capabilities used
- scheduled workflows
- API consumption
- XML and JSON transformation
- data mapping
- checkpoint management
- business rules
- error handling
Pattern 2: Create Sage Intacct invoices from commerce
When to use this pattern
Use this pattern when a commerce or billing application must create Sage Intacct Invoices while preserving customer, tax, currency, and external order references.
Integration direction
Example Mapping
| Sage Intacct Field | Canonical Field | Target Field |
|---|---|---|
| order.id | transaction.externalId | Invoice.externalTransactionId |
| order.customer | customer.reference | Invoice.customerId |
| order.total_price | invoice.total | Invoice.total |
| line_items[].sku | invoice.lines[].itemReference | Invoice.lines[].itemId |
Martini implementation pattern
Martini exposes or consumes an application API, validates the incoming order, checks an idempotency store, resolves the Sage Intacct Customer and GL Accounts, maps tax and currency details, and submits an Invoice through REST or XML Web Services. Temporary failures are retried while validation failures return an actionable exception.
Martini capabilities used
- APIs
- workflow orchestration
- data mapping
- validation
- business rules
- idempotency
- retry handling
Pattern 3: Synchronize approved accounts-payable bills
When to use this pattern
Use this pattern when an accounts-payable or expense application sends approved supplier transactions into Sage Intacct. It is useful for enforcing Vendor, dimension, currency, and duplicate-posting controls before financial submission.
Integration direction
Example Mapping
| Sage Intacct Field | Canonical Field | Target Field |
|---|---|---|
| bill.vendorId | vendor.externalId | Bill.vendorId |
| bill.invoiceNumber | bill.supplierReference | Bill.invoiceNumber |
| bill.lines[].account | bill.lines[].glAccount | Bill.lines[].glAccount |
| bill.lines[].amount | bill.lines[].amount | Bill.lines[].amount |
Martini implementation pattern
A Martini workflow receives approved bill data, looks up or creates the Vendor, validates GL Accounts and dimensions such as Department or Location, checks the external transaction identifier, and submits the Bill. The workflow records Sage Intacct identifiers and sends rejected lines to an exception workflow rather than retrying permanent validation errors.
Martini capabilities used
- API endpoints
- workflow orchestration
- mapping and transformation
- dimension resolution
- idempotency
- exception routing
- observability
Pattern 4: Post balanced journal entries from operational systems
When to use this pattern
Use this pattern when multiple operational applications must be consolidated into detailed or summarized Sage Intacct Journal Entries with consistent accounting rules and audit references.
Integration direction
Example Mapping
| Sage Intacct Field | Canonical Field | Target Field |
|---|---|---|
| transaction.account | journalLine.glAccount | JournalEntry.lines[].glAccount |
| transaction.department | journalLine.department | JournalEntry.lines[].department |
| transaction.location | journalLine.location | JournalEntry.lines[].location |
| transaction.amount | journalLine.amount | JournalEntry.lines[].amount |
Martini implementation pattern
Martini collects transactions, enriches them with Sage Intacct GL Accounts and dimensions, validates debit and credit balance, applies period and currency rules, and submits a Journal Entry through XML Web Services or a supported REST resource. Each batch carries an external identifier, and rejected lines are retained for correction and replay.
Martini capabilities used
- workflow orchestration
- batch processing
- data mapping
- business rules
- financial validation
- checkpointing
- retry and exception handling
Applications commonly integrated with Sage Intacct
Sage Intacct commonly sits at the center of financial operations, so integrations often connect it with CRM, commerce, accounts-payable, expense, workforce, service-management, and planning applications. The exact objects, direction, and transport should be validated for each deployment.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize customer information, opportunities, invoices, and payment-related financial status between CRM and accounting processes. | Salesforce → Martini → Sage Intacct | Martini exposes or consumes APIs, maps Salesforce Accounts and transaction data to Sage Intacct Customers and Invoices, resolves dimensions and identifiers, and returns or stores Sage Intacct status and object IDs. |
| Shopify | Transfer orders, customers, taxes, refunds, and settlement information into Sage Intacct for financial processing. | Shopify → Martini → Sage Intacct | A Martini workflow receives Shopify data, validates totals and tax information, resolves Customers and GL Accounts, and creates or updates supported Sage Intacct financial objects with duplicate prevention. |
| HubSpot | Synchronize company and customer data, billing status, and financial attributes with CRM records. | HubSpot → Martini → Sage Intacct | Martini maps HubSpot company data to Sage Intacct Customers and sends invoice or payment status back through the relevant APIs, applying field normalization and business rules. |
| Bill.com | Synchronize Vendors, Bills, approvals, payments, and accounting status across accounts-payable workflows. | Bill.com → Martini → Sage Intacct | Martini receives approved bill data, looks up or creates the Vendor, validates dimensions and currency, submits Bills through Sage Intacct APIs, and records external and Sage Intacct identifiers. |
| Expensify | Transfer approved expense reports and employee expenses into Sage Intacct for posting and reimbursement workflows. | Expensify → Martini → Sage Intacct | A workflow receives expense data, maps employees and dimensions, validates accounting requirements, and submits summarized or detailed financial postings while routing rejected lines to an exception process. |
| Workday | Synchronize employees, organizational dimensions, payroll-related accounting, and journal postings. | Workday → Martini → Sage Intacct | Martini orchestrates scheduled or API-triggered exchanges, maps workforce and organizational values to Sage Intacct dimensions, validates account configuration, and submits Journal Entries with reconciliation identifiers. |
| ServiceNow | Transfer service transactions, procurement data, or operational charge records into Sage Intacct for financial posting. | ServiceNow → Martini → Sage Intacct | Martini consumes ServiceNow data, applies charge and accounting rules, resolves Sage Intacct GL Accounts and dimensions, and submits validated financial objects with retry and exception handling. |
| Adaptive Planning | Exchange budgets, actuals, dimensions, and financial planning data between operational accounting and planning processes. | Sage Intacct → Martini → Adaptive Planning | A scheduled Martini workflow extracts Sage Intacct actuals, transforms account and dimension structures, loads planning data, and optionally returns approved budget references through the applicable integration endpoint. |
How to build a Sage Intacct integration in Martini
Objective
Configure the Sage Intacct authentication model appropriate to the selected API and isolate environment-specific company, sender, user, OAuth, and endpoint values.
Instructions in Martini
- Store sender credentials, company credentials, OAuth client details, and tokens in protected secrets or environment configuration.
- Select XML Web Services for broad coverage or REST for supported resources.
- Separate authentication failures from business validation failures.
Objective
Select a scheduled, API-led, or supported event-oriented trigger based on the required latency and Sage Intacct event coverage.
Instructions in Martini
- Use a scheduler for incremental synchronization and reconciliation.
- Expose a Martini API for external billing, commerce, or accounts-payable submissions.
- Use event notifications only after confirming object, event, account, and delivery support.
Objective
Read Sage Intacct objects efficiently using supported filters, query criteria, paging, and controlled batch behavior.
Instructions in Martini
- Use modified-date or other supported filters for incremental reads.
- Persist a durable checkpoint outside transient workflow state.
- Use bounded batch sizes and continuation handling where applicable.
Objective
Coordinate lookups, enrichment, validation, financial mapping, writes, and response handling as a maintainable Martini workflow.
Instructions in Martini
- Resolve Customers, Vendors, GL Accounts, and dimensions before posting dependent transactions.
- Keep transport, mapping, business, and exception stages explicit.
- Record control IDs, object IDs, and external identifiers for reconciliation.
Objective
Convert Sage Intacct XML or JSON and external application payloads into a canonical model with account-specific customization support.
Instructions in Martini
- Map fields and line details into the target object model.
- Treat custom fields, custom objects, and dimensions as tenant-sensitive configuration.
- Preserve optional fields without allowing unrelated schema changes to break processing.
Objective
Enforce accounting and duplicate-prevention rules before creating or updating financial objects.
Instructions in Martini
- Validate required Customers, Vendors, GL Accounts, dimensions, currencies, taxes, and periods.
- Check external transaction or batch identifiers before posting.
- Validate that Journal Entries balance before submission.
Common Sage Intacct data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Customers | Customer master data for accounts receivable, billing, CRM synchronization, and invoice processing. | Salesforce, HubSpot, Shopify, billing platforms, data warehouses | Martini queries or receives customer data, maps identifiers and attributes, validates required dimensions, and upserts downstream records or Sage Intacct Customers. |
| Vendors | Supplier master data for accounts payable, procurement, and bill creation. | Bill.com, procurement platforms, Workday, expense systems | Martini resolves or creates Vendors, normalizes supplier fields, checks duplicate identifiers, and supplies Vendor references when creating Bills. |
| Invoices | Accounts receivable transactions exchanged with billing, commerce, and CRM systems. | Shopify, Salesforce, billing platforms, payment systems | Martini validates customer, tax, currency, dates, and line data before creating, updating, or synchronizing Invoices through the applicable API. |
| Bills | Accounts payable transactions from suppliers, procurement, expense, and payment workflows. | Bill.com, Expensify, procurement platforms, payment systems | Martini maps approved bill lines, resolves Vendors and dimensions, prevents duplicate posting, and records Sage Intacct control and object identifiers. |
| GL Accounts | Chart-of-accounts values used to classify invoices, bills, expenses, and journal postings. | Commerce platforms, expense systems, planning applications, data warehouses | Martini retrieves and caches approved account mappings, validates account status, and applies business rules before financial submission. |
| Journal Entries | Operational postings, adjustments, allocations, accruals, and summarized financial transactions. | Workday, Expensify, Adaptive Planning, operational platforms | Martini validates debit and credit balance, maps dimensions such as Department and Location, applies idempotency checks, and submits detailed or summarized entries. |
Authentication and security considerations
Authentication models
Sage Intacct XML Web Services commonly uses sender credentials together with company or user credentials. Sender authorization or trusted application configuration can restrict which applications may connect. REST integrations use OAuth 2.0 with the required scopes or permissions.
Martini security practices
- Store sender IDs, passwords, company IDs, OAuth client details, and tokens in protected environment configuration or secrets management.
- Use separate configuration for each Sage Intacct company and deployment environment.
- Do not embed credentials in workflow definitions or write financial data and secrets to logs.
- Route authentication failures separately from Sage Intacct validation and business-rule errors.
Operational considerations for Sage Intacct integrations
Throughput and pagination
Use filtered queries, bounded concurrency, controlled batch sizes, and API-specific pagination or continuation handling. Sage Intacct usage controls can depend on the account and service, so current tenant guidance should be confirmed.
Reliability and idempotency
- Persist checkpoints only after downstream processing succeeds.
- Use external transaction or batch identifiers to prevent duplicate Invoices, Bills, and Journal Entries.
- Apply exponential backoff to temporary failures, but do not retry permanent validation errors as transport failures.
- Preserve control IDs, object IDs, correlation IDs, error messages, and retry counts for reconciliation.
Financial and schema controls
Validate balancing, tax, currency, accounting period, required dimensions, custom fields, and tenant-specific configuration. Test REST and XML behavior at the object level because coverage and required fields can differ.
Why use Martini instead of scripts or point-to-point integrations?
Beyond point-to-point scripts
Martini provides a maintainable workflow layer for Sage Intacct integrations rather than coupling each application directly to accounting APIs. It can expose controlled APIs, consume XML Web Services and REST resources, schedule incremental synchronization, and coordinate multi-step financial processing.
- Centralize mapping, dimension resolution, validation, and business rules.
- Reuse authentication, transformation, checkpoint, and exception-handling patterns across Customers, Vendors, Invoices, Bills, and Journal Entries.
- Support hybrid XML and REST designs when Sage Intacct coverage varies by object.
- Improve operational visibility with correlation data, workflow outcomes, controlled retries, and reconciliation identifiers.
Frequently asked questions
Sage Intacct can be integrated primarily through its XML Web Services API, which supports broad financial and operational object coverage, and through selected REST APIs using JSON and OAuth 2.0. Integrations can also use filtered queries, batch requests, object-specific file capabilities, and selected event-oriented features. Scheduled polling is appropriate where event coverage is unavailable.
Yes. Martini can integrate with Sage Intacct by consuming XML Web Services and selected REST APIs, securely managing the required credentials or OAuth tokens, orchestrating workflows, transforming XML and JSON, and implementing supported event or notification patterns where applicable.
No. A dedicated Sage Intacct connector is not required. Martini can use Sage Intacct’s confirmed native integration mechanisms, including XML Web Services, selected REST APIs, authentication methods, queries, batch operations, files, and supported event-oriented capabilities.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Sage Intacct. Integrations are subject to the provisioned capacity of the Martini environment. Separate costs may apply from Sage Intacct, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use XML Web Services when broad object coverage, established accounting operations, or specific functions require it. Use REST when the required resource and operation are available and OAuth 2.0 is suitable. A hybrid design is often practical because REST coverage varies by object.
Sage Intacct provides selected event-oriented and platform capabilities, but it should not be assumed to send notifications for every object or change. Availability depends on the object, event, account configuration, and delivery model. Martini can receive supported notifications or use scheduled queries when polling is required.
Martini can map XML or JSON into canonical models, resolve Customers, Vendors, GL Accounts, and dimensions, and maintain durable checkpoints for incremental synchronization. External transaction or batch identifiers should be stored and checked before creating Invoices, Bills, or Journal Entries so retries do not create duplicate financial postings.
Yes. Martini can expose a controlled REST API that accepts an external business payload, validates and transforms it, resolves Sage Intacct references, submits the applicable XML or REST request, and returns a controlled status and identifier. This can shield consuming applications from Sage Intacct-specific formats and accounting rules.
Related Martini documentation
Sage APIs
Data processing
Connect Sage Intacct with your enterprise systems
Use Martini to build secure, observable Sage Intacct integrations across APIs, workflows, financial data synchronization, and enterprise applications.