.png)
Unit4 ERP Integration Guide
Connect Unit4 ERP with enterprise applications through OAuth 2.0-secured REST APIs, scheduled workflows, data mapping, and controlled API orchestration.
Unit4 ERP integration options at a glance
Unit4 ERP provides API access through the Unit4 developer platform, with REST APIs as the primary mechanism for new integrations. Access is generally secured with OAuth 2.0, bearer tokens, tenant-specific permissions, and configured API scopes. A general webhook facility, public SOAP interface, bulk API, and file or attachment API were not confirmed, so event-driven requirements should be validated for the relevant tenant and module. Where outbound events are unavailable, Martini can run scheduled workflows that poll supported resources incrementally, paginate through results, transform JSON payloads, apply accounting and ownership rules, and write reliable updates to downstream applications.
| Integration point | Supported by Unit4 ERP? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Unit4 exposes API access for ERP integrations through its developer platform. REST resources can support customer, supplier, employee, project, invoice, and financial synchronization where enabled for the tenant. | Martini can consume Unit4 REST APIs from workflows, map JSON payloads, apply business rules, expose normalized APIs, and write transformed data to other systems. |
| Authentication | Yes | Unit4 API access uses OAuth 2.0 with client registration, bearer tokens, permissions, and tenant-specific scopes or configuration. | Martini can store client credentials and token configuration as environment secrets and send bearer tokens with protected API requests. |
| Scheduled synchronization | Yes | Scheduled polling is the conservative option when the required Unit4 outbound event or callback is unavailable. Incremental filters should be used when supported by the resource. | Martini scheduler-triggered workflows can retrieve changed data, paginate through results, checkpoint successful progress, and retry transient failures. |
| Webhooks / outbound callbacks | Not confirmed | A general Unit4 ERP webhook facility covering all business objects was not confirmed. Event or callback support may be available for selected services or customer configurations. | Martini can receive webhook-style requests when Unit4 provides a verified callback, but implementations must be limited to confirmed tenant capabilities. |
| SOAP APIs | Not confirmed | Earlier Unit4 products or integrations may have used web-service or SOAP-style interfaces, but a current recommended public SOAP interface was not confirmed. | Martini can consume SOAP services if a supported Unit4 endpoint is specifically verified for the deployment and version. |
| Bulk / asynchronous / batch APIs | Not confirmed | Resource-specific batch, import, export, or long-running processing may exist, but a general Unit4 ERP bulk or asynchronous API was not confirmed. | Martini can orchestrate documented batch operations when available and otherwise process REST results in bounded pages or batches. |
| File / attachment APIs | Not confirmed | File-based integration or attachment operations may be available for selected Unit4 products or modules, but no general public capability was confirmed. | Martini can process supported files or attachments only after the relevant Unit4 endpoint and format are verified. |
| Database / analytics access | Not confirmed | Direct database access is not the preferred boundary for cloud ERP deployments and was not confirmed as a generally supported Unit4 mechanism. | Martini should prefer Unit4 APIs; any approved database or reporting access must be implemented according to the customer deployment and access model. |
How Unit4 ERP exposes data and business events
Unit4 ERP REST APIs
Unit4 provides API access for ERP integrations through its developer platform, with REST as the primary mechanism to evaluate for new work. Available resources, operations, fields, permissions, and base URLs depend on the product generation, tenant, modules, and provisioning.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with the configured Unit4 OAuth 2.0 environment, calls the required REST resource, follows the endpoint's pagination model, maps JSON into a canonical or target schema, applies validation and business rules, and writes the result with checkpointing and error handling.
Implementation sequence
Scheduled Unit4 ERP synchronization
A general Unit4 webhook facility for all ERP objects was not confirmed. Scheduled incremental polling is therefore the conservative pattern when a required event or callback is unavailable and the resource supports modified timestamps, status filters, change identifiers, or equivalent criteria.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow, the workflow reads the last successful checkpoint, retrieves bounded Unit4 pages, processes each item idempotently, records failures for replay, and advances the checkpoint only after the relevant work succeeds.
Implementation sequence
Common Unit4 ERP integration patterns
Pattern 1: Sync customers and invoices to Salesforce
When to use this pattern
Use this pattern when CRM users need current Unit4 customer and invoice context while Unit4 remains authoritative for financial status. Scheduled or incremental polling is the default unless a verified Unit4 event mechanism is available.
Integration direction
Example Mapping
| Unit4 ERP Field | Canonical Field | Target Field |
|---|---|---|
| Customer.id | customer.externalId | Salesforce Account.Unit4CustomerId |
| Customer.name | customer.name | Salesforce Account.Name |
| Invoice.status | invoice.status | Salesforce billing status |
| Invoice.totalAmount | invoice.amount | Salesforce invoice amount |
Martini implementation pattern
A scheduler starts the workflow, which retrieves changed Customers and Invoices, follows pagination, normalizes identifiers and amounts, checks for existing Salesforce objects, and applies ownership and status rules. Unit4 identifiers are retained for idempotency, while rate-limit responses and transient failures use bounded retries and failed payloads are preserved for replay.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- business rules
- error handling
Pattern 2: Coordinate suppliers and procurement transactions
When to use this pattern
Use this pattern when Coupa or NetSuite manages supplier or procurement activity and Unit4 ERP must receive approved supplier, invoice, or accounting information without duplicate creation.
Integration direction
Example Mapping
| Unit4 ERP Field | Canonical Field | Target Field |
|---|---|---|
| Supplier.externalId | supplier.externalId | Unit4 Supplier.identifier |
| Supplier.name | supplier.name | Unit4 Supplier.name |
| Invoice.amount | invoice.total | Unit4 Invoice.amount |
| PurchaseOrder.status | procurement.status | Unit4 transaction status |
Martini implementation pattern
Martini receives or retrieves approved source transactions, validates supplier, company, currency, tax, and accounting context, then calls the appropriate Unit4 resource. Stable external IDs and pre-write existence checks prevent duplicates; business-rule failures are separated from retryable network and throttling errors.
Martini capabilities used
- workflows
- API consumption
- data transformation
- validation
- retry and error handling
Pattern 3: Synchronize employees and projects with Workday
When to use this pattern
Use this pattern when professional-services planning requires Workday employee data and Unit4 project structures to remain aligned through a controlled scheduled process.
Integration direction
Example Mapping
| Unit4 ERP Field | Canonical Field | Target Field |
|---|---|---|
| Worker.workerId | employee.externalId | Unit4 Employee.identifier |
| Worker.effectiveDate | employee.effectiveFrom | Unit4 Employee.startDate |
| Project.projectCode | project.externalId | Unit4 Project.code |
| Project.status | project.status | Unit4 Project.status |
Martini implementation pattern
A scheduled workflow retrieves changed Workday Employees and project-related data, maps effective dates and organizational identifiers, validates company and project references, and writes only permitted changes to Unit4. The workflow checkpoints successful pages and routes invalid organizational or closed-project cases to an operational error path.
Martini capabilities used
- scheduled workflows
- API orchestration
- mapping and transformation
- validation
- checkpointing
Pattern 4: Expose controlled Unit4 context to ServiceNow
When to use this pattern
Use this pattern when service teams need Unit4 customer, project, supplier, or invoice information without granting direct ERP access to every consuming application.
Integration direction
Example Mapping
| Unit4 ERP Field | Canonical Field | Target Field |
|---|---|---|
| ServiceNow request.customerId | customer.externalId | Unit4 Customer.identifier |
| ServiceNow request.projectCode | project.code | Unit4 Project.code |
| Unit4 Invoice.status | invoice.status | ServiceNow financialStatus |
| Unit4 Project.name | project.name | ServiceNow project context |
Martini implementation pattern
Martini exposes a secured REST API that validates the ServiceNow request, authorizes the requested operation, retrieves Unit4 data, and returns a normalized response. For approved write operations, the workflow validates accounting and ownership rules before updating Unit4, with correlation IDs, bounded retries, and safe error responses.
Martini capabilities used
- API exposure
- API consumption
- authorization
- data mapping
- business rules
- error handling
Applications commonly integrated with Unit4 ERP
Unit4 ERP can be integrated with adjacent enterprise applications when organizations need to coordinate financial, customer, workforce, procurement, project, service, or reporting data. These are architecture patterns rather than evidence of prebuilt Unit4 integrations; the available Unit4 resources and operations should be confirmed for each tenant.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize Unit4 Customers and Invoices with CRM accounts, contacts, and commercial processes while returning selected customer or opportunity updates to ERP. | Salesforce → Martini → Unit4 ERP | A Martini workflow polls or receives approved Salesforce changes, maps stable external identifiers and customer attributes to Unit4 resources, validates financial fields, and returns invoice status or customer updates to Salesforce with retry and duplicate controls. |
| ServiceNow | Provide service teams with Unit4 customer, project, supplier, and financial context while keeping Unit4 ERP authoritative for applicable financial data. | Unit4 ERP → Martini → ServiceNow | Martini exposes a controlled API or runs a workflow that retrieves Unit4 data, applies authorization and field-level rules, transforms the response for ServiceNow, and routes approved updates back to Unit4 where supported. |
| Workday | Align employee and organizational information with Unit4 project, workforce, and financial processes in professional-services environments. | Workday → Martini → Unit4 ERP | A scheduled Martini workflow retrieves changed Workday Employees and organizational data, maps identifiers and effective dates, validates company and project context, and writes permitted updates to Unit4 while preserving checkpoints. |
| NetSuite | Coordinate customer, supplier, invoice, and financial status information when Unit4 ERP and NetSuite operate across entities or business units. | NetSuite → Martini → Unit4 ERP | Martini orchestrates bidirectional REST calls, normalizes identifiers and currencies, applies system-of-record rules, and uses idempotent supplier and invoice writes with bounded retries. |
| Coupa | Exchange supplier, procurement, purchase-order, invoice, and accounting-status information between procurement processes and Unit4 ERP. | Coupa → Martini → Unit4 ERP | Martini receives approved procurement data from Coupa, validates supplier and company references, maps transactions to Unit4 resources, and sends Unit4 accounting or payment status back to Coupa. |
| Jira | Connect project delivery and issue information with Unit4 project, budget, and financial context for professional-services organizations. | Jira → Martini → Unit4 ERP | A scheduled workflow retrieves Jira project or work data, maps it to Unit4 Projects and activities, applies budget and ownership rules, and returns selected financial status while recording failed items for replay. |
| Microsoft Power BI | Make Unit4 financial, project, customer, and operational data available for reporting and analysis through an intermediate data model or reporting pipeline. | Unit4 ERP → Martini → Microsoft Power BI | Martini retrieves paginated Unit4 resources, converts them into reporting-oriented JSON or tabular structures, applies incremental checkpoints, and delivers curated data to the selected reporting boundary. |
| Microsoft Azure | Use Azure services for surrounding data, hosting, monitoring, identity, or integration workloads connected to Unit4 ERP. | Unit4 ERP → Martini → Microsoft Azure | Martini consumes Unit4 APIs, transforms and validates payloads, and exchanges data with the selected Azure service using environment-specific credentials, controlled workflows, and operational logging. |
How to build a Unit4 ERP integration in Martini
Objective
Establish the Unit4 ERP API connection using the tenant-specific OAuth 2.0 configuration and least-privilege permissions.
Instructions in Martini
- Configure the Unit4 base URL, token endpoint, client ID, client secret, audience, scopes, and tenant context from the customer environment.
- Store credentials and token configuration in Martini environment secrets.
- Confirm the enabled Unit4 resources and operations before building the workflow.
Objective
Select a trigger that matches the confirmed Unit4 capability and the integration latency requirement.
Instructions in Martini
- Use a scheduled workflow for incremental polling when no required Unit4 event or callback is confirmed.
- Use a verified callback only for the specific Unit4 service and event coverage it supports.
- Define the checkpoint, modified filter, status filter, or change identifier used for incremental processing.
Objective
Retrieve Unit4 resources reliably while respecting endpoint-specific pagination and throughput behavior.
Instructions in Martini
- Call the required REST resource with the configured OAuth bearer token.
- Follow the endpoint's documented pagination method rather than assuming parameter names.
- Process bounded pages and retain the last successful checkpoint only after processing succeeds.
Objective
Convert Unit4 JSON payloads into canonical and target application schemas without losing identifiers or financial meaning.
Instructions in Martini
- Map Unit4 Customers, Suppliers, Employees, Projects, Invoices, or financial transactions to target fields.
- Normalize dates, time zones, currencies, decimals, dimensions, statuses, and external identifiers.
- Preserve Unit4 IDs and correlation information for traceability and idempotency.
Objective
Apply ownership, validation, duplicate, authorization, and accounting rules before making downstream writes.
Instructions in Martini
- Validate company, business-unit, project, supplier, customer, currency, tax, and accounting-period context.
- Define which system is authoritative for each object and field.
- Reject or route invalid, duplicate, closed-period, and unauthorized changes without advancing the checkpoint.
Objective
Write transformed results to downstream applications or back to Unit4 through controlled API operations.
Instructions in Martini
- Use idempotent create and update logic with stable external IDs.
- Separate retryable network and throttling failures from validation and business-rule failures.
- Apply bounded retries with backoff for 429 and transient service responses.
Common Unit4 ERP data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Customers | Customer master data, billing details, account information, and CRM synchronization. | Salesforce, ServiceNow, NetSuite, Microsoft Power BI | Martini retrieves or receives confirmed Unit4 fields, normalizes identifiers and addresses, applies ownership and duplicate rules, and writes idempotent updates. |
| Suppliers | Supplier master data, payment information, and procurement-related details. | Coupa, NetSuite, Microsoft Power BI | Martini validates supplier identifiers, company context, payment fields, and status before synchronizing changes with procurement or finance applications. |
| Employees | Employee and worker information used in project, workforce, and organizational processes. | Workday, ServiceNow, Microsoft Power BI | Martini maps worker identifiers, effective dates, organizational attributes, and permitted personal data while enforcing source-of-record rules. |
| Projects | Project structures, activities, budgets, project transactions, and professional-services delivery context. | Workday, Jira, ServiceNow, Microsoft Power BI | Martini validates project, company, dimension, and status values, transforms project hierarchies, and checkpoints incremental synchronization. |
| Invoices | Customer and supplier invoice details, status, approvals, and financial processing information. | Salesforce, Coupa, NetSuite, Microsoft Power BI | Martini treats invoices as controlled financial transactions, preserves identifiers and status, applies duplicate protection, and avoids unsafe updates to posted or closed-period data. |
| General ledger transactions | Accounting entries, journals, dimensions, and financial postings. | Microsoft Power BI, NetSuite, data platforms | Martini maps company, account, dimension, currency, period, and amount fields carefully, validates accounting semantics, and preserves failed payloads for controlled replay. |
Authentication and security considerations
OAuth 2.0 and tenant configuration
Unit4 ERP API access is generally secured with OAuth 2.0. Client registration, token endpoints, audiences, scopes, permissions, and tenant or company context must be confirmed from the target Unit4 environment.
Secrets and least privilege
- Store client IDs, client secrets, token settings, and other sensitive configuration in Martini environment secrets.
- Use the least-privilege Unit4 permissions required for each workflow.
- Send bearer tokens through protected API requests and avoid logging tokens or sensitive financial and personal data.
Operational considerations for Unit4 ERP integrations
Throughput and pagination
Confirm Unit4 quotas, concurrency limits, throttling behavior, and endpoint-specific pagination. Respect 429 responses and Retry-After values, use bounded retries with backoff, and avoid excessive parallel calls.
Consistency and replay
- Prefer incremental synchronization using a supported modified timestamp, change token, status filter, or equivalent.
- Advance checkpoints only after the relevant page or batch succeeds.
- Use stable external IDs and idempotent writes to prevent duplicate Customers, Suppliers, Invoices, or Projects.
Financial semantics and change management
Company codes, dimensions, currencies, tax treatment, posting periods, approval states, and closed accounting periods can affect whether a transaction may be changed. Confirm API versions, resources, required fields, enumerations, custom fields, and deprecations for the tenant.
Testing and monitoring
Test multi-company, multi-currency, large-result, expired-token, unauthorized, retry, duplicate, and replay scenarios. Preserve Unit4 response details and correlation information for operational troubleshooting.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of point-to-point code
Martini provides a reusable workflow layer between Unit4 ERP and surrounding applications. It can authenticate, retrieve paginated resources, transform payloads, apply system-of-record rules, and coordinate multi-step writes without embedding all integration logic in individual scripts.
Reliable operations
- Scheduled workflows support incremental synchronization when Unit4 events are unavailable.
- Centralized mappings, validation, retries, checkpoints, and error paths make behavior easier to maintain.
- Martini can expose controlled APIs so consumers do not need direct Unit4 credentials or tenant-specific implementation details.
Frequently asked questions
Unit4 ERP can be integrated primarily through REST APIs provided by the Unit4 developer platform. Enterprise workflows can authenticate with OAuth 2.0, retrieve and update enabled resources, synchronize data incrementally, and transform Customers, Suppliers, Employees, Projects, Invoices, and financial transactions for other applications. A general webhook, current public SOAP, bulk, or file API was not confirmed and should be validated for the relevant tenant and module.
Yes. Martini can consume Unit4 ERP REST APIs using OAuth 2.0, orchestrate scheduled synchronization workflows, map and transform Unit4 JSON, apply business rules, and expose controlled APIs for Unit4 data. Any Unit4 callback or event mechanism must be verified for the target tenant before use.
No. A dedicated Unit4 ERP connector is not required. Martini can integrate using Unit4's confirmed REST APIs and OAuth 2.0 authentication, with scheduled workflows used when the required outbound event or callback is unavailable.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Unit4 ERP. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Unit4, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
REST APIs are the primary and currently recommended mechanism identified for new Unit4 ERP integrations. OAuth 2.0 is the confirmed authentication approach. Scheduled incremental polling is appropriate when a required event is unavailable, while SOAP, bulk, file, and direct database methods require specific tenant or deployment verification.
A general webhook facility covering every Unit4 ERP object and event was not confirmed. Unit4 may provide event or callback options for selected services or customer configurations, so coverage must be verified for the required resource. Martini can receive a confirmed callback or use scheduled polling instead.
Martini can retrieve paginated Unit4 resources on a schedule, use supported modified timestamps or change identifiers, checkpoint successful progress, and map JSON into canonical and target schemas. Workflows can normalize dates, currencies, dimensions, and identifiers while applying system-of-record, duplicate, and accounting rules.
Martini workflows can classify authentication, validation, rate-limit, transient, conflict, and partial-processing failures separately. Bounded retries with backoff can handle transient and 429 responses, while stable external IDs, existence checks, correlation data, and persisted failed payloads support idempotent replay. Closed-period and accounting-rule failures should be routed for business review.
Yes. Martini can expose a REST API that authenticates and authorizes consumers, retrieves Unit4 data, transforms it into a controlled contract, and returns the result. This can provide a stable integration boundary while keeping Unit4 credentials, tenant context, and resource-specific rules inside Martini.
Related Martini documentation
Workflows
Build a maintainable Unit4 ERP integration
Use Martini to connect Unit4 ERP with enterprise applications through secure API consumption, scheduled workflows, reusable mappings, controlled APIs, and operational error handling.