Multi-Channel Printing: One Workflow for Shipping Labels Across Every Sales Channel

Multi-Channel Printing solves a problem that every growing ecommerce seller hits at roughly the same point: you are selling on three or more channels and your morning fulfilment routine involves opening each platform separately, generating labels from each one, and somehow keeping track of which parcels belong to which orders. It is slow, error-prone, and gets worse with every channel you add.

The solution is not a faster version of the same process. It is a fundamentally different approach: a single queue that pulls orders from every channel, generates all labels in one action, and pushes tracking data back to each platform automatically.

This guide explains how multi-channel printing works, what it requires technically, and how to build it — whether you are doing it yourself via APIs or using a platform that handles it for you.

Multi-channel printing replaces three separate label sessions with one unified queue — all channels, one print action.

Why Printing From Each Channel Separately Breaks Down

When you sell on eBay, Amazon, and Shopify simultaneously, each platform has its own label workflow:

• eBay has Seller Hub label printing — limited bulk support, native carriers only
• Amazon has Buy Shipping — good for single orders, but you cannot batch labels across order types
• Shopify has its own shipping integration — works well for Shopify orders, nothing else

So a seller with 40 orders split across three channels typically needs to:

1. Log into eBay, bulk-print 15 labels (if it works without errors)
2. Log into Amazon Seller Central, process 18 Buy Shipping labels individually
3. Log into Shopify, print 7 labels via its shipping section

That is three separate sessions, three separate carrier selections, three separate opportunities for error — and three separate sets of tracking numbers to verify. The process takes significantly longer than processing 40 orders from a single queue, and it introduces inconsistency: eBay orders might go Tracked 48, Amazon orders might go a different service, Shopify orders might have wrong weights if your Shopify product data is out of date.

What Multi-Channel Printing Actually Requires

A functional multi-channel printing system has five components:

1. A unified order feed. All channels need to route orders to a central point. This requires API connections to each platform — eBay's Fulfillment API, Amazon's SP-API Orders endpoint, Shopify's Orders API. These pull awaiting-shipment orders in near real-time (or on a polling schedule).

2. Service selection logic. Once orders are centralised, the system needs to assign a shipping service to each one. This is rule-based: weight ranges map to services, destinations map to domestic vs. international, order values map to whether insurance is required. These rules apply consistently regardless of which channel the order came from.

3. Carrier API integration. The system submits each order to a carrier — Royal Mail Click & Drop, Evri, DPD, UPS — and receives a label in return. For high volume, this needs to be asynchronous and batched to avoid rate limits.

4. A print queue. Labels from all channels accumulate in a single queue. One print action outputs the full batch to your printer. Labels are typically output as a multi-page PDF (for desktop printers) or streamed as ZPL files (for thermal printers).

5. Tracking return. After printing, tracking numbers are pushed back to each originating channel via its API. Amazon marks the order as shipped, eBay updates the tracking, Shopify sends the customer notification. Each channel does this independently, so the return flow requires the system to remember which order came from which channel.

All channels feed one queue. Service rules apply once. Labels for every carrier print in a single action.

Building It Yourself: The API Stack

If you are building this as a custom workflow, here is the technical architecture.

Order collection (run every 10–15 minutes):

// Collect orders from all channels into a normalised format
async function collectAllOrders() {
  const [ebayOrders, amazonOrders, shopifyOrders] = await Promise.all([
    fetchEbayOrders(),     // eBay Fulfillment API
    fetchAmazonOrders(),   // SP-API /orders
    fetchShopifyOrders(),  // Shopify Orders API
  ]);

  return [...ebayOrders, ...amazonOrders, ...shopifyOrders].map(normaliseOrder);
}

function normaliseOrder(raw, source) {
  return {
    id: raw.orderId ?? raw.AmazonOrderId ?? raw.id,
    source,                         // 'ebay' | 'amazon' | 'shopify'
    recipient: extractAddress(raw),
    weightGrams: resolveWeight(raw),
    items: raw.lineItems ?? raw.OrderItems ?? raw.line_items,
  };
}

Service assignment:

function assignService(order) {
  const { weightGrams, recipient, items } = order;
  const orderValue = items.reduce((sum, i) => sum + i.price, 0);
  
  if (recipient.country !== 'GB') return 'INTERNATIONAL_TRACKED';
  if (orderValue > 100)           return 'SPECIAL_DELIVERY';
  if (weightGrams > 2000)         return 'TRACKED_24';
  if (weightGrams > 100)          return 'TRACKED_48';
  return 'LARGE_LETTER_TRACKED';
}

Label generation (submitting to Royal Mail Click & Drop):

async function generateLabel(order) {
  const res = await fetch('https://api.clickanddrop.royalmail.com/v1/orders', {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${RM_API_KEY}` },
    body: JSON.stringify({
      orderReference: order.id,
      recipient: order.recipient,
      packages: [{ weightInGrams: order.weightGrams }],
      serviceCode: serviceCodeMap[assignService(order)],
    }),
  });
  
  const { orderId, trackingNumber } = await res.json();
  
  // Fetch the label PDF
  const label = await fetch(
    `https://api.clickanddrop.royalmail.com/v1/orders/${orderId}/label`,
    { headers: { 'Authorization': `Bearer ${RM_API_KEY}` } }
  );
  
  return { trackingNumber, labelPdf: await label.arrayBuffer() };
}

Returning tracking to the source channel:

async function markShipped(order, trackingNumber) {
  switch (order.source) {
    case 'ebay':
      return markEbayShipped(order.id, trackingNumber);
    case 'amazon':
      return markAmazonShipped(order.id, trackingNumber);
    case 'shopify':
      return markShopifyShipped(order.id, trackingNumber);
  }
}

The complete flow runs in sequence: collect → normalise → assign service → generate labels → concatenate PDFs → print → mark shipped. In practice, label generation is the slowest step. Batching submissions and generating labels in parallel (with controlled concurrency to avoid API rate limits) keeps total processing time under 60 seconds for 100 orders.

Service Rules Across Channels

One of the most useful aspects of centralised multi-channel printing is consistent service selection. You define the rules once and they apply everywhere.

A practical rule set for a UK seller using Royal Mail:

Order type	Service	Reason
Weight < 100g, domestic	Large Letter Tracked	Cheapest for light items
Weight 100g–2kg, domestic	Tracked 48	Standard 2-day, cost-effective
Weight > 2kg, domestic	Tracked 24	Next-day for heavy items
Any international	International Tracked	Required for insurance
Value > £100	Special Delivery	Insurance + signature
eBay-specific: buyer selected express	Tracked 24	Honour channel promise

The channel-specific override at the bottom matters. If a buyer paid for next-day shipping on eBay, your system needs to respect that regardless of the weight-based rule. Centralised service logic handles this by reading the buyer's selected service from the eBay order data before falling back to weight rules.

Connecting Royal Mail, Evri, and DPD in the Same Queue

Multi-channel printing does not have to mean multi-carrier complexity — but if you use more than one carrier, the same architecture supports it. You route each order to the appropriate carrier API based on your rules, then aggregate labels regardless of which carrier issued them.

A seller using Royal Mail for most orders and DPD for heavyweight or time-sensitive items would add a carrier selection layer:

function selectCarrier(order) {
  if (order.weightGrams > 5000) return 'dpd';
  if (assignService(order) === 'SPECIAL_DELIVERY') return 'royal_mail';
  return 'royal_mail';
}

The label output from both carriers goes into the same print queue. Your packing team sees one label stack, not two separate batches.

The Tracking Return Problem

The step that most DIY implementations get wrong is tracking return. It is not enough to store tracking numbers — you need to push them back to the originating channel within the timeframe that channel expects.

• Amazon: Requires tracking confirmation within 48 hours of the ship date you set. Late confirmation affects your Seller Metrics
• eBay: Tracks buyer experience metrics — late dispatch marks hurt your seller rating
• Shopify: Sends customer notification on fulfillment — delay here means confused customers emailing about their order

Build the tracking return as the final step of your print flow, not an afterthought. Log every return call and implement retries on failure — carrier APIs occasionally time out and the retry ensures your channels stay clean.

For eBay specifically, see our detailed guide on bulk printing from eBay which covers the eBay Fulfillment API response format in detail.

How Multi-Channel Printing Interacts With Inventory

A side effect of centralised order processing that sellers often underestimate: when all orders flow through one system, you have a complete real-time picture of what is being despatched. This makes inventory management significantly more accurate.

If 12 units of a product are in your stock system and 15 orders come in across three channels simultaneously, a centralised fulfilment system catches this before labels are generated. A fragmented per-channel approach catches it after you have already committed to shipping.

Read our guide on managing inventory across multiple channels to see how the order flow and stock management systems connect in practice.

What the Optimised Daily Workflow Looks Like

Once multi-channel printing is running:

6:00am: Overnight orders from eBay, Amazon, and Shopify sync automatically. Service rules apply. Labels are queued.

8:00am: You arrive at the packing station. Open the print queue. Click print. The thermal printer outputs 60 labels — one stack, all channels, correct services.

8:05am–10:00am: Pack orders, apply labels. No computer interaction needed.

Before collection cut-off: Manifest submits automatically to Royal Mail. Tracking numbers have already been returned to eBay, Amazon, and Shopify.

10:05am: Collection. Done.

That is the operational reality of multi-channel printing done correctly. The setup requires investment — API connections, service rules, a print system, tracking return logic. But once it is in place, the daily fulfilment process is a physical task, not an administrative one.

The starting point is connecting Royal Mail properly. Read our Royal Mail integration guide first if you have not already, then build the channel connections outward from there.