Marketplace Connectors

Marketplace Connectors

Overview

Selling across Amazon, eBay, and Walmart Marketplace multiplies your sales channel reach but introduces operational complexity: each marketplace has its own product data model, listing requirements, order lifecycle, and inventory management API. This skill covers connecting your store to major marketplaces — using apps for managed platforms and direct API integration for custom storefronts.

When to Use This Skill

• When expanding sales channels beyond your own storefront to major marketplace platforms
• When building a multichannel commerce system that keeps inventory in sync across channels
• When automating order imports from marketplaces into your OMS or ERP
• When existing marketplace feeds are manual (spreadsheet uploads) and need automation

Core Instructions

Step 1: Determine your platform and recommended approach

Step 2: Platform-specific marketplace setup

---

Shopify

Connect Amazon with Codisto:

1. Install Codisto from the Shopify App Store ($39/month for Amazon + eBay) 2. Connect your Amazon Seller Central account (US, UK, EU, AU supported) 3. In Codisto, go to Listings → Amazon and click Link Products — it matches your Shopify products to existing ASINs or creates new listings 4. Enable Inventory Sync to update Amazon quantities automatically when Shopify inventory changes 5. Enable Order Import — Codisto imports Amazon orders as Shopify orders so you manage fulfillment from one place

Important before listing:

• Set a safety stock buffer in Codisto settings: reserve 10–20% of your Shopify inventory from marketplaces to avoid oversells if sync lags
• Configure marketplace-specific pricing in Codisto to account for Amazon fees (15% referral fee + FBA fees) — list at a higher price than your Shopify store

---

WooCommerce

Connect Amazon with WP-Lister Pro:

1. Purchase and install WP-Lister Pro for Amazon ($99 from wp-lister.com) 2. Go to WP-Lister → Settings → Amazon and enter your Amazon Marketplace Web Service (MWS) credentials 3. In WP-Lister → Products, select products to list and configure ASIN matching or create new listings 4. Enable Auto-sync inventory — WP-Lister updates Amazon quantities when WooCommerce stock changes 5. Enable Import Amazon orders — orders appear in WooCommerce automatically

For eBay with WooCommerce:

1. Install WP-Lister Pro for eBay ($99) — same workflow as Amazon version 2. Connect via eBay API credentials in WP-Lister settings 3. Configure category mapping between your WooCommerce categories and eBay categories

---

BigCommerce

Connect Amazon, eBay, and Walmart with Sellbrite:

1. Install Sellbrite from the BigCommerce App Marketplace ($79/month) 2. Connect your marketplace seller accounts (Amazon, eBay, Walmart) and your BigCommerce store 3. Sellbrite pulls your BigCommerce product catalog and syncs listings to all connected marketplaces 4. Set inventory buffer rules per channel (e.g., reserve 5 units for your BigCommerce store) 5. Configure automatic order import — marketplace orders appear in BigCommerce for unified fulfillment

---

Custom / Headless

Amazon SP-API authentication:

// lib/amazon/auth.ts — LWA OAuth token with caching
let tokenCache: { accessToken: string; expiresAt: number } | null = null;

export async function getAccessToken(): Promise<string> {
  if (tokenCache && tokenCache.expiresAt > Date.now() + 60000) return tokenCache.accessToken;

  const res = await fetch('https://api.amazon.com/auth/o2/token', {
    method: 'POST',
    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({
      grant_type: 'refresh_token',
      refresh_token: process.env.AMAZON_REFRESH_TOKEN!,
      client_id: process.env.AMAZON_CLIENT_ID!,
      client_secret: process.env.AMAZON_CLIENT_SECRET!,
    }),
  });

  const data = await res.json();
  tokenCache = { accessToken: data.access_token, expiresAt: Date.now() + data.expires_in * 1000 };
  return tokenCache.accessToken;
}

Update Amazon inventory (SP-API Listings Items):

export async function updateAmazonInventory(sellerId: string, sku: string, quantity: number) {
  const accessToken = await getAccessToken();
  // SP-API also requires AWS Signature V4 — use @smithy/signature-v4
  return fetch(`https://sellingpartnerapi-na.amazon.com/listings/2021-08-01/items/${sellerId}/${encodeURIComponent(sku)}`, {
    method: 'PATCH',
    headers: { 'x-amz-access-token': accessToken, 'Content-Type': 'application/json' },
    body: JSON.stringify({
      productType: 'PRODUCT',
      patches: [{ op: 'replace', path: '/attributes/fulfillment_availability', value: [{
        fulfillment_channel_code: 'DEFAULT',
        quantity,
        marketplace_id: 'ATVPDKIKX0DER', // US marketplace
      }] }],
    }),
  });
}

Import Amazon orders (polling every 5 minutes):

export async function pollAmazonOrders() {
  const lastPolledAt = await db.syncState.getLastPolled('amazon') ?? new Date(Date.now() - 3_600_000);
  const accessToken = await getAccessToken();

  const params = new URLSearchParams({
    MarketplaceIds: 'ATVPDKIKX0DER',
    CreatedAfter: lastPolledAt.toISOString(),
    OrderStatuses: 'Unshipped,PartiallyShipped',
  });

  const res = await fetch(`https://sellingpartnerapi-na.amazon.com/orders/v0/orders?${params}`, {
    headers: { 'x-amz-access-token': accessToken },
  });
  const { payload } = await res.json();

  for (const amazonOrder of payload.Orders ?? []) {
    // Idempotent: skip if already imported
    if (await db.orders.findByExternalId(amazonOrder.AmazonOrderId)) continue;

    await orderQueue.add('import-order', {
      externalId: amazonOrder.AmazonOrderId,
      channel: 'amazon',
      // ...map order fields
    }, { jobId: `amazon-${amazonOrder.AmazonOrderId}` });
  }

  await db.syncState.updateLastPolled('amazon', new Date());
}

Sync inventory across all channels when stock changes:

export async function syncInventoryAcrossChannels(sku: string, quantity: number, source: string) {
  const tasks = [];

  if (source !== 'amazon') {
    tasks.push(updateAmazonInventory(process.env.AMAZON_SELLER_ID!, sku, quantity)
      .catch(err => console.error(`Amazon sync failed for ${sku}:`, err)));
  }

  if (source !== 'ebay') {
    tasks.push(ebayClient.updateInventoryItem(sku, quantity)
      .catch(err => console.error(`eBay sync failed for ${sku}:`, err)));
  }

  // Run all syncs in parallel; individual failures logged but don't block others
  await Promise.allSettled(tasks);
}

Best Practices

• Set a safety stock buffer for each channel — never expose 100% of your inventory to marketplaces; reserve a buffer for your own store and to absorb sync lag
• Implement idempotent order imports — use the marketplace order ID as a unique key; polling can return the same order multiple times; a unique constraint prevents duplicates
• Acknowledge marketplace orders promptly — Walmart requires acknowledgment within 4 hours; Amazon expects shipping confirmation within the promised delivery SLA; late responses result in account defect metrics
• Respect marketplace-specific rate limits — Amazon SP-API uses token bucket limits per operation; use exponential backoff and the Feeds API for bulk inventory updates (thousands of SKUs) instead of individual calls
• Monitor listing health, not just sync status — track listing suppression, buy box win rate, and account health per marketplace; suppressed listings cost revenue

Common Pitfalls

Related Skills

• @webhook-architecture
• @product-information-management
• @erp-integration
• @monitoring-alerting-commerce

Amazon SP-API Integration Module

Problem/Feature Description

A growing outdoor equipment retailer currently manages their Amazon presence manually through Seller Central. The catalog team updates prices and quantities by hand, which takes hours each day and causes frequent stockouts and pricing errors. The engineering team has been asked to automate their Amazon channel by building a TypeScript integration library that handles authentication, product listing management, and inventory updates.

The Amazon Selling Partner API (SP-API) requires a specific authentication flow that differs from typical REST APIs. Your task is to implement the core integration modules so the team can start automating their Amazon catalog operations. The integration needs to handle token lifecycle management efficiently and make properly authenticated API calls for listing creation and inventory adjustments.

Output Specification

Produce a TypeScript project with the following structure:

• src/amazon/auth.ts — Authentication module handling token retrieval and signed API calls
• src/amazon/listings.ts — Module for creating/updating product listings and updating inventory quantities
• package.json — Package manifest with required dependencies listed

Write a brief IMPLEMENTATION_NOTES.md summarizing the key design decisions you made, including which packages you chose for authentication and why.

Do not actually call the Amazon API — use environment variable references for credentials (e.g., process.env.AMAZON_REFRESH_TOKEN) but implement the full logic as if it would be wired up to real credentials.

Multichannel Inventory Synchronization System

Problem/Feature Description

A home goods brand sells on their own website, Amazon, eBay, and Walmart simultaneously. When a product sells on any channel, inventory levels need to update everywhere else immediately to prevent overselling. Currently, when a product sells on eBay, the warehouse team manually updates the other channels — a process that takes 15-30 minutes and regularly results in customers buying out-of-stock items.

The engineering team needs to build a TypeScript library that can propagate inventory changes across all channels automatically. When any channel reports a stock change, the system should update the other channels concurrently without one slow or failing channel blocking the rest. The team also sells direct-to-consumer and is worried about marketplace sales causing issues for their own storefront customers. Additionally, the ops team wants a nightly process that can verify inventory levels are consistent across all channels and flag discrepancies for investigation.

Output Specification

Produce a TypeScript project with:

• src/inventory/multichannel-sync.ts — Core inventory sync module that propagates changes across channels
• src/ebay/client.ts — eBay API client with authentication and inventory item update capability
• src/inventory/reconciliation.ts — A job that compares inventory between the internal system and each marketplace
• package.json — Package manifest with required dependencies

Also write DESIGN.md covering your key architectural decisions for this system.

Use environment variable references for credentials. Do not make real API calls — implement the logic fully but stub out the actual HTTP calls where needed.

Marketplace Order Import Pipeline

Problem/Feature Description

A fashion retailer receives orders from Amazon and Walmart Marketplace in addition to their own website. Currently, their operations staff checks each marketplace portal manually and copies orders into their internal order management system (OMS) — a tedious process that causes fulfillment delays and occasionally results in Walmart seller performance warnings due to late order acknowledgment.

The team needs an automated order import pipeline that runs on a schedule and pulls new orders from both Amazon and Walmart into the internal OMS. The system must handle the fact that repeated polling runs may encounter orders already imported in a previous run. It also needs to handle Walmart's strict SLA requirements — Walmart penalizes sellers who fail to acknowledge orders promptly. The team is particularly concerned about a scenario where an acknowledgment failure goes unnoticed for hours.

Output Specification

Produce a TypeScript project with:

• src/amazon/orders.ts — Module that fetches new Amazon orders and maps them to an internal order format
• src/walmart/orders.ts — Module for acknowledging Walmart orders with correct headers and request format
• src/pipeline/poller.ts — Polling orchestrator that runs on a schedule, deduplicates orders, and enqueues them for processing
• src/walmart/monitor.ts — Monitor module that checks for Walmart orders not yet acknowledged and can trigger alerts
• package.json — Package manifest

Write PIPELINE_NOTES.md explaining how the pipeline handles duplicate order imports and why the Walmart acknowledgment flow is designed the way it is.

Use environment variable references for all credentials. Implement the full logic without making real API calls.