Acumatica Third-Party Logistics (3PL) Integration

Introduction

Integrating Acumatica with third-party logistics (3PL) providers enables businesses to outsource warehouse operations while maintaining real-time synchronization with their ERP system. This integration ensures accurate inventory levels, efficient order fulfillment, and seamless communication between systems.

3PL Integration Overview

The 3PL integration typically involves:

• Inventory visibility and synchronization
• Purchase order receiving
• Sales order fulfillment
• Inventory adjustments and transfers
• Shipment tracking and notifications
• Warehouse cost tracking

Data Exchange Format

3PL providers typically use EDI or API-based integrations. Here's a common JSON structure for data exchange:

{
  "transactionType": "INVENTORY_UPDATE",
  "transactionID": "INV-2024-001",
  "timestamp": "2024-02-10T10:30:00Z",
  "warehouse": {
    "warehouseID": "WH001",
    "name": "Main Distribution Center"
  },
  "items": [
    {
      "sku": "PROD-001",
      "quantity": 150,
      "location": "A-01-01",
      "lotNumber": "LOT-2024-001",
      "expirationDate": "2025-02-10"
    }
  ]
}

Inbound Receiving

When inventory arrives at the 3PL warehouse, the receiving transaction is synced to Acumatica:

POST /api/data/PO302000
Content-Type: application/json

{
  "VendorID": { "value": "3PL-001" },
  "Location": { "value": "WHOLESALE" },
  "Details": [
    {
      "InventoryID": { "value": "PROD-001" },
      "Qty": { "value": 150 },
      "UnitCost": { "value": 25.00 }
    }
  ]
}

Inventory Synchronization

Regular inventory synchronization ensures accurate stock levels across systems:

class ThreePLInventorySync {
    async syncInventoryLevels(acumaticaUrl, token, warehouseId) {
        // Get current inventory from 3PL
        const threePLInventory = await this.get3PLInventory(warehouseId);
        
        // Update Acumatica inventory
        for (const item of threePLInventory) {
            await this.updateAcumaticaInventory(
                acumaticaUrl, 
                token, 
                item.sku, 
                item.quantity, 
                item.location
            );
        }
    }

    async get3PLInventory(warehouseId) {
        const response = await fetch(
            `https://api.3pl-provider.com/v1/inventory?warehouse=${warehouseId}`
        );
        return response.json();
    }
}

Order Fulfillment

Order fulfillment involves creating shipments in Acumatica based on 3PL notifications:

// Handle shipment confirmation from 3PL
async function handleShipmentConfirmation(shipmentData) {
    // Create shipment in Acumatica
    const shipment = {
        ShipmentType: { "value": "Ship" },
        CustomerID: { "value": shipmentData.customerId },
        Details: shipmentData.items.map(item => ({
            InventoryID: { "value": item.sku },
            Qty: { "value": item.quantity }
        }))
    };

    await createAcumaticaShipment(baseUrl, token, shipment);
    
    // Update inventory allocation
    await updateInventoryAllocation(baseUrl, token, shipmentData.orderId);
}

Complete Integration Example

class ThreePLIntegration {
    constructor(acumaticaConfig, threePLConfig) {
        this.acumatica = acumaticaConfig;
        this.threePL = threePLConfig;
    }

    async processInboundReceiving(poNumber) {
        const po = await this.getPurchaseOrder(poNumber);
        
        const receiveData = {
            purchaseOrder: poNumber,
            items: po.details.map(d => ({
                sku: d.inventoryID.value,
                quantity: d.qty.value,
                expectedDate: po.expectedDate
            }))
        };

        await this.sendTo3PL('INBOUND_RECEIVING', receiveData);
        
        const receipt = await this.waitFor3PLConfirmation('RECEIPT_CONFIRMED');
        await this.createAcumaticaReceipt(receipt);
    }

    async processOutboundFulfillment(orderId) {
        const order = await this.getSalesOrder(orderId);
        
        const fulfillmentData = {
            orderId: orderId,
            customer: order.customerID.value,
            items: order.details.map(d => ({
                sku: d.inventoryID.value,
                quantity: d.qty.value
            }))
        };

        await this.sendTo3PL('OUTBOUND_FULFILLMENT', fulfillmentData);
        
        const shipment = await this.waitFor3PLConfirmation('SHIPMENT_CONFIRMED');
        await this.createAcumaticaShipment(shipment);
    }
}

Summary

Integrating Acumatica with 3PL providers creates efficient warehouse operations while maintaining real-time data synchronization. By implementing the patterns in this guide, you can automate inbound receiving, inventory sync, and order fulfillment processes.

For more information, check out our other tutorials on Shopify Integration and EDI Integration.