.png)
Medius Integration Guide
Integrate Medius AP automation with finance and enterprise systems through REST APIs, OAuth 2.0 authentication, scheduled synchronization, and workflow orchestration.
Medius integration options at a glance
Medius provides REST APIs for programmatic access to accounts payable automation capabilities, including invoices, suppliers, purchase orders, invoice status, and related accounting information. API access uses tenant-specific OAuth 2.0-style application authentication, with scopes and permissions determined by the Medius environment. A generally available, all-events webhook facility was not verified, so scheduled polling with documented filters, timestamps, pagination, and status values is the safer default for incremental synchronization. Attachment APIs, bulk APIs, GraphQL, SOAP, and direct database access were not confirmed. Martini can consume the Medius REST API, transform payloads, apply validation and business rules, expose normalized APIs, and coordinate downstream finance workflows.
| Integration point | Supported by Medius? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Medius REST APIs are the primary integration mechanism for invoices, suppliers, purchase orders, invoice status, and related accounting information. Available resources and writable operations depend on the tenant and product edition. | Martini workflows can consume Medius REST endpoints, handle pagination and filters, transform JSON payloads, apply business rules, and call downstream finance APIs. |
| Authentication | Yes | Medius API access uses OAuth 2.0-style application authentication with tenant-specific credentials, permissions, scopes, and token behavior. | Martini can keep client credentials, tokens, tenant configuration, and related secrets in environment configuration and use authenticated API requests from workflows. |
| Scheduled synchronization | Yes | Scheduled polling is the safer default when complete Medius event coverage is unavailable. Incremental queries can use documented timestamps, statuses, filters, and pagination where supported. | Martini scheduler-triggered workflows can retrieve changed invoices, suppliers, or purchase orders, checkpoint progress, and reconcile results across systems. |
| Webhooks / outbound callbacks | Not confirmed | A generally available, all-events Medius webhook facility was not verified. Any tenant-specific notifications, event coverage, delivery method, and retry behavior must be confirmed with Medius. | If supported by the tenant, Martini can receive and process the documented callback format; otherwise it can use scheduled incremental polling and status queries. |
| Bulk / async / batch APIs | Not confirmed | No distinct public Medius bulk or asynchronous API capability was verified. Large synchronizations should use documented pagination, filtering, and incremental-query features. | Martini can process paginated responses in controlled batches, limit concurrency, checkpoint progress, and retry failed pages or objects. |
| File / attachment APIs | Not confirmed | Invoice documents and supporting attachments are relevant to Medius processes, but a publicly verified attachment API or file-transfer protocol was not confirmed. | Martini can handle documented file endpoints if the tenant exposes them, but attachment metadata and document content should be designed and tested separately. |
| GraphQL APIs | Not confirmed | No official Medius GraphQL API documentation was verified. | Martini can consume GraphQL generally, but a Medius GraphQL integration should not be assumed without tenant documentation. |
| SOAP APIs | Not confirmed | No official Medius SOAP API documentation was verified. | Martini supports SOAP consumption generally, but Medius SOAP integration should not be assumed without confirmed vendor documentation. |
How Medius exposes data and business events
Medius REST APIs
Medius provides REST APIs as the primary programmatic integration mechanism for AP automation capabilities. The available resources and operations for invoices, suppliers, purchase orders, statuses, and accounting information depend on the applicable tenant and product edition.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with the tenant's OAuth 2.0-style application credentials, calls the relevant Medius REST resource, follows pagination and documented filters, transforms the response into a canonical model, and sends it to the target application. The workflow records identifiers and checkpoints for idempotency, retries, and reconciliation.
Implementation sequence
Medius scheduled synchronization
Because a generally available, all-events Medius webhook facility was not verified, scheduled incremental polling is the safer default for invoice, supplier, purchase-order, approval, and status synchronization. The exact filter and timestamp capabilities must be confirmed for each resource.
Martini implementation pattern
Martini implementation pattern: a scheduler starts a workflow at a controlled interval, retrieves records changed since the last successful checkpoint, processes pages or bounded batches, and persists the checkpoint only after successful downstream handling. Records that fail validation or delivery are separated from the successful path for retry and investigation.
Implementation sequence
Common Medius integration patterns
Pattern 1: Synchronize approved invoices to an ERP
When to use this pattern
Use this pattern when Medius is the AP approval and processing platform and an ERP must receive approved invoices for posting. A scheduled workflow retrieves approved or processed invoices, enriches them with supplier and coding context where required, and prevents duplicate posting through stable identifiers.
Integration direction
Example Mapping
| Medius Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | sourceInvoiceId | externalId |
| supplierId | supplierReference | vendorId |
| invoiceNumber | invoiceNumber | tranId |
| totalAmount | grossAmount | total |
Martini implementation pattern
Martini authenticates to Medius, retrieves incrementally changed invoices across paginated responses, validates supplier and legal-entity context, maps invoice headers and lines, and submits the result to the ERP. The workflow checks previously stored identifiers before writing, retries transient failures with bounded backoff, and routes business validation errors to reconciliation handling.
Martini capabilities used
- workflows
- scheduler triggers
- API consumption
- data mapping
- business rules
- error handling
- retry and reconciliation
Pattern 2: Synchronize suppliers and purchase orders to Medius
When to use this pattern
Use this pattern when an ERP or procurement application owns supplier and purchase-order data required for Medius invoice matching. The exact Medius create and update operations must be confirmed for the tenant before implementation.
Integration direction
Example Mapping
| Medius Field | Canonical Field | Target Field |
|---|---|---|
| vendorId | supplierReference | supplierId |
| vendorName | supplierName | name |
| purchaseOrderNumber | purchaseOrderReference | number |
| purchaseOrderLines | orderLines | lines |
Martini implementation pattern
A Martini workflow retrieves changed suppliers and purchase orders from the source application, validates required company and purchasing fields, maps identifiers and lines to documented Medius operations, and submits only supported changes. Duplicate detection, response capture, and per-object retry handling keep partial failures from corrupting the synchronization run.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- business rules
- error handling
Pattern 3: Publish Medius approval and exception status
When to use this pattern
Use this pattern when finance, service, or reporting applications need normalized visibility into invoice approval, exception, rejection, or posting states. It is suitable where Medius event coverage is unavailable or incomplete and status must be polled.
Integration direction
Example Mapping
| Medius Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | documentReference | correlationId |
| approvalStatus | normalizedStatus | state |
| exceptionDetails | exceptionReason | description |
| approver | assignedApprover | assignedTo |
Martini implementation pattern
Martini periodically retrieves documented Medius invoice and approval status data, converts vendor-specific values into a controlled status model, and publishes exceptions or tasks to the target system. Unknown statuses are not silently accepted; they are logged and routed for review, while retries remain idempotent through the invoice and tenant context.
Martini capabilities used
- scheduled workflows
- API consumption
- status normalization
- data mapping
- business rules
- monitoring
- error handling
Pattern 4: Reconcile Medius invoices with finance records
When to use this pattern
Use this pattern when finance teams need to identify missing postings, duplicate invoice numbers, amount mismatches, supplier mismatches, or approved invoices that have not reached the ERP. It creates an audit-oriented comparison rather than assuming that successful API calls equal complete financial processing.
Integration direction
Example Mapping
| Medius Field | Canonical Field | Target Field |
|---|---|---|
| invoiceId | mediusInvoiceId | sourceDocumentId |
| supplierId | supplierReference | vendorId |
| invoiceNumber | documentNumber | invoiceNumber |
| totalAmount | grossAmount | transactionTotal |
Martini implementation pattern
Martini retrieves Medius and finance-system data for the same period or checkpoint, normalizes supplier, legal-entity, currency, number, and amount values, and compares them using stable identifiers and composite keys. Differences are classified, persisted with correlation details, and made available for remediation without automatically overwriting either source system.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- validation
- business rules
- reconciliation
- logging
Applications commonly integrated with Medius
Medius commonly participates in procure-to-pay and accounts payable architectures alongside financial, procurement, and workflow applications. The exact integration scope, supported operations, and direction should be confirmed for each Medius tenant and target product. Martini can coordinate these exchanges through REST APIs, scheduled workflows, mappings, validation, and reconciliation logic.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| NetSuite | Synchronize suppliers, purchase orders, invoices, accounting dimensions, and posting status between Medius AP automation and the financial system. | NetSuite → Martini → Medius | Martini retrieves or receives approved supplier and purchasing data from NetSuite, maps it to Medius resources, and periodically retrieves approved invoices and coding data for posting back to NetSuite. Identifier persistence, validation, retries, and reconciliation support duplicate prevention. |
| Microsoft Dynamics 365 Finance | Transfer vendor data, purchase orders, invoices, tax values, and financial coding between AP processing and the finance platform. | Microsoft Dynamics 365 Finance → Martini → Medius | A Martini workflow exchanges master and transaction data through the documented APIs of each system, applies company and dimension mapping, routes validation failures separately, and stores cross-system identifiers for reconciliation. |
| Microsoft Dynamics 365 Business Central | Support invoice matching and synchronization of vendors, purchase orders, invoices, and posting information. | Microsoft Dynamics 365 Business Central → Martini → Medius | Martini orchestrates supplier and purchase-order synchronization into Medius and retrieves approved invoice results for Business Central, using explicit status mappings, idempotency keys, bounded retries, and exception handling. |
| SAP S/4HANA | Connect procurement and finance master data with invoice approval, matching, coding, and posting processes. | SAP S/4HANA → Martini → Medius | Martini transforms SAP business-partner, purchasing, company, tax, and accounting structures into Medius-compatible payloads, then maps approved invoice results back to SAP while preserving legal-entity context and audit identifiers. |
| Sage Intacct | Send approved invoice and coding data to the accounting platform and synchronize vendors or accounting dimensions. | Sage Intacct → Martini → Medius | Scheduled Martini workflows retrieve incremental Medius invoice data, validate supplier and dimension references, map the result to Sage Intacct API models, and persist posting outcomes for reprocessing and reconciliation. |
| Workday | Synchronize supplier, purchase order, cost-center, or accounting data with accounts payable processing. | Workday → Martini → Medius | Martini coordinates master-data and transaction exchanges between Workday and Medius, normalizes organizational and coding dimensions, and routes records with missing company or cost-center context to an exception path. |
| Coupa | Coordinate procurement, purchase order, supplier, and invoice data across procurement and AP automation processes. | Coupa → Martini → Medius | Martini retrieves or submits supported procurement and invoice resources, maps identifiers and line values, applies matching and validation rules, and uses scheduled incremental synchronization where event delivery is unavailable or incomplete. |
| ServiceNow | Route invoice exceptions, approval tasks, or operational support cases into service workflows. | Medius → Martini → ServiceNow | Martini polls Medius for exception or approval states, converts them into ServiceNow cases or tasks, and can return task outcomes where the required Medius operations are available. Correlation IDs and status mappings support traceability. |
How to build a Medius integration in Martini
Objective
Configure the Medius tenant, OAuth application details, scopes, and environment-specific settings without embedding secrets in workflow definitions.
Instructions in Martini
- Store Medius client credentials, tokens, tenant identifiers, and target-system secrets in Martini environment configuration.
- Confirm the Medius token endpoint, client authentication method, scopes, permissions, and test or production tenant boundaries.
- Validate access separately for invoices, suppliers, purchase orders, approvals, and accounting data.
Objective
Select a trigger based on the confirmed Medius capabilities and the required freshness of the integration.
Instructions in Martini
- Use a scheduler for incremental polling when complete Medius event coverage is unavailable or unconfirmed.
- Use a documented Medius notification or callback only after event coverage, delivery, authentication, and retry behavior are confirmed.
- Define the polling interval, status filters, timestamp window, and checkpoint strategy.
Objective
Fetch the required Medius resources reliably while accounting for pagination, filtering, changing records, and tenant-specific API behavior.
Instructions in Martini
- Call the relevant Medius REST resource with documented filters and status criteria.
- Follow pagination and avoid assuming that one response contains all invoices, suppliers, or purchase orders.
- Persist the last successful checkpoint and account for records changed during a synchronization window.
Objective
Coordinate Medius calls, target-system calls, enrichment, validation, and exception paths as a maintainable Martini workflow.
Instructions in Martini
- Separate retrieval, transformation, business validation, target writing, and audit steps into clear workflow stages.
- Use bounded concurrency and controlled batches for large synchronization windows.
- Preserve correlation IDs, source identifiers, target identifiers, timestamps, and retry counts.
Objective
Convert Medius invoice, supplier, purchase-order, line, approval, and coding structures into the target application's data model.
Instructions in Martini
- Map invoice headers, lines, taxes, currencies, suppliers, purchase orders, and accounting dimensions explicitly.
- Normalize status values and route unknown or newly introduced statuses to an exception path.
- Apply date, number, currency, legal-entity, and identifier transformations required by the target system.
Objective
Prevent invalid or duplicate processing before data is written to a financial or workflow system.
Instructions in Martini
- Use stable Medius identifiers and composite keys such as supplier, invoice number, legal entity, and target document context.
- Validate required supplier, company, tax, purchase-order, and coding references.
- Reject or quarantine records with amount mismatches, missing dimensions, unsupported statuses, or incomplete tenant context.
Common Medius data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Invoices | Synchronize supplier invoices, amounts, dates, taxes, statuses, coding, approvals, exceptions, and posting outcomes. | ERP, finance platforms, reporting systems, ServiceNow | Martini retrieves invoices through documented Medius REST resources, applies status and company validation, maps headers and totals, persists cross-system identifiers, and routes failures for retry or review. |
| Suppliers | Maintain supplier or vendor master data used to associate invoices and purchasing transactions with the correct business partner. | ERP, procurement platforms, master-data systems | Martini maps supplier identifiers, legal-entity context, status, and required master-data fields, then synchronizes only the operations supported by the relevant Medius tenant. |
| Purchase Orders | Support procurement-to-pay synchronization, invoice matching, validation, and purchase-order line alignment. | ERP, procurement platforms, finance systems | Martini retrieves or submits documented purchase-order data, maps headers and lines, validates supplier and company references, and records source and target identifiers. |
| Invoice lines | Carry descriptions, quantities, unit prices, taxes, purchase-order references, and accounting or coding information. | ERP, finance platforms, reporting systems | Martini transforms line-level values and currencies, validates totals and dimensions, and applies explicit rules for missing or inconsistent coding. |
| Approval workflows | Represent approval assignments, workflow states, approvers, exceptions, and approval decisions associated with invoices. | ERP, ServiceNow, reporting and workflow systems | Martini polls documented approval or invoice-status resources, normalizes Medius states, and routes new or unknown states to controlled exception handling. |
| Accounting or coding dimensions | Apply general ledger accounts, cost centers, projects, tax codes, and other accounting attributes to invoices or invoice lines. | ERP, finance platforms, procurement systems | Martini maps dimensions between systems, validates required combinations, preserves legal-entity context, and prevents posting when required coding is incomplete. |
Authentication and security considerations
Tenant-specific OAuth access
Medius API access uses OAuth 2.0-style application authentication. Confirm the tenant's token endpoint, client authentication method, scopes, token lifetime, refresh behavior, and administrative enablement requirements before deployment.
Permissions and isolation
Access is tenant-specific and may differ by invoices, suppliers, purchase orders, approvals, and accounting data. Do not assume that access to one Medius resource grants access to all resources.
Martini secret management
- Store client credentials, tokens, tenant identifiers, and target-system secrets in Martini environment configuration.
- Use separate configuration for test and production tenants where required.
- Limit API permissions to the resources and operations needed by each workflow.
Operational considerations for Medius integrations
Pagination and incremental processing
Design workflows to follow Medius pagination and use documented timestamps, statuses, or filters for incremental synchronization. Persist checkpoints only after the corresponding downstream work succeeds.
Rate limits and retries
Confirm applicable Medius rate limits for the tenant. Use bounded concurrency, exponential backoff, retry limits, and explicit handling for HTTP 429 responses. Do not retry authentication or business-validation failures as if they were transient.
Idempotency and reconciliation
Use Medius identifiers where available and combine supplier, invoice number, legal entity, and other context when necessary. Record source IDs, target IDs, timestamps, response statuses, and correlation IDs for audit and duplicate prevention.
Schema and attachment changes
Use the tenant API definition as the source of truth for optional fields, statuses, coding dimensions, and writable properties. Attachment APIs and document formats were not confirmed, so document content should be designed and tested separately from invoice metadata.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration beyond point-to-point calls
Martini coordinates Medius API consumption, target-system calls, scheduled synchronization, validation, transformation, reconciliation, and exception handling in maintainable workflows rather than scattering logic across scripts.
Reusable integration behavior
Common authentication, pagination, status normalization, identifier correlation, and error-handling patterns can be reused across ERP, procurement, finance, and workflow integrations.
Controlled APIs and operations
Martini can expose normalized APIs for downstream applications so they do not need to understand Medius-specific statuses or payload structures. Monitoring, checkpoints, retries, and environment-based configuration improve operational control as integrations evolve.
Frequently asked questions
Medius can be integrated primarily through its REST APIs using tenant-specific OAuth 2.0-style application authentication. Typical integrations synchronize invoices, suppliers, purchase orders, invoice lines, approval states, and accounting dimensions with ERP, finance, procurement, reporting, or workflow applications. Because a generally available all-events webhook facility was not verified, scheduled incremental polling is often the safer default.
Yes. Martini can integrate with Medius by consuming its documented REST APIs, securely managing the required OAuth credentials, transforming Medius payloads, applying validation and business rules, and orchestrating calls to ERP or finance applications. Any tenant-specific notifications or callbacks can be considered only after their availability and behavior are confirmed.
No. A dedicated Medius connector is not required. Martini can use Medius's confirmed native REST API and authentication mechanisms from workflows, with scheduled synchronization where event notifications are unavailable or incomplete.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Medius. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Medius, cloud infrastructure, or other third-party systems depending on subscriptions, usage, and deployment model.
REST APIs are the primary and documented method for new Medius integrations. OAuth 2.0-style application authentication is required for protected API access. Bulk or asynchronous APIs, GraphQL, SOAP, direct database access, and a general-purpose webhook facility were not confirmed, so they should not be assumed.
A generally available Medius webhook facility with complete event coverage was not verified. The applicable product or tenant may provide outbound notifications, but event types, delivery, authentication, and retry behavior must be confirmed with Medius. Scheduled polling with documented filters and timestamps is the safer fallback.
Martini can run scheduled workflows that retrieve paginated Medius resources incrementally, map them into canonical or target-system models, normalize statuses, and write the results to finance or workflow applications. Mappings can include invoice headers and lines, suppliers, purchase orders, taxes, currencies, approval states, and accounting dimensions.
A robust integration uses bounded retries and exponential backoff for transient failures, special handling for authentication and validation failures, and idempotency based on stable Medius identifiers or composite keys. Martini workflows can persist checkpoints, correlation IDs, target identifiers, response statuses, and retry counts so failed or duplicate-prone transactions can be investigated and safely reprocessed.
Related Martini documentation
Medius APIs
Workflows
Integrate Medius with Martini
Use Martini to connect Medius AP automation with ERP, finance, procurement, and workflow applications through secure API integrations, scheduled synchronization, transformation, validation, and reliable operational workflows.