# ShippingBo MCP

> ShippingBo MCP Server manages all your e-commerce logistics, from order placement to final delivery. It centralizes fulfillment by connecting directly to multi-warehouse stock levels and carrier networks used by French retailers. Your AI agent handles everything: listing orders, checking product inventory status, updating stock counts, and tracking shipments—all without you leaving the chat window.

## Overview
- **Category:** industry-titans
- **Price:** Free
- **Tags:** fulfillment-automation, multi-warehouse, inventory-management, order-centralization, logistics-software, carrier-integration

## Description

Listen up. This **ShippingBo MCP Server** runs your whole e-commerce operation through your AI client. Forget juggling dashboards; you connect this server and let your agent handle everything from the moment an order hits the system until it's actually in a customer’s hands. It connects directly to multi-warehouse stock levels and carrier networks used by French retailers, so you don't have to worry about geographical headaches. Your AI client handles the whole loop: listing orders, checking inventory, updating counts, and tracking shipments—all from your chat window.

### **Handling Orders & Catalog Data**

When it comes to order flow, you've got two ways to pull data. If you know the specific ID of an order, run `get_order` and you'll get all the metadata for that single transaction. But if you need a full picture—the whole backlog—you just call `list_orders`. That generates an aggregated list of every current and past order in your system. For product info, you can pull the complete data sheet for one item using `get_product` with its SKU, or grab the entire catalog listing by running `list_products`. If you need to know what packaging materials are available for a shipment, just check out `list_packs`.

### **Inventory and Stock Control**

Managing stock is where this thing shines. You can view every product SKU sold on the platform using `list_products`, which gives you the master list. If an item's count changes—say, a shipment gets lost or you get a bulk return—you don't have to manually update anything; you use `update_stock` and pass the new count for any product ID, making sure your records match reality immediately. You can also check physical storage capacity by running `list_warehouse_slots`, which maps out every available slot in your warehouse.

### **Shipment Tracking & Fulfillment**

Shipping is a process that needs eyes on it constantly. To get a comprehensive overview of everything going out the door, you use `list_shipments`. This pulls real-time tracking and status data for multiple outgoing shipments at once. If you need to know exactly what slots are available before staging goods, you run `list_warehouse_slots` again; this shows a map of physical storage locations. Because all these tools are grouped together, your agent can process a sequence: first, it checks `get_order` for the details on Order 1234; then, it uses `get_product` to confirm that SKU XYZ is still in stock; next, it calls `list_warehouse_slots` to find an empty spot; and finally, it triggers `update_stock` if needed. It's one conversation, all the data you need.

### **How Your Agent Uses This**

Your AI agent doesn't just read a list of functions—it knows how they talk to each other. You tell it, 'I gotta ship Order 500,' and your agent immediately figures out that it needs to run `get_order` first. Then, it checks the stock using `list_products`, looks up packaging options with `list_packs`, finds a spot in the warehouse via `list_warehouse_slots`, adjusts the count with `update_stock`, and finally uses all that info to verify the shipment status through `list_shipments`. It's an automated, end-to-end logistics system you run right from your chat window. You don't leave the conversation; you just get stuff done.

## Tools

### get_order
Pulls specific details about one single order using its ID.

### get_product
Retrieves the full data sheet for a specified product SKU.

### list_orders
Generates an aggregated list of all placed orders in the system.

### list_packs
Lists available packaging materials and options for shipments.

### list_products
Gets a complete list of every product SKU sold through the platform.

### list_shipments
Retrieves tracking and status data for multiple outgoing shipments.

### list_warehouse_slots
Displays a map of all available physical storage slots in the warehouse.

### update_stock
Changes the active stock count for any product ID, reflecting inventory changes.

## Prompt Examples

**Prompt:** 
```
List all products in my ShippingBo catalog.
```

**Response:** 
```
I've retrieved your product catalog. You have 125 active SKUs including 'Summer T-Shirt (Blue)', 'Wireless Headphones', and 'Eco Water Bottle'. Which one would you like to check stock for?
```

**Prompt:** 
```
Update stock for product ID 54321 to 150 units.
```

**Response:** 
```
Stock update processed! Product 54321 now has 150 units in your main warehouse. Should I verify if any pending orders can now be fulfilled?
```

**Prompt:** 
```
List the last 5 shipments in ShippingBo.
```

**Response:** 
```
Retrieving shipments... Your last 5 shipments include 'SH-9901' (Delivered), 'SH-9902' (In Transit), and three others. Would you like to see the tracking progress for the one in transit?
```

## Capabilities

### Get Order Details
Retrieves specific metadata for a single sales order.

### List All Orders
Generates a complete list of all current and past orders in the system.

### Update Stock Count
Changes the available stock level for any given product ID.

### List Product Details
Retrieves comprehensive information about a specific product SKU.

### List All Products
Pulls the complete catalog listing for every item you sell.

### Track Shipments
Lists existing shipments and provides real-time tracking updates on delivery status.

### Check Warehouse Slots
Maps out the available physical storage locations within your warehouse.

## Use Cases

### Handling High-Volume Stock Adjustments
A warehouse manager realizes 50 units of Product X were damaged during receiving. Instead of logging into the WMS and navigating menus, they simply prompt their agent: 'Run `update_stock` for Product X, reducing count by 50.' The stock level is instantly corrected for fulfillment.

### Fulfilling a Complex Order
A customer needs to know the status of three different shipments. They prompt their agent, which uses `list_shipments`. The agent then confirms: 'Shipment A is delivered; Shipment B is in transit and tracking progress is available via this link.' The problem is solved without logging into three separate carrier sites.

### Catalog Auditing
An e-commerce analyst needs to check if a new product was entered correctly. They first run `list_products` to confirm the SKU exists, and then use `get_product` to validate all dimensions and pricing metadata against their requirements.

### Pre-Packing Verification
Before dispatching a large order, an ops worker checks if enough space is reserved. They run `list_warehouse_slots` to confirm available capacity, ensuring the physical storage supports the incoming volume before calling for new inventory.

## Benefits

- Stop switching between dashboards. You can get a full picture of your fulfillment pipeline by running `list_orders` and then immediately calling `get_order` to pull specific details—all in one conversation. This saves time and context-switching fatigue.
- Inventory updates become instantaneous. Instead of logging into the WMS, you just tell your agent, 'Increase stock for SKU 123 by 50,' and it executes the `update_stock` tool immediately.
- Shipping visibility is centralized. Use `list_shipments` to check dozens of orders at once, getting status updates (In Transit, Delivered) without ever touching a carrier's website or portal.
- Never guess where something is stored again. Calling `list_warehouse_slots` gives you the real-time physical map, confirming if an item can actually be picked and packed before dispatching it.
- Product data retrieval is precise. Need to know the dimensions for customs? Use `get_product` to pull all metadata on a specific SKU immediately, which is much faster than cross-referencing multiple database tables.

## How It Works

The bottom line is your AI client acts as a dedicated logistics coordinator, running specific checks on demand so you don't have to switch tabs.

1. Subscribe to the ShippingBo server and provide your API credentials via Vinkius.
2. Your AI client sends a natural language request (e.g., 'Check stock for SKU 456').
3. The agent uses the appropriate tool (like `get_product` or `list_orders`) and returns the data directly into the chat.

## Frequently Asked Questions

**How do I list all products in my ShippingBo catalog using the MCP Server?**
You call `list_products`. This tool pulls a comprehensive listing of every active SKU, giving you the full inventory scope right from your chat interface.

**What is the difference between list_orders and get_order in ShippingBo?**
`list_orders` gives you an overview—a bulk list of all orders. You use `get_order` when you need deep, specific metadata for a single order ID.

**Can I check warehouse slot availability with the ShippingBo MCP Server?**
Yes, call `list_warehouse_slots`. This tool lets you monitor and confirm physical storage capacity, ensuring you know exactly where items are stored before they get picked.

**Does updating stock using update_stock affect current orders?**
The agent handles the transaction flow. After running `update_stock`, your AI client can immediately check if any pending orders can now be fulfilled, confirming the change's impact.

**How do I track multiple shipments in ShippingBo?**
Use the `list_shipments` tool. It retrieves status and tracking data for a group of outgoing packages, allowing you to monitor dozens of deliveries at once.

**How do I configure API access credentials for using `get_product`?**
You need an active API Token and User ID from your ShippingBo dashboard. Your agent uses these keys to authorize the connection, so make sure they're up-to-date before you try running any tool.

**Does `update_stock` automatically handle negative inventory checks?**
Yes, the system validates that product stock counts cannot drop below zero when you run this update. If a negative count is detected for a specific SKU, the tool fails and returns an error code.

**How do I retrieve large volumes of data using `list_orders`?**
The server handles pagination automatically for bulk requests. If you need more than the default batch size, just tell your agent to 'get the next page' and it will continue retrieving records until all orders are listed.

**Can my AI automatically update the stock count for a specific product just by providing its ID?**
Yes! Use the `update_stock` tool. Provide the Product ID and the new stock count, and your agent will synchronize it across your ShippingBo warehouses instantly.

**How do I monitor the status of warehouse slots to see how my inventory is organized?**
Simply ask the agent to run the `list_warehouse_slots` action. It will retrieve the full list of storage slots configured in your ShippingBo account.

**How do I find my ShippingBo API credentials?**
Log in to your ShippingBo account, navigate to **Settings** > **API**, and you will find your unique **API User** (X-API-USER) and **Token** (X-API-TOKEN) there.