> ## Documentation Index > Fetch the complete documentation index at: https://docs.stateset.com/llms.txt > Use this file to discover all available pages before exploring further. # Multi-Channel Commerce Integration Guide > Complete guide to integrating TikTok Shop, Amazon, Walmart, and other e-commerce channels with StateSet # Multi-Channel Commerce Integration Guide Welcome to the StateSet Multi-Channel Commerce Integration Guide! This comprehensive guide will walk you through integrating major e-commerce channels including TikTok Shop, Amazon, Walmart, and more into your unified commerce platform using StateSet's powerful APIs and tools. ## Table of Contents 1. [Introduction](#introduction) 2. [Prerequisites](#prerequisites) 3. [Channel Overview](#channel-overview) 4. [TikTok Shop Integration](#tiktok-shop-integration) 5. [Amazon Integration](#amazon-integration) 6. [Walmart Integration](#walmart-integration) 7. [Shopify Integration](#shopify-integration) 8. [eBay Integration](#ebay-integration) 9. [Multi-Channel Order Management](#multi-channel-order-management) 10. [Inventory Synchronization](#inventory-synchronization) 11. [Pricing Strategies](#pricing-strategies) 12. [Analytics and Reporting](#analytics-and-reporting) 13. [Best Practices](#best-practices) 14. [Troubleshooting](#troubleshooting) *** ## Introduction In today's omnichannel commerce landscape, selling across multiple platforms is essential for maximizing reach and revenue. However, managing inventory, orders, and customer data across TikTok Shop, Amazon, Walmart, and other channels can quickly become overwhelming without the right tools. StateSet provides a unified platform that seamlessly integrates with major e-commerce channels, enabling you to: * **Centralize order management** across all sales channels * **Synchronize inventory** in real-time to prevent overselling * **Automate product listings** with channel-specific optimizations * **Track performance** with unified analytics * **Streamline fulfillment** with intelligent order routing ### Benefits of Multi-Channel Integration Reach customers where they shop with presence across multiple platforms Manage all channels from a single dashboard with automated workflows Provide consistent service and faster fulfillment across all channels Make informed decisions with unified analytics across all platforms *** ## Prerequisites Before starting your multi-channel integration journey, ensure you have: Sign up for a StateSet account at [StateSet.com/sign-up](https://StateSet.com/sign-up) and obtain your API credentials from the dashboard: [app.StateSet.com/settings/api-keys](https://app.StateSet.com/settings/api-keys) Active seller accounts on the platforms you want to integrate: * TikTok Shop Seller Center account * Amazon Seller Central or Vendor Central account * Walmart Marketplace seller account * Additional platform accounts as needed * Node.js 16+ or Python 3.8+ * Git for version control * Your preferred code editor * Postman or similar API testing tool * Product catalog with SKUs, descriptions, and images * Warehouse/fulfillment setup * Customer service processes * Return/refund policies for each channel *** ## Channel Overview ### Supported Channels StateSet supports integration with major e-commerce platforms, each with unique features and requirements: | Channel | Type | Key Features | Best For | | ---------------------- | ------------------- | ----------------------------------------------------- | --------------------------------------- | | **TikTok Shop** | Social Commerce | Live streaming, short videos, influencer partnerships | Trending products, younger demographics | | **Amazon** | Marketplace | FBA/FBM, Prime eligibility, vast customer base | All product types, fast shipping | | **Walmart** | Marketplace | Competitive pricing, WFS program, trusted brand | Value-focused products, US market | | **Shopify** | Direct-to-Consumer | Full customization, brand control, apps ecosystem | Brand building, customer relationships | | **eBay** | Marketplace/Auction | Auctions, global reach, collectibles | Unique items, international sales | | **Etsy** | Marketplace | Handmade/vintage focus, creative community | Artisan products, crafts | | **Facebook/Instagram** | Social Commerce | Social shopping, targeted ads, shops | Visual products, brand awareness | ### Integration Architecture ```mermaid theme={null} graph TB A[StateSet Platform] --> B[Channel Connector API] B --> C[TikTok Shop API] B --> D[Amazon SP-API] B --> E[Walmart API] B --> F[Shopify API] B --> G[Other Channels] H[Your Store] --> A I[Inventory System] --> A J[Order Management] --> A K[Analytics] --> A style A fill:#f9f,stroke:#333,stroke-width:4px style H fill:#bbf,stroke:#333,stroke-width:2px ``` *** ## TikTok Shop Integration TikTok Shop has rapidly become a major player in social commerce, combining entertainment with shopping through short-form videos and live streams. Integrating TikTok Shop with StateSet allows you to tap into this growing marketplace while maintaining centralized control. ### TikTok Shop Setup 1. Visit [TikTok Shop Seller Center](https://seller.tiktok.com) 2. Complete the business verification process 3. Set up your shop profile and policies 4. Configure shipping and return settings Navigate to the API settings in TikTok Shop Seller Center: ```javascript theme={null} // TikTok Shop API Configuration const tiktokConfig = { appKey: process.env.TIKTOK_APP_KEY, appSecret: process.env.TIKTOK_APP_SECRET, shopId: process.env.TIKTOK_SHOP_ID, accessToken: null // Will be set after OAuth }; ``` Implement TikTok Shop OAuth flow: ```javascript theme={null} import { StateSetClient } from 'StateSet-node'; import axios from 'axios'; import crypto from 'crypto'; class TikTokShopConnector { constructor(config) { this.config = config; this.baseURL = 'https://open-api.tiktokglobalshop.com'; this.StateSet = new StateSetClient(process.env.STATESET_API_KEY); } // Generate signature for TikTok API requests generateSignature(path, params, body = '') { const timestamp = Math.floor(Date.now() / 1000); const signString = [ this.config.appKey, path, timestamp, JSON.stringify(params), body ].join(''); return crypto .createHmac('sha256', this.config.appSecret) .update(signString) .digest('hex'); } // Get OAuth authorization URL getAuthorizationURL() { const state = crypto.randomBytes(16).toString('hex'); const params = new URLSearchParams({ app_key: this.config.appKey, state: state, redirect_uri: process.env.TIKTOK_REDIRECT_URI }); return { url: `https://auth.tiktok-shops.com/oauth/authorize?${params}`, state: state }; } // Exchange authorization code for access token async getAccessToken(code) { const path = '/api/v2/token/get'; const params = { app_key: this.config.appKey, app_secret: this.config.appSecret, auth_code: code, grant_type: 'authorized_code' }; const response = await axios.post( `${this.baseURL}${path}`, params ); if (response.data.code === 0) { this.config.accessToken = response.data.data.access_token; // Store token in StateSet await this.StateSet.channels.updateCredentials({ channel: 'tiktok_shop', credentials: { access_token: response.data.data.access_token, refresh_token: response.data.data.refresh_token, expires_at: new Date(Date.now() + response.data.data.expires_in * 1000) } }); return response.data.data; } throw new Error(`TikTok OAuth failed: ${response.data.message}`); } } ``` ### Product Synchronization Synchronize your product catalog with TikTok Shop while handling platform-specific requirements: ```javascript theme={null} class TikTokProductSync { constructor(connector, StateSet) { this.connector = connector; this.StateSet = StateSet; } // Map StateSet product to TikTok Shop format mapProductToTikTok(product) { return { title: product.name, description: this.formatDescription(product.description), category_id: this.mapCategory(product.category), brand: product.brand || 'Unbranded', images: product.images.map(img => ({ url: img.url })), skus: product.variants.map(variant => ({ seller_sku: variant.sku, price: { amount: variant.price * 100, // TikTok uses cents currency: 'USD' }, inventory: [{ warehouse_id: process.env.TIKTOK_WAREHOUSE_ID, quantity: variant.inventory_quantity }], sales_attributes: this.mapVariantAttributes(variant) })), package_dimensions: { length: product.dimensions?.length || 10, width: product.dimensions?.width || 10, height: product.dimensions?.height || 10, unit: 'CENTIMETER', weight: product.weight || 100, weight_unit: 'GRAM' }, is_cod_allowed: false, delivery_service_ids: [process.env.TIKTOK_DELIVERY_SERVICE_ID] }; } // Sync products from StateSet to TikTok Shop async syncProducts(options = {}) { const { limit = 100, offset = 0 } = options; try { // Fetch products from StateSet const products = await this.StateSet.products.list({ limit, offset, expand: ['variants', 'images'] }); const results = { success: [], failed: [], skipped: [] }; for (const product of products.data) { try { // Check if product should be listed on TikTok if (!product.channels?.includes('tiktok_shop')) { results.skipped.push({ sku: product.sku, reason: 'Not enabled for TikTok Shop' }); continue; } // Map and validate product data const tiktokProduct = this.mapProductToTikTok(product); // Create or update product on TikTok const response = await this.createOrUpdateProduct(tiktokProduct); // Update StateSet with TikTok product ID await this.StateSet.products.update(product.id, { external_ids: { ...product.external_ids, tiktok_shop: response.product_id } }); results.success.push({ sku: product.sku, tiktok_id: response.product_id }); } catch (error) { results.failed.push({ sku: product.sku, error: error.message }); } } // Log sync results await this.StateSet.logs.create({ type: 'channel_sync', channel: 'tiktok_shop', action: 'product_sync', results: results, timestamp: new Date() }); return results; } catch (error) { logger.error('Product sync failed:', error); throw error; } } // Format description for TikTok requirements formatDescription(description) { // TikTok has specific requirements for product descriptions let formatted = description .replace(/<[^>]*>/g, '') // Remove HTML tags .substring(0, 2000); // Max 2000 characters // Add required disclaimers if needed if (!formatted.includes('shipping')) { formatted += '\n\nShipping: Standard shipping available.'; } return formatted; } // Map categories between platforms mapCategory(StateSetCategory) { const categoryMap = { 'electronics': '6001', 'clothing': '6002', 'home-garden': '6003', 'beauty': '6004', 'sports': '6005', // Add more mappings based on TikTok's category tree }; return categoryMap[StateSetCategory] || '9999'; // Default category } } ``` ### Order Management Handle TikTok Shop orders and sync them with your StateSet order management system: ```javascript theme={null} class TikTokOrderManager { constructor(connector, StateSet) { this.connector = connector; this.StateSet = StateSet; } // Fetch new orders from TikTok Shop async fetchNewOrders() { const path = '/api/orders/search'; const params = { create_time_from: Math.floor((Date.now() - 3600000) / 1000), // Last hour create_time_to: Math.floor(Date.now() / 1000), order_status: 'AWAITING_SHIPMENT', page_size: 100 }; const orders = await this.connector.makeRequest('POST', path, params); for (const tiktokOrder of orders.data.orders) { await this.processOrder(tiktokOrder); } } // Process individual TikTok order async processOrder(tiktokOrder) { try { // Check if order already exists const existingOrder = await this.StateSet.orders.list({ external_id: tiktokOrder.order_id, channel: 'tiktok_shop' }); if (existingOrder.data.length > 0) { return; // Order already processed } // Create order in StateSet const StateSetOrder = await this.StateSet.orders.create({ external_id: tiktokOrder.order_id, channel: 'tiktok_shop', customer: { email: tiktokOrder.buyer_email || `tiktok_${tiktokOrder.buyer_user_id}@example.com`, name: tiktokOrder.recipient_address.name, phone: tiktokOrder.recipient_address.phone }, shipping_address: { line1: tiktokOrder.recipient_address.address_line1, line2: tiktokOrder.recipient_address.address_line2, city: tiktokOrder.recipient_address.city, state: tiktokOrder.recipient_address.state, postal_code: tiktokOrder.recipient_address.zipcode, country: tiktokOrder.recipient_address.country_code }, line_items: tiktokOrder.item_list.map(item => ({ external_id: item.sku_id, sku: item.seller_sku, name: item.product_name, quantity: item.quantity, price: item.sku_original_price / 100, // Convert from cents discount: item.sku_platform_discount / 100 })), subtotal: tiktokOrder.payment_info.sub_total / 100, shipping_cost: tiktokOrder.payment_info.shipping_fee / 100, tax: tiktokOrder.payment_info.tax / 100, total: tiktokOrder.payment_info.total_amount / 100, currency: tiktokOrder.payment_info.currency, payment_status: 'paid', fulfillment_status: 'unfulfilled', tags: ['tiktok_shop', tiktokOrder.order_type], metadata: { tiktok_order_status: tiktokOrder.order_status, tiktok_tracking_number: tiktokOrder.tracking_number, tiktok_carrier: tiktokOrder.shipping_provider } }); // Create webhook for order updates await this.StateSet.webhooks.subscribe({ url: process.env.WEBHOOK_URL, events: [`order.${StateSetOrder.id}.updated`], metadata: { channel: 'tiktok_shop', external_order_id: tiktokOrder.order_id } }); logger.info(`Created order ${StateSetOrder.id} from TikTok order ${tiktokOrder.order_id}`); } catch (error) { logger.error(`Failed to process TikTok order ${tiktokOrder.order_id}:`, error); // Log error for manual review await this.StateSet.logs.create({ type: 'order_sync_error', channel: 'tiktok_shop', order_id: tiktokOrder.order_id, error: error.message, raw_data: tiktokOrder }); } } } ``` ### Live Commerce Integration TikTok Shop's unique live streaming features require special handling: ```javascript theme={null} class TikTokLiveCommerce { constructor(connector, StateSet) { this.connector = connector; this.StateSet = StateSet; } // Create live stream session async createLiveSession(sessionData) { const products = await this.StateSet.products.list({ ids: sessionData.product_ids }); // Register products for live stream const liveProducts = await this.connector.makeRequest( 'POST', '/api/products/live_stream/add', { product_ids: products.data.map(p => p.external_ids.tiktok_shop), session_id: sessionData.session_id } ); // Create campaign in StateSet const campaign = await this.StateSet.campaigns.create({ name: sessionData.name, type: 'live_stream', channel: 'tiktok_shop', start_date: sessionData.start_time, end_date: sessionData.end_time, products: sessionData.product_ids, metadata: { tiktok_session_id: sessionData.session_id, host: sessionData.host_username, expected_viewers: sessionData.expected_viewers } }); return campaign; } // Track live stream performance async trackLiveMetrics(sessionId) { const metrics = await this.connector.makeRequest( 'GET', `/api/live_stream/metrics/${sessionId}` ); await this.StateSet.analytics.create({ type: 'live_stream_metrics', channel: 'tiktok_shop', session_id: sessionId, metrics: { viewers: metrics.viewer_count, engagement_rate: metrics.engagement_rate, conversion_rate: metrics.conversion_rate, revenue: metrics.total_revenue / 100, orders: metrics.order_count, top_products: metrics.top_selling_products }, timestamp: new Date() }); } } ``` *** ## Amazon Integration Amazon remains the largest e-commerce marketplace globally. Integrating with Amazon through their SP-API (Selling Partner API) enables automated inventory management, order processing, and listing optimization. ### Amazon SP-API Setup 1. Go to [Amazon Developer Portal](https://developer.amazonservices.com) 2. Register your application 3. Define your app's data access requirements 4. Complete the approval process Set up your Amazon SP-API configuration: ```javascript theme={null} const amazonConfig = { clientId: process.env.AMAZON_CLIENT_ID, clientSecret: process.env.AMAZON_CLIENT_SECRET, refreshToken: process.env.AMAZON_REFRESH_TOKEN, region: 'na', // na, eu, fe marketplace: 'ATVPDKIKX0DER', // US marketplace ID }; ``` Create an Amazon connector with LWA (Login with Amazon) authentication: ```javascript theme={null} import { SellingPartnerAPI } from 'amazon-sp-api'; import { StateSetClient } from 'StateSet-node'; class AmazonConnector { constructor(config) { this.config = config; this.StateSet = new StateSetClient(process.env.STATESET_API_KEY); this.sp = new SellingPartnerAPI({ region: config.region, refresh_token: config.refreshToken, credentials: { SELLING_PARTNER_APP_CLIENT_ID: config.clientId, SELLING_PARTNER_APP_CLIENT_SECRET: config.clientSecret, }, }); } async testConnection() { try { const markets = await this.sp.callAPI({ operation: 'getMarketplaceParticipations', endpoint: 'sellers', }); logger.info('Connected to Amazon marketplaces:', markets); return true; } catch (error) { logger.error('Amazon connection failed:', error); return false; } } } ``` ### Product Listing Management ```javascript theme={null} class AmazonProductManager { constructor(connector) { this.connector = connector; this.sp = connector.sp; this.StateSet = connector.StateSet; } // Create or update Amazon listing async createListing(product) { const feedDocument = await this.createProductFeed(product); // Submit feed to Amazon const feed = await this.sp.callAPI({ operation: 'createFeed', endpoint: 'feeds', body: { feedType: 'POST_PRODUCT_DATA', marketplaceIds: [this.connector.config.marketplace], inputFeedDocumentId: feedDocument.feedDocumentId, }, }); // Monitor feed processing await this.monitorFeed(feed.feedId); // Update StateSet with Amazon ASIN const catalogItem = await this.getProductBySkU(product.sku); await this.StateSet.products.update(product.id, { external_ids: { ...product.external_ids, amazon_asin: catalogItem.asin, }, }); } // Create product feed XML createProductFeed(product) { const xml = `
1.01 ${this.connector.config.merchantId}
Product 1 Update ${product.sku} ${product.id_type || 'UPC'} ${product.id_value} A_GEN_TAX ${this.sanitizeForAmazon(product.name)} ${product.brand} ${this.sanitizeForAmazon(product.description)} ${product.features[0]} ${product.features[1]} ${product.category} HealthMisc `; return this.uploadFeedDocument(xml); } // Inventory synchronization async syncInventory() { const inventory = await this.StateSet.inventory.list({ channel: 'amazon', }); const feedItems = inventory.data.map(item => ({ sku: item.sku, quantity: item.available_quantity, fulfillment_center_id: item.warehouse_id || 'DEFAULT', })); const feed = await this.submitInventoryFeed(feedItems); return this.monitorFeed(feed.feedId); } } ``` ### Order Processing ```javascript theme={null} class AmazonOrderProcessor { constructor(connector) { this.connector = connector; this.sp = connector.sp; this.StateSet = connector.StateSet; } // Fetch and process new orders async processNewOrders() { const orders = await this.sp.callAPI({ operation: 'getOrders', endpoint: 'orders', query: { MarketplaceIds: [this.connector.config.marketplace], CreatedAfter: new Date(Date.now() - 3600000).toISOString(), OrderStatuses: ['Unshipped', 'PartiallyShipped'], }, }); for (const amazonOrder of orders.Orders) { await this.createStateSetOrder(amazonOrder); } } // Create order in StateSet async createStateSetOrder(amazonOrder) { // Get order items const orderItems = await this.sp.callAPI({ operation: 'getOrderItems', endpoint: 'orders', path: { orderId: amazonOrder.AmazonOrderId, }, }); const StateSetOrder = await this.StateSet.orders.create({ external_id: amazonOrder.AmazonOrderId, channel: 'amazon', customer: { email: amazonOrder.BuyerEmail || `amazon_${amazonOrder.BuyerInfo?.BuyerName}@marketplace.com`, name: amazonOrder.BuyerInfo?.BuyerName || 'Amazon Customer', }, shipping_address: { line1: amazonOrder.ShippingAddress?.AddressLine1, line2: amazonOrder.ShippingAddress?.AddressLine2, city: amazonOrder.ShippingAddress?.City, state: amazonOrder.ShippingAddress?.StateOrRegion, postal_code: amazonOrder.ShippingAddress?.PostalCode, country: amazonOrder.ShippingAddress?.CountryCode, }, line_items: orderItems.OrderItems.map(item => ({ external_id: item.OrderItemId, sku: item.SellerSKU, asin: item.ASIN, name: item.Title, quantity: parseInt(item.QuantityOrdered), price: parseFloat(item.ItemPrice?.Amount || 0), tax: parseFloat(item.ItemTax?.Amount || 0), })), subtotal: parseFloat(amazonOrder.OrderTotal?.Amount) - parseFloat(amazonOrder.TaxTotal?.Amount || 0), tax: parseFloat(amazonOrder.TaxTotal?.Amount || 0), total: parseFloat(amazonOrder.OrderTotal?.Amount), currency: amazonOrder.OrderTotal?.CurrencyCode, fulfillment_channel: amazonOrder.FulfillmentChannel, metadata: { amazon_order_status: amazonOrder.OrderStatus, is_prime: amazonOrder.IsPrime, is_premium_order: amazonOrder.IsPremiumOrder, shipment_service_level: amazonOrder.ShipmentServiceLevel, }, }); return StateSetOrder; } // Update shipment tracking async updateShipmentTracking(orderId, trackingInfo) { const feed = await this.sp.callAPI({ operation: 'createFeed', endpoint: 'feeds', body: { feedType: 'POST_ORDER_FULFILLMENT_DATA', marketplaceIds: [this.connector.config.marketplace], content: this.createFulfillmentFeed(orderId, trackingInfo), }, }); return this.monitorFeed(feed.feedId); } } ``` ### FBA Integration ```javascript theme={null} class AmazonFBAManager { constructor(connector) { this.connector = connector; this.sp = connector.sp; this.StateSet = connector.StateSet; } // Create FBA shipment async createInboundShipment(products) { // Prepare shipment items const items = products.map(p => ({ SellerSKU: p.sku, QuantityShipped: p.quantity, PrepDetailsList: p.prep_instructions || [], })); // Create shipment plan const plan = await this.sp.callAPI({ operation: 'createInboundShipmentPlan', endpoint: 'fulfillmentInbound', body: { ShipFromAddress: { Name: process.env.WAREHOUSE_NAME, AddressLine1: process.env.WAREHOUSE_ADDRESS, City: process.env.WAREHOUSE_CITY, StateOrProvinceCode: process.env.WAREHOUSE_STATE, PostalCode: process.env.WAREHOUSE_ZIP, CountryCode: 'US', }, InboundShipmentPlanRequestItems: items, }, }); // Create actual shipment for (const shipment of plan.InboundShipmentPlans) { await this.createShipment(shipment); } } // Monitor FBA inventory async getFBAInventory() { const inventory = await this.sp.callAPI({ operation: 'getInventorySummaries', endpoint: 'fbaInventory', query: { marketplaceIds: [this.connector.config.marketplace], details: true, }, }); // Update StateSet inventory levels for (const item of inventory.inventorySummaries) { await this.StateSet.inventory.update({ sku: item.sellerSku, channel: 'amazon_fba', available: item.totalQuantity - item.reservedQuantity, reserved: item.reservedQuantity, inbound: item.inboundQuantity, }); } } } ``` *** ## Walmart Integration Walmart Marketplace is a rapidly growing platform with strict performance requirements. Integration requires careful attention to their API specifications and fulfillment standards. ### Walmart Setup 1. Apply at [Walmart Marketplace](https://marketplace.walmart.com) 2. Complete the approval process 3. Set up your seller profile 4. Configure tax settings and shipping templates Access Walmart Developer Portal: ```javascript theme={null} const walmartConfig = { clientId: process.env.WALMART_CLIENT_ID, clientSecret: process.env.WALMART_CLIENT_SECRET, consumerId: process.env.WALMART_CONSUMER_ID, privateKey: process.env.WALMART_PRIVATE_KEY, keyVersion: process.env.WALMART_KEY_VERSION, }; ``` Walmart uses a unique signature-based authentication: ```javascript theme={null} import crypto from 'crypto'; import { StateSetClient } from 'StateSet-node'; class WalmartConnector { constructor(config) { this.config = config; this.baseURL = 'https://marketplace.walmartapis.com/v3'; this.StateSet = new StateSetClient(process.env.STATESET_API_KEY); } generateSignature(consumerId, privateKey, keyVersion, timestamp) { const stringToSign = `${consumerId}\n${timestamp}\n${keyVersion}`; const sign = crypto.createSign('RSA-SHA256'); sign.update(stringToSign); return sign.sign(privateKey, 'base64'); } getAuthHeaders() { const timestamp = Date.now(); const signature = this.generateSignature( this.config.consumerId, this.config.privateKey, this.config.keyVersion, timestamp ); return { 'WM_CONSUMER.ID': this.config.consumerId, 'WM_CONSUMER.INTIMESTAMP': timestamp, 'WM_SEC.AUTH_SIGNATURE': signature, 'WM_SEC.KEY_VERSION': this.config.keyVersion, 'WM_QOS.CORRELATION_ID': crypto.randomUUID(), 'Content-Type': 'application/json', }; } async makeRequest(method, endpoint, data = null) { const response = await axios({ method, url: `${this.baseURL}${endpoint}`, headers: this.getAuthHeaders(), data, }); return response.data; } } ``` ### Product Management ```javascript theme={null} class WalmartProductManager { constructor(connector) { this.connector = connector; this.StateSet = connector.StateSet; } // Create Walmart listing async createListing(product) { const walmartItem = { Item: [{ sku: product.sku, productIdentifiers: { productIdType: product.id_type || 'UPC', productId: product.id_value, }, MPProduct: { productName: product.name, shortDescription: product.short_description, longDescription: product.description, mainImageUrl: product.images[0]?.url, additionalImageUrl: product.images.slice(1).map(img => img.url), price: { currency: 'USD', amount: product.price, }, shippingWeight: { value: product.weight || 1, unit: 'lb', }, category: this.mapToWalmartCategory(product.category), brand: product.brand, }, }], }; const response = await this.connector.makeRequest( 'POST', '/items', walmartItem ); // Update StateSet with Walmart item ID await this.StateSet.products.update(product.id, { external_ids: { ...product.external_ids, walmart_item_id: response.ItemResponse[0].itemId, }, }); return response; } // Bulk inventory update async updateInventory(inventoryUpdates) { const inventory = { InventoryHeader: { version: '1.4', }, Inventory: inventoryUpdates.map(item => ({ sku: item.sku, quantity: { unit: 'EACH', amount: item.quantity, }, })), }; return this.connector.makeRequest( 'PUT', '/inventory', inventory ); } // Price updates with competitive intelligence async updatePricing(priceUpdates) { const priceFeed = { PriceHeader: { version: '1.7', }, Price: priceUpdates.map(item => ({ sku: item.sku, pricing: [{ currentPrice: { value: { currency: 'USD', amount: item.price, }, }, comparisonPrice: item.compare_at_price ? { value: { currency: 'USD', amount: item.compare_at_price, }, } : undefined, }], })), }; return this.connector.makeRequest( 'PUT', '/price', priceFeed ); } } ``` ### Order Management ```javascript theme={null} class WalmartOrderManager { constructor(connector) { this.connector = connector; this.StateSet = connector.StateSet; } // Fetch new orders async fetchOrders() { const orders = await this.connector.makeRequest( 'GET', '/orders?createdStartDate=' + new Date(Date.now() - 3600000).toISOString() ); for (const order of orders.list.elements.order) { await this.processOrder(order); } } // Process Walmart order async processOrder(walmartOrder) { const StateSetOrder = await this.StateSet.orders.create({ external_id: walmartOrder.purchaseOrderId, channel: 'walmart', customer: { email: walmartOrder.customerEmailId, name: `${walmartOrder.shippingInfo.postalAddress.name}`, phone: walmartOrder.shippingInfo.phone, }, shipping_address: { line1: walmartOrder.shippingInfo.postalAddress.address1, line2: walmartOrder.shippingInfo.postalAddress.address2, city: walmartOrder.shippingInfo.postalAddress.city, state: walmartOrder.shippingInfo.postalAddress.state, postal_code: walmartOrder.shippingInfo.postalAddress.postalCode, country: walmartOrder.shippingInfo.postalAddress.country, }, line_items: walmartOrder.orderLines.orderLine.map(line => ({ external_id: line.lineNumber, sku: line.item.sku, name: line.item.productName, quantity: line.orderLineQuantity.amount, price: line.charges.charge.find(c => c.chargeType === 'PRODUCT').chargeAmount.amount, tax: line.charges.charge.find(c => c.chargeType === 'TAX')?.chargeAmount.amount || 0, })), shipping_method: walmartOrder.shippingInfo.methodCode, metadata: { walmart_order_date: walmartOrder.orderDate, walmart_estimated_delivery: walmartOrder.shippingInfo.estimatedDeliveryDate, walmart_shipping_program: walmartOrder.fulfillment?.shipMethod, }, }); // Acknowledge order await this.acknowledgeOrder(walmartOrder.purchaseOrderId); return StateSetOrder; } // Ship order with tracking async shipOrder(orderId, shipmentData) { const shipment = { orderShipment: { orderLines: { orderLine: shipmentData.lines.map(line => ({ lineNumber: line.lineNumber, orderLineStatuses: { orderLineStatus: [{ status: 'Shipped', statusQuantity: { unitOfMeasurement: 'EACH', amount: line.quantity, }, trackingInfo: { shipDateTime: new Date().toISOString(), carrierName: { carrier: shipmentData.carrier, }, methodCode: shipmentData.method, trackingNumber: shipmentData.tracking_number, }, }], }, })), }, }, }; return this.connector.makeRequest( 'POST', `/orders/${orderId}/shipping`, shipment ); } } ``` ### Walmart Fulfillment Services (WFS) ```javascript theme={null} class WalmartWFSManager { constructor(connector) { this.connector = connector; this.StateSet = connector.StateSet; } // Create WFS inbound shipment async createInboundShipment(items) { const shipment = { inboundOrderId: crypto.randomUUID(), orderType: 'NEW_PRODUCT', preferredCarrier: 'FedEx', estimatedDeliveryDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString(), inboundOrderItems: items.map(item => ({ sku: item.sku, quantity: item.quantity, itemDetails: { countryOfOrigin: 'US', isHazmat: false, }, })), }; const response = await this.connector.makeRequest( 'POST', '/fulfillment/inbound-shipments', shipment ); // Store shipment details await this.StateSet.shipments.create({ type: 'inbound', channel: 'walmart_wfs', external_id: response.inboundOrderId, items: items, status: 'pending', }); return response; } // Monitor WFS inventory async getWFSInventory() { const inventory = await this.connector.makeRequest( 'GET', '/fulfillment/inventory' ); // Sync with StateSet for (const item of inventory.elements) { await this.StateSet.inventory.update({ sku: item.sku, channel: 'walmart_wfs', available: item.availableQuantity, reserved: item.reservedQuantity, inbound: item.inboundQuantity, }); } } } ``` *** ## Multi-Channel Order Management Centralizing order management across all channels is crucial for operational efficiency and customer satisfaction. StateSet provides a unified order management system that aggregates orders from all channels. ### Unified Order Dashboard ```javascript theme={null} class MultiChannelOrderManager { constructor(StateSet) { this.StateSet = StateSet; this.channels = { tiktok: new TikTokOrderManager(), amazon: new AmazonOrderProcessor(), walmart: new WalmartOrderManager(), shopify: new ShopifyOrderManager(), }; } // Aggregate orders from all channels async syncAllChannels() { const syncResults = await Promise.all([ this.channels.tiktok.fetchNewOrders(), this.channels.amazon.processNewOrders(), this.channels.walmart.fetchOrders(), this.channels.shopify.syncOrders(), ]); return { total_orders: syncResults.reduce((sum, result) => sum + result.count, 0), by_channel: syncResults.map((result, index) => ({ channel: Object.keys(this.channels)[index], count: result.count, errors: result.errors, })), }; } // Intelligent order routing async routeOrder(orderId) { const order = await this.StateSet.orders.get(orderId); // Determine optimal fulfillment location const fulfillmentLocation = await this.determineOptimalFulfillment(order); // Route based on criteria if (order.tags.includes('priority')) { return this.routeToPriorityFulfillment(order, fulfillmentLocation); } else if (order.channel === 'amazon' && order.metadata.is_prime) { return this.routeToFBA(order); } else { return this.routeToStandardFulfillment(order, fulfillmentLocation); } } // Batch order processing async processBatchOrders(orderIds) { const orders = await this.StateSet.orders.list({ ids: orderIds }); // Group by fulfillment method const grouped = orders.data.reduce((acc, order) => { const method = order.fulfillment_method || 'standard'; if (!acc[method]) acc[method] = []; acc[method].push(order); return acc; }, {}); // Process each group const results = await Promise.all( Object.entries(grouped).map(([method, orders]) => this.processFulfillmentGroup(method, orders) ) ); return results; } } ``` ### Order Status Synchronization ```javascript theme={null} class OrderStatusSync { constructor(StateSet) { this.StateSet = StateSet; } // Sync order status back to channels async syncOrderStatus(orderId, newStatus) { const order = await this.StateSet.orders.get(orderId); switch (order.channel) { case 'tiktok_shop': await this.updateTikTokStatus(order, newStatus); break; case 'amazon': await this.updateAmazonStatus(order, newStatus); break; case 'walmart': await this.updateWalmartStatus(order, newStatus); break; case 'shopify': await this.updateShopifyStatus(order, newStatus); break; } // Update StateSet order await this.StateSet.orders.update(orderId, { status: newStatus, status_updated_at: new Date(), }); } // Bulk status updates async bulkStatusUpdate(updates) { const results = await Promise.allSettled( updates.map(update => this.syncOrderStatus(update.orderId, update.status) ) ); return { success: results.filter(r => r.status === 'fulfilled').length, failed: results.filter(r => r.status === 'rejected').map(r => r.reason), }; } } ``` *** ## Inventory Synchronization Real-time inventory synchronization prevents overselling and ensures accurate availability across all channels. ### Centralized Inventory Management ```javascript theme={null} class MultiChannelInventorySync { constructor(StateSet) { this.StateSet = StateSet; this.syncInterval = 300000; // 5 minutes this.channels = ['tiktok_shop', 'amazon', 'walmart', 'shopify']; } // Real-time inventory sync async syncInventory(sku, adjustment) { const inventory = await this.StateSet.inventory.get(sku); // Calculate new available quantity const newQuantity = inventory.available_quantity + adjustment; // Update all channels in parallel const updates = await Promise.allSettled([ this.updateTikTokInventory(sku, newQuantity), this.updateAmazonInventory(sku, newQuantity), this.updateWalmartInventory(sku, newQuantity), this.updateShopifyInventory(sku, newQuantity), ]); // Update StateSet inventory await this.StateSet.inventory.update(sku, { available_quantity: newQuantity, last_sync: new Date(), sync_status: this.determineSyncStatus(updates), }); return updates; } // Buffer stock management async allocateBufferStock(sku) { const inventory = await this.StateSet.inventory.get(sku); const salesVelocity = await this.calculateSalesVelocity(sku); // Allocate buffer based on channel performance const bufferAllocation = { tiktok_shop: Math.ceil(salesVelocity.tiktok * 1.2), amazon: Math.ceil(salesVelocity.amazon * 1.5), // Higher buffer for Amazon walmart: Math.ceil(salesVelocity.walmart * 1.3), shopify: Math.ceil(salesVelocity.shopify * 1.1), }; // Ensure total doesn't exceed available const totalBuffer = Object.values(bufferAllocation).reduce((a, b) => a + b, 0); if (totalBuffer > inventory.available_quantity) { // Proportionally reduce buffers const ratio = inventory.available_quantity / totalBuffer; Object.keys(bufferAllocation).forEach(channel => { bufferAllocation[channel] = Math.floor(bufferAllocation[channel] * ratio); }); } return bufferAllocation; } // Inventory forecasting async forecastInventoryNeeds() { const products = await this.StateSet.products.list({ active: true }); const forecasts = []; for (const product of products.data) { const salesHistory = await this.getSalesHistory(product.sku, 30); // Last 30 days const forecast = { sku: product.sku, current_stock: product.inventory_quantity, avg_daily_sales: salesHistory.average, days_of_stock: Math.floor(product.inventory_quantity / salesHistory.average), reorder_point: salesHistory.average * 7, // 7-day buffer suggested_reorder_quantity: salesHistory.average * 30, // 30-day supply }; if (forecast.current_stock <= forecast.reorder_point) { forecast.action = 'REORDER_NOW'; forecast.urgency = 'HIGH'; } else if (forecast.days_of_stock < 14) { forecast.action = 'REORDER_SOON'; forecast.urgency = 'MEDIUM'; } else { forecast.action = 'MONITOR'; forecast.urgency = 'LOW'; } forecasts.push(forecast); } return forecasts; } } ``` ### Inventory Reconciliation ```javascript theme={null} class InventoryReconciliation { constructor(StateSet) { this.StateSet = StateSet; } // Daily reconciliation process async performReconciliation() { const discrepancies = []; const products = await this.StateSet.products.list(); for (const product of products.data) { // Get inventory from each channel const channelInventory = await Promise.all([ this.getTikTokInventory(product.sku), this.getAmazonInventory(product.sku), this.getWalmartInventory(product.sku), this.getShopifyInventory(product.sku), ]); // Compare with StateSet master inventory const StateSetInventory = await this.StateSet.inventory.get(product.sku); channelInventory.forEach((inv, index) => { if (inv && Math.abs(inv.quantity - StateSetInventory.available_quantity) > 0) { discrepancies.push({ sku: product.sku, channel: ['tiktok', 'amazon', 'walmart', 'shopify'][index], channel_quantity: inv.quantity, StateSet_quantity: StateSetInventory.available_quantity, difference: inv.quantity - StateSetInventory.available_quantity, }); } }); } // Auto-resolve minor discrepancies for (const discrepancy of discrepancies) { if (Math.abs(discrepancy.difference) <= 5) { await this.autoResolveDiscrepancy(discrepancy); } else { await this.flagForManualReview(discrepancy); } } return { total_checked: products.data.length, discrepancies_found: discrepancies.length, auto_resolved: discrepancies.filter(d => Math.abs(d.difference) <= 5).length, manual_review_required: discrepancies.filter(d => Math.abs(d.difference) > 5).length, }; } } ``` *** ## Pricing Strategies Dynamic pricing across channels requires careful consideration of platform fees, competition, and margin requirements. ### Dynamic Pricing Engine ```javascript theme={null} class MultiChannelPricingEngine { constructor(StateSet) { this.StateSet = StateSet; this.channelFees = { tiktok_shop: 0.05, // 5% commission amazon: 0.15, // 15% average referral fee walmart: 0.15, // 15% referral fee shopify: 0.029, // 2.9% + $0.30 transaction fee }; } // Calculate channel-specific pricing async calculateChannelPrices(product, targetMargin = 0.30) { const baseCost = product.cost || 0; const prices = {}; for (const [channel, feeRate] of Object.entries(this.channelFees)) { // Calculate minimum price to achieve target margin const minPrice = baseCost / (1 - targetMargin - feeRate); // Get competitive pricing data const competitorPrices = await this.getCompetitorPrices(product.sku, channel); // Determine optimal price prices[channel] = { minimum: Math.ceil(minPrice * 100) / 100, competitive: competitorPrices.median, recommended: this.calculateOptimalPrice(minPrice, competitorPrices), margin: this.calculateMargin(prices[channel].recommended, baseCost, feeRate), }; } return prices; } // Implement repricing strategies async implementRepricingStrategy(strategy = 'competitive') { const products = await this.StateSet.products.list({ active: true }); for (const product of products.data) { const channelPrices = await this.calculateChannelPrices(product); // Update prices on each channel await Promise.all([ this.updateTikTokPrice(product.sku, channelPrices.tiktok_shop.recommended), this.updateAmazonPrice(product.sku, channelPrices.amazon.recommended), this.updateWalmartPrice(product.sku, channelPrices.walmart.recommended), this.updateShopifyPrice(product.sku, channelPrices.shopify.recommended), ]); // Log pricing changes await this.StateSet.pricing_history.create({ sku: product.sku, timestamp: new Date(), strategy: strategy, prices: channelPrices, }); } } } ``` *** ## Analytics and Reporting Comprehensive analytics across all channels provide insights for optimization and growth. ### Multi-Channel Analytics Dashboard ```javascript theme={null} class MultiChannelAnalytics { constructor(StateSet) { this.StateSet = StateSet; } // Generate comprehensive channel performance report async generateChannelReport(dateRange) { const channels = ['tiktok_shop', 'amazon', 'walmart', 'shopify']; const report = { summary: {}, by_channel: {}, top_products: [], recommendations: [], }; // Aggregate data for each channel for (const channel of channels) { const channelData = await this.getChannelMetrics(channel, dateRange); report.by_channel[channel] = { revenue: channelData.revenue, orders: channelData.order_count, aov: channelData.revenue / channelData.order_count, conversion_rate: channelData.conversion_rate, return_rate: channelData.return_rate, profit_margin: channelData.profit_margin, top_products: channelData.top_products.slice(0, 5), }; } // Calculate summary metrics report.summary = { total_revenue: Object.values(report.by_channel).reduce((sum, ch) => sum + ch.revenue, 0), total_orders: Object.values(report.by_channel).reduce((sum, ch) => sum + ch.orders, 0), average_margin: this.calculateWeightedAverage(report.by_channel, 'profit_margin', 'revenue'), best_channel: this.identifyBestChannel(report.by_channel), }; // Generate recommendations report.recommendations = this.generateRecommendations(report); return report; } // Real-time performance monitoring async monitorPerformance() { const alerts = []; // Check inventory levels const lowStock = await this.checkLowStockItems(); if (lowStock.length > 0) { alerts.push({ type: 'LOW_STOCK', severity: 'HIGH', items: lowStock, action: 'Reorder immediately to prevent stockouts', }); } // Check pricing competitiveness const pricingIssues = await this.checkPricingCompetitiveness(); if (pricingIssues.length > 0) { alerts.push({ type: 'PRICING_ALERT', severity: 'MEDIUM', items: pricingIssues, action: 'Review and adjust pricing to remain competitive', }); } // Check channel performance const performanceIssues = await this.checkChannelPerformance(); performanceIssues.forEach(issue => alerts.push(issue)); return alerts; } } ``` *** ## Best Practices ### 1. **Channel-Specific Optimization** Each platform has unique requirements and best practices: * Use trending sounds and hashtags in product videos * Partner with influencers for live selling events * Optimize for mobile-first shopping experience * Leverage TikTok's algorithm with engaging content * Optimize listings with A+ content * Maintain high seller metrics (>95% positive feedback) * Use FBA for Prime eligibility * Implement aggressive pricing strategies * Focus on competitive pricing * Maintain fast shipping times (less than 2 days) * Use Walmart Fulfillment Services (WFS) * Optimize for Walmart's search algorithm ### 2. **Inventory Management** ```javascript theme={null} // Best practice: Implement safety stock calculations function calculateSafetyStock(sku, leadTime, servicelevel = 0.95) { const dailyDemand = getAverageDailyDemand(sku); const demandStdDev = getDemandStandardDeviation(sku); const zScore = getZScore(servicelevel); // 1.65 for 95% service level return Math.ceil(zScore * Math.sqrt(leadTime) * demandStdDev); } ``` ### 3. **Order Processing Automation** ```javascript theme={null} // Best practice: Implement automated order routing class AutomatedOrderRouter { async routeOrder(order) { const rules = [ { condition: o => o.shipping_speed === 'express', action: 'route_to_nearest_warehouse' }, { condition: o => o.total > 500, action: 'flag_for_fraud_review' }, { condition: o => o.channel === 'amazon' && o.is_prime, action: 'route_to_fba' }, { condition: o => o.items.some(i => i.is_hazmat), action: 'route_to_specialized_fulfillment' }, ]; for (const rule of rules) { if (rule.condition(order)) { return this.executeAction(rule.action, order); } } return this.defaultRouting(order); } } ``` *** ## Troubleshooting ### Common Integration Issues **Problem**: API authentication fails across channels **Solutions**: * Verify API credentials are correctly set in environment variables * Check if tokens have expired and need refresh * Ensure IP whitelisting is configured if required * Validate signature generation for platforms like Walmart ```javascript theme={null} // Debug authentication async function debugAuth(channel) { logger.info(`Testing ${channel} authentication...`); try { const result = await testChannelConnection(channel); logger.info('Success:', result); } catch (error) { logger.error('Auth failed:', error.message); logger.info('Check:', getAuthChecklistForChannel(channel);); } } ``` **Problem**: Inventory levels don't match across channels **Solutions**: * Implement regular reconciliation jobs * Use webhooks for real-time updates * Add buffer stock to prevent overselling * Log all inventory movements for audit trail **Problem**: Orders take too long to process **Solutions**: * Implement parallel processing for bulk operations * Use queue systems for order processing * Optimize API calls with batch operations * Cache frequently accessed data *** ## Complete Implementation Example Here's a complete example bringing together all the concepts: ```javascript theme={null} // main.js - Complete multi-channel integration setup import { StateSetClient } from 'StateSet-node'; import { TikTokShopConnector } from './channels/tiktok'; import { AmazonConnector } from './channels/amazon'; import { WalmartConnector } from './channels/walmart'; import { MultiChannelOrderManager } from './orders/manager'; import { MultiChannelInventorySync } from './inventory/sync'; import { MultiChannelAnalytics } from './analytics/dashboard'; class MultiChannelCommerceSystem { constructor() { this.StateSet = new StateSetClient(process.env.STATESET_API_KEY); this.initializeChannels(); this.setupAutomation(); } async initializeChannels() { // Initialize channel connectors this.channels = { tiktok: new TikTokShopConnector({ appKey: process.env.TIKTOK_APP_KEY, appSecret: process.env.TIKTOK_APP_SECRET, }), amazon: new AmazonConnector({ clientId: process.env.AMAZON_CLIENT_ID, clientSecret: process.env.AMAZON_CLIENT_SECRET, }), walmart: new WalmartConnector({ consumerId: process.env.WALMART_CONSUMER_ID, privateKey: process.env.WALMART_PRIVATE_KEY, }), }; // Test all connections await this.testAllConnections(); } setupAutomation() { // Order sync every 5 minutes setInterval(() => this.syncOrders(), 300000); // Inventory sync every 15 minutes setInterval(() => this.syncInventory(), 900000); // Price optimization daily scheduleDaily(() => this.optimizePricing(), '02:00'); // Analytics report weekly scheduleWeekly(() => this.generateWeeklyReport(), 'Monday', '09:00'); } async syncOrders() { const orderManager = new MultiChannelOrderManager(this.StateSet); const results = await orderManager.syncAllChannels(); logger.info(`Synced ${results.total_orders} orders across all channels`); // Process any alerts if (results.alerts?.length > 0) { await this.handleAlerts(results.alerts); } } async syncInventory() { const inventorySync = new MultiChannelInventorySync(this.StateSet); const results = await inventorySync.performFullSync(); // Check for low stock const lowStock = await inventorySync.checkLowStock(); if (lowStock.length > 0) { await this.createReorderSuggestions(lowStock); } } async optimizePricing() { const pricingEngine = new MultiChannelPricingEngine(this.StateSet); await pricingEngine.implementRepricingStrategy('competitive'); } async generateWeeklyReport() { const analytics = new MultiChannelAnalytics(this.StateSet); const report = await analytics.generateChannelReport({ start: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000), end: new Date(), }); // Send report to stakeholders await this.emailReport(report); } } // Initialize the system const commerceSystem = new MultiChannelCommerceSystem(); // Express server for webhooks import express from 'express'; const app = express(); app.post('/webhooks/orders', async (req, res) => { const { channel, event, data } = req.body; await commerceSystem.handleOrderWebhook(channel, event, data); res.status(200).send('OK'); }); app.post('/webhooks/inventory', async (req, res) => { const { sku, adjustment } = req.body; await commerceSystem.handleInventoryWebhook(sku, adjustment); res.status(200).send('OK'); }); app.listen(process.env.PORT || 3000, () => { logger.info('Multi-channel commerce system running'); }); ``` *** ## Conclusion Successfully integrating multiple e-commerce channels requires careful planning, robust error handling, and continuous optimization. By following this guide and implementing the provided examples, you'll be able to: * **Centralize operations** across TikTok Shop, Amazon, Walmart, and other platforms * **Automate routine tasks** like inventory sync and order processing * **Optimize performance** with data-driven insights * **Scale efficiently** as your business grows Remember to: * Start with one channel and gradually add others * Monitor performance metrics closely * Keep your integration code modular and maintainable * Stay updated with platform API changes * Implement proper error handling and logging For additional support and resources, visit the [StateSet Documentation](https://docs.StateSet.com) or contact our support team. ***