.png)
ChannelEngine Integration Guide
Connect ChannelEngine marketplace products, offers, orders, shipments, and returns with enterprise systems through its REST API and scheduled workflows.
ChannelEngine integration options at a glance
ChannelEngine provides an account-specific REST API for reading and updating Products, Offers, Orders, Shipments, Returns, and Channels. API access uses an API key supplied in request headers, with the exact header and permissions requiring validation in the target account. Webhook-style notifications may be available for selected scenarios, but comprehensive event coverage is not confirmed, so scheduled polling is often the safer synchronization pattern. Martini can securely consume the REST API, paginate and checkpoint data retrieval, apply marketplace and fulfillment rules, transform payloads, and write results to ERP, commerce, warehouse, or returns systems. Bulk APIs, file interfaces, and direct database access were not confirmed.
| Integration point | Supported by ChannelEngine? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Read Products, Offers, Orders, Shipments, Returns, and Channels; update offer prices and stock or shipment information where supported by the account API. | Martini can consume the account-specific REST API, map responses, apply business rules, paginate requests, and orchestrate writes to other systems. |
| Webhooks / outbound callbacks | Limited | Selected notification or webhook-style scenarios may be available, but comprehensive coverage for product, offer, order, shipment, and return events was not confirmed. | Martini can expose an API endpoint to receive supported notifications, validate them, retrieve the current resource, and fall back to scheduled polling where coverage is incomplete. |
| Authentication | Yes | ChannelEngine API access uses an API key supplied in request headers; the exact header and account permissions should be confirmed before deployment. | Martini stores the key as a secret, injects it at runtime, uses HTTPS, and keeps credentials out of workflow definitions and logs. |
| Scheduled synchronization | Yes | Scheduled polling is a practical approach for Orders, Shipments, Returns, Products, and Offers when event coverage is unavailable or incomplete. | Martini can schedule workflows, persist checkpoints, use overlap windows, paginate results, and reconcile missed or changed objects. |
| Bulk / asynchronous APIs | Not confirmed | Bulk or asynchronous endpoints for high-volume catalog or offer updates were not sufficiently confirmed. | Martini can process paginated REST data in bounded batches with throttling, retry, backoff, and checkpointing until account documentation confirms bulk endpoints. |
| File / attachment APIs | Not confirmed | A general-purpose ChannelEngine file or attachment interface was not confirmed; marketplace feed behavior should not be treated as a generic file API. | Martini can process files from other confirmed systems when required, but should use the ChannelEngine REST API for ChannelEngine data unless an account-specific file interface is verified. |
| Database / analytics access | No | No supported direct ChannelEngine database or analytics-database interface was confirmed. | Martini should consume the supported API rather than attempting direct database access. |
How ChannelEngine exposes data and business events
ChannelEngine REST APIs
ChannelEngine provides an account-specific HTTP REST API for reading and updating Products, Offers, Orders, Shipments, Returns, and Channels. The base URL, API version, endpoint paths, fields, and permissions should be confirmed in the target account documentation.
Martini implementation pattern
Martini implementation pattern: a workflow authenticates with a securely stored API key, retrieves paginated resources, normalizes the response, applies business rules, and writes the mapped result to an ERP, commerce, warehouse, or returns system. For updates, Martini validates identifiers and fields, submits bounded requests, and records outcomes for retry and reconciliation.
Implementation sequence
ChannelEngine webhook-style notifications
Some notification or webhook-style capabilities may be available for selected scenarios, but comprehensive event coverage across Products, Offers, Orders, Shipments, and Returns was not confirmed.
Martini implementation pattern
Martini implementation pattern: expose a controlled Martini API endpoint only after the target account’s notification capability and event coverage are verified. The workflow validates the notification, retrieves the current ChannelEngine resource when appropriate, processes it idempotently, and uses scheduled polling as a fallback for uncovered events.
Implementation sequence
ChannelEngine scheduled synchronization
Scheduled synchronization is the principal fallback when webhook coverage is unavailable or incomplete. It is suitable for incremental Orders, Shipments, Returns, Products, and Offers processing.
Martini implementation pattern
Martini implementation pattern: a scheduled workflow retrieves records using supported timestamps or bounded time windows, maintains a persisted checkpoint with a small overlap, deduplicates stable identifiers, and periodically reconciles the source with downstream systems.
Implementation sequence
Common ChannelEngine integration patterns
Pattern 1: Synchronize marketplace orders to an ERP
When to use this pattern
Use this pattern when ChannelEngine Orders must become sales orders in NetSuite, SAP S/4HANA, or another order-management system. It supports scheduled polling or a verified notification mechanism and protects against duplicate downstream order creation.
Integration direction
Example Mapping
| ChannelEngine Field | Canonical Field | Target Field |
|---|---|---|
| Order ID | externalOrderId | External ID |
| Order lines | lineItems | Sales order lines |
| Shipping method | shippingMethod | Shipping method |
| Customer address | shippingAddress | Ship-to address |
Martini implementation pattern
Retrieve Orders incrementally with pagination and an overlap window, normalize marketplace and customer data, apply channel, currency, tax, and fulfillment rules, then check the ChannelEngine order identifier before creating or updating the ERP order. Persist the checkpoint and route validation failures separately from transient failures for retry.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- idempotency
- error handling
Pattern 2: Synchronize inventory and prices to ChannelEngine Offers
When to use this pattern
Use this pattern when an ERP or commerce platform is the source of truth for stock and pricing and ChannelEngine must publish marketplace-specific Offers.
Integration direction
Example Mapping
| ChannelEngine Field | Canonical Field | Target Field |
|---|---|---|
| SKU | productSku | Product SKU |
| Available quantity | availableStock | Offer stock |
| Sales price | channelPrice | Offer price |
| Marketplace code | channelId | Channel identifier |
Martini implementation pattern
Read inventory and prices from the source system, map deterministic product and channel keys, apply safety-stock, currency, tax, and channel-price rules, and submit only changed and valid Offer updates. Process bounded batches, back off on throttling, retry transient errors, and retain rejected updates for operational review.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- batch processing
- retry and backoff
- monitoring
Pattern 3: Update shipment status and tracking
When to use this pattern
Use this pattern after a warehouse or ERP fulfills a ChannelEngine order and the marketplace requires shipment, carrier, or tracking information.
Integration direction
Example Mapping
| ChannelEngine Field | Canonical Field | Target Field |
|---|---|---|
| Order ID | orderId | ChannelEngine order identifier |
| Tracking number | trackingNumber | Shipment tracking number |
| Carrier | carrierCode | Shipment carrier |
| Fulfillment lines | shipmentLines | Shipment lines |
Martini implementation pattern
Consume fulfillment output, validate order and shipment identifiers, normalize carrier and tracking values, and update ChannelEngine through the REST API when the target version exposes the required operation. Use deterministic shipment keys to make retries safe and explicitly handle partial shipments and marketplace-specific validation.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- business rules
- idempotency
- error handling
Pattern 4: Synchronize returns and return outcomes
When to use this pattern
Use this pattern when ChannelEngine Returns must be routed to an ERP or returns-management process and resulting status changes may need to be sent back through the API.
Integration direction
Example Mapping
| ChannelEngine Field | Canonical Field | Target Field |
|---|---|---|
| Return ID | externalReturnId | Return reference |
| Return lines | returnedItems | Credit or return lines |
| Return reason | returnReason | Reason code |
| Return status | returnStatus | Return status |
Martini implementation pattern
Retrieve Returns incrementally, map quantities and reasons, distinguish requested, received, accepted, rejected, and refund-related states, and write the result to the target system. If the API version supports outbound return status updates, validate the permitted values before sending them; otherwise retain the target outcome for reconciliation.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- validation
- reconciliation
Applications commonly integrated with ChannelEngine
ChannelEngine commonly sits between marketplace operations and commerce, ERP, fulfillment, and marketplace applications. The exact objects and direction depend on the customer’s channel configuration and API version; Martini can orchestrate these flows without assuming a dedicated ChannelEngine connector.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Shopify | Synchronize catalog, inventory, prices, marketplace orders, and fulfillment between a storefront and ChannelEngine-managed marketplaces. | Shopify → Martini → ChannelEngine | Retrieve approved products, stock, and prices from Shopify, map them to ChannelEngine Products and Offers, apply channel pricing and safety-stock rules, and use scheduled workflows to return marketplace Orders or fulfillment updates where required. |
| WooCommerce | Publish WooCommerce catalog and stock information to marketplace channels while consolidating marketplace orders and fulfillment data. | WooCommerce → Martini → ChannelEngine | Consume WooCommerce data, transform SKUs and channel attributes into ChannelEngine Products and Offers, then retrieve ChannelEngine Orders incrementally and route them to the appropriate commerce or fulfillment process. |
| Adobe Commerce | Coordinate marketplace listings with Adobe Commerce catalog, inventory, pricing, and order processes. | Adobe Commerce → Martini → ChannelEngine | Use workflows to synchronize product and offer data in one direction and marketplace orders in the other, with identifier mapping, currency and tax handling, validation, retries, and checkpointed reconciliation. |
| NetSuite | Synchronize marketplace orders, inventory, fulfillment, returns, and financially relevant information with an ERP. | NetSuite → Martini → ChannelEngine | Read inventory and pricing from NetSuite, update ChannelEngine Offers, retrieve ChannelEngine Orders and Returns into NetSuite, and send validated shipment information back through the ChannelEngine REST API. |
| SAP S/4HANA | Connect enterprise product, inventory, pricing, order, and fulfillment processes with marketplace operations. | SAP S/4HANA → Martini → ChannelEngine | Expose or consume the required SAP interfaces through Martini workflows, normalize product and fulfillment data, apply channel-specific rules, and synchronize ChannelEngine objects with persisted identifiers and retry handling. |
| Amazon Seller Central | Coordinate Amazon-related offers and marketplace order flows with other channels managed through ChannelEngine. | Amazon Seller Central → ChannelEngine → Martini | Treat ChannelEngine as the marketplace-management boundary, retrieve configured Amazon-related Products, Offers, Orders, and Shipments through ChannelEngine, and route normalized data to enterprise systems with reconciliation controls. |
| bol.com | Manage Dutch and Belgian marketplace listings, offers, orders, and fulfillment processes alongside other sales channels. | bol.com → ChannelEngine → Martini | Use ChannelEngine API data for the configured bol.com channel, map channel identifiers and statuses into a canonical model, and synchronize inventory, order, shipment, and return outcomes with downstream systems. |
| Zalando | Coordinate product and offer data, orders, and fulfillment processes for Zalando marketplace operations. | Zalando → ChannelEngine → Martini | Retrieve or update the ChannelEngine objects associated with the configured Zalando channel, validate marketplace-specific values, and use idempotent workflows for catalog, order, shipment, and return processing. |
How to build a ChannelEngine integration in Martini
Objective
Establish the ChannelEngine API connection with the account-specific base URL and current API-key requirements.
Instructions in Martini
- Confirm the target ChannelEngine account, API version, base URL, required header, and permissions.
- Store the API key in Martini secrets management.
- Use HTTPS and prevent credentials or sensitive order data from entering logs.
Objective
Select the trigger that matches the object and event coverage required by the integration.
Instructions in Martini
- Use a scheduled workflow for incremental polling when comprehensive notifications are not confirmed.
- Use a Martini API endpoint only for verified ChannelEngine notification scenarios.
- Define checkpoints and overlap windows for recurring synchronization.
Objective
Read the required ChannelEngine Products, Offers, Orders, Shipments, Returns, or Channels using bounded API requests.
Instructions in Martini
- Implement pagination and stable ordering where supported.
- Limit concurrency and request volume.
- Persist progress only after successful processing of the corresponding page or batch.
Objective
Coordinate source retrieval, transformation, business rules, target writes, and recovery behavior in one maintainable workflow.
Instructions in Martini
- Separate retrieval, normalization, validation, target writing, and checkpointing stages.
- Route transient failures to retry handling and validation failures to an operational exception path.
- Use reusable mappings and services for repeated object transformations.
Objective
Convert ChannelEngine fields and marketplace-specific values into the canonical target model.
Instructions in Martini
- Map stable identifiers for Products, Offers, Orders, Shipments, Returns, and Channels.
- Handle currency, tax, addresses, variants, shipping methods, statuses, and partial quantities explicitly.
- Preserve relevant source identifiers for traceability.
Objective
Enforce commercial, fulfillment, and synchronization rules before writing data.
Instructions in Martini
- Apply safety-stock and channel-price rules to Offer updates.
- Validate carrier, tracking, order, and shipment values.
- Use idempotency keys and suppress unchanged updates where practical.
Common ChannelEngine data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Products | Product catalog information, identifiers, attributes, and variant-related data used for marketplace listings. | Shopify, WooCommerce, Adobe Commerce, NetSuite, SAP S/4HANA | Martini maps catalog identifiers and attributes, validates required fields, applies channel rules, and synchronizes through paginated REST workflows. |
| Offers | Marketplace-specific price, stock, and listing information associated with Products. | ChannelEngine marketplaces, Shopify, NetSuite, SAP S/4HANA | Martini calculates channel prices and safety stock, suppresses unchanged updates, maps product and channel keys, and retries transient update failures. |
| Orders | Orders received from connected marketplaces and routed to commerce, ERP, or fulfillment processes. | NetSuite, SAP S/4HANA, Shopify, WooCommerce, warehouse systems | Martini retrieves Orders incrementally, maps addresses, currency, tax, lines, and shipping values, applies idempotency checks, and records synchronization state. |
| Shipments | Shipment, carrier, tracking, and fulfillment information associated with Orders. | NetSuite, SAP S/4HANA, warehouse and fulfillment systems | Martini validates order and shipment identifiers, carrier and tracking values, partial-shipment rules, and duplicate update behavior before writing through the API. |
| Returns | Returned order lines, quantities, reasons, and return-processing information. | NetSuite, SAP S/4HANA, returns-management systems | Martini maps return reasons and statuses, handles partial returns and multiple lines, and synchronizes accepted, rejected, received, or refund-related outcomes where supported. |
| Channels | Connected marketplaces or sales channels through which Products, Offers, Orders, and related data are managed. | ChannelEngine, enterprise catalog and order systems | Martini uses channel identifiers to apply marketplace-specific routing, pricing, tax, status, and validation rules. |
Authentication and security considerations
API-key authentication
ChannelEngine API access generally uses an API key supplied in request headers. Confirm the exact header name, API version, base URL, and permissions in the target account documentation before production deployment.
Credential protection
- Store the API key as a Martini secret and inject it at runtime.
- Use HTTPS for every request.
- Restrict access to secrets and workflows according to deployment responsibilities.
- Avoid logging API keys or complete customer and order payloads.
Operational considerations for ChannelEngine integrations
Throughput and pagination
Use pagination for Products, Offers, Orders, Shipments, and Returns. Confirm account limits, limit concurrency, process bounded batches, and apply exponential backoff for throttling.
State and idempotency
Persist checkpoints with a small overlap window, deduplicate stable ChannelEngine identifiers, and use deterministic keys for products, offers, shipments, and returns. Reconcile periodically rather than relying only on incremental processing.
Schema and testing
Validate API versions, response envelopes, required fields, status values, and channel-specific variations. Test representative payloads from every active marketplace and separate transformation logic from orchestration logic.
Recovery
Retry transient failures only, route validation and marketplace rejection errors to an exception process, and retain enough request and object context to support troubleshooting without exposing sensitive data.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini provides a structured workflow for authenticating to ChannelEngine, retrieving paginated data, applying business rules, transforming payloads, writing to multiple target systems, and recording synchronization state.
Maintainable integration logic
Reusable mappings, validation, checkpointing, retry handling, and controlled API exposure reduce duplicated point-to-point logic. The same patterns can support orders, offers, shipments, returns, and catalog synchronization.
Operational visibility
Workflow-level error handling and monitoring make it easier to distinguish authentication, validation, throttling, marketplace rejection, and downstream failures from one-off script errors.
Frequently asked questions
ChannelEngine can be integrated through its account-specific REST API, which supports operations involving Products, Offers, Orders, Shipments, Returns, and Channels. API-key authentication is used, while webhook-style notifications may be available for selected scenarios. Where event coverage is incomplete or unconfirmed, scheduled API polling with pagination, checkpoints, retries, and reconciliation is the appropriate pattern.
Yes. Martini can consume the ChannelEngine REST API, securely supply the account API key, orchestrate scheduled or verified event-driven workflows, transform marketplace data, and synchronize it with commerce, ERP, warehouse, or returns systems. No native Martini ChannelEngine connector was documented in the supplied materials.
No. A dedicated ChannelEngine connector is not required. Martini can use ChannelEngine’s confirmed REST API and, where the target account supports the required notifications, receive webhook-style events through a Martini API endpoint. Scheduled polling can cover gaps in event support.
Lonti does not charge an additional per-connector or per-vendor fee to integrate ChannelEngine. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from ChannelEngine, marketplaces, cloud infrastructure, or other third-party systems depending on subscription, API usage, and deployment model.
The REST API is the primary confirmed integration method and should be used for Products, Offers, Orders, Shipments, Returns, and Channels. Webhook-style notifications are only a secondary option because comprehensive event coverage was not confirmed. Bulk APIs, GraphQL, SOAP, file interfaces, and direct database access were not confirmed.
Some notification or webhook-style capabilities may be available for selected scenarios, but the research did not confirm comprehensive coverage for all object changes. Validate the target account, plan, and required event types. Martini can receive verified notifications and use scheduled polling for unsupported or uncertain events.
Martini can map ChannelEngine identifiers, SKUs, prices, stock, order lines, addresses, shipment values, and return statuses into a canonical target model. Workflows should persist stable ChannelEngine identifiers, use overlap windows and checkpoints, suppress unchanged updates, and apply idempotency checks before creating downstream objects.
Martini workflows can limit concurrency, process bounded pages, apply retry and backoff for transient failures, and route validation or marketplace rejection errors for operational review. Implementations should validate required fields, tolerate new status values where appropriate, test representative payloads from active channels, and periodically reconcile Products, Offers, Orders, Shipments, and Returns.
Related Martini documentation
APIs
Workflows
Mapping
Connect ChannelEngine with your enterprise systems
Use Martini to build a secure, maintainable ChannelEngine integration for marketplace catalog, offer, order, shipment, and return workflows.