.png)
SYSPRO Integration Guide
Integrate SYSPRO ERP with enterprise applications through REST APIs, business-object services, scheduled workflows, and controlled API orchestration.
SYSPRO integration options at a glance
SYSPRO provides a modern REST API platform for accessing ERP data and business operations, including Customers, Suppliers, Inventory Items, Sales Orders, Purchase Orders, and Invoices. Legacy or deployment-specific e.net business objects and service interfaces may support operations not available through REST, but their protocol must be confirmed for the target release. SYSPRO webhook coverage is not generally confirmed, so scheduled polling, incremental queries, or customer-managed outbound processes may be required. Martini can authenticate securely, consume SYSPRO APIs, expose controlled REST endpoints, orchestrate workflows, transform payloads, and process paged or batched synchronization jobs.
| Integration point | Supported by SYSPRO? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Access Customers, Suppliers, Inventory Items, Sales Orders, Purchase Orders, and Invoices; create or update supported business data; retrieve order and invoice status; and run synchronization workflows. | Martini can consume SYSPRO REST endpoints from workflows, map request and response payloads, apply validation, and expose its own REST APIs for downstream applications. |
| SOAP APIs | Limited | Some legacy or business-object service interfaces may expose XML or service-based operations, particularly where a required capability is unavailable through the modern REST API. | Martini can consume a confirmed SOAP endpoint, but the target SYSPRO release and deployment must first establish that the interface is actually SOAP and define its authentication model. |
| Business-object and service APIs | Limited | SYSPRO e.net business objects may provide access to application logic and operations in existing or deployment-specific integrations. | Martini can call a documented business-object or service interface and orchestrate its XML or service responses, provided the protocol, operations, and security requirements are confirmed. |
| Webhooks and outbound callbacks | Not confirmed | A generally available SYSPRO webhook model covering all business objects and events was not confirmed. An existing customer integration layer may still be able to call an external endpoint. | Martini can receive callbacks when the target SYSPRO deployment or intermediary supports them; otherwise, scheduled polling or incremental queries can provide the trigger. |
| Bulk, asynchronous, or batch processing | Limited | Batch-oriented processing may be available through particular APIs or business objects, but a universal SYSPRO bulk API model was not confirmed. | Martini can divide large jobs into pages or batches, validate each item, apply controlled concurrency and retries, and record item- or batch-level outcomes. |
| File and attachment exchange | Not confirmed | File-based imports or exports may be available through a customer's SYSPRO deployment or surrounding integration infrastructure, but no general-purpose SYSPRO file or attachment API was confirmed. | Martini can process files when a supported exchange location and format are provided, including validation, duplicate-file detection, archival, and workflow-based import or export handling. |
| Database and analytics access | Not confirmed | Direct SYSPRO database access is deployment-specific and is not the recommended primary integration mechanism. Reporting access requires confirmation of schema, engine, read-only permissions, and supportability. | Martini can connect to supported SQL databases through JDBC, but database access should be used only after explicit supportability approval and should not bypass SYSPRO business logic by default. |
| Authentication | Yes | Modern SYSPRO API access uses an application and token-based security model, with company context, operator permissions, scopes, and deployment-specific settings requiring confirmation. | Martini can store credentials and tokens in environment configuration or secrets, use secure HTTPS connections, and apply controlled authentication to API-consuming workflows and exposed APIs. |
How SYSPRO exposes data and business events
SYSPRO REST APIs
SYSPRO's modern API platform provides REST-style access to ERP data and business operations. Available resources, create and update operations, API versions, modules, and permissions vary by target environment, so the API definition for the relevant SYSPRO release should be treated as authoritative.
Martini implementation pattern
Martini implementation pattern: A Martini workflow authenticates to the SYSPRO API, retrieves or submits the required resource, transforms the payload into a canonical or target model, applies business rules, and records the source identifier, response, and checkpoint. Martini can also expose a controlled REST API that hides SYSPRO-specific details from consumers.
Implementation sequence
SYSPRO business-object services
SYSPRO e.net business objects and related service or XML-based interfaces may support operations not available through REST or may be required by existing implementations. The precise protocol, endpoint, authentication, and available operations must be confirmed for the installed release and deployment.
Martini implementation pattern
Martini implementation pattern: Martini consumes the confirmed service or business-object interface, transforms request and response structures, preserves SYSPRO business logic, and routes interface-specific errors separately from validation and transport failures. e.net should not be described as SOAP unless a SOAP endpoint is confirmed.
Implementation sequence
SYSPRO batch processing
Batch-oriented processing may be available through particular SYSPRO APIs or business objects, although a universal bulk API model was not confirmed. Large loads should therefore be designed around the documented operations available in the target environment.
Martini implementation pattern
Martini implementation pattern: Martini divides a synchronization job into pages or batches, applies controlled concurrency, validates each item, retries transient failures, and records item-level and batch-level outcomes. This allows partial progress to be reconciled without blindly replaying successful transactions.
Implementation sequence
Scheduled SYSPRO synchronization
Because broad SYSPRO webhook coverage was not confirmed, scheduled polling and incremental queries are practical options when the target environment does not provide outbound events. Modification timestamps, status fields, sequences, or another documented change mechanism should drive the synchronization.
Martini implementation pattern
Martini implementation pattern: A scheduler-triggered Martini workflow reads the last successful checkpoint, queries changed Customers, Suppliers, Inventory Items, Sales Orders, Purchase Orders, or Invoices, processes pages incrementally, and advances the checkpoint only after results are safely handled.
Implementation sequence
Common SYSPRO integration patterns
Pattern 1: Synchronize SYSPRO orders with Salesforce
When to use this pattern
Use this pattern when sales and service teams need Salesforce visibility into SYSPRO Customers, Sales Orders, fulfillment details, and status. The workflow can be scheduled or triggered by a confirmed outbound process, with optional status updates sent back when supported by the relevant APIs.
Integration direction
Example Mapping
| SYSPRO Field | Canonical Field | Target Field |
|---|---|---|
| CustomerCode | customer.externalId | Account.External_Id__c |
| CustomerName | customer.name | Account.Name |
| SalesOrderNumber | order.externalId | Order.SYSPRO_Order_Number__c |
| OrderStatus | order.status | Order.Status |
Martini implementation pattern
Martini retrieves changed Customers and Sales Orders, normalizes identifiers and statuses, enriches records with required account relationships, and validates order ownership before writing to Salesforce. The workflow checks for an existing external identifier before upserting, records correlation IDs, and routes failed or ambiguous updates to an exception process rather than replaying them blindly.
Martini capabilities used
- scheduled workflows
- API consumption
- data mapping
- business rules
- duplicate prevention
- error handling
Pattern 2: Process Shopify orders into SYSPRO
When to use this pattern
Use this pattern to transfer online orders into SYSPRO for fulfillment, inventory allocation, and invoicing. Shopify may provide order events or be polled for new orders, while the precise SYSPRO create operations must be confirmed for the target environment.
Integration direction
Example Mapping
| SYSPRO Field | Canonical Field | Target Field |
|---|---|---|
| id | order.externalId | SalesOrder.CustomerPoNumber |
| customer.email | customer.email | Customer.Email |
| line_items[].sku | order.lines[].itemCode | SalesOrder.Lines[].StockCode |
| shipping_address | order.deliveryAddress | SalesOrder.DeliveryAddress |
Martini implementation pattern
Martini receives or retrieves Shopify orders, validates customer, item, quantity, address, and currency information, and resolves existing SYSPRO Customers and Inventory Items before creating a Sales Order. It uses the Shopify order identifier for duplicate detection, separates validation errors from transient API failures, and records the SYSPRO order reference after successful creation.
Martini capabilities used
- workflow triggers
- API consumption
- data mapping
- validation
- business rules
- retry and exception handling
Pattern 3: Synchronize procurement with NetSuite
When to use this pattern
Use this pattern when SYSPRO and NetSuite both participate in procurement or financial processes and ownership must be explicitly defined for Suppliers, Purchase Orders, and invoice status. Bidirectional synchronization should be limited to fields with clear system ownership.
Integration direction
Example Mapping
| SYSPRO Field | Canonical Field | Target Field |
|---|---|---|
| SupplierCode | supplier.externalId | Vendor.externalId |
| SupplierName | supplier.name | Vendor.companyName |
| PurchaseOrderNumber | purchaseOrder.externalId | PurchaseOrder.tranId |
| InvoiceStatus | invoice.status | VendorBill.status |
Martini implementation pattern
Martini retrieves changed SYSPRO Suppliers, Purchase Orders, and Invoices, applies source-of-truth rules, maps identifiers and statuses, and submits only approved changes to NetSuite. Checkpoints, reconciliation totals, and idempotent external references allow the workflow to resume without duplicating procurement transactions.
Martini capabilities used
- scheduled synchronization
- orchestration
- data mapping
- business rules
- checkpointing
- reconciliation
Pattern 4: Expose SYSPRO service data to ServiceNow
When to use this pattern
Use this pattern when ServiceNow users need selected SYSPRO Customers, Inventory Items, Sales Orders, or invoice and fulfillment status without direct access to the ERP. A controlled API façade can enforce data minimization and authorization at the integration boundary.
Integration direction
Example Mapping
| SYSPRO Field | Canonical Field | Target Field |
|---|---|---|
| CustomerCode | customer.id | ServiceNow.account.external_id |
| StockCode | inventoryItem.code | ServiceNow.cmdb_ci.asset_tag |
| SalesOrderNumber | order.number | ServiceNow.u_syspro_order_number |
| InvoiceStatus | invoice.status | ServiceNow.u_invoice_status |
Martini implementation pattern
Martini exposes a REST API that validates ServiceNow requests, retrieves only the permitted SYSPRO data, transforms the response into a stable contract, and returns controlled errors. Caching or request throttling can reduce ERP load, while correlation identifiers and audit logging support support-team troubleshooting.
Martini capabilities used
- API exposure
- API consumption
- authorization
- data mapping
- business rules
- monitoring and error handling
Applications commonly integrated with SYSPRO
SYSPRO commonly participates in architectures that connect ERP data and business operations with customer-facing, service, commerce, reporting, and collaboration applications. The exact direction and scope should be determined by system ownership, available APIs, and the customer's SYSPRO release and modules.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Synchronize SYSPRO Customers, Sales Orders, and fulfillment or financial status so sales teams can view ERP context. | SYSPRO → Martini → Salesforce | Martini can poll or retrieve changed SYSPRO Customers and Sales Orders, map them to Salesforce Accounts and Orders, apply ownership and status rules, and route failures to an exception workflow. Optional updates can be sent back to SYSPRO where the relevant operations are supported. |
| Shopify | Transfer online orders and customer information into SYSPRO for fulfillment, inventory allocation, and invoicing, with status returned to the commerce channel. | Shopify → Martini → SYSPRO | Martini can receive or retrieve Shopify orders, validate customer and inventory data against SYSPRO, transform order lines and delivery details, and create Sales Orders where the target API permits. Stable external identifiers and duplicate checks protect retries. |
| NetSuite | Coordinate Suppliers, Purchase Orders, invoices, and procurement or financial information across ERP environments. | SYSPRO → Martini → NetSuite | Martini can orchestrate bidirectional synchronization using explicit ownership rules, map supplier and transaction identifiers, validate totals and statuses, and use checkpoints and reconciliation reports for recoverable processing. |
| ServiceNow | Provide service and operations teams with customer, inventory, order, invoice, and fulfillment context without granting direct SYSPRO access. | SYSPRO → Martini → ServiceNow | Martini can retrieve approved SYSPRO data, normalize it behind a controlled Martini REST API, and allow ServiceNow to request the required context. Authorization, field filtering, caching, and error responses are handled in the Martini API and workflows. |
| Jira | Create operational or implementation issues from SYSPRO validation and processing exceptions and optionally return resolution status. | SYSPRO → Martini → Jira | Martini can classify failed SYSPRO transactions, create Jira issues with correlation identifiers and business context, and update or close issues when the exception workflow completes. Duplicate detection prevents repeated issue creation. |
| Microsoft Power BI | Deliver curated SYSPRO Customers, Inventory Items, orders, invoices, and operational status data for reporting and management analysis. | SYSPRO → Martini → Microsoft Power BI | Martini can retrieve approved SYSPRO datasets, apply business rules and canonical mappings, and publish them to the selected reporting or data-platform interface. The reporting architecture should define whether data is delivered through an API, database, or managed file process. |
How to build a SYSPRO integration in Martini
Objective
Establish the SYSPRO application, company, operator, and permission context for the target release and deployment.
Instructions in Martini
- Confirm the SYSPRO API version, resources, operations, company context, and operator permissions.
- Configure the required OAuth-style or application credentials in Martini environment configuration.
- Store client secrets and tokens in Martini secrets rather than workflow definitions.
- Use HTTPS and separate development, test, and production configuration.
Objective
Select the trigger that matches the confirmed SYSPRO capabilities and the required freshness of the integration.
Instructions in Martini
- Use a scheduler for polling when broad outbound event support is unavailable.
- Use a confirmed callback or intermediary process only when the target deployment supports it.
- Define the initial-load, incremental-sync, and reconciliation schedules.
- Set an explicit checkpoint strategy for each object family.
Objective
Read or receive SYSPRO business objects using documented operations and controlled request sizes.
Instructions in Martini
- Retrieve Customers, Suppliers, Inventory Items, Sales Orders, Purchase Orders, or Invoices through the confirmed API surface.
- Use pagination, stable sorting, and documented modification or sequence fields for incremental queries.
- Capture request identifiers, source identifiers, response status, and the current checkpoint.
- Avoid direct database reads unless supportability and access requirements are explicitly approved.
Objective
Coordinate calls, dependencies, validation, enrichment, and target writes in a maintainable Martini workflow.
Instructions in Martini
- Separate master-data preparation from transaction creation where partial failures would be difficult to recover.
- Sequence customer and item resolution before creating Sales Orders or Purchase Orders.
- Use reusable workflow logic for authentication, pagination, status normalization, and exception handling.
- Apply controlled concurrency and batch sizing appropriate to the SYSPRO environment.
Objective
Convert SYSPRO payloads into canonical and target-specific models without passing uncontrolled structures between systems.
Instructions in Martini
- Map stable identifiers such as CustomerCode, SupplierCode, StockCode, and order numbers.
- Normalize dates, monetary values, tax, units of measure, statuses, addresses, and line structures.
- Use explicit versioned mappings for API and module-specific fields.
- Validate required fields before submitting create or update operations.
Objective
Protect transactional integrity and ensure that integration behavior reflects system ownership and operational policy.
Instructions in Martini
- Define which system is authoritative for Customers, Suppliers, orders, invoices, inventory, and status fields.
- Check external identifiers before creating transactions.
- Classify validation, authorization, business-rule, throttling, and transport failures separately.
- Prevent checkpoint advancement until the corresponding data has been durably handled.
Common SYSPRO data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Customers | Synchronize customer master data, contacts, credit information, account status, and customer identifiers. | Salesforce, Shopify, ServiceNow, reporting platforms | Martini retrieves or receives Customers through confirmed SYSPRO operations, maps stable customer codes to canonical identifiers, validates required fields, and performs duplicate-aware upserts where supported. |
| Suppliers | Coordinate supplier master data, payment details, procurement relationships, and supplier identifiers. | NetSuite, procurement applications, finance platforms, reporting platforms | Martini applies supplier ownership and validation rules, transforms payment and address structures, and records source and target identifiers for reconciliation. |
| Sales Orders | Process order headers, lines, pricing, delivery information, warehouse details, and order status. | Shopify, Salesforce, ServiceNow, fulfillment platforms | Martini validates the complete order before submission, maps lines and delivery data, checks for an existing external order identifier, and routes uncertain or failed outcomes for controlled recovery. |
| Purchase Orders | Synchronize procurement orders, supplier references, lines, delivery dates, and order status. | NetSuite, procurement platforms, supplier portals, reporting platforms | Martini maps supplier and item identifiers, applies approval and status rules, batches retrieval where appropriate, and maintains checkpoints for incremental synchronization. |
| Inventory Items | Share item master data, stock codes, descriptions, units of measure, warehouse information, and inventory context. | Shopify, Salesforce, ServiceNow, reporting platforms | Martini normalizes item and warehouse structures, filters the fields appropriate for each consumer, and uses pagination and modification checkpoints for large datasets. |
| Invoices | Exchange accounts receivable or supplier invoice information, amounts, tax, references, and status. | NetSuite, finance platforms, ServiceNow, reporting platforms | Martini validates monetary and reference fields, maps invoice status and identifiers, separates transport failures from business errors, and supports reconciliation and retry workflows. |
Authentication and security considerations
Application and token security
Modern SYSPRO API access generally uses an application registration and token-based authentication model. Confirm the authorization server, grant type, scopes, token lifetime, and client registration process for the target environment.
Company and operator context
SYSPRO access commonly depends on company identifiers, operator or service-account permissions, and business-object security. Validate these settings before implementing create, update, or query operations.
Martini configuration
- Store client credentials, tokens, and sensitive configuration in Martini secrets or environment configuration.
- Use HTTPS for API communication and avoid logging credentials or tokens.
- Use separate credentials and permissions for development, test, and production.
- Apply least-privilege access to exposed Martini APIs and downstream workflows.
Operational considerations for SYSPRO integrations
Version and deployment differences
SYSPRO capabilities vary by release, deployment model, enabled modules, API version, installed business objects, and security configuration. Validate the target API definition and test create, update, and query operations before finalizing mappings.
Throughput and synchronization
- Use pagination, stable sorting, and documented modification or sequence fields for large datasets.
- Confirm rate limits and use controlled concurrency, appropriate batch sizes, and exponential backoff.
- Define initial-load, incremental-sync, deletion, archival, and deactivation behavior.
- Use stable identifiers and duplicate checks before creating Sales Orders, Purchase Orders, or master data.
Errors and schema changes
- Separate authentication, transport, validation, throttling, and SYSPRO business-rule errors.
- Capture response details, correlation identifiers, source transaction IDs, workflow IDs, retry counts, and final outcomes without exposing secrets.
- Use versioned mappings and contract tests for Sales Orders, Purchase Orders, and other critical objects.
- Do not blindly retry an operation when the first request may have succeeded.
Why use Martini instead of scripts or point-to-point integrations?
Centralized orchestration
Martini provides a workflow layer for coordinating SYSPRO API calls, target-system writes, validation, enrichment, checkpoints, and exception handling. This avoids duplicating integration logic across isolated scripts.
Reusable and governed interfaces
Martini can consume SYSPRO APIs and expose controlled REST APIs with consistent authentication, mappings, business rules, and error contracts. External applications do not need to understand SYSPRO-specific payloads or company context.
Maintainability and operations
- Use explicit mappings and reusable workflows as SYSPRO releases, modules, and target applications evolve.
- Apply bounded retries, duplicate prevention, reconciliation, and structured error handling.
- Monitor workflow execution, API responses, checkpoints, and unresolved business exceptions.
- Keep credentials and environment-specific settings outside the integration logic.
Frequently asked questions
SYSPRO can be integrated through its modern REST APIs for ERP data and business operations. Depending on the release and deployment, e.net business objects or service-based interfaces may also be available. Where broad outbound event coverage is not available, scheduled polling, incremental queries, or a customer-managed integration process can be used.
Yes. Martini can consume confirmed SYSPRO REST APIs, use a documented business-object or service interface when required, expose REST APIs for controlled access, and orchestrate scheduled or callback-driven workflows. The exact resources, operations, authentication settings, and company context must be validated for the target SYSPRO environment.
No. A dedicated SYSPRO connector is not required. Martini can integrate using SYSPRO's confirmed native REST APIs, documented business-object or service interfaces, authentication mechanisms, and any deployment-supported callbacks or file processes.
Lonti does not charge an additional per-connector or per-vendor fee to integrate SYSPRO. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from SYSPRO, hosting or database infrastructure, or other third-party systems depending on subscriptions, usage, and deployment model.
Use the documented SYSPRO REST API when it provides the required object and operation. Consider a confirmed business-object or service interface when REST does not provide the capability or when an existing implementation depends on it. Do not infer that an e.net business object is a SOAP endpoint without verifying the target release.
A generally available SYSPRO webhook model covering all business objects and events was not confirmed. Event coverage is deployment- and version-dependent. Martini can receive a callback when the customer's SYSPRO environment or intermediary provides one; otherwise, scheduled polling and incremental synchronization are suitable alternatives.
A typical design uses an initial load followed by incremental synchronization based on a documented modification timestamp, sequence, status, or change mechanism. Martini can manage pagination, checkpoints, validation, retries, duplicate detection, reconciliation, and controlled batch processing for Customers, Suppliers, Inventory Items, Sales Orders, Purchase Orders, and Invoices.
Yes. Martini can expose a controlled REST API that retrieves or submits approved SYSPRO data through workflows. This can hide SYSPRO-specific structures, enforce authentication and authorization, filter fields, apply business rules, and provide a stable contract for applications such as ServiceNow or other enterprise consumers.
Related Martini documentation
Data processing
Connect SYSPRO to your enterprise systems
Use Martini to build maintainable SYSPRO integrations around REST APIs, confirmed business-object services, scheduled synchronization, controlled API access, and enterprise workflow orchestration.