Odoo 19 for Logistics & 3PL:
Warehouse to Last Mile

Your 3PL Clients Want Real-Time Visibility. Your Warehouse Runs on Spreadsheets.

Third-party logistics providers face a unique operational challenge: they manage inventory, shipping, and returns for multiple clients simultaneously, each with different SLAs, carrier preferences, and reporting requirements. Most 3PLs start with a patchwork of spreadsheets, standalone WMS tools, and carrier web portals — stitched together by manual data entry and heroic effort from operations staff.

The result is predictable: misrouted shipments, billing disputes over storage fees, and clients who can't see their own inventory without calling your ops team. When a brand asks "where is my pallet?" and it takes 20 minutes to answer, they start shopping for a new 3PL.

Odoo 19 changes the equation. The Inventory, Sales, and Delivery Carrier modules — combined with the new multi-warehouse routing engine and the improved barcode app — give 3PLs a single system that handles warehouse operations, carrier rate-shopping, label printing, real-time tracking, and client-facing portals. This guide walks through the full implementation: from multi-client warehouse configuration to carrier API integration to KPI dashboards that show exactly where your margin is going.

How to Configure Multi-Client Warehouse Operations in Odoo 19 for 3PL

The foundation of any 3PL operation in Odoo is strict inventory segregation by client. Each client's stock must be tracked separately for billing, reporting, and liability purposes — even when goods physically share the same warehouse floor.

Owner-Based Inventory Segregation

Odoo 19's consignment (owner tracking) feature lets you assign inventory ownership at the quant level. Enable it under Inventory → Configuration → Settings → Traceability → Consignment. Once active, every stock move records the owner_id — meaning you can have Client A's SKUs and Client B's identical SKUs in the same bin, tracked separately.

from odoo import models, fields, api


class StockWarehouse(models.Model):
    _inherit = 'stock.warehouse'

    is_3pl_warehouse = fields.Boolean(
        string='3PL Warehouse',
        help='Enable multi-client segregation features',
    )
    default_billing_cycle = fields.Selection([
        ('weekly', 'Weekly'),
        ('biweekly', 'Bi-Weekly'),
        ('monthly', 'Monthly'),
    ], default='monthly', string='Default Billing Cycle')

    def action_create_client_locations(self, partner_id):
        """Create dedicated sub-locations for a new 3PL client."""
        self.ensure_one()
        Location = self.env['stock.location']
        parent = self.lot_stock_id

        zones = ['Receiving', 'Storage', 'Picking', 'Packing', 'Returns']
        created = self.env['stock.location']
        for zone in zones:
            loc = Location.create({{
                'name': f"{{partner_id.name}} - {{zone}}",
                'location_id': parent.id,
                'usage': 'internal',
                'company_id': self.company_id.id,
                'owner_id': partner_id.id,
            }})
            created |= loc
        return created

This approach gives each client their own receiving dock, storage zone, picking face, packing station, and returns area — all as sub-locations of the main warehouse. The owner_id on each location ensures that inventory reports, cycle counts, and billing queries can be filtered per client without ambiguity.

FedEx, UPS, and DHL Carrier API Integration for Odoo 19 Shipping

Every 3PL ships with multiple carriers. Client A wants FedEx Ground for domestic and DHL Express for international. Client B uses UPS exclusively but needs rate-shopping across service levels. Odoo 19's delivery carrier framework supports all of this — but the out-of-the-box connectors only handle the basics. Here's what production-grade integration looks like.

Multi-Carrier Rate Shopping

Rate shopping queries multiple carriers simultaneously and selects the cheapest option (or the fastest, or the one that meets a specific SLA). Odoo's delivery.carrier model provides rate_shipment(), but calling it serially for 5 carriers on 200 orders is painfully slow. We use threaded rate fetching:

import concurrent.futures
from odoo import models, api


class DeliveryCarrierRateShop(models.Model):
    _inherit = 'delivery.carrier'

    @api.model
    def rate_shop(self, order, carrier_ids=None, strategy='cheapest'):
        """
        Query multiple carriers and return the best rate.
        strategy: 'cheapest' | 'fastest' | 'best_value'
        """
        carriers = self.browse(carrier_ids) if carrier_ids else \
            self.search([('delivery_type', '!=', 'fixed')])

        results = []

        def _fetch_rate(carrier):
            try:
                rate = carrier.rate_shipment(order)
                if rate.get('success'):
                    return {{
                        'carrier_id': carrier.id,
                        'carrier_name': carrier.name,
                        'price': rate['price'],
                        'transit_days': rate.get('transit_days', 99),
                        'currency': rate.get('currency', 'USD'),
                    }}
            except Exception:
                return None

        # Parallel rate fetching — 10s timeout per carrier
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as pool:
            futures = {{pool.submit(_fetch_rate, c): c for c in carriers}}
            for future in concurrent.futures.as_completed(futures, timeout=10):
                result = future.result()
                if result:
                    results.append(result)

        if not results:
            return {{'success': False, 'error': 'No carrier returned a rate'}}

        # Apply strategy
        if strategy == 'cheapest':
            best = min(results, key=lambda r: r['price'])
        elif strategy == 'fastest':
            best = min(results, key=lambda r: r['transit_days'])
        else:
            # Best value: price per transit day
            best = min(results, key=lambda r: r['price'] / max(r['transit_days'], 1))

        return {{'success': True, 'rates': results, 'recommended': best}}

Label Generation and Manifest

After rate selection, the carrier API returns a shipping label (typically a PDF or ZPL for thermal printers). Odoo 19 stores these as ir.attachment records on the picking. For 3PLs printing hundreds of labels per hour, the key optimization is batch label generation — request all labels for a wave in a single API call where the carrier supports it (FedEx and UPS both offer multi-piece shipment endpoints).

Building a Client-Facing Shipment Tracking Portal in Odoo 19

Your 3PL clients shouldn't need to call your ops team for tracking updates. Odoo 19's portal framework lets you expose a self-service tracking dashboard where clients log in and see every shipment — status, carrier, tracking number, estimated delivery, and proof of delivery — in real time.

Webhook-Based Tracking Updates

Instead of polling carrier APIs on a cron (which is slow and rate-limited), register webhooks with each carrier. When a package status changes — picked up, in transit, out for delivery, delivered — the carrier pushes the update to your Odoo instance. Here's the controller that receives these webhooks:

import hmac
import hashlib
import json
from odoo import http
from odoo.http import request


class CarrierWebhookController(http.Controller):

    @http.route(
        '/api/v1/carrier/webhook/<string:carrier_code>',
        type='json', auth='public', methods=['POST'], csrf=False,
    )
    def receive_tracking_update(self, carrier_code, **kwargs):
        """Receive push tracking updates from carrier APIs."""
        body = request.jsonrequest
        secret = request.env['ir.config_parameter'].sudo().get_param(
            f'carrier_webhook_secret_{carrier_code}'
        )

        # Verify webhook signature
        signature = request.httprequest.headers.get('X-Webhook-Signature', '')
        expected = hmac.new(
            secret.encode(), json.dumps(body).encode(), hashlib.sha256,
        ).hexdigest()
        if not hmac.compare_digest(signature, expected):
            return {{'status': 'error', 'message': 'Invalid signature'}}

        tracking_number = body.get('tracking_number')
        status = body.get('status')  # e.g. 'in_transit', 'delivered'
        timestamp = body.get('timestamp')
        location = body.get('current_location', '')

        # Find the picking by tracking reference
        picking = request.env['stock.picking'].sudo().search([
            ('carrier_tracking_ref', '=', tracking_number),
        ], limit=1)

        if not picking:
            return {{'status': 'error', 'message': 'Unknown tracking number'}}

        # Update tracking status
        picking.sudo().write({{
            'x_tracking_status': status,
            'x_tracking_updated': timestamp,
            'x_tracking_location': location,
        }})

        # Notify client via portal message
        if status == 'delivered':
            picking.sudo().message_post(
                body=f"Package delivered at {{location}} on {{timestamp}}",
                message_type='notification',
                subtype_xmlid='mail.mt_note',
            )

        return {{'status': 'ok'}}

The portal page then reads x_tracking_status and displays a clean timeline for each shipment. Clients see the same information your ops team sees — no phone calls, no emails, no "let me check and get back to you."

• HMAC signature verification — prevents spoofed webhook calls from updating shipment status. Every carrier provides a webhook secret during setup.
• Portal notifications — when a package is delivered, the client gets an automatic notification in their Odoo portal inbox and, optionally, via email.
• Idempotent updates — if a carrier sends the same status update twice (common with DHL), the write is a no-op because the values are identical.

Cross-Docking Configuration in Odoo 19 for Just-in-Time 3PL Fulfillment

Cross-docking routes incoming goods directly to outbound docks without entering storage. For 3PLs, this is essential for pre-allocated inventory — goods that arrive at the warehouse already assigned to a customer order. Odoo 19 supports cross-docking through route rules, but the setup requires precision.

Route Configuration

Enable cross-docking under Inventory → Configuration → Settings → Warehouse → Multi-Step Routes. Then create a route that bypasses storage:

<odoo>
  <data>
    <!-- Cross-Dock Route -->
    <record id="route_cross_dock_3pl" model="stock.route">
      <field name="name">3PL Cross-Dock</field>
      <field name="sequence">5</field>
      <field name="product_selectable">True</field>
      <field name="product_categ_selectable">True</field>
    </record>

    <!-- Rule: Input → Packing (skip storage) -->
    <record id="rule_cross_dock_input_pack" model="stock.rule">
      <field name="name">Cross-Dock: Input → Pack</field>
      <field name="route_id" ref="route_cross_dock_3pl"/>
      <field name="action">pull_push</field>
      <field name="picking_type_id" ref="stock.picking_type_internal"/>
      <field name="location_src_id" ref="stock.stock_location_company"/>
      <field name="location_dest_id" ref="stock.location_pack_zone"/>
      <field name="auto">transparent</field>
      <field name="procure_method">make_to_order</field>
    </record>

    <!-- Rule: Pack → Customer -->
    <record id="rule_cross_dock_pack_out" model="stock.rule">
      <field name="name">Cross-Dock: Pack → Ship</field>
      <field name="route_id" ref="route_cross_dock_3pl"/>
      <field name="action">pull</field>
      <field name="picking_type_id" ref="stock.picking_type_out"/>
      <field name="location_src_id" ref="stock.location_pack_zone"/>
      <field name="location_dest_id" ref="stock.stock_location_customers"/>
      <field name="procure_method">make_to_order</field>
    </record>
  </data>
</odoo>

The key is auto="transparent" on the first rule — this makes the internal transfer happen automatically when the receipt is validated. The picker sees goods arrive at the input dock and immediately move to packing, with no manual intervention. For products that can be cross-docked or stored depending on demand, assign both routes and let Odoo's procurement engine choose based on whether there's a pending outbound order.

Freight Cost Allocation and Client Billing in Odoo 19 for 3PL Operations

3PL profitability lives and dies by accurate cost allocation. You negotiate volume discounts with carriers, but each client pays a different rate based on their contract. The spread between what you pay FedEx and what you charge Client A is your margin — and if your billing system can't track it precisely, you're either losing money or losing clients.

Cost Tracking Model

Odoo's default delivery cost is a single field on the sale order. For 3PL, you need a freight cost ledger that records the actual carrier charge, the client-facing markup, and the margin — per shipment:

from odoo import models, fields, api


class FreightCostLine(models.Model):
    _name = 'freight.cost.line'
    _description = 'Freight Cost Allocation for 3PL Billing'

    picking_id = fields.Many2one('stock.picking', required=True, index=True)
    client_id = fields.Many2one(
        'res.partner', string='3PL Client', required=True, index=True,
    )
    carrier_id = fields.Many2one('delivery.carrier', required=True)
    tracking_ref = fields.Char(related='picking_id.carrier_tracking_ref')

    # Actual cost from carrier
    carrier_cost = fields.Monetary(
        string='Carrier Cost', currency_field='currency_id',
    )
    # What we charge the client
    billed_amount = fields.Monetary(
        string='Billed Amount', currency_field='currency_id',
    )
    # Margin
    margin = fields.Monetary(
        compute='_compute_margin', store=True, currency_field='currency_id',
    )
    margin_pct = fields.Float(
        compute='_compute_margin', store=True, string='Margin %',
    )
    currency_id = fields.Many2one(
        'res.currency',
        default=lambda self: self.env.company.currency_id,
    )
    invoice_id = fields.Many2one('account.move', string='Client Invoice')

    @api.depends('carrier_cost', 'billed_amount')
    def _compute_margin(self):
        for rec in self:
            rec.margin = rec.billed_amount - rec.carrier_cost
            rec.margin_pct = (
                (rec.margin / rec.billed_amount * 100)
                if rec.billed_amount else 0.0
            )

At billing time, a scheduled action aggregates all unbilled freight.cost.line records by client and creates a draft invoice with line items for each shipment. The client sees exactly what they shipped, which carrier was used, and what they owe. You see the margin on every shipment.

KPI Dashboards for 3PL Warehouse Performance in Odoo 19

3PL operations generate enormous amounts of data. Without dashboards, that data sits in database tables and nobody makes decisions from it. Odoo 19's reporting engine, combined with custom SQL views, lets you build real-time KPI dashboards that track the metrics that actually drive profitability.

Core 3PL KPIs

For the on-time shipment rate, the logic is straightforward: compare the date_done on the delivery picking against the client's SLA deadline (stored as a custom field on the sale order). Any shipment where date_done > sla_deadline counts as late. Aggregate by client, by week, and you have the metric that matters most to your clients' satisfaction.

For the freight margin dashboard, group freight.cost.line records by client and carrier, then visualize with Odoo's graph views. This immediately shows which client-carrier combinations are profitable and which are eroding margin — often a surprise to ops teams who assumed all shipments were equally profitable.

3 Logistics Gotchas That Break Multi-Client Odoo 19 Warehouse Operations

Optimization Metadata