> This page is for version Experimental.
> For other versions, use one of these documentation indexes:
> - 2026-07 (default): https://developer-stage.shipbob.dev/2026-07/llms.txt
> - 2026-01: https://developer-stage.shipbob.dev/2026-01/llms.txt
> - 2025-07: https://developer-stage.shipbob.dev/2025-07/llms.txt
> - v2.0: https://developer-stage.shipbob.dev/v2.0/llms.txt
> - v1.0: https://developer-stage.shipbob.dev/v1.0/llms.txt
> - Experimental: https://developer-stage.shipbob.dev/experimental/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developer-stage.shipbob.dev/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developer-stage.shipbob.dev/_mcp/server.

#     Get All Inventory Levels by Channel


GET https://sandbox-api.shipbob.com/Experimental/inventory-level/channels

    Retrieves current inventory levels across all locations. Returns available, on-hand, committed, and other quantity types. Supports filtering by inventory IDs, product attributes, and quarantine status.

    This version adds the per-channel split of sellable inventory: b2b_reservation_quantity, b2b_sellable_quantity and d2c_sellable_quantity. b2b_sellable_quantity is the quantity the merchant reserved for B2B (0 when none is set). d2c_sellable_quantity is the sellable quantity left for D2C after the B2B reservation, with a minimum of 0. Set the reservation with PUT /inventory:setB2bReservationQuantity. This operation is the channel-aware version of Get All Inventory Levels (GET /inventory-level). These three fields are returned only for merchants where feature flag PIX.GIS.B2bInventoryReservation is enabled. For other merchants the fields are omitted from the response. There is no request parameter that filters by channel. Both channels are returned in each item.


Reference: https://developer-stage.shipbob.dev/experimental/api/inventory/get-all-inventory-levels-by-channel

## Authentication

- `Authorization` header (bearer token, required) — Authentication using Personal Access Token (PAT) token
- `Authorization` header (bearer token, required) — OAuth2 authentication using JWT tokens

## Request

### Query parameters

- `SearchBy` (string, optional)
- `InventoryIds` (list of integer, optional)
- `IsActive` (boolean, optional)
- `IsDigital` (boolean, optional)
- `PageSize` (integer, optional)
- `SortBy` (string, optional)
- `has_quarantine` (boolean, optional)

## Response

### 200

OK

- `first` (string, optional, nullable) — URL to retrieve the first page of results. Null if already on the first page.
- `items` (list of Inventory.InventoryQuantityV5Response, optional, nullable) — Array of inventory quantity items in the current page of results.
- `last` (string, optional, nullable) — URL to retrieve the last page of results. Null if already on the last page.
- `next` (string, optional, nullable) — URL to retrieve the next page of results. Null if on the last page.
- `prev` (string, optional, nullable) — URL to retrieve the previous page of results. Null if on the first page.

## Errors

### 400 Bad Request Error

Bad Request

- `detail` (string, optional, nullable) — A human-readable explanation specific to this occurrence of the problem.
- `instance` (string, optional, nullable) — A URI reference that identifies the specific occurrence of the problem. It may or may not yield further information if dereferenced.
- `status` (integer, optional, nullable) — The HTTP status code for this occurrence of the problem.
- `title` (string, optional, nullable) — A short, human-readable summary of the problem type.
- `type` (string, optional, nullable) — A URI reference that identifies the problem type. This URI should provide human-readable documentation for the problem.

### 401 Unauthorized Error

Unauthorized

- `detail` (string, optional, nullable) — A human-readable explanation specific to this occurrence of the problem.
- `instance` (string, optional, nullable) — A URI reference that identifies the specific occurrence of the problem. It may or may not yield further information if dereferenced.
- `status` (integer, optional, nullable) — The HTTP status code for this occurrence of the problem.
- `title` (string, optional, nullable) — A short, human-readable summary of the problem type.
- `type` (string, optional, nullable) — A URI reference that identifies the problem type. This URI should provide human-readable documentation for the problem.

### 403 Forbidden Error

Forbidden

- `detail` (string, optional, nullable) — A human-readable explanation specific to this occurrence of the problem.
- `instance` (string, optional, nullable) — A URI reference that identifies the specific occurrence of the problem. It may or may not yield further information if dereferenced.
- `status` (integer, optional, nullable) — The HTTP status code for this occurrence of the problem.
- `title` (string, optional, nullable) — A short, human-readable summary of the problem type.
- `type` (string, optional, nullable) — A URI reference that identifies the problem type. This URI should provide human-readable documentation for the problem.

### 500 Internal Server Error

Internal Server Error

- `any`

### 503 Service Unavailable Error

Service Unavailable

- `any`

## Types

### Inventory.InventoryQuantityV5Response

- `b2b_reservation_quantity` (integer, optional, nullable) — Quantity the merchant has reserved for the B2B channel. Null when no value has been stored; after a reservation is cleared with PUT /inventory:setB2bReservationQuantity, this field is 0. Returned only when feature flag PIX.GIS.B2bInventoryReservation is enabled for the merchant. Otherwise the field is omitted from the response.
- `b2b_sellable_quantity` (integer, optional) — Sellable quantity assigned to the B2B channel. Equals b2b_reservation_quantity, or 0 when no reservation is set. Returned only when feature flag PIX.GIS.B2bInventoryReservation is enabled for the merchant. Otherwise the field is omitted from the response.
- `d2c_sellable_quantity` (integer, optional) — Sellable quantity assigned to the D2C channel. Equals the total sellable quantity minus the B2B reservation, with a minimum of 0. Returned only when feature flag PIX.GIS.B2bInventoryReservation is enabled for the merchant. Otherwise the field is omitted from the response.
- `inventory_id` (integer, optional) — Unique identifier for the inventory item
- `name` (string, optional, nullable) — Name of the inventory item
- `sku` (string, optional, nullable) — Stock keeping unit identifier
- `total_awaiting_quantity` (integer, optional) — Total quantity expected to arrive from receiving or transfers
- `total_backordered_quantity` (integer, optional) — Total quantity on backorder for pending shipments
- `total_committed_quantity` (integer, optional) — Total quantity reserved for existing orders and allocations
- `total_damaged_quantity` (integer, optional) — Total quantity currently marked as damaged
- `total_exception_quantity` (integer, optional) — Total quantity in exception status (damaged, lost, or under investigation)
- `total_fulfillable_quantity` (integer, optional) — Total quantity available to fulfill new orders (on-hand minus committed)
- `total_in_fulfillment_quantity` (integer, optional) — Total quantity of inventory items that are currently in the fulfillment process
- `total_internal_transfer_quantity` (integer, optional) — Total quantity currently in transit between fulfillment centers
- `total_on_hand_quantity` (integer, optional) — Total quantity physically present in all fulfillment centers
- `total_quarantine_quantity` (integer, optional) — Total quantity currently in quarantine status
- `total_sellable_quantity` (integer, optional) — Total quantity available for sale across all channels (fulfillable plus awaiting minus quarantine minus damaged). It is not split by channel. Use d2c_sellable_quantity and b2b_sellable_quantity for the channel view.

## Examples

**Response**

```json
{
  "first": "string",
  "items": [
    {
      "b2b_reservation_quantity": 0,
      "b2b_sellable_quantity": 0,
      "d2c_sellable_quantity": 0,
      "inventory_id": 0,
      "name": "string",
      "sku": "string",
      "total_awaiting_quantity": 0,
      "total_backordered_quantity": 0,
      "total_committed_quantity": 0,
      "total_damaged_quantity": 0,
      "total_exception_quantity": 0,
      "total_fulfillable_quantity": 0,
      "total_in_fulfillment_quantity": 0,
      "total_internal_transfer_quantity": 0,
      "total_on_hand_quantity": 0,
      "total_quarantine_quantity": 0,
      "total_sellable_quantity": 0
    }
  ],
  "last": "string",
  "next": "string",
  "prev": "string"
}
```

**SDK Code**

```python default
import requests

url = "https://sandbox-api.shipbob.com/Experimental/inventory-level/channels"

querystring = {"SearchBy":"string","InventoryIds":"[0]","IsActive":"true","IsDigital":"true","SortBy":"string","has_quarantine":"true"}

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())
```

```javascript default
const url = 'https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go default
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby default
require 'uri'
require 'net/http'

url = URI("https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body
```

```java default
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true")
  .header("Authorization", "Bearer <token>")
  .asString();
```

```php default
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

echo $response->getBody();
```

```csharp default
using RestSharp;

var client = new RestClient("https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift default
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://sandbox-api.shipbob.com/Experimental/inventory-level/channels?SearchBy=string&InventoryIds=%5B0%5D&IsActive=true&IsDigital=true&SortBy=string&has_quarantine=true")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```