.png)
IBM Maximo Application Suite Integration Guide
IBM Maximo Application Suite integrates with enterprise systems primarily through Maximo Manage REST APIs, configured Integration Framework processing, selected outbound callbacks, and scheduled synchronization.
IBM Maximo Application Suite integration options at a glance
Maximo Manage provides REST APIs for querying, creating, updating, and selectively deleting configured business objects and object structures such as Assets, Work Orders, Locations, Service Requests, Items, and Purchase Orders. The Maximo Integration Framework can support enterprise services, publish channels, invocation channels, queues, and configured outbound processing. Selected deployments may provide callback-style notifications, but Maximo does not offer a universal webhook stream for every event. Collection operations support bounded batch synchronization, while attachments and approved read-only database access require separate design consideration. Martini can consume these APIs, receive configured messages, expose APIs, schedule polling workflows, transform data, and manage retries and checkpoints.
| Integration point | Supported by IBM Maximo Application Suite? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Maximo Manage REST APIs support queries, retrieval, creation, updates, filtering, selected attributes, related data, and configured object structures for Assets, Work Orders, Locations, Service Requests, Items, and Purchase Orders. | Martini can consume the Maximo REST API, map request and response models, apply workflow rules, expose intermediary APIs, and handle authentication and errors. |
| Integration Framework | Yes | Object structures, enterprise services, publish channels, invocation channels, external systems, queues, and integration processing support inbound and outbound enterprise integration. | Martini can orchestrate calls to configured endpoints, receive messages through exposed APIs where applicable, transform payloads, and coordinate asynchronous processing. |
| Webhooks and outbound callbacks | Limited | Selected Maximo deployments can produce outbound notifications through publish channels, event processing, queues, or configured callbacks. Coverage depends on version, configuration, and enabled components. | Martini can receive configured notifications through an API or webhook-triggered workflow, while scheduled polling can cover events that are not emitted. |
| Bulk, asynchronous, and batch processing | Limited | Collection-oriented REST access, Integration Framework messages, and queue-based processing can support larger synchronizations, subject to object structure, request-size, and server configuration limits. | Martini can paginate collections, bound batch sizes, queue or schedule work, checkpoint progress, and retry transient failures. |
| File and attachment APIs | Limited | Maximo supports document attachments associated with objects such as Work Orders, Assets, and Service Requests through its document-management and Doclinks model. | Martini can transfer metadata and binary content in separate workflow steps, validate files, preserve correlations, and recover from partial attachment failures. |
| SOAP web services | Legacy | Earlier Maximo versions and integration configurations support web services and SOAP-related integration, but REST is generally preferred for new integrations. | Martini can consume SOAP services when a legacy Maximo deployment requires them, including configured authentication, XML mapping, and error handling. |
| Database and analytics access | Limited | Approved read-only database or reporting access may be available in customer-managed architectures. Direct transactional writes are not the preferred Maximo integration boundary. | Martini can connect to supported SQL databases through JDBC for approved analytics or read-only scenarios, while business transactions should use Maximo APIs or supported integration facilities. |
| Authentication | Yes | Depending on deployment and identity configuration, Maximo access may use API keys, Basic Authentication, bearer tokens, OAuth-based flows, and Maximo security-group permissions over HTTPS. | Martini can store credentials in environment-managed secrets and apply the configured authentication method to API calls and exposed integration endpoints. |
How IBM Maximo Application Suite exposes data and business events
Maximo REST APIs
Maximo Manage REST APIs are the primary standards-based integration method for querying, retrieving, creating, and updating configured business objects and object structures. The exact resources, fields, relationships, and permissions depend on the deployed Maximo version and configuration.
Martini implementation pattern
Martini implementation pattern: a workflow calls the configured Maximo REST resource with environment-managed authentication, applies filters and pagination, transforms the response into a canonical model, invokes the target system, and records identifiers and checkpoints.
Implementation sequence
Integration Framework messages
Maximo Integration Framework facilities can use object structures, enterprise services, publish channels, invocation channels, external systems, queues, and message processing for inbound and outbound integration. Availability and behavior are deployment-dependent.
Martini implementation pattern
Martini implementation pattern: expose or consume the configured endpoint, accept the Maximo message, validate its correlation and object context, transform the payload, and route synchronous or asynchronous processing according to the integration contract.
Implementation sequence
Outbound callbacks and selected events
Maximo can support selected outbound notifications through publish channels, event processing, queues, or configured callbacks, but it should not be treated as a universal webhook source for every object and event.
Martini implementation pattern
Martini implementation pattern: receive configured notifications through a Martini API or webhook-triggered workflow, use the event as a signal, retrieve the authoritative Maximo resource when needed, and apply deduplication before downstream processing. Where notifications are unavailable, a scheduled workflow polls using a high-water mark.
Implementation sequence
Batch synchronization and attachments
Collection-oriented REST access, queues, and bounded message processing support batch-oriented synchronization. Maximo document attachments associated with objects such as Work Orders, Assets, and Service Requests require separate validation of binary upload and retrieval behavior.
Martini implementation pattern
Martini implementation pattern: divide collection results into bounded batches, checkpoint each successful page or message, and process attachments separately from parent JSON records. Rate controls and retry policies protect Maximo capacity and prevent duplicate transfers.
Implementation sequence
Common IBM Maximo Application Suite integration patterns
Pattern 1: Synchronize Work Orders with an ERP
When to use this pattern
Use this pattern when maintenance work in Maximo must be represented in an ERP such as SAP S/4HANA or Oracle Fusion Cloud ERP, with selected status, cost, procurement, or completion information returned to Maximo.
Integration direction
Example Mapping
| IBM Maximo Application Suite Field | Canonical Field | Target Field |
|---|---|---|
| wonum | maintenanceOrderNumber | OrderNumber |
| siteid | siteCode | Plant |
| status | workStatus | OrderStatus |
| assetnum | assetIdentifier | Equipment |
Martini implementation pattern
A scheduled Martini workflow queries changed Work Orders with stable ordering and a persisted checkpoint, maps site, organization, asset, status, and cost values, and checks for an existing external identifier before creating or updating the ERP transaction. Maximo is updated only after successful downstream processing; transient errors are retried and permanent validation failures are recorded for reconciliation.
Martini capabilities used
- scheduled workflows
- API consumption
- pagination and checkpointing
- data mapping
- business rules
- idempotency
- error handling
Pattern 2: Synchronize Assets and Locations with GIS
When to use this pattern
Use this pattern when an asset-intensive organization needs Maximo operational asset data and location hierarchies aligned with ArcGIS geographic identifiers and spatial information.
Integration direction
Example Mapping
| IBM Maximo Application Suite Field | Canonical Field | Target Field |
|---|---|---|
| assetnum | assetIdentifier | assetId |
| location | locationCode | locationId |
| description | assetName | name |
| status | operationalStatus | status |
Martini implementation pattern
Martini retrieves changed Assets and Locations, resolves parent-location dependencies, maps identifiers and approved coordinates, and applies validation before writing to ArcGIS. A reconciliation store records source and target identifiers, while invalid spatial data or unavailable parent locations are isolated without stopping unrelated records.
Martini capabilities used
- workflow orchestration
- REST API consumption
- data mapping
- validation
- conditional routing
- reconciliation
- error handling
Pattern 3: Create Service Requests from Customer Systems
When to use this pattern
Use this pattern when Salesforce, ServiceNow, or a portal needs to submit customer or employee service requests into Maximo and receive an authoritative Maximo identifier and status.
Integration direction
Example Mapping
| IBM Maximo Application Suite Field | Canonical Field | Target Field |
|---|---|---|
| subject | requestSummary | description |
| priority | priorityCode | reportedpriority |
| assetId | assetIdentifier | assetnum |
| caseId | sourceReference | externalrefid |
Martini implementation pattern
Martini exposes a controlled REST API, validates required fields and Maximo site, location, asset, classification, and domain values, then creates the Service Request through the configured object structure. The workflow returns the Maximo identifier, uses the source reference for duplicate detection, and routes Maximo validation or authorization failures to an operational error process.
Martini capabilities used
- API exposure
- API consumption
- input validation
- data mapping
- business rules
- idempotency
- error handling
Pattern 4: Synchronize Items and Purchase Orders
When to use this pattern
Use this pattern when Maximo inventory and procurement processes must exchange item, supplier, purchase-order, fulfillment, or receipt information with an ERP or procurement platform.
Integration direction
Example Mapping
| IBM Maximo Application Suite Field | Canonical Field | Target Field |
|---|---|---|
| itemnum | itemNumber | ItemNumber |
| vendor | supplierIdentifier | Supplier |
| ponum | purchaseOrderNumber | PurchaseOrder |
| status | purchaseOrderStatus | Status |
Martini implementation pattern
A Martini workflow processes changed Items and Purchase Orders in bounded batches, translates units, suppliers, sites, organizations, and statuses, and uses deterministic correlation keys before creating procurement transactions. Response identifiers and order status are stored for later updates; retries are limited to transient capacity or network failures, while duplicate and validation responses are reconciled explicitly.
Martini capabilities used
- batch workflows
- REST API consumption
- mapping and transformation
- controlled-value translation
- idempotency
- checkpointing
- retry handling
Applications commonly integrated with IBM Maximo Application Suite
Maximo Manage commonly participates in broader asset, maintenance, procurement, service, spatial, and enterprise-data architectures. The following relationships are typical integration scenarios rather than assertions that every deployment includes a prebuilt integration.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| SAP S/4HANA | Synchronize materials, suppliers, purchase orders, maintenance orders, costs, and financial information across asset management and ERP processes. | IBM Maximo Application Suite → Martini → SAP S/4HANA | A Martini workflow retrieves changed Maximo objects through REST, maps site, organization, material, order, and cost values to SAP APIs, applies duplicate checks, and routes transient failures to bounded retries. Selected SAP status or purchasing updates can be written back to Maximo. |
| Oracle Fusion Cloud ERP | Exchange procurement, supplier, invoice, item, and financial information between Maximo operations and enterprise resource planning processes. | IBM Maximo Application Suite → Martini → Oracle Fusion Cloud ERP | Martini can schedule incremental Maximo queries, transform configured object structures into Oracle payloads, correlate external identifiers, and update Maximo after downstream processing succeeds. Reconciliation records handle partial success across both systems. |
| Salesforce | Create Maximo Service Requests from customer cases and return service status or asset information to customer-service users. | Salesforce → Martini → IBM Maximo Application Suite | Martini exposes an API for Salesforce requests, validates site, location, asset, priority, and classification values, creates a Maximo Service Request, and returns the Maximo identifier. Status changes can be polled or received through configured outbound processing and mapped back to Salesforce. |
| ServiceNow | Coordinate incidents, requests, changes, and operational work with Maximo maintenance activities. | ServiceNow → Martini → IBM Maximo Application Suite | Martini orchestrates bidirectional REST calls, maps ServiceNow tickets to Maximo Work Orders or Service Requests, applies domain and status translation, and uses correlation identifiers to prevent duplicate work creation. |
| ArcGIS | Synchronize Maximo Assets and Locations with geographic identifiers, spatial information, and location hierarchies. | IBM Maximo Application Suite → Martini → ArcGIS | A scheduled Martini workflow retrieves changed Assets and Locations, enriches or reconciles geographic identifiers, maps coordinates and operational status, and writes accepted changes to the target API. Invalid spatial data is rejected with an operational error record. |
| Jira | Send engineering or development issues related to maintenance work to Jira and return issue status to Maximo processes. | IBM Maximo Application Suite → Martini → Jira | Martini filters eligible Work Orders or related issues, creates or updates Jira issues using a stored Maximo correlation key, maps priority and status values, and synchronizes selected Jira status changes back through Maximo APIs. |
| Workday | Provide worker, organization, and cost-center information used for labor and maintenance administration. | Workday → Martini → IBM Maximo Application Suite | Martini consumes approved Workday data, transforms worker and organization identifiers to Maximo Labor or administrative structures, validates site and organization context, and processes changes in bounded batches with checkpoint persistence. |
How to build a IBM Maximo Application Suite integration in Martini
Objective
Establish access to the actual Maximo Manage deployment and confirm its version, object structures, security model, and enabled authentication flow.
Instructions in Martini
- Use the Maximo endpoint and API documentation supplied by the administrator.
- Configure API keys, Basic Authentication, or bearer-token credentials according to the deployment.
- Store credentials in Martini environment-managed secrets.
- Use HTTPS and verify the required Maximo security-group permissions.
Objective
Select a trigger that matches the Maximo event coverage and synchronization requirements rather than assuming universal webhooks.
Instructions in Martini
- Use a Martini API or webhook-triggered workflow for configured outbound notifications.
- Use a scheduler for polling-based incremental synchronization.
- Use a message or queue-oriented design when the Maximo Integration Framework provides asynchronous processing.
- Define the checkpoint or event identifier before production execution.
Objective
Retrieve authoritative Maximo objects with bounded queries and predictable pagination.
Instructions in Martini
- Query the required object structure or REST resource.
- Apply supported filters for site, organization, status, and change timestamp.
- Use stable ordering, explicit page sizes, and continuation or offset handling where supported.
- Retrieve related data separately when the object structure does not expose it safely inline.
Objective
Coordinate Maximo calls, target-system calls, transformations, business rules, and compensation within a maintainable Martini workflow.
Instructions in Martini
- Separate transport, mapping, validation, and business decision steps.
- Use reusable services or workflow components for repeated Maximo operations.
- Define transaction boundaries because Maximo and the target system are not automatically atomic.
- Route asynchronous work through bounded processing rather than unrestricted parallel requests.
Objective
Convert Maximo object structures and configured domain values into the canonical and target schemas.
Instructions in Martini
- Map actual Maximo fields such as siteid, assetnum, wonum, status, itemnum, and ponum.
- Translate site, organization, status, priority, classification, unit, and work-type values explicitly.
- Normalize timestamps, identifiers, null values, related objects, and attachment metadata.
- Validate required target fields before making the downstream request.
Objective
Prevent invalid, duplicate, or unauthorized transactions before they reach Maximo or the target system.
Instructions in Martini
- Use external references or synchronization records for idempotency.
- Resolve asset, location, supplier, site, and organization dependencies.
- Distinguish create, update, and reconciliation paths.
- Apply approval, status, eligibility, and compensation rules required by the business process.
Common IBM Maximo Application Suite data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Assets | Synchronize physical assets, equipment identifiers, operational status, classifications, and related location information. | ArcGIS, SAP S/4HANA, ServiceNow, data platforms | Martini retrieves or receives configured Asset data, maps site and organization context, reconciles external identifiers, and updates Maximo only when target processing succeeds. |
| Work Orders | Exchange maintenance, inspection, corrective, preventive, status, cost, and scheduling information. | SAP S/4HANA, ServiceNow, Jira, Oracle Fusion Cloud ERP | Martini uses incremental queries or configured outbound processing, applies status and domain mappings, performs idempotent create-or-update logic, and persists failures for retry or reconciliation. |
| Locations | Synchronize physical or logical location hierarchies and the relationship between locations and Assets. | ArcGIS, SAP S/4HANA, enterprise asset data stores | Martini processes hierarchy and identifier mappings, validates site and organization values, and separates parent-location dependencies where required. |
| Service Requests | Intake service, maintenance, customer, or operational assistance requests and return their status to originating systems. | Salesforce, ServiceNow, employee portals, customer applications | Martini validates required fields, resolves asset and location references, maps priority and categorization domains, creates the request, and returns the Maximo identifier. |
| Items | Synchronize item master data, descriptions, units of measure, and material information used in maintenance and procurement. | SAP S/4HANA, Oracle Fusion Cloud ERP, procurement platforms | Martini applies controlled-value mappings, processes changes in bounded batches, and stores external references to avoid duplicate item creation. |
| Purchase Orders | Exchange procurement transactions, supplier information, order status, receipts, and fulfillment details. | SAP S/4HANA, Oracle Fusion Cloud ERP, procurement platforms | Martini validates supplier, site, organization, and line-item data, correlates external order numbers, and uses compensation or reconciliation for cross-system partial failures. |
Authentication and security considerations
Authentication and security
Maximo authentication depends on the deployed MAS and Maximo Manage version, identity configuration, and security settings. API keys, Basic Authentication, bearer tokens, or OAuth-based flows may be available, and access is further constrained by Maximo users, security groups, application permissions, object permissions, sites, and organizations.
- Store API keys, passwords, client credentials, and tokens in Martini environment-managed secrets.
- Use HTTPS for production traffic and restrict Martini API access with appropriate authentication and authorization.
- Grant only the Maximo permissions required for the configured objects and operations.
- Verify authentication behavior and permissions against the actual tenant before deployment.
Operational considerations for IBM Maximo Application Suite integrations
Operational considerations
Maximo API behavior varies by MAS version, deployment model, object-structure configuration, custom attributes, domains, and site or organization settings. Treat the target environment as the integration contract.
- Use explicit pagination, stable ordering, bounded concurrency, and checkpoint persistence for collections.
- Apply backoff for gateway, server-capacity, queue, or temporary network failures.
- Use external references, deterministic lookups, and synchronization records to make retries idempotent.
- Separate authentication, authorization, validation, duplicate, rate, and server-processing failures.
- Process attachments separately from parent JSON records and validate file size, MIME type, metadata, and duplicate behavior.
- Maintain contract tests and representative payloads for custom attributes, domains, relationships, and object-structure changes.
- Use reconciliation or compensation logic because transactions across Maximo and another system are not automatically atomic.
Why use Martini instead of scripts or point-to-point integrations?
Why Martini
Scripts and point-to-point integrations can connect to a Maximo endpoint, but they often place authentication, pagination, mapping, retries, business rules, and monitoring in isolated codebases. Martini provides a governed workflow and API layer for coordinating these concerns across Maximo and other enterprise systems.
- Consume Maximo REST APIs and configured integration endpoints without requiring a dedicated vendor connector.
- Expose controlled APIs for Service Request intake or other inbound processes.
- Reuse mappings, validation, business rules, authentication configuration, and error-handling patterns.
- Support scheduled, event-driven, synchronous, asynchronous, and batch-oriented workflows.
- Keep checkpoints, correlation identifiers, retry behavior, and operational diagnostics explicit and maintainable.
- Extend standard workflow behavior with custom logic when Maximo-specific transformations or reconciliation rules require it.
Frequently asked questions
The primary approach is to consume Maximo Manage REST APIs for configured business objects and object structures. Enterprise integrations can also use Maximo Integration Framework capabilities such as enterprise services, publish channels, invocation channels, queues, and selected outbound callbacks. Scheduled polling is appropriate where universal event coverage is unavailable, and approved read-only database or analytics access may be used in specific customer-managed architectures.
Yes. Martini can consume Maximo Manage REST APIs, expose APIs for Maximo or adjacent systems to call, receive configured outbound messages or callbacks, schedule incremental synchronization, transform Maximo object structures, and orchestrate Maximo with ERP, GIS, service, procurement, and other enterprise applications.
No. A dedicated IBM Maximo connector is not required. Martini can integrate using Maximo's confirmed native mechanisms, including REST APIs, configured Integration Framework endpoints, selected outbound notifications, files or attachments, authentication methods, and approved database access where appropriate.
Lonti does not charge an additional per-connector or per-vendor fee to integrate IBM Maximo Application Suite. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from IBM, cloud infrastructure, identity providers, or other third-party systems based on subscription, usage, and deployment model.
REST is generally the preferred starting point for new Maximo Manage integrations. The final choice depends on the deployed MAS and Maximo versions, configured object structures, security model, event requirements, and whether synchronous REST calls or asynchronous Integration Framework processing is more suitable. SOAP should normally be reserved for legacy configurations.
Selected deployments can send outbound notifications through publish channels, event processing, queues, configured callbacks, or other Integration Framework facilities. Maximo should not be assumed to provide universal webhooks for every object and event. Martini can receive configured notifications through an API, or use scheduled polling with a high-water mark when event coverage is unavailable.
A Martini workflow can query configured Maximo resources using supported timestamps, status filters, site or organization values, and stable ordering. It persists a checkpoint or synchronization record, processes pages or bounded batches, maps the data, and advances the checkpoint only after successful downstream handling. Exact change indicators and query behavior must be validated against the target deployment.
Martini maps Maximo object structures and controlled values to canonical and target schemas, validates required fields, and applies business rules for sites, organizations, statuses, identifiers, and duplicates. It can expose a REST API façade for controlled intake, retry transient network or capacity failures, persist failed identifiers and response details, and route permanent validation or authorization errors for operational review.
Related Martini documentation
Integrate IBM Maximo Application Suite with Martini
Use Martini to connect Maximo Manage with enterprise applications through REST APIs, configured integration endpoints, scheduled workflows, controlled API exposure, and maintainable data synchronization.