---
# === IDENTITY ===
id: business/erp-integration/pim-product-information-management/2026
canonical_question: "How do you integrate ERP with PIM systems like Akeneo, Salsify, or InRiver?"
aliases:
  - "ERP to PIM product master data synchronization pattern"
  - "How to sync product data between ERP and Akeneo PIM"
  - "PIM integration architecture for product enrichment and channel syndication"
  - "Product information management ERP integration best practices"
entity_type: erp_integration
domain: business > erp-integration > pim-product-information-management
region: global
jurisdiction: global
temporal_scope: 2024-2026

# === SYSTEM PROFILE ===
systems:
  - name: "Akeneo PIM"
    vendor: "Akeneo"
    version: "v7 / SaaS (REST API v1, GraphQL)"
    edition: "Growth / Enterprise / Serenity (SaaS)"
    deployment: cloud
    api_surface: "REST, GraphQL, Event Platform"
  - name: "Salsify PXM"
    vendor: "Salsify"
    version: "PXM Platform 2025"
    edition: "Full Platform"
    deployment: cloud
    api_surface: "REST, GraphQL, Webhooks, SFTP"
  - name: "inRiver iPMC"
    vendor: "inRiver"
    version: "iPMC 2025"
    edition: "Enterprise"
    deployment: cloud
    api_surface: "REST, Webhooks, Syndication Feeds"
  - name: "Stibo STEP"
    vendor: "Stibo Systems"
    version: "STEP 2025"
    edition: "Enterprise"
    deployment: "cloud / on-premise / hybrid"
    api_surface: "REST, STEPXML, SOAP, Extension API"
  - name: "SAP S/4HANA (ERP source)"
    vendor: "SAP"
    version: "2408"
    edition: "Public / Private Edition"
    deployment: cloud
    api_surface: "OData v4, BAPI, IDoc"
  - name: "Oracle NetSuite (ERP source)"
    vendor: "Oracle"
    version: "2024.2"
    edition: "SuiteCloud Plus"
    deployment: cloud
    api_surface: "SuiteTalk SOAP, RESTlets, SuiteQL"
  - name: "Microsoft Dynamics 365 (ERP source)"
    vendor: "Microsoft"
    version: "10.0.39"
    edition: "Finance & SCM"
    deployment: cloud
    api_surface: "OData v4, Data Entities, Business Events"

# === VERIFICATION ===
last_verified: 2026-03-03
confidence: 0.85
version: 1.0
first_published: 2026-03-03

# === TEMPORAL VALIDITY ===
temporal_validity:
  status: volatile
  last_breaking_change: "Akeneo v7 Event Platform GA (2024); Salsify GraphQL API GA (2024)"
  next_review: 2026-08-30
  change_sensitivity: high

# === CONSTRAINTS ===
constraints:
  - "ERP is source of truth for SKU, cost, weight, regulatory classification — PIM must never overwrite these fields"
  - "PIM is source of truth for marketing descriptions, media assets, translations, channel-specific attributes — ERP must not overwrite enriched content"
  - "Akeneo REST API: rate limits vary by edition (Serenity SaaS: managed throttling; on-premise: configurable) — batch imports via /api/rest/v1/products with max 100 products per PATCH request"
  - "Salsify bulk import: max 50,000 products per import job via API; SFTP imports have no hard limit but process in 50K-record chunks"
  - "Live pricing and inventory must bypass PIM entirely — sync ERP directly to ecommerce/POS channels (PIM handles 'cold' product data only)"
  - "Media assets (images, videos, PDFs) require separate DAM-to-PIM sync — binary file sizes up to 100MB per asset in most PIM systems"
  - "Channel syndication completeness gates must be satisfied before publishing — incomplete products silently dropped from feeds"

# === SKIP CONDITIONS ===
skip_this_unit_if:
  - condition: "Need single ERP API reference (Salesforce, SAP, NetSuite)"
    use_instead: "business/erp-integration/salesforce-rest-api-capabilities/2026 or sap-s4hana-odata-api-capabilities/2026"
  - condition: "Need ecommerce platform integration only (Shopify, Magento, commercetools)"
    use_instead: "business/erp-integration/order-to-cash-integration/2026"
  - condition: "Need master data management (MDM) strategy, not PIM specifically"
    use_instead: "business/erp-integration/master-data-management-erp/2026"
  - condition: "Need DAM (Digital Asset Management) integration only"
    use_instead: "N/A — check vendor-specific DAM documentation"

# === AGENT HINTS ===
inputs_needed:
  - key: integration_pattern
    question: "What integration pattern do you need?"
    type: choice
    options:
      - "real-time sync (individual product updates, <1s latency)"
      - "batch/bulk (scheduled, high volume catalog sync)"
      - "event-driven (webhook/CDC on product changes)"
      - "file-based (CSV/XML export/import for legacy ERP)"
  - key: data_volume
    question: "How many SKUs in your catalog?"
    type: choice
    options:
      - "< 10,000 SKUs"
      - "10,000-100,000 SKUs"
      - "100,000-1,000,000 SKUs"
      - "> 1,000,000 SKUs"
  - key: direction
    question: "What's the primary data flow direction?"
    type: choice
    options:
      - "ERP → PIM (product master data seeding)"
      - "PIM → channels (enrichment and syndication)"
      - "bidirectional (ERP ↔ PIM ↔ channels full loop)"
  - key: pim_system
    question: "Which PIM system are you using?"
    type: choice
    options:
      - "Akeneo PIM"
      - "Salsify PXM"
      - "inRiver iPMC"
      - "Stibo STEP"
      - "Pimcore"
      - "Other / evaluating"

# === DISTRIBUTION ===
canonical_source: "https://knowledgelib.io/business/erp-integration/pim-product-information-management/2026"
suggested_citation: "Source: knowledgelib.io — AI Knowledge Library (verified 2026-03-03)"

# === RELATED UNITS ===
related_kos:
  depends_on:
    - id: "business/erp-integration/master-data-management-erp/2026"
      label: "Master Data Management — MDM strategy underpins PIM data governance"
  related_to:
    - id: "business/erp-integration/order-to-cash-integration/2026"
      label: "Order-to-Cash — PIM feeds product catalog to ecommerce channels in O2C"
    - id: "business/erp-integration/field-mapping-data-type-comparison/2026"
      label: "Field Mapping & Data Types — cross-system data type transformation reference"
  solves:
    - id: "business/erp-integration/salesforce-sap-integration/2026"
      label: "Salesforce-SAP Integration — PIM can mediate product data between CRM and ERP"
  alternative_to:
    - id: "business/erp-integration/master-data-management-erp/2026"
      label: "MDM platforms (Informatica, Reltio) — broader scope but heavier implementation"
  often_confused_with:
    - id: "business/erp-integration/master-data-management-erp/2026"
      label: "MDM vs PIM — MDM governs all master data domains; PIM specializes in product data enrichment and syndication"

# === SOURCES ===
sources:
  - id: src1
    title: "ERP Connection Guide — Akeneo API Documentation"
    author: Akeneo
    url: https://api.akeneo.com/guides/erp-connection/introduction.html
    type: official_docs
    published: 2025-01-15
    reliability: authoritative
  - id: src2
    title: "PIM ERP Integration: How They Work Together — Bluestone PIM"
    author: Bluestone PIM
    url: https://www.bluestonepim.com/blog/pim-erp-integration
    type: technical_blog
    published: 2025-06-10
    reliability: high
  - id: src3
    title: "Salsify PXM Platform Integration API"
    author: Salsify
    url: https://www.salsify.com/pxm/platform-integration-api
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src4
    title: "PIM Integration as Connective Tissue for E-commerce — inRiver"
    author: inRiver
    url: https://www.inriver.com/resources/what-is-pim-integration/
    type: official_docs
    published: 2025-03-01
    reliability: authoritative
  - id: src5
    title: "PIM Data Model and Master Data Guide — inRiver"
    author: inRiver
    url: https://www.inriver.com/resources/pim-data-model/
    type: official_docs
    published: 2025-02-01
    reliability: high
  - id: src6
    title: "The PIM as System Hub: Architecture for ERP + OMS + IMS + DAM + eCommerce Orchestration"
    author: HumCommerce
    url: https://humcommerce.com/knowledge-center/the-pim-as-system-hub-architecture-for-erp-oms-ims-dam-ecommerce-orchestration/
    type: technical_blog
    published: 2025-04-15
    reliability: moderate_high
  - id: src7
    title: "Akeneo Accelerators for SAP S/4HANA — Akeneo App Store"
    author: Akeneo
    url: https://apps.akeneo.com/apps/akeneo-accelerators-for-s4hana
    type: official_docs
    published: 2025-01-01
    reliability: authoritative
  - id: src8
    title: "PIM Syndication: How to Automate Product Content Distribution — Bluestone PIM"
    author: Bluestone PIM
    url: https://www.bluestonepim.com/blog/pim-syndication-guide
    type: technical_blog
    published: 2025-05-20
    reliability: high
---

# ERP-to-PIM Integration: Product Information Management Playbook

## TL;DR

- **Bottom line**: ERP owns operational product data (SKU, cost, weight, compliance); PIM owns commercial product data (descriptions, media, translations, channel attributes). Integrate via API or iPaaS with clear data ownership boundaries — never let both systems write the same field.
- **Key limit**: Akeneo REST API batches max 100 products per PATCH; Salsify bulk API caps at 50K products per import job; all PIM systems throttle concurrent API connections (typically 5-10 parallel requests).
- **Watch out for**: Live pricing and inventory must bypass PIM entirely — route ERP-to-ecommerce directly. PIM handles only "cold" product data (descriptions, media, specifications). Syncing hot data through PIM adds latency and creates stale pricing.
- **Best for**: Organizations with 10K+ SKUs selling across 3+ channels that need attribute enrichment, translations, and channel-specific content beyond what ERP can manage.
- **Authentication**: Akeneo uses OAuth 2.0 client credentials; Salsify uses API key + org ID; inRiver uses API key; Stibo STEP uses SAML/OAuth 2.0 depending on deployment.

## System Profile

This playbook covers the end-to-end integration pattern for connecting any major ERP system (SAP S/4HANA, Oracle NetSuite, Microsoft Dynamics 365, or others) with a PIM system (Akeneo, Salsify, inRiver, or Stibo STEP). The ERP acts as the operational product master, while the PIM serves as the commercial content enrichment and channel syndication layer. This is a multi-system integration playbook — not a single-system API reference.

The architecture follows a hub-and-spoke model where the PIM sits between the ERP (upstream source of truth for operational data) and multiple sales channels (downstream consumers of enriched product content). Middleware or iPaaS platforms (MuleSoft, Boomi, Workato, Celigo, SAP Integration Suite) typically orchestrate the data flow. [src2, src6]

| System | Role | API Surface | Direction |
|---|---|---|---|
| ERP (SAP, NetSuite, D365) | Operational product master — SKU, cost, weight, dimensions, compliance codes | OData v4, REST, SOAP, SuiteTalk | Outbound (ERP → PIM) |
| PIM (Akeneo, Salsify, inRiver, Stibo) | Content enrichment hub — descriptions, media, translations, channel attributes | REST, GraphQL, Webhooks | Inbound (ERP → PIM) + Outbound (PIM → channels) |
| DAM (optional: Cloudinary, Bynder, Widen) | Media asset management — product images, videos, 3D models | REST | Bidirectional with PIM |
| iPaaS / Middleware | Integration orchestration — data mapping, transformation, error handling | N/A | Orchestrator |
| eCommerce / Marketplace | Sales channels — Shopify, Magento, commercetools, Amazon, eBay | REST, GraphQL | Inbound (PIM → channel) |

## API Surfaces & Capabilities

| PIM System | API Surface | Protocol | Best For | Bulk Import | Webhook Support | Event-Driven? |
|---|---|---|---|---|---|---|
| Akeneo PIM | REST API v1 | HTTPS/JSON | Product CRUD, attribute management, category trees | PATCH /api/rest/v1/products (max 100/batch) | Event Platform (Enterprise/Serenity) | Yes — Event Subscriptions |
| Akeneo PIM | GraphQL API | HTTPS/GraphQL | Complex product queries with relationships | No | N/A | No |
| Salsify PXM | REST API | HTTPS/JSON | Product CRUD, property management, digital assets | Bulk import API (max 50K/job) | Yes — webhook callbacks | Yes |
| Salsify PXM | GraphQL API | HTTPS/GraphQL | Complex queries, nested relationships | No | N/A | No |
| Salsify PXM | SFTP | SFTP/CSV | Legacy bulk import, scheduled catalog exports | Unlimited (chunked at 50K) | N/A | No |
| inRiver iPMC | REST API | HTTPS/JSON | Entity CRUD, link management, media | Bulk via REST endpoints | Yes — outbound webhooks | Yes |
| Stibo STEP | REST API | HTTPS/JSON | Product CRUD, workflow management | STEPXML import (unlimited) | Yes — outbound events | Yes |
| Stibo STEP | STEPXML | XML/HTTPS | Bulk import/export, migration | Unlimited batch size | N/A | No |

[src1, src3, src4]

## Rate Limits & Quotas

### Per-Request Limits

| PIM System | Limit Type | Value | Notes |
|---|---|---|---|
| Akeneo | Products per PATCH batch | 100 | Use `/api/rest/v1/products` with JSON array |
| Akeneo | Request body size | 50 MB | Applies to product import payloads |
| Akeneo | Media file size | 100 MB per asset | Larger assets require chunked upload |
| Salsify | Products per bulk import job | 50,000 | Jobs auto-chunk internally; queue additional jobs for larger catalogs |
| Salsify | API response page size | 250 records | Use cursor-based pagination |
| inRiver | Entities per batch write | 500 | Batch entity creation endpoint |
| Stibo STEP | STEPXML import file size | No hard limit | Practical limit ~500MB for reliable processing |

[src1, src3, src4]

### Rolling / Daily Limits

| PIM System | Limit Type | Value | Window | Edition Differences |
|---|---|---|---|---|
| Akeneo (SaaS) | API calls | Managed throttling | Rolling | Serenity: higher burst; Growth: lower concurrency |
| Akeneo (on-prem) | API calls | Configurable | N/A | Depends on server sizing; no vendor-imposed limit |
| Salsify | API calls | Fair use — typically 100-300 req/min | Per minute | Throttled with 429 + Retry-After header |
| inRiver | API calls | Fair use — throttled per tenant | Per minute | Enterprise tier: higher concurrent connections |
| Stibo STEP | API calls | Configurable per deployment | N/A | On-premise: unlimited; SaaS: vendor-managed |

[src1, src3, src4]

## Authentication

| PIM System | Auth Method | Use When | Token Lifetime | Refresh? | Notes |
|---|---|---|---|---|---|
| Akeneo | OAuth 2.0 Client Credentials | Server-to-server integration | 1 hour (default) | Yes — refresh token | Generate client ID/secret in Akeneo PIM settings > Connections |
| Salsify | API Key + Org ID | All integrations | No expiry (until revoked) | N/A | Bearer token in Authorization header; scoped per user |
| inRiver | API Key | All integrations | No expiry (until revoked) | N/A | X-inRiver-APIKey header; scoped per environment |
| Stibo STEP | OAuth 2.0 / SAML SSO | Cloud or hybrid | Session-based (configurable) | Yes | Depends on deployment; on-prem supports basic auth for legacy |

[src1, src3, src4]

### Authentication Gotchas

- Akeneo OAuth tokens expire after 1 hour by default — middleware must implement automatic refresh. Stale tokens return 401 with no retry hint. [src1]
- Salsify API keys are user-scoped — when the user is deactivated, all integrations using that key break silently. Use a service account. [src3]
- inRiver API keys are environment-scoped (sandbox vs production) — a key from staging will return 403 on production endpoints. [src4]

## Constraints
<!-- Agents: read this section before recommending any integration approach from this unit.
     These are hard constraints that must not be violated. -->

- **Data ownership is non-negotiable**: ERP owns SKU, cost/price, weight, dimensions, regulatory/compliance codes, supplier info. PIM owns marketing descriptions, media assets, translations, SEO content, channel-specific attributes. A field can have only ONE authoritative source. [src1, src2]
- **Live pricing and inventory bypass PIM**: Price and stock data must flow directly from ERP to ecommerce/POS channels. PIM can store reference pricing for internal workflow support, but never as the live feed to customer-facing channels. [src1]
- **Completeness gates block syndication**: PIM systems enforce completeness rules per channel — products missing required attributes (e.g., images, descriptions in target language) are silently excluded from channel exports. Test completeness rules before go-live. [src8]
- **Media asset sync is separate from product data sync**: Binary files (images, videos, PDFs) should use dedicated DAM-to-PIM connectors, not the product data API. Embedding base64 media in product API calls causes timeouts and hits payload limits. [src1]
- **Attribute model mismatch is the #1 integration failure**: ERP uses flat or minimally structured attributes; PIM uses hierarchical attribute groups, families, and inheritance. A product "family" in Akeneo defines which attributes apply — you must map ERP product types to PIM families before any data flows. [src1, src5]
- **Channel-specific attribute formatting**: Each sales channel (Amazon, Shopify, Google Shopping) requires different attribute names, value formats, and taxonomy codes. PIM handles this per-channel mapping, but the mappings must be configured upfront. [src8]

## Integration Pattern Decision Tree

```
START — Integrate ERP with PIM for product data enrichment
├── What's the data flow?
│   ├── ERP → PIM (product master seeding)
│   │   ├── Catalog size < 10K SKUs?
│   │   │   ├── YES → REST API batch import (Akeneo: 100/batch, Salsify: API)
│   │   │   └── NO ↓
│   │   ├── Catalog size < 100K SKUs?
│   │   │   ├── YES → Bulk API or SFTP (Salsify: bulk import, Stibo: STEPXML)
│   │   │   └── NO → File-based + chunked processing (split into 50K batches)
│   │   └── Need incremental sync (only changes)?
│   │       ├── YES → Event-driven (Akeneo Event Platform, iPaaS CDC listener)
│   │       └── NO → Scheduled full/delta export from ERP (nightly batch)
│   ├── PIM → Channels (enrichment → syndication)
│   │   ├── Channel supports API?
│   │   │   ├── YES → PIM native connector or iPaaS (preferred)
│   │   │   └── NO → PIM scheduled export → SFTP/file drop
│   │   └── Need real-time updates?
│   │       ├── YES → Webhook-triggered publish on PIM completeness
│   │       └── NO → Scheduled channel feed (hourly/daily)
│   └── Bidirectional (ERP ↔ PIM)
│       ├── What flows back from PIM to ERP?
│       │   ├── Enriched descriptions for ERP portal → two-way sync with conflict rules
│       │   ├── New product requests from PIM → ERP item creation workflow
│       │   └── Nothing — PIM only consumes from ERP → use one-way pattern
│       └── Conflict resolution strategy defined?
│           ├── YES → Implement with field-level ownership rules
│           └── NO → STOP — define data ownership matrix FIRST
├── Which middleware?
│   ├── SAP ERP → Akeneo → Use Akeneo Accelerators for S/4HANA on SAP BTP
│   ├── NetSuite → Any PIM → Celigo (native NetSuite integration) or Boomi
│   ├── Dynamics 365 → Any PIM → Azure Integration Services or MuleSoft
│   └── Generic → Any PIM → Workato, MuleSoft, or Boomi (all have PIM connectors)
└── Error handling?
    ├── Zero-loss required → idempotent operations + dead letter queue + reconciliation job
    └── Best-effort → retry with backoff + daily reconciliation report
```

## Quick Reference

### End-to-End Integration Flow

| Step | Source System | Action | Target System | Data Objects | Failure Handling |
|---|---|---|---|---|---|
| 1 | ERP | Export product master data (SKU, cost, weight, dims, classification) | iPaaS / Middleware | Item master records | Retry 3x, then DLQ |
| 2 | iPaaS | Transform: map ERP fields to PIM attribute families; convert units, codes | PIM | Product entities | Validation errors → error log |
| 3 | PIM | Enrichment team adds descriptions, media, translations, SEO content | PIM (internal) | Enriched product records | Completeness workflow notifications |
| 4 | PIM | Completeness gate passed — product marked "ready for channel" | PIM (internal) | Channel-ready products | Incomplete → held in workflow |
| 5 | PIM | Syndication: export channel-specific product feed | eCommerce / Marketplace | Channel-formatted catalog | Per-channel error logs; retry |
| 6 | ERP | Price/inventory update (bypasses PIM) | eCommerce / Marketplace | Pricing + stock levels | Direct ERP-to-channel integration |
| 7 | eCommerce | Order placed (triggers O2C flow) | ERP | Sales order | Separate O2C integration |

[src1, src2, src6]

### PIM System Comparison

| Capability | Akeneo PIM | Salsify PXM | inRiver iPMC | Stibo STEP |
|---|---|---|---|---|
| **API Style** | REST + GraphQL | REST + GraphQL | REST | REST + STEPXML + SOAP |
| **Bulk Import** | 100 products/PATCH batch | 50K/job via API; unlimited via SFTP | 500 entities/batch | STEPXML (no hard limit) |
| **Event-Driven** | Event Platform (Enterprise+) | Webhooks | Outbound webhooks | Outbound events + workflows |
| **Authentication** | OAuth 2.0 client credentials | API Key + Org ID | API Key | OAuth 2.0 / SAML |
| **DAM Integration** | Built-in basic DAM; connectors for Cloudinary, Bynder | Built-in DAM | Built-in DAM | Connectors for DAM systems |
| **Channel Syndication** | Via connectors (Shopify, Magento, Amazon) | Built-in syndication engine | Built-in syndication feeds | Via outbound integrations |
| **SAP Connector** | Akeneo Accelerators for S/4HANA (SAP BTP) | Partner connectors | Standard SAP connector | Dedicated SAP connector |
| **Open Source** | Community Edition (free, limited) | No | No | No |
| **Pricing Model** | Free (CE) / SaaS subscription (Growth/Enterprise) | SaaS subscription | SaaS subscription | SaaS or on-premise license |

[src1, src3, src4, src7]

## Step-by-Step Integration Guide

### 1. Define data ownership matrix

Before any technical integration, create a field-by-field ownership matrix specifying which system is authoritative for each attribute. This prevents the single most common PIM integration failure: two systems overwriting each other's data. [src1, src2]

```
DATA OWNERSHIP MATRIX (example)

| Attribute          | Owner | Source System | Consumers       | Update Frequency |
|--------------------|-------|---------------|-----------------|------------------|
| SKU / Item Number  | ERP   | SAP S/4HANA   | PIM, eCommerce  | On creation      |
| Cost Price         | ERP   | SAP S/4HANA   | Internal only   | On change        |
| Sell Price         | ERP   | SAP S/4HANA   | eCommerce (direct) | On change     |
| Weight / Dims      | ERP   | SAP S/4HANA   | PIM, eCommerce  | On change        |
| Product Name       | PIM   | Akeneo        | eCommerce, marketplace | On enrichment |
| Description (EN)   | PIM   | Akeneo        | eCommerce, marketplace | On enrichment |
| Description (DE)   | PIM   | Akeneo        | eCommerce (DE)  | On translation   |
| Hero Image         | DAM   | Cloudinary    | PIM, eCommerce  | On upload        |
| GTIN / EAN         | ERP   | SAP S/4HANA   | PIM, marketplace | On creation     |
| Category           | PIM   | Akeneo        | eCommerce       | On enrichment    |
| Compliance Code    | ERP   | SAP S/4HANA   | PIM (read-only) | On change        |
```

**Verify**: Every field has exactly ONE owner. No field is blank in the "Owner" column.

### 2. Map ERP product types to PIM attribute families

Each PIM system groups attributes into families (Akeneo), schemas (Salsify), or entity types (inRiver). Map each ERP product category or material type to the corresponding PIM family. [src1, src5]

```json
// Akeneo: Create product family via REST API
// POST /api/rest/v1/families
{
  "code": "electronics_accessories",
  "attributes": [
    "sku", "name", "description", "short_description",
    "weight", "dimensions", "ean",
    "hero_image", "gallery_images",
    "color", "material", "warranty_months",
    "amazon_bullet_points", "shopify_tags"
  ],
  "attribute_as_label": "name",
  "attribute_as_image": "hero_image",
  "attribute_requirements": {
    "ecommerce": ["sku", "name", "description", "hero_image", "ean"],
    "amazon": ["sku", "name", "amazon_bullet_points", "hero_image", "ean"],
    "print_catalog": ["sku", "name", "short_description"]
  }
}
```

**Verify**: `GET /api/rest/v1/families/electronics_accessories` returns the family with all attributes and channel requirements.

### 3. Configure ERP product export

Set up the ERP to export product master data to the middleware/iPaaS. Use change-based triggers where possible to avoid full catalog rescans. [src2]

```python
# Example: SAP S/4HANA OData product export via Python
# Input:  SAP S/4HANA OData endpoint, OAuth token
# Output: Product master records as JSON

import requests

SAP_BASE = "https://your-s4hana.cloud.sap/sap/opu/odata4/sap/api_product/srvd_a2x/sap/product/0002"
headers = {
    "Authorization": f"Bearer {sap_token}",
    "Accept": "application/json"
}

# Fetch products modified since last sync (delta pattern)
params = {
    "$filter": f"LastChangeDateTime gt datetime'{last_sync_timestamp}'",
    "$select": "Product,ProductDescription,GrossWeight,WeightUnit,ProductGroup",
    "$top": 1000
}

response = requests.get(f"{SAP_BASE}/Product", headers=headers, params=params)
products = response.json().get("value", [])
print(f"Exported {len(products)} changed products from SAP")
```

**Verify**: Response status 200, `value` array contains product records with expected fields.

### 4. Transform and load into PIM

Map ERP fields to PIM attributes, convert data types, and batch-import into the PIM system. [src1]

```python
# Example: Akeneo PIM batch product import via REST API
# Input:  Transformed product records from ERP
# Output: Import status (created/updated counts)

import requests
import json

AKENEO_BASE = "https://your-akeneo.cloud.akeneo.com"

# Step 4a: Get OAuth token
token_resp = requests.post(f"{AKENEO_BASE}/api/oauth/v1/token", json={
    "grant_type": "client_credentials",
    "client_id": AKENEO_CLIENT_ID,
    "client_secret": AKENEO_CLIENT_SECRET
})
access_token = token_resp.json()["access_token"]

headers = {
    "Authorization": f"Bearer {access_token}",
    "Content-Type": "application/vnd.akeneo.collection+json"
}

# Step 4b: Transform ERP records to Akeneo format
def transform_to_akeneo(erp_product):
    return {
        "identifier": erp_product["Product"],  # SKU as identifier
        "family": "electronics_accessories",
        "values": {
            "sku": [{"data": erp_product["Product"], "locale": None, "scope": None}],
            "name": [{"data": erp_product["ProductDescription"], "locale": "en_US", "scope": None}],
            "weight": [{"data": {
                "amount": str(erp_product["GrossWeight"]),
                "unit": erp_product["WeightUnit"].lower()
            }, "locale": None, "scope": None}]
        }
    }

# Step 4c: Batch import (max 100 products per PATCH request)
batch = [transform_to_akeneo(p) for p in products[:100]]
payload = "\n".join(json.dumps(p) for p in batch)  # JSONL format

resp = requests.patch(
    f"{AKENEO_BASE}/api/rest/v1/products",
    headers=headers,
    data=payload
)

# Parse line-by-line response for per-product status
for line in resp.text.strip().split("\n"):
    result = json.loads(line)
    status = result.get("status_code")
    if status not in (201, 204):
        print(f"Error for {result.get('identifier')}: {result.get('message')}")
```

**Verify**: Response contains per-product status lines. 201 = created, 204 = updated, 422 = validation error.

### 5. Configure channel syndication

Set up PIM completeness rules and channel-specific exports so enriched products automatically flow to sales channels. [src8]

```python
# Example: Salsify channel syndication — export products to Shopify
# Input:  Salsify API key, channel ID
# Output: Syndication job status

import requests

SALSIFY_BASE = "https://app.salsify.com/api/v1"
headers = {
    "Authorization": f"Bearer {SALSIFY_API_KEY}",
    "Content-Type": "application/json"
}

# Trigger channel export
export_resp = requests.post(
    f"{SALSIFY_BASE}/orgs/{ORG_ID}/channel_runs",
    headers=headers,
    json={"channel_id": SHOPIFY_CHANNEL_ID}
)
run_id = export_resp.json()["id"]

# Poll for completion
import time
while True:
    status_resp = requests.get(
        f"{SALSIFY_BASE}/orgs/{ORG_ID}/channel_runs/{run_id}",
        headers=headers
    )
    status = status_resp.json()["status"]
    if status in ("completed", "completed_with_errors"):
        print(f"Syndication {status}: {status_resp.json().get('products_exported', 0)} products")
        break
    time.sleep(10)
```

**Verify**: Channel run status is "completed" and `products_exported` matches expected count. Check channel for missing products (completeness gate failures).

### 6. Implement delta sync and reconciliation

Set up ongoing incremental sync from ERP to PIM and a periodic reconciliation job to catch drift. [src2]

```python
# Example: Akeneo Event Platform — subscribe to product updates for bidirectional awareness
# This uses Akeneo's Event Subscription API (Enterprise/Serenity only)

# Subscribe to product events from Akeneo (PIM → external systems)
subscription_resp = requests.post(
    f"{AKENEO_BASE}/api/rest/v1/event-subscriptions",
    headers={"Authorization": f"Bearer {access_token}", "Content-Type": "application/json"},
    json={
        "url": "https://your-middleware.example.com/webhooks/akeneo",
        "events": ["product.updated", "product.created", "product.removed"]
    }
)

# For ERP → PIM delta sync, use a reconciliation approach:
# 1. ERP exports changed products (last modified > last_sync_timestamp)
# 2. iPaaS transforms and imports into PIM via batch API
# 3. Store last_sync_timestamp on success
# 4. Weekly: full reconciliation — compare ERP product list vs PIM, flag discrepancies
```

**Verify**: Webhook endpoint receives test event from Akeneo. Delta sync updates only changed products, not the full catalog.

## Code Examples

### Python: Full ERP-to-Akeneo PIM Sync Pipeline

```python
# Input:  ERP product records (list of dicts), Akeneo OAuth credentials
# Output: Sync report with created/updated/failed counts

import requests
import json
from datetime import datetime

class AkeneoPIMSync:
    def __init__(self, base_url, client_id, client_secret):
        self.base_url = base_url
        self.client_id = client_id
        self.client_secret = client_secret
        self.token = None

    def authenticate(self):
        resp = requests.post(f"{self.base_url}/api/oauth/v1/token", json={
            "grant_type": "client_credentials",
            "client_id": self.client_id,
            "client_secret": self.client_secret
        })
        resp.raise_for_status()
        self.token = resp.json()["access_token"]

    def batch_upsert(self, products, batch_size=100):
        """Upsert products in batches of 100 (Akeneo limit)."""
        headers = {
            "Authorization": f"Bearer {self.token}",
            "Content-Type": "application/vnd.akeneo.collection+json"
        }
        results = {"created": 0, "updated": 0, "failed": 0, "errors": []}

        for i in range(0, len(products), batch_size):
            batch = products[i:i + batch_size]
            payload = "\n".join(json.dumps(p) for p in batch)

            resp = requests.patch(
                f"{self.base_url}/api/rest/v1/products",
                headers=headers,
                data=payload
            )

            for line in resp.text.strip().split("\n"):
                result = json.loads(line)
                code = result.get("status_code")
                if code == 201:
                    results["created"] += 1
                elif code == 204:
                    results["updated"] += 1
                else:
                    results["failed"] += 1
                    results["errors"].append({
                        "identifier": result.get("identifier"),
                        "code": code,
                        "message": result.get("message")
                    })

        return results
```

### JavaScript/Node.js: inRiver Entity Import

```javascript
// Input:  ERP product records, inRiver API key
// Output: Created entity IDs

const axios = require('axios'); // axios@1.7

const INRIVER_BASE = 'https://apieuw.productmarketingcloud.com/api/v1.0.0';

async function importToInRiver(products, apiKey) {
  const headers = {
    'X-inRiver-APIKey': apiKey,
    'Content-Type': 'application/json'
  };

  const results = { created: 0, failed: 0, errors: [] };

  // inRiver: batch create entities (max 500 per request)
  const batchSize = 500;
  for (let i = 0; i < products.length; i += batchSize) {
    const batch = products.slice(i, i + batchSize).map(p => ({
      entityTypeId: 'Product',
      fieldValues: [
        { fieldTypeId: 'ProductNumber', value: p.sku },
        { fieldTypeId: 'ProductName', value: p.name },
        { fieldTypeId: 'ProductWeight', value: p.weight }
      ]
    }));

    try {
      const resp = await axios.post(
        `${INRIVER_BASE}/entities:createmany`,
        batch,
        { headers }
      );
      results.created += resp.data.length;
    } catch (err) {
      results.failed += batch.length;
      results.errors.push(err.response?.data || err.message);
    }
  }

  return results;
}
```

### cURL: Quick Akeneo API Test

```bash
# Input:  Akeneo base URL, client_id, client_secret
# Output: OAuth token, then product list

# Step 1: Get OAuth token
curl -X POST "https://your-akeneo.cloud.akeneo.com/api/oauth/v1/token" \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"client_credentials","client_id":"YOUR_CLIENT_ID","client_secret":"YOUR_CLIENT_SECRET"}'
# Expected: {"access_token":"...","expires_in":3600,"token_type":"bearer","scope":null}

# Step 2: List products (first page)
curl -X GET "https://your-akeneo.cloud.akeneo.com/api/rest/v1/products?limit=10" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
# Expected: {"_links":{...},"current_page":1,"_embedded":{"items":[...]}}

# Step 3: Get a specific product
curl -X GET "https://your-akeneo.cloud.akeneo.com/api/rest/v1/products/SKU-12345" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
# Expected: {"identifier":"SKU-12345","family":"electronics_accessories","values":{...}}
```

## Data Mapping

### Field Mapping Reference

| ERP Field (SAP S/4HANA) | PIM Field (Akeneo) | Type | Transform | Gotcha |
|---|---|---|---|---|
| MATNR (Material Number) | identifier (SKU) | String | Direct — strip leading zeros | SAP pads with zeros to 18 chars; PIM identifiers typically exclude padding |
| MAKTX (Material Description) | name (localizable) | String | Map per locale — ERP may have single-language only | ERP description is often internal/technical, not customer-facing |
| BRGEW (Gross Weight) | weight (metric) | Decimal + Unit | Convert unit code (SAP KG → Akeneo KILOGRAM) | SAP stores in 3 decimal places; PIM may expect different precision |
| MEINS (Base Unit of Measure) | base_unit | Enum | Map SAP UoM codes to PIM unit codes (EA, PC, KG) | SAP has 500+ UoM codes; PIM typically supports 20-50 |
| MATKL (Material Group) | family + categories | Mapping table | Lookup table: SAP material group → PIM family + category path | This is the hardest mapping — requires business input, not just technical |
| EAN11 (GTIN/EAN) | ean (global) | String | Direct — validate check digit | Some ERP records have placeholder GTINs (all zeros) — filter before PIM import |
| PRDHA (Product Hierarchy) | categories (multi-value) | String → Array | Split SAP hierarchy code into PIM category path segments | SAP uses 18-char concatenated codes; PIM uses tree-based categories |
| FERTH (Production/Batch No.) | N/A — skip | N/A | Do not sync to PIM | Internal manufacturing data; no value in PIM |

[src1, src2, src5]

### Data Type Gotchas

- **Localized attributes**: ERP typically stores one language per field; PIM stores multiple locales per attribute. Middleware must route to the correct locale scope (e.g., `{"locale": "en_US", "scope": null}`). Sending without locale on a localizable attribute causes a 422 error in Akeneo. [src1]
- **Measurement attributes**: Akeneo requires measurement values as `{"amount": "1.500", "unit": "KILOGRAM"}` objects. Sending a bare number causes a validation error. Convert ERP's numeric weight + separate unit field into this composite structure. [src1]
- **Multi-value attributes**: SAP stores multi-value fields as concatenated strings (semicolon or pipe-delimited); PIM systems expect arrays. Split and trim before import. [src2]
- **Media references**: ERP stores file paths or document numbers; PIM expects uploaded binary assets or URLs. Media sync requires a separate pipeline — download from ERP/DAM, upload to PIM media endpoint, then reference by media code in product record. [src1]
- **Category trees**: ERP uses flat classification codes (material groups, product hierarchies); PIM uses hierarchical category trees. Build a mapping table and maintain it as both systems evolve. [src5]

## Error Handling & Failure Points

### Common Error Codes

| Code | PIM System | Meaning | Cause | Resolution |
|---|---|---|---|---|
| 401 | All | Unauthorized | Expired token (Akeneo) or revoked API key (Salsify/inRiver) | Refresh OAuth token; verify API key is active |
| 422 | Akeneo | Unprocessable entity | Invalid attribute value, missing required attribute, wrong locale/scope | Check error message for specific field; validate against family definition |
| 429 | All | Rate limit exceeded | Too many API calls in throttling window | Exponential backoff: wait 2^n seconds; respect Retry-After header |
| 404 | All | Entity not found | Referencing a product, family, or category that doesn't exist | Ensure prerequisite entities (families, categories) are created before products |
| 400 | Salsify | Bad request | Malformed JSON, missing required property, invalid property value | Validate payload against Salsify schema before sending |
| 409 | inRiver | Conflict | Concurrent update to same entity | Retry with jitter; implement optimistic locking with version stamps |

[src1, src3, src4]

### Failure Points in Production

- **Attribute family mismatch**: Product import fails when the ERP sends a product type that doesn't map to any PIM family. Fix: `Create a catch-all family for unmapped products; route them to a manual classification queue`. [src1]
- **Completeness gate blocking syndication**: Products that pass all PIM validation but fail channel-specific completeness rules are silently excluded from feeds — no error, just missing products. Fix: `Build a monitoring dashboard that compares PIM product count vs channel product count; alert on delta > 5%`. [src8]
- **Media upload timeout on large assets**: Product images >20MB frequently timeout on PIM upload APIs, especially behind corporate proxies. Fix: `Compress images before upload (max 5MB for web); upload via async job endpoint if available; use CDN-based DAM with URL references instead of binary upload`. [src1]
- **OAuth token race condition**: Multiple integration workers refresh the same OAuth token simultaneously, causing one worker to invalidate the other's token. Fix: `Use a token cache with mutex/lock; or use separate client credentials per worker`. [src1]
- **Character encoding mismatch**: ERP exports in Windows-1252 or ISO-8859-1; PIM APIs expect UTF-8. Special characters (umlauts, accents, CJK) get corrupted or cause 422 errors. Fix: `Force UTF-8 encoding in middleware transformation step; validate encoding before PIM API call`. [src2]
- **Category tree reorganization breaks mappings**: When the PIM team reorganizes the category tree, all ERP-to-PIM category mappings break silently (products go to root or are rejected). Fix: `Store category mappings in middleware config, not hardcoded; add alerting for unmapped categories; use PIM webhooks on category changes`. [src5]

## Anti-Patterns

### Wrong: Syncing live pricing through PIM

```
# BAD — routing price updates through PIM adds latency and creates stale pricing
ERP (price change) → iPaaS → PIM → iPaaS → eCommerce
# Result: 15-60 minute delay on price updates; customers see old prices
```

### Correct: Direct ERP-to-channel for hot data

```
# GOOD — hot data (price, inventory) bypasses PIM entirely
ERP (price change) → iPaaS → eCommerce (direct, <1 min)
ERP (product master) → iPaaS → PIM (cold data only)
PIM (enriched content) → iPaaS → eCommerce (descriptions, images, SEO)
```

### Wrong: Full catalog rescan on every sync

```python
# BAD — scanning all 500K products every hour
all_products = erp.get_all_products()  # 500K records, 45 min export
pim.batch_import(all_products)          # 5,000 API calls, 2 hours
# Result: 3-hour sync cycle for maybe 50 changed products
```

### Correct: Delta sync with change tracking

```python
# GOOD — only sync products changed since last run
last_sync = load_last_sync_timestamp()  # e.g., "2026-03-03T10:00:00Z"
changed_products = erp.get_products(modified_after=last_sync)  # ~50 records
pim.batch_import(changed_products)  # 1 API call (50 < 100 batch limit)
save_last_sync_timestamp(datetime.utcnow())
```

### Wrong: Embedding base64 media in product API calls

```python
# BAD — embedding binary image data in product payload
product = {
    "identifier": "SKU-123",
    "values": {
        "hero_image": [{"data": base64_encode(read_file("product.jpg")), ...}]
    }
}
# Result: 50MB payload, timeout, 413 Payload Too Large
```

### Correct: Upload media separately, then reference by code

```python
# GOOD — upload media asset first, then reference in product
# Step 1: Upload media file
files = {"file": ("product.jpg", open("product.jpg", "rb"), "image/jpeg")}
media_resp = requests.post(
    f"{AKENEO_BASE}/api/rest/v1/media-files",
    headers={"Authorization": f"Bearer {token}"},
    data={"product": json.dumps({"identifier": "SKU-123", "attribute": "hero_image", "locale": None, "scope": None})},
    files=files
)
media_code = media_resp.headers["Location"].split("/")[-1]

# Step 2: Product record references the uploaded media code
product = {
    "identifier": "SKU-123",
    "values": {
        "hero_image": [{"data": media_code, "locale": None, "scope": None}]
    }
}
```

## Common Pitfalls

- **Not mapping ERP product types to PIM families before import**: Products imported without a family assignment get default/empty attributes, making enrichment impossible. Fix: `Build the ERP product type → PIM family mapping table first; validate every incoming product has a mapped family; reject unmapped products to a review queue`. [src1]
- **Assuming PIM handles pricing and inventory**: PIM is designed for "cold" product content, not transactional data. Teams that route pricing through PIM discover 30-60 minute latency on price changes. Fix: `Integrate ERP-to-ecommerce directly for hot data; PIM handles descriptions, media, and translations only`. [src1, src2]
- **Ignoring channel completeness rules**: Each sales channel requires specific attributes (Amazon: bullet points + search terms; Google Shopping: GTIN + brand + google_product_category). Products silently fail to syndicate if these are missing. Fix: `Define completeness rules per channel in PIM; build pre-syndication validation reports; don't assume successful PIM import means successful channel publishing`. [src8]
- **Not handling PIM attribute model changes**: When the PIM team adds or renames attributes, the ERP integration breaks or produces nulls. Fix: `Version your field mapping configuration; use PIM API to detect attribute model changes; alert on new required attributes`. [src5]
- **Ignoring locale and scope in Akeneo**: Sending attribute values without proper locale (for localizable attributes) or scope (for channel-scoped attributes) causes silent data loss — the value is saved but invisible in the wrong context. Fix: `Always specify locale and scope in Akeneo API calls; validate against the attribute's properties (localizable: true/false, scopable: true/false)`. [src1]
- **Treating initial load the same as delta sync**: Initial catalog import (50K-500K SKUs) requires different batch sizes, error handling, and timing than daily deltas (50-500 changes). Fix: `Build two separate integration flows — initial load (SFTP/STEPXML, overnight, with reconciliation) and delta sync (API, event-driven or scheduled, with incremental tracking)`. [src2]

## Diagnostic Commands

```bash
# Test Akeneo OAuth authentication
curl -s -o /dev/null -w "%{http_code}" \
  -X POST "https://your-akeneo.cloud.akeneo.com/api/oauth/v1/token" \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"client_credentials","client_id":"ID","client_secret":"SECRET"}'
# Expected: 200

# Check Akeneo product count (verify catalog size)
curl -s "https://your-akeneo.cloud.akeneo.com/api/rest/v1/products?limit=1" \
  -H "Authorization: Bearer TOKEN" | python -c "import sys,json; print(json.load(sys.stdin).get('items_count','unknown'))"

# List Akeneo families (verify attribute families exist)
curl -s "https://your-akeneo.cloud.akeneo.com/api/rest/v1/families" \
  -H "Authorization: Bearer TOKEN" | python -c "import sys,json; [print(f['code']) for f in json.load(sys.stdin)['_embedded']['items']]"

# Test Salsify API key
curl -s -o /dev/null -w "%{http_code}" \
  "https://app.salsify.com/api/v1/orgs/ORG_ID/products?per_page=1" \
  -H "Authorization: Bearer API_KEY"
# Expected: 200

# Test inRiver API key
curl -s -o /dev/null -w "%{http_code}" \
  "https://apieuw.productmarketingcloud.com/api/v1.0.0/model/entitytypes" \
  -H "X-inRiver-APIKey: YOUR_API_KEY"
# Expected: 200

# Check Akeneo Event Platform subscriptions
curl -s "https://your-akeneo.cloud.akeneo.com/api/rest/v1/event-subscriptions" \
  -H "Authorization: Bearer TOKEN"

# Verify product sync — compare ERP vs PIM product count
echo "ERP count: $(curl -s ERP_COUNT_ENDPOINT | jq '.count')"
echo "PIM count: $(curl -s AKENEO_PRODUCTS_ENDPOINT | jq '.items_count')"
echo "Delta: check if counts match within acceptable tolerance (±1%)"
```

## Version History & Compatibility

| System | Version | Release | Status | Breaking Changes | Notes |
|---|---|---|---|---|---|
| Akeneo PIM | v7.0 | 2024-03 | Current | Event Platform GA; new permission model | GraphQL API expanded |
| Akeneo PIM | v6.0 | 2023-03 | Supported | Asset Manager replaced PAM | Migrate from PAM to Asset Manager |
| Akeneo PIM | v5.0 | 2022-01 | EOL | New category tree API | Minimum for Event Platform |
| Salsify PXM | 2025 | 2025-01 | Current | GraphQL API GA | Enhanced bulk operations |
| Salsify PXM | 2024 | 2024-01 | Supported | Channel syndication v2 | New webhook format |
| inRiver iPMC | 2025 | 2025-01 | Current | None | Enhanced REST API endpoints |
| Stibo STEP | 2025 | 2025-01 | Current | REST API v2 endpoints | Legacy SOAP deprecated for new development |
| Stibo STEP | 2024 | 2024-01 | Supported | None | STEPXML remains stable |

[src1, src3, src4]

### Deprecation Policy

Akeneo supports N-2 major versions (current v7: v5 is EOL). Salsify operates as evergreen SaaS with backward-compatible API changes and deprecation notices 6+ months in advance. inRiver and Stibo STEP follow annual release cycles with 2-year support windows on major API changes. Always test integrations in sandbox after vendor upgrades. [src1, src3, src4]

## When to Use / When Not to Use

| Use When | Don't Use When | Use Instead |
|---|---|---|
| 10K+ SKUs with rich product content needed across multiple sales channels | <500 SKUs with basic attributes — ERP direct-to-channel is sufficient | Direct ERP-to-eCommerce integration |
| Product descriptions need translations, localization, and channel-specific formatting | All content is single-language and identical across channels | Ecommerce platform's built-in product management |
| Multiple teams (marketing, ecommerce, category managers) need to enrich product data collaboratively | Single person manages product data — PIM adds unnecessary complexity | Spreadsheet-based management or ERP-native fields |
| Selling on 3+ channels (own site, Amazon, eBay, Google Shopping, B2B portal) with different attribute requirements | Single ecommerce channel with standard attributes | Channel-native product management |
| Compliance requires audit trails for product data changes | No regulatory requirements for product data governance | Simpler integration pattern |
| Need a DAM (Digital Asset Management) layer for product media | Text-only product data with no images or media | ERP-to-channel text field sync |

## Cross-System Comparison

| Capability | Akeneo PIM | Salsify PXM | inRiver iPMC | Stibo STEP |
|---|---|---|---|---|
| **Deployment** | SaaS or on-premise | SaaS only | SaaS only | SaaS, on-premise, or hybrid |
| **API Style** | REST + GraphQL | REST + GraphQL | REST | REST + STEPXML + SOAP |
| **Bulk Import Speed** | 100/batch via API; SFTP for large | 50K/job via API; SFTP unlimited | 500/batch via API | STEPXML unlimited |
| **Event/Webhook** | Event Platform (Enterprise+) | Webhooks (all editions) | Webhooks (all editions) | Outbound events + workflows |
| **SAP Connector** | Akeneo Accelerators on SAP BTP | Partner connectors | Built-in SAP connector | Built-in SAP connector |
| **Open Source Option** | Community Edition (free, limited) | No | No | No |
| **DAM Capabilities** | Basic built-in + connectors | Full built-in DAM | Full built-in DAM | Connectors only |
| **Channel Syndication** | Via marketplace connectors | Built-in syndication engine (strongest) | Built-in syndication feeds | Via outbound integrations |
| **MDM Overlap** | PIM-focused only | PIM + content syndication | PIM-focused | Full MDM platform (PIM + MDM) |
| **Best For** | Developer-friendly; open ecosystem | Brand manufacturers selling via retail/marketplace | B2B manufacturers with complex products | Enterprises needing MDM + PIM combined |
| **Typical Price** | Free (CE); $30K-150K/yr (SaaS) | $100K-500K/yr | $80K-300K/yr | $150K-500K/yr |

[src1, src3, src4, src7]

## Important Caveats

- PIM API rate limits and quotas are edition-dependent and change with vendor releases — always verify current limits against your specific contract and edition before sizing an integration.
- This playbook covers the most common ERP-to-PIM integration patterns. Specific middleware/iPaaS configuration varies significantly by platform (MuleSoft, Boomi, Workato, Celigo) — consult vendor-specific documentation for connector setup.
- Akeneo Community Edition (free) has limited API capabilities compared to Enterprise/Serenity — Event Platform, advanced permissions, and some API endpoints are Enterprise-only.
- Media/DAM integration is deliberately kept high-level in this playbook because each PIM vendor's media handling differs substantially. Plan a dedicated DAM integration workstream alongside PIM integration.
- Pricing for PIM systems varies dramatically by catalog size, number of channels, and number of users — the figures in the comparison table are rough market ranges as of early 2026, not quotes.
- PIM systems evolve rapidly. Salsify and Akeneo ship monthly updates; inRiver and Stibo STEP release quarterly. Pin integration code to specific API versions and test after every vendor upgrade.

## Related Units

- [Master Data Management ERP Integration](/business/erp-integration/master-data-management-erp/2026)
- [Order-to-Cash Integration](/business/erp-integration/order-to-cash-integration/2026)
- [Field Mapping & Data Type Comparison](/business/erp-integration/field-mapping-data-type-comparison/2026)
- [Salesforce-SAP Integration](/business/erp-integration/salesforce-sap-integration/2026)
- [iPaaS Platform Comparison](/business/erp-integration/ipaas-platform-comparison/2026)