SAP Business One: Transfer Master Data and Inventory to the MARINI Data Cloud

Before we dive into the individual steps, it’s worth looking at the big picture. This cookbook article covers four SAP B1 objects that are read via the Service Layer and transferred to the MARINI DataEngine:

For each of these data streams, a separate MARINI HubEngine plan is created that controls the synchronization between B1 and the DataEngine. The following diagram shows the structure:

Four endpoints on the left, four plans in the middle, four data objects on the right. Clear, transparent, maintainable. And now we’ll build this step by step.

Before you start, here’s an overview of all the building blocks for this recipe:

API Endpoints in SAP Business One (Source System):

• BusinessPartners: Customers and suppliers (distinguished by CardType)
• Items: Item master incl. item number, description, unit
• PriceLists / Products.ItemPrices: Price lists and item prices (prices are stored as JSON field ItemPrices on the product)
• Inventory endpoint: Stock levels per item and warehouse, depending on B1 version

MARINI Platform Features:

• DataEngine Source Module: Define data schema and store B1 data in it (Create Module)
• HubEngine Plan: Establish connection to SAP B1, store credentials, configure sync logic (HubEngine Handbook)
• HubEngine Mapping: Visual field mapping from B1 fields to the DataEngine schema (Field Mapping)
• Monitoring and Logs: Monitor running synchronization

SAP-side requirement: The SAP Business One Service Layer (REST/OData) must be active on the B1 system and accessible over the network. This is the technical foundation for any MARINI connection to B1.

The first step isn’t technical. It’s conceptual: Which B1 objects do you want to make available in the MARINI Data Cloud? This sounds trivial, but the answer determines everything that follows: the number of source modules, the field selection in mapping, the complexity of the plans.

In SAP Business One, there are four classics that are needed in almost every integration:

1. Business Partners (BusinessPartners): Customers and suppliers, distinguished by the CardType field. Each Business Partner has a unique CardCode, a name (CardName), contact data and can have multiple addresses.
2. Items (Items): The item master with ItemCode, ItemName, sales and purchase units as well as the current total inventory (QuantityOnStock).
3. Price Lists (PriceLists / ItemPrices): The price lists themselves contain name and currency. However, the specific item prices are not stored directly on the price list, but as a JSON field ItemPrices on the respective product.
4. Inventory (Inventory): Inventory exists per item and per warehouse. The appropriate endpoint varies depending on the B1 version and configuration.

The question of data direction is also important. In this scenario, SAP B1 is the leading system: Data flows from B1 to the Data Cloud (unidirectional). The DataEngine is the intermediate layer that harmonizes the B1 schema and prepares it for all target systems. Write-backs to B1 are a separate topic and not part of this article.

Now it gets concrete. In the MARINI DataEngine, you create a separate Source Module for each B1 entity. A source module is a data container: It defines the schema, i.e. which fields are synchronized, but it doesn’t contain connection data. The actual connection to SAP B1 only emerges in the HubEngine plan (we’ll get to that shortly).

Start with the source module for Business Partners. The most important fields:

BPAddresses deserves special attention: This is an embedded collection. Each Business Partner can have multiple addresses (delivery address, billing address, etc.), which are represented as a list of address objects with street, postal code, city, country and address type. Whether you map this collection flat (as comma-separated fields) or structured (as a separate relation in the DataEngine) depends on your target scenario. For starters, the flat variant is sufficient.

Then the source module for Items:

The MARINI Help Center shows in detail how to create a source module. The process is identical for both modules: Create new module, define fields, set primary key, save.

We continue with the two remaining objects. Both have a special feature that you should consider when building the source module.

Price lists and item prices: In SAP B1, there is the PriceLists endpoint that delivers the metadata of the price lists: name, currency, basic information. However, the specific item prices are not stored there, but as a JSON field ItemPrices on the respective product (under Items). When creating the source module for prices, you therefore need to decide:

• Variant A: You synchronize the price list metadata (PriceLists) as a standalone object and pull the item prices separately via ItemPrices in the items module.
• Variant B: You build a combined module that merges price list reference and item price.

For getting started, variant A is recommended: clean separation, less complexity in mapping. You can establish the link between price list and item price later via a lookup in the DataEngine.

Inventory: Stock levels in SAP B1 are complex: They exist per item and per warehouse (Warehouse). Which endpoint delivers the current stock levels per warehouse depends on the B1 version and configuration.

However, the basic structure of the DataEngine object for inventory always remains the same:

Only now, after all source modules are in place, is the connection to SAP Business One established. In the MARINI HubEngine, you create a plan for this. The plan is the central unit: This is where you store access credentials, define sync logic and link the source modules as synchronization targets.

For the connection to SAP B1, you need the following credentials:

SAP Business One uses session-based authentication: The MARINI HubEngine logs in with username and password, receives a session ID and uses it for all subsequent API calls. This happens automatically, you don’t have to worry about token refresh or session management.

After saving the plan, you perform a connection test. If the connection is established, you can explore the available endpoints and confirm that BusinessPartners, Items, PriceLists and the inventory endpoint are accessible. The HubEngine Handbook provides detailed instructions for plan configuration.

Whether you create one plan for all four objects or four separate plans depends on your setup. In practice, separate plans per object have proven successful: You can start, stop and monitor each sync independently. If the inventory sync gets stuck, Business Partners and Items continue to run anyway.

The connection is established. The source modules know their schema. Now you bring both together: In HubEngine Mapping, you assign a field in the DataEngine data object to each field from the B1 endpoint.

For Business Partners, the mapping looks like this as an example:

The same principle applies to Items (ItemCode → item_id, ItemName → name, etc.), price lists and inventory. In addition to pure field assignment, the MARINI HubEngine also offers transformation rules in mapping: Reformat values, set conditions (e.g. only synchronize records with CardType = Customer), define required fields and implement validations.

Three tips for clean mapping:

1. Primary keys first: Define for each data object which field is the unique identifier. For Business Partners, this is CardCode, for Items ItemCode. Without a primary key, the DataEngine cannot distinguish updates from new records.
2. Harmonize field names: In the DataEngine, you’re free in naming. Use this: Instead of keeping CardCode and ItemCode in the DataEngine, choose descriptive, system-independent names like partner_id and item_id. This makes the data easier to consume for target systems.
3. Think about collections separately: Embedded lists like BPAddresses require their own mapping (or their own data object with relation). Consider in advance whether the addresses should be mapped flat in the same data object or modeled as a separate entity with 1:n relationship.

Plans configured, mapping established. Now it gets serious: You start the first synchronization. This happens with one click in the HubEngine plan. The MARINI HubEngine reads the data from the B1 endpoints, applies the mapping and writes the results to the DataEngine data objects.

On the first run, all records are transferred (initial sync). After that, the HubEngine only synchronizes changes (delta sync), based on timestamps or change markers from B1. This keeps run times short and the load on the B1 server low.

Use the monitoring and logs in the MARINI platform to observe the sync:

• Sync status: Successful, failed or still running, visible per plan
• Record counter: How many records were read, written, skipped?
• Error logs: Which records could not be synchronized and why? Typical causes: Required field empty, data type mismatch, invalid value
• Alerts: Configurable notifications for errors or anomalies

Take a close look at the error logs after the first run. The most common problems with B1 sync:

• Empty required fields: A Business Partner without CardCode cannot be written. Solution: Required field validation in mapping or data cleanup in B1.
• Special characters in field values: Some B1 installations contain historical data with unusual characters. The DataEngine logs these cases so you can clean them up specifically.
• Inventory endpoint not accessible: If the inventory endpoint is named differently depending on the B1 version, this becomes apparent here at the latest. The error message leads you to the correct endpoint.

For production operation, you define a sync rhythm. Master data like Business Partners and Items change rarely. Daily or hourly sync is usually sufficient. Inventory can be updated more frequently, depending on how time-critical the inventory information is for your target systems.

The data is flowing. But is it flowing correctly? After the first successful sync, you open the data objects in the MARINI DataEngine and check randomly:

• Do the field values match? Did CardCode really arrive as partner_id?
• Are the data types correct? Number fields as numbers, date fields as dates?
• What do the address collections look like? Were the BPAddresses cleanly mapped?
• Do the inventory quantities match? Compare an item in B1 and in the DataEngine randomly.

If everything fits, you now have a central, harmonized data model of your SAP B1 master data in the MARINI Data Cloud. From here, it gets exciting: The DataEngine is not a dead end, but the starting point for everything else.

You can build ETL pipelines on this data that transform, enrich and forward the data to target systems. You can define workflows that automatically trigger an action for new Business Partners. And you can immediately analyze and search the data via the DataEngine Quickstart.

In this cookbook article, you’ve brought four SAP B1 data streams into the MARINI Data Cloud: Business Partners, items, price lists and inventory. The architecture: one source module per object, one HubEngine plan per sync, clean mapping in between. SAP B1 remains the leading system, the DataEngine becomes the central hub from which all target systems are served.

What you’ve gained:

• One source instead of many: Each target system (CRM, shop, marketing automation) gets the data from the DataEngine, not directly from B1.
• Schema changes in one place: If B1 renames a field, you adjust one mapping, not five separate connections.
• Consistency across system boundaries: All target systems work with the same, current master data.

The master data in the Data Cloud is the foundation. From here, you can build in many directions:

• Items and inventory to the shop: Automatically supply Shopware or Shopify with current product data and availability.
• Business Partners to CRM: Feed HubSpot, Salesforce or Dynamics 365 Sales with current customer master data.
• Price lists for sales: Make current prices available in CRM or in the quotation process.
• Inventory changes in real-time: Shorten inventory sync interval and pass inventory changes to all connected systems.
• Build Golden Record: Based on the B1 master data, create a deduplicated, cross-system master data model that serves as the single source of truth for all target systems.

All Help Center articles that help you with implementation:

• DataEngine Quickstart: Getting started with the MARINI DataEngine
• Create Module: Creating source modules step by step
• HubEngine Handbook: Plan configuration and connection management
• Field Mapping: Visual field assignment and transformation rules
• ETL Pipelines: Transform and forward data in the DataEngine
• Lookup Workflow Action: Link data objects in the DataEngine