.png)
Zalando Integration Guide
Integrate Zalando partner operations with enterprise systems through OAuth 2.0-secured REST APIs, selective callbacks, and scheduled synchronization.
Zalando integration options at a glance
Zalando partner integrations are primarily based on REST APIs for Articles, Orders, order lines, Shipments, Returns, Settlements, and related marketplace operations. Access uses OAuth 2.0 bearer tokens, with scopes and permissions determined by the applicable partner API. Selected API products may provide event notifications or outbound callbacks, but coverage is not universal. Martini can consume the REST APIs, process paginated and incremental responses, transform payloads, and expose normalized APIs to ERP, warehouse, finance, and service applications. Where callbacks are unavailable, scheduled Martini workflows can poll Zalando, maintain checkpoints, and reconcile results. Bulk or asynchronous processing may be available for selected API products and should be verified per use case.
| Integration point | Supported by Zalando? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Zalando partner REST APIs support catalog, order, fulfillment, return, settlement, and related marketplace operations subject to enabled products and permissions. | Martini can consume Zalando REST endpoints from workflows, handle pagination, transform payloads, apply validation, and expose normalized APIs to internal applications. |
| Webhooks and outbound callbacks | Limited | Selected Zalando API products may provide event notifications or outbound callbacks, but coverage should not be assumed for every Article, Order, Shipment, Return, or Settlement change. | Martini can receive documented callback or webhook-style notifications and trigger workflows; scheduled polling remains the fallback where coverage is unavailable. |
| Bulk, asynchronous, and batch APIs | Limited | Some Zalando API products may support multi-item or asynchronous processing for catalog or operational use cases. | Martini can orchestrate documented asynchronous exchanges and batch processing, but the applicable Zalando API must be verified before implementation. |
| OAuth 2.0 authentication | Yes | Partner API requests use OAuth 2.0 bearer tokens, with client registration, scopes, permissions, and flows determined by the API product and partner configuration. | Martini can keep client credentials and environment-specific values in secure configuration and use bearer access tokens in API workflows. |
| Scheduled synchronization | Yes | Polling is appropriate for objects or state transitions without a suitable Zalando callback, including incremental order, return, settlement, or catalog synchronization. | Martini scheduling workflows can retrieve filtered and paginated data, persist cursors or timestamps, and run periodic reconciliation. |
| File and attachment APIs | Not confirmed | No general Zalando file or attachment API was confirmed for ordinary partner integrations. | Martini should use documented Zalando APIs unless a specific partner service confirms another import or export mechanism. |
| Database and analytics access | No | Direct database access is not part of the normal Zalando partner integration model. | Martini can write transformed Zalando data to supported databases, but data must first be obtained through Zalando APIs or supported partner processes. |
How Zalando exposes data and business events
Zalando REST APIs
Zalando's partner integration model is primarily REST-based. Partner APIs provide access to catalog, order, fulfillment, return, settlement, and related marketplace operations according to the enabled API products and permissions.
Martini implementation pattern
Martini authenticates with OAuth 2.0, calls the relevant Zalando endpoints from a workflow, follows pagination, applies incremental filters, maps responses to canonical models, and writes results to enterprise systems or exposes normalized APIs.
Implementation sequence
Zalando callbacks and notifications
Selected Zalando partner API products may provide event notifications or outbound callbacks. Coverage is selective and should be confirmed for the required object and state transition.
Martini implementation pattern
Martini can expose or receive the documented callback endpoint, validate the notification, retrieve the current Zalando resource when necessary, and process the event through a reusable workflow. Polling remains necessary for uncovered events.
Implementation sequence
Scheduled Zalando synchronization
Scheduled polling is the practical fallback when Zalando does not provide a suitable callback for a required object or state transition.
Martini implementation pattern
Martini schedules an incremental workflow that retrieves filtered and paginated Articles, Orders, Returns, Shipments, or Settlements, stores a cursor or timestamp, and periodically reconciles results against internal systems.
Implementation sequence
Zalando batch and asynchronous processing
Some Zalando partner API products may support multi-item or asynchronous operations, but universal bulk coverage was not confirmed.
Martini implementation pattern
Where the selected Zalando API documents batch or asynchronous operations, Martini can submit grouped work, track the resulting status, process completed responses, and isolate failed items without assuming that the same model applies to every object.
Implementation sequence
Common Zalando integration patterns
Pattern 1: Sync Zalando orders to ERP and warehouse systems
When to use this pattern
Use this pattern when Zalando Orders and order lines must create or update sales orders and fulfillment work in enterprise systems. Incremental retrieval and durable identifiers help prevent missed or duplicate orders.
Integration direction
Example Mapping
| Zalando Field | Canonical Field | Target Field |
|---|---|---|
| orderId | externalOrderId | salesOrder.externalReference |
| orderLines.articleId | productId | salesOrder.items.product |
| orderLines.quantity | orderedQuantity | salesOrder.items.quantity |
| fulfillmentDetails | fulfillmentInstructions | warehouseOrder.instructions |
Martini implementation pattern
A scheduled Martini workflow authenticates with Zalando, retrieves paginated Orders using incremental filters, maps Articles and order lines into ERP and warehouse models, validates required values, and uses the Zalando order identifier for idempotency. Retryable failures are retried with controlled backoff while permanent validation errors are routed for review.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
Pattern 2: Send shipment confirmations to Zalando
When to use this pattern
Use this pattern when warehouse or ERP systems produce shipment, tracking, or dispatch updates that must be sent back to Zalando for order fulfillment status.
Integration direction
Example Mapping
| Zalando Field | Canonical Field | Target Field |
|---|---|---|
| shipmentId | externalShipmentId | shipment.id |
| trackingNumber | trackingReference | shipment.trackingNumber |
| carrier | carrierCode | shipment.carrier |
| dispatchStatus | fulfillmentStatus | orderLine.status |
Martini implementation pattern
Martini receives shipment information from the warehouse or ERP endpoint, validates carrier and tracking data, maps the payload to the applicable Zalando fulfillment operation, and submits the update through the REST API. Duplicate shipment messages are safely handled using external identifiers, and transient Zalando responses are retried.
Martini capabilities used
- workflows
- API exposure
- API consumption
- data mapping
- validation
- retry handling
Pattern 3: Publish catalog data to Zalando Articles
When to use this pattern
Use this pattern when product information from a PIM or commerce platform must be transformed into marketplace-specific Article payloads before publication.
Integration direction
Example Mapping
| Zalando Field | Canonical Field | Target Field |
|---|---|---|
| productIdentifier | sku | article.productIdentifier |
| brand | brandName | article.brand |
| sizeAndColor | variantAttributes | article.attributes |
| availability | availableQuantity | article.availability |
Martini implementation pattern
Martini retrieves approved product data, applies category, brand, size, color, price, availability, and market-specific mappings, validates required Article fields, and submits updates to Zalando. Invalid products are rejected before transmission and successful submissions are recorded for later reconciliation.
Martini capabilities used
- workflows
- API consumption
- data mapping
- validation
- business rules
- reconciliation
Pattern 4: Reconcile Zalando returns and settlements
When to use this pattern
Use this pattern when finance, inventory, and customer-service systems need consistent views of marketplace Returns and Settlements and discrepancies must be identified.
Integration direction
Example Mapping
| Zalando Field | Canonical Field | Target Field |
|---|---|---|
| returnId | externalReturnId | return.externalReference |
| orderLineId | orderLineReference | return.orderLine |
| settlementAmount | marketplaceAmount | settlement.amount |
| settlementStatus | reconciliationStatus | settlement.status |
Martini implementation pattern
A scheduled Martini workflow retrieves Returns and Settlements, matches them to Orders and order lines, maps financial and inventory effects into NetSuite, and loads normalized data into Snowflake. Unmatched, duplicated, or financially inconsistent items are flagged while successful checkpoints are retained.
Martini capabilities used
- scheduling
- API consumption
- data mapping
- business rules
- database integration
- error handling
Applications commonly integrated with Zalando
Zalando data can be coordinated with retail, fulfillment, finance, product-information, customer-service, and analytics applications. The specific API permissions and object coverage should be confirmed for each partner account and use case.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| SAP S/4HANA | Synchronize Zalando sales orders, inventory, shipments, returns, and settlement information with enterprise ERP processes. | Zalando → Martini → SAP S/4HANA | Martini retrieves Zalando Orders and Returns, maps them to SAP business objects, and sends fulfillment or availability updates from SAP back through Zalando REST APIs. External identifiers, validation, retries, and reconciliation are handled in workflows. |
| NetSuite | Reconcile marketplace orders and Settlements with finance, inventory, and fulfillment records. | Zalando → Martini → NetSuite | A scheduled workflow retrieves incremental Zalando Orders, Returns, and Settlements, transforms them into NetSuite-compatible payloads, and records external identifiers to prevent duplicate postings. |
| Microsoft Dynamics 365 | Connect Zalando marketplace activity with sales orders, inventory, warehouse operations, and finance. | Zalando → Martini → Microsoft Dynamics 365 | Martini orchestrates bidirectional REST exchanges, applies explicit status and marketplace validation rules, and routes failed updates for retry or operational review. |
| Shopify | Coordinate selected catalog, availability, and order data when a retailer operates both Shopify and Zalando channels. | Shopify → Martini → Zalando | Martini normalizes Shopify product and availability data into Zalando Article payloads, validates marketplace-specific fields, and sends Zalando order information to the retailer's back office. |
| Salesforce | Make Zalando order, return, and customer-service information available to service teams. | Zalando → Martini → Salesforce | Martini polls or receives supported Zalando notifications, maps Orders and Returns into Salesforce service data, and applies idempotent upsert and exception handling. |
| Manhattan Active | Coordinate Zalando Orders and Shipments with distributed order management and warehouse fulfillment. | Zalando → Martini → Manhattan Active | Martini transforms Zalando order lines into fulfillment requests for Manhattan Active and maps shipment confirmations and tracking information back to Zalando. |
| Akeneo | Manage and transform product information before publishing selected Article data to Zalando. | Akeneo → Martini → Zalando | A Martini workflow retrieves approved Akeneo product data, maps brands, categories, sizes, colors, images, prices, and availability, validates required fields, and submits Article updates. |
| Snowflake | Centralize Orders, Returns, Settlements, and operational data for analytics and reconciliation. | Zalando → Martini → Snowflake | Martini incrementally retrieves Zalando data, converts payloads into governed analytical structures, and loads them into Snowflake with checkpoints and replayable error handling. |
How to build a Zalando integration in Martini
Objective
Establish access to the applicable Zalando partner API using the required OAuth 2.0 client registration, scopes, permissions, and environment-specific credentials.
Instructions in Martini
- Configure the Zalando OAuth 2.0 client and required scopes
- Store client secrets and tokens in secure Martini configuration
- Separate development, test, and production credentials
- Confirm the enabled Zalando API products and permissions
Objective
Select event-driven processing only where Zalando documents suitable callbacks; otherwise use scheduled incremental polling.
Instructions in Martini
- Confirm callback coverage for the required Zalando object
- Use a Martini API or webhook workflow for documented notifications
- Use a scheduler trigger for uncovered changes
- Define the cursor, timestamp, or status filter
Objective
Call the relevant Zalando REST APIs and retrieve complete, incremental datasets without skipping pages or duplicating work.
Instructions in Martini
- Call the documented endpoint from a Martini workflow
- Follow the API pagination mechanism
- Persist a checkpoint after successful processing
- Capture request, response, and correlation identifiers
Objective
Coordinate retrieval, validation, transformation, target writes, retries, and reconciliation as maintainable Martini workflow logic.
Instructions in Martini
- Separate transport, mapping, business rules, and target operations
- Branch for retryable versus permanent failures
- Process individual objects or batch results safely
- Preserve external Zalando identifiers
Objective
Transform Articles, Orders, order lines, Shipments, Returns, and Settlements into canonical and target-specific models.
Instructions in Martini
- Map fields into the target application model
- Validate required identifiers, statuses, quantities, and marketplace values
- Handle additive fields and unknown business-critical statuses explicitly
- Apply country, category, size, color, and availability rules where relevant
Objective
Write valid data to ERP, warehouse, finance, service, or analytics systems and compare results periodically with Zalando.
Instructions in Martini
- Upsert using Zalando identifiers as external keys
- Send shipment and fulfillment updates where required
- Record successful checkpoints only after target confirmation
- Schedule reconciliation for missed, late, unmatched, or inconsistent data
Common Zalando data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Articles | Products or sellable catalog items made available through Zalando. | Akeneo, Shopify, SAP S/4HANA, Microsoft Dynamics 365, Snowflake | Martini maps product identifiers, attributes, prices, availability, and marketplace-specific values, validates the payload, and sends or stores the result. |
| Orders | Customer purchases received through the Zalando marketplace. | SAP S/4HANA, NetSuite, Microsoft Dynamics 365, Salesforce, Manhattan Active | Martini retrieves Orders incrementally, maps them into sales-order or fulfillment models, stores Zalando identifiers, and applies idempotent upsert and retry logic. |
| Order lines | Individual article quantities and fulfillment details within an Order. | ERP, warehouse management, order management, inventory systems | Martini preserves line-level identifiers, quantities, Article references, prices, and fulfillment states while applying explicit validation and status mappings. |
| Shipments | Dispatch, tracking, and delivery-related information associated with Orders. | Manhattan Active, SAP S/4HANA, NetSuite, Zalando | Martini transforms warehouse or ERP shipment confirmations into Zalando updates and handles transient API failures, duplicate notifications, and reconciliation. |
| Returns | Items or order lines returned by customers. | ERP, finance, customer service, inventory, Snowflake | Martini matches Returns to Orders and order lines, updates internal refund or inventory processes, and flags unmatched or duplicated returns. |
| Settlements | Financial and reconciliation information for marketplace activity. | NetSuite, SAP S/4HANA, Microsoft Dynamics 365, Snowflake | Martini retrieves and normalizes settlement data, matches it to internal transactions, and routes discrepancies for review. |
Authentication and security considerations
OAuth 2.0 and partner authorization
Zalando partner APIs use OAuth 2.0 bearer-token authentication. Client registration, scopes, permissions, token endpoints, and authorization flows depend on the selected Zalando API product and partner configuration.
Secure Martini configuration
- Store client IDs, client secrets, tokens, and environment-specific values in secure configuration.
- Use separate credentials for development, testing, and production.
- Request only the permissions required by the integration.
- Protect normalized Martini APIs with appropriate authentication and authorization controls.
Operational considerations for Zalando integrations
Synchronization and API limits
- Follow Zalando pagination and persist durable cursors or timestamps.
- Respect API-specific rate limits and use controlled polling with exponential backoff.
- Use Zalando identifiers for idempotency across retries and repeated observations.
Data quality and change management
- Map statuses explicitly across Orders, Shipments, Returns, and Settlements.
- Validate marketplace-specific catalog and fulfillment requirements before submission.
- Tolerate additive fields and route unknown business-critical values for review.
Reliability and reconciliation
Separate retryable transport or throttling errors from permanent validation and authorization failures. Capture response details, correlation information, object identifiers, and retry counts. Periodically reconcile Zalando with ERP, warehouse, finance, and analytics systems.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration instead of isolated scripts
Martini provides a maintainable workflow layer for OAuth authentication, scheduled polling, selective callback handling, pagination, transformation, validation, target writes, retries, and reconciliation. This avoids duplicating Zalando-specific logic across point-to-point scripts.
Reusable integration behavior
Teams can expose normalized APIs and reuse mappings, business rules, error handling, and secure configuration across ERP, warehouse, finance, service, and analytics integrations.
Operational control
Workflow structure, checkpoints, idempotency, logging, and controlled deployment make marketplace synchronization easier to troubleshoot and evolve as Zalando API products and partner requirements change.
Frequently asked questions
Zalando is primarily integrated through its partner REST APIs for Articles, Orders, order lines, Shipments, Returns, Settlements, and related marketplace operations. OAuth 2.0 bearer-token authentication is required, while selected API products may offer callbacks or event notifications. Where events are unavailable, scheduled polling with pagination, checkpoints, idempotency, and reconciliation is appropriate.
Yes. Martini can integrate with Zalando by consuming Zalando's documented REST APIs, securely managing OAuth 2.0 credentials, orchestrating workflows, transforming payloads, exposing normalized APIs, and using documented callbacks or scheduled polling where appropriate.
No. A dedicated Zalando connector is not required. Martini can use Zalando's confirmed native integration mechanisms, primarily REST APIs and OAuth 2.0, together with documented callbacks or scheduled synchronization where available.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Zalando. Integration use is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Zalando, cloud infrastructure, or other third-party systems depending on subscriptions, usage, and deployment.
Use the relevant Zalando partner REST API for catalog, order, fulfillment, return, settlement, or other enabled operations. Selected APIs may support callbacks or batch processing, but those capabilities must be verified for the specific partner product. GraphQL and SOAP were not confirmed for these use cases.
Only where the applicable Zalando API product documents outbound callbacks or event notifications for the required events. Coverage should not be assumed for all Articles, Orders, Shipments, Returns, or Settlements. Martini can use scheduled REST polling as a fallback.
Use Zalando object identifiers as external keys, process updates idempotently, follow pagination, and persist a cursor or timestamp after successful processing. Explicitly map status transitions, tolerate additive fields, and periodically reconcile internal data with Zalando.
Yes. Martini can expose controlled REST APIs that normalize Zalando Articles, Orders, Shipments, Returns, or Settlements for ERP, warehouse, finance, service, or analytics consumers. The façade can centralize authentication, mapping, validation, business rules, and error handling without exposing Zalando-specific details to every downstream application.
Related Martini documentation
Zalando APIs
Data processing
Build a maintainable Zalando integration with Martini
Use Martini to connect Zalando partner APIs with your ERP, warehouse, finance, service, and analytics systems through secure workflows, reusable mappings, controlled APIs, and reliable synchronization.