​
Stateset Warehouse Management Quickstart: Optimize Your Operations

Imagine you’re running a busy warehouse. You’re dealing with countless inventory items, complex receiving processes, and a never-ending flow of orders. How do you ensure accuracy, efficiency, and smooth operations while minimizing costs and errors? Stateset’s Warehouse Management API provides the tools you need to address these challenges. This guide will walk you through the essentials of using Stateset to:
  • Manage Inventory: Keep accurate track of your stock levels and locations.
  • Optimize Warehouse Layout: Design an efficient layout that minimizes travel time.
  • Streamline Receiving: Handle incoming shipments smoothly and accurately.
  • Improve Order Fulfillment: Optimize picking, packing, and shipping processes.
  • Handle Returns: Process returns efficiently and minimize disruptions.

​
Table of Contents

  1. The Importance of Efficient Warehouse Management
  2. Getting Started with Stateset
  3. Core Concepts: The Fundamentals of Warehouse Operations
  4. Streamlining Key Processes with Stateset
  5. Advanced Warehouse Optimization Techniques
  6. Key Integrations for a Seamless System
  7. Essential Considerations
  8. Troubleshooting & Support
  9. Quick Links

​
1. The Importance of Efficient Warehouse Management

Before we dive in, it’s essential to understand why warehouse management is so critical for your business:
  • Inventory Accuracy: Without accurate inventory tracking, you risk stockouts or overstocking, leading to lost sales and higher costs.
  • Order Fulfillment: Slow or inaccurate order fulfillment results in customer dissatisfaction and potential revenue loss.
  • Space Utilization: Inefficient warehouse layouts can waste valuable space, increasing your overhead costs.
  • Labor Efficiency: Optimized processes can significantly reduce labor costs, improve worker morale and throughput.
  • Returns Processing: Without a clear returns management system, you can lose track of inventory and potentially incur additional losses.
Stateset provides the tools you need to overcome these challenges, optimize your operations, and keep your warehouse running smoothly.

​
2. Getting Started with Stateset

Let’s get your environment set up so you can start using the Stateset Warehouse Management API.

​
1. Account Setup

First, you need a Stateset account and an API key.
  1. Sign Up: Visit stateset.io/sign-up to create your free account.
  2. Access Cloud Console: After signing in, go to the Stateset Cloud Console.
  3. Generate API Key: Create a new API key—you’ll use this to authenticate your API requests.

​
2. SDK Installation

Next, install the Stateset Node.js SDK to simplify interactions with the API. Using npm: 
npm install stateset-node
Using yarn: 
yarn add stateset-node

​
3. Client Initialization

Finally, initialize the Stateset client in your application using your API key. 
import { stateset } from 'stateset-node';

const client = new stateset(process.env.STATESET_API_KEY);

// Verify connection
async function verifyConnection() {
  try {
    const status = await client.system.healthCheck();
    console.log('Connection status:', status);
  } catch (error) {
    console.error('Failed to connect:', error);
  }
}

verifyConnection();
Actionable Next Step: Ensure your API key is properly configured and your client connection is successful.

​
3. Core Concepts: The Fundamentals of Warehouse Operations

Before diving into the specifics, let’s cover the basic concepts that form the core of warehouse operations.

​
Inventory Management

Inventory management involves tracking stock levels, maintaining accurate records, and managing items efficiently. Here’s how it works in Stateset: First, you add an item to your system, this includes a unique identifier, name, dimensions, and other details: 
async function createItem() {
  try {
    const newItem = await client.inventoryItems.create({
      sku: 'WIDGET-001',
      name: 'Premium Widget',
      description: 'High-quality widget for various applications',
      category: 'Widgets',
      unit_of_measure: 'EA',
      weight: 0.5,
      dimensions: { length: 10, width: 5, height: 2 }
    });
    console.log('New item created:', newItem);
  } catch (error) {
    console.error('Failed to create item:', error);
  }
}

createItem();
Next, you can update the quantity of this item at a specific location: 
const updatedItem = await client.inventoryItems.updateQuantity(newItem.id, {
  quantity: 100,
  location_id: 'loc_A1'
});

console.log('Item quantity updated:', updatedItem);
Benefits of inventory management with Stateset:
  • Accurate real-time tracking of your inventory.
  • Easily update stock levels, locations, and other details.
  • Reduced risk of stockouts and overstocking.
Actionable Next Step: Try creating your first inventory item using the code above. For more detailed information on inventory management, see the Inventory Quickstart.

​
Warehouse Layout and Slotting

Warehouse layout and slotting define how items are stored in your warehouse. This includes the location, how much can be stored there, and what type of area it is: 
const newLocation = await client.storageLocations.create({
  name: 'A1-01',
  type: 'SHELF',
  zone: 'PICKING',
  capacity: { units: 100, weight: 50 }
});

console.log('New storage location created:', newLocation);
You can also use Stateset to help optimize your slotting, this is a process that takes into account historical data to make recommendations on where each item should go: 
const slottingPlan = await client.warehouse.optimizeSlotting({
  optimization_criteria: ['pick_frequency', 'item_affinity']
});

console.log('Slotting plan:', slottingPlan);
Benefits of optimized slotting:
  • Reduced travel time for picking orders.
  • Maximized use of available space.
  • Improved picking accuracy.
Actionable Next Step: Explore creating storage locations and optimizing your warehouse slotting.

​
4. Streamlining Key Processes with Stateset

Now, let’s explore how Stateset can help with various key processes in your warehouse.

​
Receiving Process

The receiving process involves the handling of incoming shipments, counting and verifying items, and putting them away. Here’s how you can do it with Stateset: 
const receivingOrder = await client.receivingOrders.create({
  supplier_id: 'sup_123',
  expected_delivery_date: '2024-10-01',
  items: [
    { sku: 'WIDGET-001', expected_quantity: 500 }
  ]
});

console.log('Receiving order created:', receivingOrder);
Next, record the items you actually received: 
const receivedItems = await client.receivingOrders.recordReceivedItems(receivingOrder.id, {
  items: [
    { sku: 'WIDGET-001', received_quantity: 498, location_id: 'loc_A1' }
  ]
});

console.log('Received items recorded:', receivedItems);
Benefits of using Stateset for receiving:
  • Track incoming shipments effectively.
  • Record received items accurately and efficiently.
  • Reduce errors and time spent on manual processes.
Actionable Next Step: Try creating a new receiving order and record the received items. See also: Supplier Quickstart for managing suppliers.

​
Pick, Pack, and Ship Processes

The pick, pack, and ship processes are fundamental to order fulfillment. Here’s how you can do it in Stateset: First, you create a pick order: 
const pickOrder = await client.pickOrders.create({
  order_id: 'ord_456',
  items: [
    { sku: 'WIDGET-001', quantity: 5 }
  ]
});

console.log('Pick order created:', pickOrder);
Next, you record the picked items: 
const pickedItems = await client.pickOrders.recordPickedItems(pickOrder.id, {
  items: [
    { sku: 'WIDGET-001', picked_quantity: 5, location_id: 'loc_A1' }
  ]
});

console.log('Picked items recorded:', pickedItems)
Now, you create a packing list for the picked items: 
const packingList = await client.packingLists.create({
  pick_order_id: pickOrder.id,
  items: pickedItems
});

console.log('Packing list created:', packingList);
Finally, you create a shipment to be sent out: 
const shipment = await client.shipments.create({
  packing_list_id: packingList.id,
  carrier: 'UPS',
  service_level: 'GROUND',
  tracking_number: '1Z999AA1234567890'
});

console.log('Shipment created:', shipment);
Benefits of using Stateset for pick, pack, and ship:
  • Track order fulfillment progress.
  • Optimize pick paths to save time.
  • Create shipping documentation quickly and easily.
Actionable Next Step: Create pick orders and walk through the pick, pack, and ship process. For more on orders, see Orders Quickstart.

​
Returns Management

Handling returns efficiently is essential for customer satisfaction and inventory management. Here’s a basic example of how you can initiate a return in Stateset: 
// Create a return order
const returnOrder = await client.returnOrders.create({
  order_id: 'ord_456',
  items: [
    { sku: 'WIDGET-001', quantity: 1, reason: 'Damaged' }
  ]
});

console.log('Return order created:', returnOrder);
Once a return is created, you can approve it: 
// Approve the return
const approvedReturn = await client.returnOrders.approve(returnOrder.id);

console.log('Return approved:', approvedReturn);
After processing, close the return: 
// Close the return
const closedReturn = await client.returnOrders.close(returnOrder.id);

console.log('Return closed:', closedReturn);
Benefits of using Stateset for returns:
  • Easily track returns from customers.
  • Maintain accurate inventory records.
  • Streamline return processes.
Actionable Next Step: Simulate a product return using the example code above. For comprehensive returns handling, refer to the Returns Quickstart.

​
5. Advanced Warehouse Optimization Techniques

Now that you’ve explored the basic processes, let’s look at some advanced optimization techniques.

​
ABC Analysis for Inventory

ABC analysis helps categorize items based on their value and pick frequency. This helps you optimize storage locations. 
async function performABCAnalysis() {
  const items = await client.inventoryItems.list({ limit: 1000 });
  const totalValue = items.reduce((sum, item) => sum + item.value * item.quantity, 0);
  const totalPicks = items.reduce((sum, item) => sum + item.pick_frequency, 0);

  const categorizedItems = items.map(item => ({
    ...item,
    value_score: (item.value * item.quantity) / totalValue,
    pick_score: item.pick_frequency / totalPicks
  })).sort((a, b) => b.value_score + b.pick_score - (a.value_score + a.pick_score));

  let cumulativeScore = 0;
  const abcCategories = categorizedItems.map(item => {
    cumulativeScore += item.value_score + item.pick_score;
    if (cumulativeScore <= 0.8) return { ...item, category: 'A' };
    if (cumulativeScore <= 0.95) return { ...item, category: 'B' };
    return { ...item, category: 'C' };
  });

  // Update items with their ABC category
  for (const item of abcCategories) {
    await client.inventoryItems.update(item.id, { abc_category: item.category });
  }

  return abcCategories;
}

const abcResults = await performABCAnalysis();
console.log('ABC Analysis complete:', abcResults);
Benefit:
  • Improves warehouse organization and efficiency by prioritizing high-value, frequently picked items.
Actionable Next Step: Implement and review the results of your ABC analysis.

​
Cross-Docking for Fast-Moving Items

Cross-docking minimizes storage time for high-demand items by moving them directly from receiving to shipping. 
async function setupCrossDocking(receivingOrderId) {
  const receivingOrder = await client.receivingOrders.get(receivingOrderId);
  const crossDockItems = receivingOrder.items.filter(item => item.cross_dock_eligible);

  if (crossDockItems.length > 0) {
    const crossDockOrder = await client.crossDockOrders.create({
      receiving_order_id: receivingOrderId,
      items: crossDockItems
    });

    // Assign cross-dock items to pending shipments
    await assignCrossDockItemsToShipments(crossDockOrder);
  }
}

async function assignCrossDockItemsToShipments(crossDockOrder) {
  const pendingShipments = await client.shipments.list({ status: 'PENDING' });
  
  for (const item of crossDockOrder.items) {
    const matchingShipment = pendingShipments.find(shipment => 
      shipment.items.some(shipmentItem => shipmentItem.sku === item.sku)
    );

    if (matchingShipment) {
      await client.shipments.update(matchingShipment.id, {
        items: matchingShipment.items.map(shipmentItem => 
          shipmentItem.sku === item.sku 
            ? { ...shipmentItem, cross_dock: true, location_id: crossDockOrder.id }
            : shipmentItem
        )
      });
    }
  }
}

const crossDockingResults = await setupCrossDocking('rec_123');
console.log('Cross docking setup completed:', crossDockingResults);
Benefit:
  • Reduces storage time, speeds up order fulfillment, and minimizes handling costs.
Actionable Next Step: Set up cross-docking for applicable items.

​
Wave Picking for Order Efficiency

Wave picking involves grouping multiple orders into waves for more efficient picking, reducing the time spent in travel: 
async function createPickingWave() {
  const pendingOrders = await client.orders.list({ status: 'PENDING', limit: 50 });
  
  const wave = await client.pickingWaves.create({
    orders: pendingOrders.map(order => order.id)
  });

  const optimizedPickPath = await client.warehouse.optimizePickPath(wave.id);

  return { wave, optimizedPickPath };
}

async function processPickingWave(waveId) {
  const wave = await client.pickingWaves.get(waveId);
  
  for (const orderId of wave.orders) {
    const pickedItems = await pickOrderItems(orderId);
    await createPackingList(orderId, pickedItems);
  }

  await client.pickingWaves.complete(waveId);
}

const wavePickingResults = await createPickingWave();
console.log("Wave picking created:", wavePickingResults)
Benefit:
  • Improves picker efficiency, reduces travel time, and increases overall throughput.
Actionable Next Step: Start implementing wave picking for your orders.

​
6. Key Integrations for a Seamless System

To maximize the benefits of Stateset, consider integrating it with other systems:
  • E-Commerce Platforms: Integrate with platforms like Shopify, Magento, or WooCommerce for automatic order syncing. See Shopify Quickstart.
  • ERP Systems: Connect with your ERP system for centralized data management.
  • Carrier APIs: Integrate with carriers like UPS, FedEx, or USPS for real-time shipping updates.
  • WMS Systems: Connect with other Warehouse Management Systems if you need more specialized functionality.
For specific integrations, check out our integration guides such as Shopify Quickstart and Gorgias Quickstart.

​
7. Essential Considerations

​
Error Handling and Logging

  • Implement try-catch blocks around API calls to handle potential errors.
  • Log errors for analysis and debugging.
  • Set up alerts for critical errors to notify you immediately.

​
Real-time Monitoring

  • Use Stateset’s webhook functionality to get real-time updates on warehouse events.
  • Monitor inventory changes, order progress, and other key metrics.

​
Security Best Practices

  • Store API keys securely, using environment variables or secret managers.
  • Follow best practices for protecting your application and data.

​
8. Troubleshooting & Support

If you have issues or questions, check these resources:
By following this quickstart guide, you are now equipped to use Stateset to optimize your warehouse operations. Explore the documentation and integrate with other systems to build a powerful, efficient warehouse management solution.