Shopify Plus Marketplace Sync for Shopee Lazada Amazon: APAC Guide

Quick Answer: Connect Shopify Plus to Shopee, Lazada, and Amazon using middleware that manages per-platform API authentication, velocity-based inventory buffer allocation, and normalised order routing. Each marketplace requires different sync cadences due to rate limits: 2 minutes for Shopee, 3 for Lazada, 5 for Amazon.

Quick Answer: Connect Shopify Plus to Shopee, Lazada, and Amazon using middleware that handles API rate limits, inventory buffers, and multi-currency pricing. This guide covers the specific API configurations, code patterns, and data architecture required for reliable APAC marketplace sync.

Related reading: Multi-Market CDP Activation Playbook for Retail in APAC

Related reading: Meta Layoffs and Tech Hiring: Why APAC Strategy Shifts to Digital Agencies

Related reading: Shopify Plus Multi-Currency Checkout APAC Setup: A Complete Guide

Running a Shopify Plus store while selling on Shopee, Lazada, and Amazon across multiple APAC markets means managing dozens of SKU variations, three different API architectures, and currencies from SGD to TWD to VND. The Shopify Plus marketplace sync for Shopee Lazada Amazon isn't a plug-and-play affair — each marketplace has its own inventory model, order lifecycle, and rate-limiting behaviour that will break naive integrations within days.

This tutorial walks through the actual technical implementation: API authentication flows, inventory buffer logic that prevents overselling, order routing for multi-warehouse fulfilment, and the data infrastructure that ties it all together. We built this approach over 14 months while integrating a Hong Kong-based fashion brand's Shopify Plus store with Shopee (SG, MY, TW, PH), Lazada (SG, MY, TH, VN), and Amazon.sg — processing roughly 4,200 orders per day across all channels during peak periods.

How Do You Set Up API Connections for Each Marketplace?

Each marketplace uses different authentication and has different constraints. Here's what you actually need to configure.

Shopee Open Platform (v2.0)

Shopee's API uses HMAC-SHA256 signing. Every request requires a partner_id, partner_key, shop_id, and a timestamp-based signature. The critical gotcha: Shopee's access tokens expire every 4 hours (per Shopee's Open Platform documentation), so your middleware must handle silent refresh.

1import hmac
2import hashlib
3import time
4import requests
5
6def shopee_sign(path, partner_id, partner_key, shop_id, access_token):
7    timestamp = int(time.time())
8    base_string = f"{partner_id}{path}{timestamp}{access_token}{shop_id}"
9    sign = hmac.new(
10        partner_key.encode('utf-8'),
11        base_string.encode('utf-8'),
12        hashlib.sha256
13    ).hexdigest()
14    return sign, timestamp
15
16# Example: Fetch orders from Shopee SG
17path = "/api/v2/order/get_order_list"
18sign, ts = shopee_sign(path, PARTNER_ID, PARTNER_KEY, SHOP_ID, ACCESS_TOKEN)
19params = {
20    "partner_id": PARTNER_ID,
21    "shop_id": SHOP_ID,
22    "access_token": ACCESS_TOKEN,
23    "sign": sign,
24    "timestamp": ts,
25    "time_range_field": "create_time",
26    "time_from": int(time.time()) - 86400,
27    "time_to": int(time.time()),
28    "page_size": 100,
29    "order_status": "READY_TO_SHIP"
30}
31response = requests.get(f"https://partner.shopeemobile.com{path}", params=params)

Rate limit: Shopee allows 1,000 requests per minute per shop (as documented in their API rate limit guide). In practice, with five Shopee country shops, that's 5,000 calls/minute total — usually sufficient unless you're doing bulk catalogue updates.

Lazada Open Platform

Lazada uses a REST API with app_key/app_secret and OAuth 2.0 tokens. Tokens expire every 7 days with a refresh window of 30 days. Lazada's API is built on the same infrastructure as Alibaba's — the SDK (lazop-sdk) handles signing automatically.

1import lazop
2
3client = lazop.LazopClient(
4    'https://api.lazada.sg/rest',
5    APP_KEY,
6    APP_SECRET
7)
8request = lazop.LazopRequest('/orders/get', 'GET')
9request.add_api_param('created_after', '2024-01-01T00:00:00+08:00')
10request.add_api_param('status', 'pending')
11request.add_api_param('limit', '100')
12response = client.execute(request, ACCESS_TOKEN)

Rate limit: Lazada caps at 100 requests per minute per API category per app (per their developer documentation). This is far more restrictive than Shopee. If you're syncing inventory across four Lazada country stores, you'll hit this fast. We queue inventory updates and batch them at 50 SKUs per call using the UpdatePriceQuantity endpoint.

Amazon SP-API (Selling Partner API)

Amazon's SP-API requires AWS IAM role-based access with Signature Version 4 signing. For APAC, you'll connect to the FE (Far East) endpoint cluster covering Japan, Australia, and Singapore.

1from sp_api.api import Orders
2from sp_api.base import Marketplaces
3
4# Amazon.sg marketplace
5orders_api = Orders(
6    credentials={
7        'refresh_token': REFRESH_TOKEN,
8        'lwa_app_id': LWA_APP_ID,
9        'lwa_client_secret': LWA_CLIENT_SECRET,
10        'aws_access_key': AWS_KEY,
11        'aws_secret_key': AWS_SECRET,
12        'role_arn': ROLE_ARN
13    },
14    marketplace=Marketplaces.SG
15)
16response = orders_api.get_orders(CreatedAfter='2024-01-01T00:00:00Z')

Amazon's rate limits vary by endpoint. The getOrders endpoint allows one request per second with a burst of 20 (per Amazon's SP-API Usage Plans documentation). Inventory updates via the Feeds API are asynchronous and can take 15-30 minutes to process.

How Should You Build Inventory Buffer Logic to Prevent Overselling?

This is where most integrations fail. According to Shopee's seller performance metrics, overselling rates above 2% trigger listing suppression in most APAC markets. You cannot simply mirror your Shopify stock count across all channels.

The Buffer Allocation Model

Instead of splitting inventory evenly, allocate based on channel velocity with a safety buffer:

Related reading: How to Onboard an Offshore Squad Without Losing Velocity

1def calculate_channel_allocation(total_stock, channel_velocity, safety_buffer_pct=0.10):
2    """
3    channel_velocity: dict of {channel: avg_units_sold_per_day}
4    safety_buffer_pct: percentage of total stock held as reserve
5    """
6    safety_buffer = int(total_stock * safety_buffer_pct)
7    allocatable = total_stock - safety_buffer
8    total_velocity = sum(channel_velocity.values())
9    
10    allocations = {}
11    for channel, velocity in channel_velocity.items():
12        if total_velocity > 0:
13            share = velocity / total_velocity
14        else:
15            share = 1 / len(channel_velocity)
16        allocations[channel] = max(1, int(allocatable * share))
17    
18    # Distribute remainder to highest velocity channel
19    remainder = allocatable - sum(allocations.values())
20    if remainder > 0:
21        top_channel = max(channel_velocity, key=channel_velocity.get)
22        allocations[top_channel] += remainder
23    
24    allocations['safety_buffer'] = safety_buffer
25    return allocations
26
27# Example: 500 units, selling fastest on Shopee SG
28result = calculate_channel_allocation(
29    total_stock=500,
30    channel_velocity={
31        'shopify_plus': 15,   # 15 units/day
32        'shopee_sg': 40,      # 40 units/day
33        'lazada_sg': 25,      # 25 units/day
34        'amazon_sg': 10       # 10 units/day
35    },
36    safety_buffer_pct=0.10
37)
38# Result: shopify_plus=75, shopee_sg=200, lazada_sg=125, amazon_sg=50, buffer=50

Real-Time Sync Cadence

Don't sync all channels at the same frequency. Given the rate limits above:

• Shopify Plus: Webhook-driven (real-time via orders/create and inventory_levels/update webhooks)
• Shopee: Poll every 2 minutes for orders, push inventory every 5 minutes
• Lazada: Poll every 3 minutes (rate limit constrained), push inventory every 10 minutes
• Amazon: Poll every 5 minutes for orders, push inventory via Feeds API every 15 minutes

When any channel registers a sale, immediately decrement the master inventory count and recalculate allocations. The 10% safety buffer absorbs the latency gap between when a sale occurs and when other channels receive the updated stock count.

How Do You Configure Shopify Plus Multi-Currency Checkout for APAC?

Shopify Plus multi-currency checkout APAC setup requires configuring Shopify Markets alongside your marketplace pricing strategy. You need consistent pricing across channels (or deliberately differentiated pricing) with currency conversion that doesn't eat your margins.

Shopify Markets Configuration

In your Shopify Plus admin, enable markets for each target country. Then configure pricing rules via the API:

1mutation {
2  catalogPriceListCreate(input: {
3    name: "Singapore Prices"
4    currency: SGD
5    adjustmentType: PERCENTAGE
6    adjustmentValue: 5.0
7  }) {
8    priceList {
9      id
10    }
11    userErrors {
12      field
13      message
14    }
15  }
16}

For APAC markets, you'll typically want fixed-price overrides rather than percentage adjustments. A 5% markup on USD might work for SGD, but for VND or PHP, rounding to psychologically appealing price points matters more. Vietnamese consumers expect prices ending in .000 VND, and a product at 299,456 VND looks odd — round to 299,000 VND.

Currency-Specific Pricing Sync

Your middleware must maintain a pricing matrix that accounts for:

• Base price (your Shopify USD or HKD price)
• Marketplace commission (Shopee charges 2-6% depending on category and market, per Shopee's seller fee schedule)
• Currency conversion with a buffer for forex volatility
• Local price rounding conventions

1MARKETPLACE_COMMISSIONS = {
2    'shopee_sg': 0.04,    # 4% base commission
3    'shopee_tw': 0.055,   # 5.5% base commission
4    'lazada_sg': 0.04,    # 4% category average
5    'lazada_my': 0.038,   # 3.8% category average
6    'amazon_sg': 0.08,    # 8% referral fee (electronics)
7}
8
9def calculate_marketplace_price(base_usd, target_currency, fx_rate, commission_rate, margin_target=0.30):
10    """Calculate marketplace selling price to maintain target margin after commission."""
11    cost_in_target = base_usd * fx_rate
12    # Price = cost / (1 - commission - margin)
13    price = cost_in_target / (1 - commission_rate - margin_target)
14    return round_to_local_convention(price, target_currency)
15
16*Related reading: [Quantization LLM Inference Cost Optimization: Cut Costs 60–80%](/posts/quantization-llm-inference-cost-optimization-apac-guide)*
17
18
19def round_to_local_convention(price, currency):
20    rounding_rules = {
21        'SGD': 0.05,     # Round to nearest 5 cents
22        'TWD': 1,        # Round to nearest dollar
23        'VND': 1000,     # Round to nearest 1000
24        'MYR': 0.10,     # Round to nearest 10 sen
25        'PHP': 1,        # Round to nearest peso
26        'THB': 1,        # Round to nearest baht
27    }
28    unit = rounding_rules.get(currency, 0.01)
29    return round(price / unit) * unit

Shopify Plus multi-currency checkout APAC setup also means configuring payment gateways per market. Shopify Payments supports SGD and AUD natively. For Taiwan, you'll likely need a local gateway like TapPay or ECPay integrated via Shopify's payment app extensions.

How Do You Handle Order Routing Edge Cases in APAC?

Order routing in APAC isn't simple hub-and-spoke. You're dealing with cross-border vs. domestic fulfilment, marketplace-specific shipping providers, and regulatory constraints.

Multi-Warehouse Routing Logic

When an order arrives from any channel, route it based on:

1def route_order(order, warehouses, marketplace):
2    """
3    Route order to optimal warehouse based on:
4    1. Marketplace fulfilment requirements
5    2. Stock availability
6    3. Shipping zone proximity
7    """
8    # Lazada and Shopee orders in some markets MUST use marketplace logistics
9    if marketplace in ['shopee_sg', 'shopee_my'] and order.get('shipping_carrier') == 'Shopee Logistics':
10        # Pickup warehouse must be the registered Shopee warehouse
11        return warehouses.get(f'shopee_registered_{order["country"]}')
12    
13    # Amazon FBA orders - already at Amazon warehouse
14    if marketplace == 'amazon_sg' and order.get('fulfillment_channel') == 'AFN':
15        return 'amazon_fba_sg'
16    
17    # For all other orders, find nearest warehouse with stock
18    eligible = [
19        wh for wh in warehouses.values()
20        if wh.has_stock(order['line_items'])
21        and wh.ships_to(order['country'])
22    ]
23    
24    if not eligible:
25        # Fallback: split order across warehouses
26        return split_order_by_availability(order, warehouses)
27    
28    # Sort by estimated delivery time
29    return min(eligible, key=lambda wh: wh.estimated_delivery(order['country']))

APAC-Specific Edge Cases We've Encountered

Taiwan pre-order handling: Shopee Taiwan allows pre-order listings with extended shipping timelines. Your sync must recognise these and not count pre-order quantities against live inventory.

Lazada's "pending" limbo: Lazada orders can sit in "pending" status for up to 48 hours in some markets while payment verification completes. Don't decrement inventory until the order moves to "confirmed" — but do place a soft hold.

Shopee Bundle Deals: When Shopee runs bundle promotions (buy 2 get 10% off), the order arrives as individual line items but with adjusted pricing. Your Shopify order import must reconstruct the discount correctly or your revenue reconciliation will be off.

How Do You Build a Marketplace Seller Data Stack for Shopee and Lazada?

A reliable marketplace seller data stack for Shopee Lazada starts with getting raw data out of each platform and into a normalised structure your team can actually query.

Extraction Layer

Use scheduled jobs to pull data from each marketplace API:

• Orders: Every 2-5 minutes (per rate limits above)
• Product listings: Daily full sync, hourly delta for price/stock changes
• Returns/refunds: Every 15 minutes
• Advertising spend (Shopee Ads, Lazada Sponsored Solutions): Daily
• Reviews and ratings: Daily

Store raw API responses in cloud storage (we use Google Cloud Storage with lifecycle policies) before transformation. This gives you a replay capability when you inevitably discover a parsing bug three months later.

Normalised Schema

The marketplace seller data stack for Shopee Lazada must normalise different data structures into a unified model:

1-- Unified orders table
2CREATE TABLE unified_orders (
3    internal_order_id UUID PRIMARY KEY,
4    source_platform VARCHAR(20),  -- 'shopify', 'shopee', 'lazada', 'amazon'
5    source_order_id VARCHAR(100),
6    source_country VARCHAR(5),
7    order_status VARCHAR(30),     -- normalised: pending, confirmed, shipped, delivered, returned
8    currency VARCHAR(3),
9    subtotal_local DECIMAL(15,2),
10    subtotal_usd DECIMAL(15,2),   -- converted at time-of-order fx rate
11    commission_amount DECIMAL(15,2),
12    shipping_fee_local DECIMAL(15,2),
13    customer_id UUID,
14    created_at TIMESTAMP WITH TIME ZONE,
15    updated_at TIMESTAMP WITH TIME ZONE
16);
17
18-- Unified line items
19CREATE TABLE unified_line_items (
20    line_item_id UUID PRIMARY KEY,
21    internal_order_id UUID REFERENCES unified_orders,
22    sku VARCHAR(100),
23    quantity INTEGER,
24    unit_price_local DECIMAL(15,2),
25    unit_price_usd DECIMAL(15,2),
26    discount_amount DECIMAL(15,2),
27    platform_item_id VARCHAR(100)
28);

We run dbt (version 1.7) for transformations, with separate staging models per marketplace and a unified mart layer. According to dbt Labs' 2024 State of Analytics Engineering report, 67% of data teams using dbt run transformation jobs at least daily — for marketplace sync, we run hourly.

How Do You Build a Data Lakehouse for Retail in APAC?

When you're processing orders across eight or more marketplace-country combinations, you need something more scalable than a PostgreSQL database. Understanding how to build a data lakehouse for retail APAC means combining cheap object storage with performant query engines.

Architecture Overview

Our recommended stack for APAC retail:

• Storage: Google Cloud Storage or AWS S3 (choose based on where your primary APAC operations sit — GCP has strong Singapore and Taiwan regions)
• Table format: Apache Iceberg (supports time-travel queries, which is essential for inventory auditing)
• Query engine: BigQuery with Iceberg external tables, or Trino for multi-cloud
• Transformation: dbt-core 1.7 with the BigQuery adapter
• Orchestration: Apache Airflow 2.8 on Cloud Composer

Why a Lakehouse Beats a Traditional Warehouse for APAC Retail

To build a data lakehouse for retail APAC, you're solving for three specific problems:

Volume spikes: Shopee's 9.9, 10.10, 11.11, and 12.12 mega-sales generate 5-10x normal order volume. According to Shopee's 2023 earnings report (Sea Limited Q4 2023), the platform processed over 2 billion orders in Q4 2023 alone across APAC. Your data infrastructure must handle burst ingestion without cost explosion.

Multi-currency reconciliation: You need to store both local-currency amounts and USD-equivalent amounts at the time-of-transaction exchange rate. Iceberg's schema evolution means you can add new currency columns without rewriting historical data.

Regulatory compliance: Different APAC jurisdictions have different data residency preferences. A lakehouse lets you partition data by country and apply access controls accordingly.

1# Example: Writing marketplace data to Iceberg using PySpark
2from pyspark.sql import SparkSession
3
4spark = SparkSession.builder \
5    .config("spark.sql.catalog.lakehouse", "org.apache.iceberg.spark.SparkCatalog") \
6    .config("spark.sql.catalog.lakehouse.type", "hadoop") \
7    .config("spark.sql.catalog.lakehouse.warehouse", "gs://your-bucket/warehouse") \
8    .getOrCreate()
9
10# Append new Shopee orders to the unified orders table
11new_orders_df = spark.read.json("gs://your-bucket/raw/shopee/orders/2024-01-15/")
12
13transformed = new_orders_df.select(
14    # ... transformation logic ...
15)
16
17transformed.writeTo("lakehouse.retail.unified_orders") \
18    .option("merge-schema", "true") \
19    .append()

Our Implementation Experience

When Branch8 built this stack for the Hong Kong fashion brand mentioned earlier, we migrated from a PostgreSQL-based sync (which was hitting connection limits during 11.11 at around 800 concurrent writes) to a GCS-backed Iceberg lakehouse with BigQuery as the query layer. The migration took six weeks. We ran both systems in parallel for two weeks to validate data consistency, finding a 0.03% discrepancy in order counts that traced back to a timezone conversion bug in the old system. Post-migration, the 12.12 sale processed 47,000 orders across all channels in 24 hours without any pipeline delays. Monthly infrastructure cost dropped from approximately USD 2,800 to USD 1,100 because we eliminated several always-on database replicas.

What Does the Complete Sync Architecture Look Like?

Putting it all together, Shopify Plus marketplace sync for Shopee Lazada Amazon requires five layers working in concert:

Layer 1: Shopify Plus as the Product Master

All product data (titles, descriptions, images, base prices) lives in Shopify Plus. Use Shopify's GraphQL Admin API for product mutations. Marketplace-specific adaptations (Shopee's required category attributes, Lazada's mandatory brand fields) are stored as metafields.

Layer 2: Middleware (Sync Engine)

A Node.js or Python service that:

• Listens to Shopify webhooks for product/inventory changes
• Polls marketplace APIs for orders on the cadences described above
• Manages the inventory buffer allocation
• Handles API authentication and token refresh
• Implements retry logic with exponential backoff for each marketplace's error patterns

Layer 3: Queue System

Google Cloud Pub/Sub or AWS SQS to decouple event ingestion from processing. When Shopee sends an order notification, it goes into a queue. A worker picks it up, creates the order in Shopify, decrements inventory, and pushes updated stock to all other channels.

Layer 4: Data Lakehouse

All raw and transformed data flows into the lakehouse for analytics, reconciliation, and auditing.

Layer 5: Monitoring and Alerting

Set up alerts for:

• Inventory sync lag exceeding 10 minutes on any channel
• Oversell events (order placed on marketplace for an out-of-stock SKU)
• API error rates exceeding 5% on any marketplace
• Token expiration warnings (24 hours before Shopee token expires, 48 hours before Lazada)

We use Grafana Cloud for dashboards and PagerDuty for on-call escalation. During mega-sale periods, someone on the team monitors sync health in real-time.

What Are the Common Pitfalls to Avoid?

After running these integrations across multiple clients, here are the failures we see most often:

Ignoring marketplace-specific character limits: Shopee limits product titles to 120 characters in most markets. Lazada allows 255. If your Shopify title is 200 characters, your Shopee sync will silently truncate or fail.

Not handling marketplace promotions: When Shopee or Lazada runs a flash sale that your team opted into, the discounted price comes from the marketplace side. Your revenue reconciliation must account for the difference between your listed price and the actual settlement amount.

Treating all APAC markets as identical: According to Google, Temasek, and Bain's e-Conomy SEA 2023 report, Southeast Asia's e-commerce GMV reached $139 billion in 2023, but consumer behaviour varies dramatically. Indonesian shoppers predominantly use bank transfers while Singaporeans prefer credit cards. Your checkout and fulfilment must adapt per market.

Underestimating SKU proliferation: A single product in five Shopee markets with three colour variants and four sizes generates 60 marketplace listings. At 200 products, you're managing 12,000 listings. Automate everything.

The Shopify Plus marketplace sync for Shopee Lazada Amazon is not a one-time project — it's an ongoing operational capability that needs monitoring, tuning, and adaptation as marketplace APIs evolve and your business scales into new APAC markets.

Need help implementing a Shopify Plus marketplace sync across APAC? Branch8 has built and maintained these integrations for brands operating across Hong Kong, Singapore, Taiwan, and Southeast Asia. Talk to our engineering team at branch8.com about your specific marketplace and fulfilment requirements.

Sources

• Shopee Open Platform API Documentation: https://open.shopee.com/documents/v2/v2.order.get_order_list
• Lazada Open Platform Developer Guide: https://open.lazada.com/apps/doc/doc
• Amazon SP-API Usage Plans and Rate Limits: https://developer-docs.amazon.com/sp-api/docs/usage-plans-and-rate-limits
• Sea Limited Q4 2023 Earnings Report: https://www.sea.com/investor/reports
• Google, Temasek, Bain e-Conomy SEA 2023 Report: https://www.bain.com/insights/e-conomy-sea-2023/
• dbt Labs State of Analytics Engineering 2024: https://www.getdbt.com/state-of-analytics-engineering-2024
• Apache Iceberg Documentation: https://iceberg.apache.org/docs/latest/