Data Flow

Shop and marketplace integrations handle data flowing in two directions: outbound (ERP to platform) and inbound (platform to ERP). Understanding these patterns is key to building a reliable integration.

Overview

                    OUTBOUND (ERP → Platform)
              ┌──────────────────────────────────┐
              │  Articles, Stock, Prices,        │
              │  Order Status, Fulfillment       │
              │                                  │
┌──────────┐  │  ┌───────────┐  ┌────────────┐  │  ┌──────────┐
│          │──┼─►│  Fetch    │─►│ Transform  │──┼─►│          │
│  VARIO   │  │  │  from ERP │  │ to Platform│  │  │ External │
│  ERP     │  │  └───────────┘  └────────────┘  │  │ Platform │
│          │  └──────────────────────────────────┘  │          │
│          │                                        │          │
│          │  ┌──────────────────────────────────┐  │          │
│          │◄─┼──┌───────────┐  ┌────────────┐  │◄─│          │
│          │  │  │  Import   │◄─│ Transform  │  │  │          │
│          │  │  │  to ERP   │  │ to ERP fmt │  │  │          │
└──────────┘  │  └───────────┘  └────────────┘  │  └──────────┘
              │                                  │
              │  Orders, Customers, Products     │
              └──────────────────────────────────┘
                    INBOUND (Platform → ERP)

Outbound Data Flow (ERP to Platform)

Outbound synchronization pushes data from VARIO ERP to the external platform. This is typically triggered by changes in the ERP — when a product is updated, stock levels change, or an order is fulfilled.

Trigger

A webhook from VARIO ERP notifies your app about the change. Common outbound triggers:

Webhook Event	Data Synced
article.update	Product master data, descriptions, images
stock.update	Inventory levels
article-price.update	Prices and price tiers
Document status change	Order fulfillment, tracking numbers

Flow

1. Webhook received — VARIO ERP sends a notification to your app with the entity ID

2. Queue — Your app adds the item to a processing queue (see Queue-Based Processing)

3. Fetch — The queue processor retrieves the full entity data from VARIO ERP using VQL or the REST API

4. Transform — Your app maps the ERP data structure to the platform's expected format

5. Push — Your app sends the transformed data to the platform's API

Example: Outbound Article Sync

// 1. Webhook handler — receives the trigger
app.apiServer.post('/webhooks/article-update', async (req, res) =>
{
  res.status(200).send({ success: true });
  // 2. Queue the item for processing (your implementation)
  await addToQueue('article-sync', req.body.entityId);
});

// 3. Queue processor — fetches and syncs
async function processArticleSync(articleId)
{
  // Fetch from ERP
  const { data } = await ErpApi.vql(
    `SELECT id, articleNumber, descriptions.description
     FROM article.queryArticles
     WHERE id = '${articleId}'`,
    {},
    1
  );

  // 4. Transform to platform format
  const platformProduct = {
    sku: data[0].articleNumber,
    title: data[0]['descriptions.description']
  };

  // 5. Push to platform API
  await platformApi.updateProduct(platformProduct);
}

Inbound Data Flow (Platform to ERP)

Inbound synchronization pulls data from the external platform into VARIO ERP. The most common inbound flow is order import — pulling new orders from the shop into the ERP for processing.

Trigger

Inbound flows are typically triggered by:

• Polling — Your app periodically checks the platform for new data (e.g., new orders since the last check)

• Platform webhooks — The external platform notifies your app about changes (if the platform supports webhooks)

• Manual trigger — A user clicks a button in your app's UI to start an import

Flow

1. Fetch — Your app retrieves data from the platform's API

2. Transform — Map the platform data to VARIO ERP's expected format

3. Import — Use the MultiPart Import API to push data into the ERP

Example: Inbound Order Import

async function importOrders()
{
  // 1. Fetch new orders from the platform
  const lastImport = await getLastImportTimestamp();
  const orders = await platformApi.getOrders({ since: lastImport });

  // 2. Transform to ERP format
  const erpOrders = orders.map(order => ({
    externalOrderId: order.id,
    customerEmail: order.customer.email,
    items: order.lineItems.map(item => ({
      sku: item.sku,
      quantity: item.quantity,
      unitPrice: item.price
    }))
  }));

  // 3. Import to ERP using MultiPart Import
  const result = await ErpApi.fetch('/cmn/data-import/runs/multi-part', {
    method: 'POST',
    useInternalApi: true,
    body: JSON.stringify({
      presetId: orderImportPresetId,
      data: erpOrders
    })
  });

  // 4. Update the timestamp for incremental imports
  await setLastImportTimestamp(new Date().toISOString());
}

Choosing the Right Pattern

Scenario	Recommended Pattern
Product data to platform	Outbound, webhook-triggered
Stock levels to platform	Outbound, webhook-triggered
Prices to platform	Outbound, webhook-triggered
Orders from platform	Inbound, polling or platform webhooks
Customers from platform	Inbound, alongside order import
Order status to platform	Outbound, webhook-triggered

Incremental vs. Full Sync

Incremental sync processes only the data that changed since the last sync. This is the default approach for ongoing operations — webhooks naturally deliver only changed entities.

Full sync processes all data regardless of change status. This is useful for:

• Initial setup (first-time sync of the entire product catalog)

• Recovery after errors

• Periodic reconciliation

For full syncs, consider performance implications and rate limiting.