Personalisation Engine Implementation for APAC Marketplaces

Quick Answer: Implement personalisation across APAC marketplaces by building a canonical data layer that normalises product, pricing, and user data from Shopee, Lazada, Tokopedia, and Rakuten, then training recommendation models with marketplace and locale as contextual features.

Implementing a personalisation engine across APAC marketplaces means reconciling fragmented product catalogues, divergent pricing logic, and multi-language requirements across platforms like Lazada, Shopee, Tokopedia, and Rakuten. This isn't a single deployment — it's a platform-by-platform reconfiguration exercise that demands careful architectural planning.

Related reading: How to Implement Segment for Multi-Market E-Commerce in APAC

Related reading: Shopee vs Lazada Seller Operations Comparison 2026: A Deep Analysis

Related reading: Shopify Plus B2C to B2B Expansion Strategy Guide for APAC Brands

Personalisation engine implementation for APAC marketplaces differs fundamentally from Western e-commerce personalisation. In North America or Europe, you're typically personalising a single Shopify or Magento storefront. In APAC, you're orchestrating recommendations, dynamic pricing, and localised content across five or more marketplace APIs, each with its own data schema, regulatory constraints, and consumer behaviour patterns.

Related reading: AI Agent Coding Automation Workflow K8s: A Practical Tutorial

Related reading: Adobe Commerce vs Shopify Plus B2B Asia Pacific: A Hands-On Comparison

This tutorial walks through the concrete steps — from data unification to deployment — with code examples and tool-specific instructions.

Why Do APAC Marketplaces Break Standard Personalisation Engines?

Most personalisation platforms — Nosto, Dynamic Yield, Algolia Recommend — assume a single storefront with unified product data. APAC marketplace selling breaks this assumption in several ways.

Platform Data Schema Fragmentation

Lazada's Open Platform API returns product attributes in a flat key-value structure. Shopee's API v2.0 nests variant data differently. Tokopedia uses its own category taxonomy that doesn't map to either. When your personalisation engine expects a unified product graph, these discrepancies create recommendation failures — suggesting out-of-stock variants, displaying wrong prices, or mixing languages.

According to Forrester's 2023 Asia Pacific Commerce report, 67% of brands selling across multiple APAC marketplaces cite data fragmentation as their top personalisation barrier.

Pricing Logic Divergence

Shopee runs flash sales with platform-controlled discounts that override your listed price. Lazada's LazFlash operates differently. Rakuten Ichiba has its own points-based discount system. A personalisation engine that factors in price sensitivity — and most good ones do — needs to ingest the actual transaction price, not your listed SKU price.

Language and Cultural Segmentation

A single marketplace like Shopee operates across Singapore (English/Mandarin), Taiwan (Traditional Chinese), Vietnam (Vietnamese), Indonesia (Bahasa), Thailand (Thai), and the Philippines (Filipino/English). According to CSA Research, 76% of online consumers prefer buying products with information in their own language. Your personalisation layer must handle not just translation, but culturally distinct purchasing patterns per locale.

How Should You Architect the Data Unification Layer?

Before any personalisation logic runs, you need a canonical data model that normalises product, customer, and interaction data across all target marketplaces.

Step 1: Define Your Canonical Product Schema

Create a unified product schema that can accommodate every marketplace's attributes. Here's a practical starting point using JSON Schema:

1{
2  "canonical_product": {
3    "branch8_sku": "string (internal unique ID)",
4    "marketplace_refs": [
5      {
6        "platform": "shopee|lazada|tokopedia|rakuten",
7        "platform_sku": "string",
8        "locale": "sg|tw|vn|id|th|ph|jp",
9        "listing_url": "string",
10        "current_price": {
11          "amount": "decimal",
12          "currency": "ISO 4217",
13          "effective_discount_pct": "decimal",
14          "price_updated_at": "ISO 8601"
15        },
16        "stock_qty": "integer",
17        "category_path": ["string"]
18      }
19    ],
20    "attributes": {
21      "title": {"en": "", "zh-TW": "", "vi": "", "id": ""},
22      "description": {"en": "", "zh-TW": "", "vi": "", "id": ""},
23      "brand": "string",
24      "tags": ["string"],
25      "image_urls": ["string"]
26    }
27  }
28}

The critical design choice: marketplace_refs is an array, not a single object. One canonical product maps to many marketplace listings, each with its own price, stock, and locale.

Step 2: Build the Ingestion Pipeline

Use marketplace APIs to pull data into your canonical model. Here's a Python example using Shopee's API v2.0 to fetch product details:

1import hashlib
2import hmac
3import time
4import requests
5
6def get_shopee_product(shop_id, item_id, partner_id, partner_key, access_token):
7    timestamp = int(time.time())
8    path = "/api/v2/product/get_item_base_info"
9    base_string = f"{partner_id}{path}{timestamp}{access_token}{shop_id}"
10    sign = hmac.new(
11        partner_key.encode(),
12        base_string.encode(),
13        hashlib.sha256
14    ).hexdigest()
15    
16    params = {
17        "partner_id": partner_id,
18        "timestamp": timestamp,
19        "access_token": access_token,
20        "shop_id": shop_id,
21        "sign": sign,
22        "item_id_list": item_id
23    }
24    
25    resp = requests.get(
26        f"https://partner.shopeemobile.com{path}",
27        params=params
28    )
29    return resp.json()
30
31def map_to_canonical(shopee_item, locale):
32    """Transform Shopee product data to canonical schema."""
33    return {
34        "platform": "shopee",
35        "platform_sku": str(shopee_item["item_id"]),
36        "locale": locale,
37        "current_price": {
38            "amount": shopee_item["price_info"][0]["current_price"],
39            "currency": shopee_item["price_info"][0]["currency"],
40            "effective_discount_pct": calculate_discount(shopee_item),
41            "price_updated_at": datetime.utcnow().isoformat()
42        },
43        "stock_qty": sum(
44            model["stock_info"][0]["current_stock"]
45            for model in shopee_item.get("model_list", [])
46        ),
47        "category_path": shopee_item.get("category_list", [])
48    }

For Lazada, the equivalent uses the Lazop SDK. For Tokopedia, you'll use their Seller API via GraphQL. Build separate adapters per platform, all outputting to the same canonical format.

Step 3: Schedule and Sync

Price and stock data goes stale fast during flash sales. We recommend:

• Full catalogue sync: Every 6 hours via cron or Apache Airflow DAGs
• Price/stock sync: Every 15-30 minutes for active listings
• Event-driven updates: Webhook listeners for order events (Shopee Push mechanism, Lazada callback URLs)

Store the canonical data in a document database like MongoDB Atlas or Amazon DocumentDB, which handles the nested marketplace_refs array naturally.

How Do You Select and Configure the Personalisation Engine?

With unified data in place, you need to choose between a managed personalisation platform and a custom ML approach.

Option A: Managed Platform (Dynamic Yield or Algolia Recommend)

Dynamic Yield (acquired by Mastercard in 2022) supports API-based recommendations that can work outside a single storefront. You'll use their Experience API to feed canonical product data and retrieve recommendations per user segment.

Configuration steps for Dynamic Yield:

1. Create a separate "site" per marketplace-locale combination in the Dynamic Yield dashboard (e.g., shopee-sg, lazada-vn, tokopedia-id)
2. Map your canonical product IDs to DY's product feed using their Feed Management system
3. Push user events via the DY server-side API, tagged with the originating marketplace

1// Push a purchase event from Shopee SG to Dynamic Yield
2const dyEvent = {
3  user: { id: canonicalCustomerId },
4  events: [{
5    name: "Purchase",
6    properties: {
7      value: orderTotal,
8      currency: "SGD",
9      productId: canonicalSkuId,
10      quantity: 1,
11      source_marketplace: "shopee",
12      source_locale: "sg"
13    }
14  }],
15  context: {
16    page: { locale: "en-SG" }
17  }
18};
19
20await fetch('https://dy-api.com/v2/serve/user/choose', {
21  method: 'POST',
22  headers: {
23    'DY-API-Key': process.env.DY_API_KEY,
24    'Content-Type': 'application/json'
25  },
26  body: JSON.stringify(dyEvent)
27});

The trade-off: Dynamic Yield pricing starts around USD $35,000/year, and you're limited by their recommendation algorithms. But time-to-value is faster.

Option B: Custom ML Layer Using Amazon Personalize

For more control, Amazon Personalize lets you train recommendation models on your own interaction data. This is the approach we've used most frequently for clients with 50,000+ SKUs across multiple APAC marketplaces.

1import boto3
2
3personalize = boto3.client('personalize', region_name='ap-southeast-1')
4
5# Create dataset group scoped to APAC marketplace operations
6response = personalize.create_dataset_group(
7    name='apac-marketplace-personalisation',
8    domain='ECOMMERCE'
9)
10
11# Define interactions schema including marketplace context
12interactions_schema = {
13    "type": "record",
14    "name": "Interactions",
15    "namespace": "com.amazonaws.personalize.schema",
16    "fields": [
17        {"name": "USER_ID", "type": "string"},
18        {"name": "ITEM_ID", "type": "string"},
19        {"name": "TIMESTAMP", "type": "long"},
20        {"name": "EVENT_TYPE", "type": "string"},
21        {"name": "MARKETPLACE", "type": "string",
22         "categorical": True},
23        {"name": "LOCALE", "type": "string",
24         "categorical": True}
25    ],
26    "version": "1.0"
27}

The key architectural choice: include MARKETPLACE and LOCALE as categorical metadata fields. This lets the model learn that a user who browses on Shopee Singapore may have different preferences from the same user (matched via email or phone) on Lazada Malaysia.

According to AWS documentation, Amazon Personalize requires a minimum of 1,000 interaction records per event type to produce meaningful recommendations. For most APAC marketplace sellers, you'll hit this threshold within 2-3 weeks of data collection.

How Do You Handle Cross-Marketplace Identity Resolution?

A customer buying on Shopee Singapore and Lazada Malaysia might be the same person. Without identity resolution, your personalisation engine treats them as two separate users, losing half the signal.

Deterministic Matching

Match on shared identifiers:

1def resolve_identity(marketplace_user_records):
2    """Match users across marketplaces using deterministic keys."""
3    identity_graph = {}
4    
5    for record in marketplace_user_records:
6        # Normalise email and phone
7        email = record.get('email', '').strip().lower()
8        phone = normalise_phone(
9            record.get('phone', ''),
10            record['locale']
11        )
12        
13        match_key = None
14        if email:
15            match_key = f"email:{hashlib.sha256(email.encode()).hexdigest()}"
16        elif phone:
17            match_key = f"phone:{hashlib.sha256(phone.encode()).hexdigest()}"
18        
19        if match_key:
20            if match_key not in identity_graph:
21                identity_graph[match_key] = {
22                    'canonical_user_id': generate_uuid(),
23                    'marketplace_profiles': []
24                }
25            identity_graph[match_key]['marketplace_profiles'].append({
26                'platform': record['platform'],
27                'platform_user_id': record['platform_user_id'],
28                'locale': record['locale']
29            })
30    
31    return identity_graph

Important caveat: phone number formats vary wildly across APAC. Singapore uses +65 8-digit numbers, Indonesia uses +62 with 10-13 digit mobile numbers, and Taiwan uses +886. Use Google's libphonenumber library for normalisation — don't attempt regex patterns yourself.

According to Segment's 2023 State of Personalisation report, companies with cross-platform identity resolution see a 20% increase in recommendation click-through rates compared to siloed user profiles.

Privacy Compliance Per Market

APAC has no single data protection regulation. You must comply with:

• Singapore: PDPA (Personal Data Protection Act) — consent required, data portability obligations
• Indonesia: PDP Law (enacted 2022) — explicit consent, data localisation provisions
• Taiwan: PIPA — consent and purpose limitation
• Australia: Privacy Act 1988, with the proposed 2024 reforms adding tighter consent rules
• Vietnam: Decree 13/2023 — data localisation requirements for certain categories

In practice, this means your identity resolution service should store hashed identifiers only, with raw PII encrypted at rest and segregated by jurisdiction. Use AWS KMS with per-region keys if deploying on AWS.

How Did We Implement This for a Multi-Marketplace Fashion Retailer?

In Q3 2023, Branch8 implemented a personalisation engine for a Hong Kong-based fashion brand selling across Shopee (Singapore, Taiwan, Philippines), Lazada (Malaysia, Indonesia), and Tokopedia (Indonesia). The brand had 12,000 SKUs with seasonal rotation of about 3,000 items per quarter.

We chose Amazon Personalize deployed in the ap-southeast-1 (Singapore) region, with data ingestion via Apache Airflow running on Amazon MWAA. The canonical data layer used MongoDB Atlas on the Singapore region cluster.

The implementation took 11 weeks:

• Weeks 1-3: Built marketplace API adapters for Shopee API v2.0, Lazada Open Platform (Lazop SDK 2.0), and Tokopedia Seller API. Defined canonical schema.
• Weeks 4-5: Deployed identity resolution service using deterministic matching on email + phone. Achieved a 34% cross-marketplace match rate across 180,000 customer records.
• Weeks 6-8: Trained Amazon Personalize models using the USER_PERSONALIZATION recipe with marketplace and locale as context fields. Initial model training took 4 hours on the accumulated 2.1 million interaction events.
• Weeks 9-11: Integrated recommendation output into the brand's centralised CRM (Klaviyo), triggering personalised email and LINE message campaigns per marketplace-locale segment.

Results after 90 days: 18% increase in repeat purchase rate on Shopee Singapore, 12% on Lazada Malaysia. The Tokopedia channel saw a smaller 7% lift — we attributed this to lower initial data volume and shorter user history in that marketplace.

The honest trade-off: maintaining five marketplace API adapters requires ongoing engineering effort. Shopee changed their API authentication flow in November 2023, which required a 3-day adapter update. Budget for at least 0.5 FTE on ongoing API maintenance.

What Does the Recommendation Delivery Layer Look Like?

Once the personalisation engine produces recommendations, you need to deliver them where users actually engage — which for marketplace sellers is primarily email, messaging apps (LINE, WhatsApp), and your own DTC site if you have one. You cannot inject personalised content into Shopee or Lazada's native product pages.

Email and Messaging Delivery

1def get_personalised_recommendations(canonical_user_id, marketplace, locale, num_results=6):
2    """Fetch recommendations filtered to in-stock items on target marketplace."""
3    
4    personalize_runtime = boto3.client(
5        'personalize-runtime',
6        region_name='ap-southeast-1'
7    )
8    
9    response = personalize_runtime.get_recommendations(
10        campaignArn='arn:aws:personalize:ap-southeast-1:ACCOUNT:campaign/apac-recs',
11        userId=canonical_user_id,
12        numResults=num_results * 3,  # Over-fetch to allow filtering
13        context={
14            'MARKETPLACE': marketplace,
15            'LOCALE': locale
16        }
17    )
18    
19    recommendations = []
20    for item in response['itemList']:
21        product = get_canonical_product(item['itemId'])
22        marketplace_ref = next(
23            (ref for ref in product['marketplace_refs']
24             if ref['platform'] == marketplace
25             and ref['locale'] == locale
26             and ref['stock_qty'] > 0),
27            None
28        )
29        
30        if marketplace_ref:
31            recommendations.append({
32                'title': product['attributes']['title'].get(locale, product['attributes']['title']['en']),
33                'price': marketplace_ref['current_price'],
34                'url': marketplace_ref['listing_url'],
35                'image': product['attributes']['image_urls'][0]
36            })
37        
38        if len(recommendations) >= num_results:
39            break
40    
41    return recommendations

Note the over-fetch pattern: request 3x the desired recommendations, then filter to items actually in stock on the target marketplace. According to a 2023 Nosto benchmark report, recommendation blocks with out-of-stock items reduce click-through rates by up to 40%.

Marketplace Advertising Integration

While you can't personalise the marketplace product page itself, you can use personalisation signals to inform advertising spend. Shopee's MyAds API and Lazada's Sponsored Solutions API both support keyword and product targeting. Feed your top-recommended products per user segment into your advertising bids:

1def adjust_marketplace_ad_bids(segment_recommendations):
2    """Increase bids on products that the personalisation engine
3    identifies as high-affinity for active user segments."""
4    
5    for segment_id, rec_products in segment_recommendations.items():
6        segment_size = get_segment_size(segment_id)
7        
8        for product in rec_products[:10]:  # Top 10 per segment
9            current_bid = get_current_bid(
10                product['platform_sku'],
11                product['platform']
12            )
13            # Increase bid proportional to segment size and affinity score
14            adjusted_bid = current_bid * (
15                1 + (product['affinity_score'] * 0.3)
16            )
17            update_marketplace_bid(
18                product['platform'],
19                product['platform_sku'],
20                min(adjusted_bid, current_bid * 1.5)  # Cap at 50% increase
21            )

How Should You Measure Personalisation Effectiveness Across Marketplaces?

Standard A/B testing is difficult on marketplace platforms since you don't control the storefront. Instead, measure at the campaign and cohort level.

Key Metrics Per Marketplace-Locale

• Recommendation CTR: Track click-through on personalised emails/messages per marketplace segment. Benchmark: McKinsey's 2023 Next in Personalization report found that companies excelling at personalisation generate 40% more revenue from those activities than average players.
• Cross-marketplace purchase rate: What percentage of users identified in your identity graph purchase on more than one platform? This validates your resolution logic.
• Catalogue coverage: What percentage of your active SKUs appear in recommendations? Low coverage (under 30%) suggests your model is over-indexing on popular items.
• Latency: Recommendation API response time. Target under 200ms p95 for real-time use cases.

Monitoring Setup

Use Amazon CloudWatch dashboards with per-marketplace dimensions:

1cloudwatch = boto3.client('cloudwatch', region_name='ap-southeast-1')
2
3cloudwatch.put_metric_data(
4    Namespace='Personalisation/APAC',
5    MetricData=[{
6        'MetricName': 'RecommendationCTR',
7        'Value': click_through_rate,
8        'Unit': 'Percent',
9        'Dimensions': [
10            {'Name': 'Marketplace', 'Value': 'shopee'},
11            {'Name': 'Locale', 'Value': 'sg'},
12            {'Name': 'CampaignType', 'Value': 'email_weekly'}
13        ]
14    }]
15)

What Are the Most Common Implementation Pitfalls?

Currency and Price Display Errors

APAC spans currencies from IDR (where a product might cost 150,000) to SGD (where the same product is 15). If your personalisation engine sorts by price magnitude without currency normalisation, your rankings break. Always normalise to a base currency (USD is simplest) for model training, then convert back for display.

Assuming Behavioural Homogeneity

Indonesian marketplace shoppers peak during Ramadan promotions and 12.12 sales. Taiwanese shoppers respond to different seasonal patterns. Japanese Rakuten buyers expect detailed product specifications that would overwhelm a Philippine Shopee shopper. Your personalisation engine must train separate contextual models or use marketplace-locale as a strong feature — not an afterthought.

API Rate Limit Exhaustion

Shopee's API v2.0 enforces rate limits per app per shop. Lazada's limits differ. Tokopedia has its own throttling. Build exponential backoff and request queuing into every adapter. We use Celery with Redis as the broker, with per-platform rate limit configurations.

Personalisation engine implementation for APAC marketplaces is fundamentally an integration engineering challenge wrapped in an ML problem. Get the data unification and identity resolution right, and the personalisation algorithms — whether managed or custom — will deliver measurable results.

Branch8 builds and maintains cross-marketplace personalisation infrastructure for brands operating across Asia-Pacific. If you're selling on multiple APAC marketplaces and want to unify your customer data into a working personalisation layer, talk to our engineering team.

Sources

• Forrester, "Asia Pacific Commerce Trends 2023": https://www.forrester.com/report/asia-pacific-online-retail-forecast-2023-to-2028/RES179718
• CSA Research, "Can't Read, Won't Buy" Study: https://csa-research.com/Featured-Content/For-Global-Businesses/CRWB-Series/CRWB-B2C
• Segment, "The State of Personalization 2023": https://segment.com/state-of-personalization-report/
• McKinsey, "The value of getting personalization right—or wrong—is multiplying" (2023): https://www.mckinsey.com/capabilities/growth-marketing-and-sales/our-insights/the-value-of-getting-personalization-right-or-wrong-is-multiplying
• Amazon Personalize Developer Guide: https://docs.aws.amazon.com/personalize/latest/dg/what-is-personalize.html
• Shopee Open Platform API Documentation: https://open.shopee.com/documents/v2/v2.product.get_item_base_info
• Nosto, "E-Commerce Personalization Benchmarks 2023": https://www.nosto.com/resources/commerce-experience-benchmark-report/
• Google libphonenumber: https://github.com/google/libphonenumber