How do I use the Logentic API?

Last updated: May 18, 2026

Quick answer

Use this article to connect an external system to Logentic through the public API.

At a glance

What you are doing	What you need	Good result	Contact us if
Connect an external system to Logentic through the public API.	A Logentic API token, server-side storage, the right account and warehouse context, and a clear integration goal.	Your system can authenticate, call the needed endpoint, and handle Logentic responses without exposing credentials.	You need a token, see repeated `401` or `403` responses, need webhook verification details, or endpoint behavior differs from this reference.

Useful links

Applies to

Developers and integration partners.
Server-side systems that create or read orders, items, inventory quantities, payment items, or webhook events.
API version v1.

Before you start

Get a Logentic API token from Logentic.
Store the token securely on your server.
Do not expose the token in browser code, mobile apps, public repositories, logs, screenshots, or customer-visible errors.
Confirm which warehouse, Shopify store, and account the integration should access.
Confirm whether the integration is read-only, creates orders, updates orders, or receives webhooks.

Base URL

```plain text https://api.getlogentic.com/v1


### Authentication

Use Bearer token authentication on every request.

```plain text
Authorization: Bearer YOUR_LOGENTIC_API_TOKEN
Accept: application/json
Content-Type: application/json

For GET requests, Content-Type is optional. For POST and PUT requests, send Content-Type: application/json.

Quick start

List orders:

curl "https://api.getlogentic.com/v1/orders" \
  -H "Authorization: Bearer $LOGENTIC_API_TOKEN" \
  -H "Accept: application/json"

Create an order:

curl -X POST "https://api.getlogentic.com/v1/orders" \
  -H "Authorization: Bearer $LOGENTIC_API_TOKEN" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  --data '{
    "order_type": "DELIVERY",
    "warehouse_id": 1,
    "status": "PENDING",
    "recipient": {
      "name": "Customer Name",
      "email": "customer@example.com",
      "phone": "5144145145"
    },
    "stored_items": [
      {
        "item_id": 28488,
        "quantity": 1
      }
    ],
    "place": {
      "address1": "4606 Test Avenue",
      "address2": "Suite 440",
      "postal_code": "H2R 2Y8",
      "city": "Montreal",
      "province_code": "QC",
      "country_code": "CA"
    }
  }'

Response format

Single-resource responses are wrapped in data.

{
  "data": {
    "id": 19015
  }
}

List responses return data plus pagination metadata.

{
  "data": [],
  "meta": {
    "pagination": {
      "total": 150,
      "count": 50,
      "per_page": 50,
      "current_page": 2,
      "total_pages": 3,
      "links": {
        "previous": "https://api.getlogentic.com/v1/orders?page=1",
        "next": "https://api.getlogentic.com/v1/orders?page=3"
      }
    }
  }
}

Pagination

List endpoints use page-based pagination.

Parameter	Type	Description
`page`	integer	Page number to retrieve.
`per_page`	integer	Page size where supported.

When meta.pagination.links.next is present, use that URL to fetch the next page. Stop when next is null or absent.

Status codes

Code	Meaning
`200`	Request succeeded.
`201`	Resource was created.
`204`	Request succeeded and no body is returned.
`400`	Request is malformed or missing required parameters.
`401`	Authentication failed or the token is missing.
`403`	The authenticated user cannot access the requested resource.
`404`	Resource was not found.
`405`	HTTP method is not supported for this endpoint.
`422`	Request validation failed.

Orders

Orders represent delivery work that Logentic can fulfill, track, and update.

Endpoint	Purpose
`GET /orders`	Returns a paginated list of orders.
`GET /orders/{order_id}`	Retrieves one order by Logentic order ID.
`POST /orders`	Creates a delivery order.
`PUT /orders/{order_id}`	Updates a pending order.
`PUT /shopify_orders/{shopify_order_id}`	Updates a pending order by Shopify order ID.

Useful GET /orders filters:

Query	Type	Required	Description
`page`	integer	no	Page number.
`external_name`	string	no	External or ecommerce order reference. Multiple values may be comma-separated.
`updated_at_start`	date	no	Include orders updated after this date.
`updated_at_end`	date	no	Include orders updated before this date.
`shopify_order_id`	string	no	Filter by Shopify order ID.

Required fields for POST /orders:

Field	Type	Required	Description
`order_type`	string	yes	Public examples use `DELIVERY`.
`status`	string	yes	Use `PENDING` when creating a new order.
`warehouse_id`	integer	yes	Warehouse to ship from.
`recipient.name`	string	yes	Recipient name.
`recipient.email`	string	yes	Recipient email.
`recipient.phone`	string	yes	Recipient phone.
`stored_items`	array	yes	Items to ship.
`stored_items[].item_id`	integer	conditional	Required when `shopify_variant_id` is not present.
`stored_items[].shopify_variant_id`	string	conditional	Required when `item_id` is not present.
`stored_items[].quantity`	number	yes	Quantity to ship.
`place.address1`	string	yes	First address line.
`place.postal_code`	string	yes	Postal or ZIP code.
`place.city`	string	yes	City.
`place.province_code`	string	yes	Province or state code.
`place.country_code`	string	yes	Two-character ISO country code.

Known order statuses include PENDING, CANCELLED, IN_TRANSIT, and COMPLETED.

Items

Items represent SKU or product records used by orders and inventory.

Endpoint	Purpose
`GET /items`	Returns a paginated list of items.
`GET /items/{item_id}`	Retrieves one item by Logentic item ID.
`POST /items`	Creates an item.
`PUT /items/{item_id}`	Updates an item.
`DELETE /items/{item_id}`	Deletes an item.

Useful GET /items filters:

Query	Type	Required	Description
`page`	integer	no	Page number.
`shopify_variant_id`	string	no	Filter by Shopify variant ID.
`external_name`	string	no	Filter by SKU or external reference.

Required fields for POST /items:

Field	Type	Required	Description
`name`	string	yes	Product name.
`width_in`	number	yes	Width in inches.
`depth_in`	number	yes	Depth in inches.
`height_in`	number	yes	Height in inches.
`weight`	number	yes	Item weight. Confirm account-specific unit expectations before bulk imports.

Optional item fields include description, price, notify_email, expiration_warning_in_days, ht_code, country_of_origin, back_order_limit, is_prepackaged, external_name, and shopify_variant_id.

Payment items

Payment items represent charges such as shipping, handling, picking, and storage.

Endpoint	Purpose
`GET /payment_items`	Returns payment items.
`GET /payment_items/{payment_item_id}`	Retrieves one payment item.

Useful GET /payment_items filters:

Query	Type	Required	Description
`start`	date	no	Payment start date, `YYYY-MM-DD`.
`end`	date	no	Payment end date, `YYYY-MM-DD`.
`billed_date_start`	date	no	Billed-date start, `YYYY-MM-DD`.
`billed_date_end`	date	no	Billed-date end, `YYYY-MM-DD`.
`page`	integer	no	Page number.
`group_by_invoice`	boolean	no	Group charges by invoice.
`payment_id`	integer	no	Filter by payment ID.
`exclude_storage_info`	boolean	no	Exclude storage-specific fields.

Inventory history

Inventory endpoints expose item quantity, volume, and storage data over time.

Endpoint	Purpose
`GET /items/inventory`	Returns inventory history across items.
`GET /items/inventory/{item_id}`	Returns inventory history for one item.

Required query parameters:

Query	Type	Required	Description
`start`	date	yes	Start date, `YYYY-MM-DD`.
`end`	date	yes	End date, `YYYY-MM-DD`.

Optional query parameters include page, per_page, and exclude_storage_price.

Inventory history responses may include id, name, external_name, cubic_size, weight, date, total_volume, total_storage_price, prepared, receiving, and supply.

Item quantities

Item quantity endpoints expose point-in-time stock state.

Endpoint	Purpose
`GET /items/item_quantities`	Returns item quantity records.
`GET /items/{item_id}/item_quantities`	Returns quantity history for one item.

Useful filters:

Query	Type	Required	Description
`updated_at_start`	datetime	no	Include records updated after this timestamp.
`updated_at_end`	datetime	no	Include records updated before this timestamp.
`shopify_variant_id`	string	no	Filter by Shopify variant ID.
`page`	integer	no	Page number.

Item quantity responses may include id, item_id, sku, supply, receiving, prepared, back_ordered, delivered, updated_at, and created_at.

Webhooks

Logentic can send webhook events for order lifecycle changes.

Supported event families include:

Event	Description
Order Created	An order was created.
Order Picked	An order was picked.
Order Packed	An order was packed.
Order In Transit	An order moved into transit.
Order Completed	An order was completed.

Webhook deliveries include headers similar to:

```plain text Signature: <hex signature> Logentic-Api-Version: V1 Logentic-Topic: order-completed User-Agent: GuzzleHttp/6.5.5 curl/7.79.1 PHP/7.4.24


Receiver guidance:

- Return a `2xx` response after the webhook is durably queued.
- Treat webhook delivery as at-least-once.
- De-duplicate repeated events before applying side effects.
- Use `Logentic-Topic` to route event handling.
- Fetch the order by ID after important lifecycle events if your integration needs the latest canonical state.
- Confirm webhook signature verification details before production launch.

### Machine-readable route catalog

This compact route catalog can be used by AI systems, SDK generators, and integration scaffolding tools. It is not a full OpenAPI schema.

api_name: Logentic Public API version: v1 base_url: https://api.getlogentic.com/v1 auth: type: bearer header: Authorization format: "Bearer ${LOGENTIC_API_TOKEN}" default_headers: Accept: application/json Content-Type: application/json resources: orders: operations:

operation_id: list_orders

method: GET path: /orders query: [page, external_name, updated_at_start, updated_at_end, shopify_order_id]

operation_id: get_order

method: GET path: /orders/{order_id}

operation_id: create_order

method: POST path: /orders

operation_id: update_order

method: PUT path: /orders/{order_id}

operation_id: update_shopify_order

method: PUT path: /shopify_orders/{shopify_order_id} items: operations:

operation_id: list_items

method: GET path: /items query: [page, shopify_variant_id, external_name]

operation_id: get_item

method: GET path: /items/{item_id}

operation_id: create_item

method: POST path: /items

operation_id: update_item

method: PUT path: /items/{item_id}

operation_id: delete_item

method: DELETE path: /items/{item_id} payment_items: operations:

operation_id: list_payment_items

method: GET path: /payment_items

operation_id: get_payment_item

method: GET path: /payment_items/{payment_item_id} inventory: operations:

operation_id: list_inventory_history

method: GET path: /items/inventory required_query: [start, end]

operation_id: get_item_inventory_history

method: GET path: /items/inventory/{item_id} required_query: [start, end] item_quantities: operations:

operation_id: list_item_quantities

method: GET path: /items/item_quantities

operation_id: get_item_quantity_history

method: GET path: /items/{item_id}/item_quantities