Go to www.exsited.com Book a Demo
Developers
» Item Module SDK Documentation
     
Introduction
Installation
Python
PHP
GitHub
Composer
Documentation
Account
Item
Item Fulfillment
Item Receipts
Order
Usage
Express
Invoice
Payment
Credit Note
Refund
Purchase Order
Purchase Invoice
Purchase Payment
Purchase Credit Notes
Purchase Refund
Gift Certificate
Return Merchandise Authorizations
RVA
Settings
Integration
Portal
Communications
Reports
Proforma
Custom Development
Custom Component
Custom Attribute
Custom Object
Custom Database

Getting Item List

Function: item_list()

Purpose

This SDK function retrieves a comprehensive list of all items configured within the system using the list() method of the ExsitedSDK. It is primarily used for inventory, pricing, and configuration review.

Parameters

This function does not require any input parameters.

Use Case

The item_list() function is used to fetch all item records available in the system. It is useful for users who want to display or review product information, pricing structure, unit of measurement details, inventory levels, or purchase configurations. This is typically used by inventory managers, procurement staff, or billing modules where item-based filtering or display is needed. The list may also be used to allow selection of items during order creation or product configuration.

php

def item_list():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False
    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
    try:
        response = exsited_sdk.item.list()
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

The response returns a list of all items with detailed configurations. Each item includes its name, type, base unit of measurement (UOM), sales charge and pricing details, purchase tax settings, and inventory information such as available quantity and warehouse data. These details support operations like product display, order processing, and stock management. On failure, an ABException is raised with error details and raw response for debugging.

ItemListResponseDTO(
  items = [
    ItemDataDTO(
      status = "ITEM_STATUS",
      id = "ITEM_ID",
      name = "ITEM_NAME",
      displayName = "ITEM_DISPLAY_NAME",
      description = "ITEM_DESCRIPTION",
      type = "ITEM_TYPE",
      baseUom = "ITEM_BASE_UOM",
      parentItemId = None,
      origin = "ITEM_ORIGIN",
      createdBy = "CREATED_BY",
      createdOn = "CREATED_ON",
      lastUpdatedBy = "LAST_UPDATED_BY",
      lastUpdatedOn = "LAST_UPDATED_ON",
      uuid = "ITEM_UUID",
      version = "ITEM_VERSION",
      imageUri = "ITEM_IMAGE_URI",
      group = None,
      manager = None,
      customForm = CustomFormDTO(
        name = "CUSTOM_FORM_NAME",
        uuid = "CUSTOM_FORM_UUID"
      ),
      customAttributes = [
        CustomAttributesDTO(name = "ATTRIBUTE_NAME_1", value = "ATTRIBUTE_VALUE_1"),
        CustomAttributesDTO(name = "ATTRIBUTE_NAME_2", value = "ATTRIBUTE_VALUE_2"),
        CustomAttributesDTO(name = "ATTRIBUTE_NAME_3", value = "ATTRIBUTE_VALUE_3")
      ],
      customObjects = [],
      codes = [
        CodesDTO(name = "CODE_NAME_1", value = "CODE_VALUE_1"),
        CodesDTO(name = "CODE_NAME_2", value = "CODE_VALUE_2")
      ],
      uoms = [],
      currencies = [
        CurrenciesDTO(
          name = "CURRENCY_NAME",
          suppliers = None,
          usedForSale = "true",
          defaultForSale = "true",
          usedForPurchase = "true",
          defaultForPurchase = "false",
          isUsedForSale = None,
          isDefaultForSale = None,
          isUsedForPurchase = None,
          isDefaultForPurchase = None
        )
      ],
      sale = SaleDTO(
        isEnable = None,
        enabled = "true",
        invoiceNote = "SALE_INVOICE_NOTE",
        accountingCode = AccountingCodeDTO(salesRevenue = None),
        defaultSalePrice = "DEFAULT_SALE_PRICE",
        shippingProfile = "SHIPPING_PROFILE",
        taxExemptWhenSold = "false",
        pricingMethod = "STANDARD",
        taxConfiguration = SaleTaxConfigurationDTO(
          salePriceEnteredIsInclusiveOfTax = None,
          salePriceIsBasedOn = None,
          taxCode = None
        ),
        pricingProfile = None,
        pricingSchedules = None,
        pricingLevels = None,
        charge = SaleChargeDTO(
          type = "RECURRING",
          pricePeriod = "",
          properties = [
            SaleChargePropertiesDTO(name = "PROPERTY_NAME_1", value = "PROPERTY_VALUE_1"),
            SaleChargePropertiesDTO(name = "PROPERTY_NAME_2", value = "PROPERTY_VALUE_2")
          ]
        ),
        paymentProperties = [
          SaleChargePropertiesDTO(name = "PAYMENT_PROPERTY_NAME_1", value = "PAYMENT_PROPERTY_VALUE_1"),
          SaleChargePropertiesDTO(name = "PAYMENT_PROPERTY_NAME_2", value = "PAYMENT_PROPERTY_VALUE_2")
        ],
        discountProfile = {},
        pricing = PricingDTO(
          type = "PRICING_TYPE",
          version = "PRICING_VERSION",
          latestUsedPricingVersion = "",
          pricingModule = []
        ),
        width = None,
        height = None,
        length = None,
        weight = None,
        useOnSalePrice = "false",
        salePriceVariant = "",
        salePrice = "",
        startDate = "",
        endDate = ""
      ),
      purchase = PurchaseDTO(
        isEnable = None,
        enabled = "true",
        enableSupplierManagement = None,
        supplierManagementIsEnabled = None,
        accountingCode = AccountingCodeDTO(salesRevenue = None),
        purchaseOrderNote = "PURCHASE_NOTE",
        defaultPurchasePrice = "DEFAULT_PURCHASE_PRICE",
        defaultPurchaseCurrency = None,
        taxExemptWhenPurchase = None,
        taxConfiguration = PurchaseTaxConfigurationDTO(
          purchasePriceEnteredIsInclusiveOfTax = None,
          taxCode = None
        ),
        pricingProfile = None,
        purchaseProperties = [
          PurchasePropertiesDTO(name = "RECEIVE_MODE", value = "MANUAL"),
          PurchasePropertiesDTO(name = "RECEIVE_TERM", value = "Immediately")
        ],
        pricing = PricingDTO(
          type = "PER_UNIT_PRICING",
          version = "1",
          latestUsedPricingVersion = "",
          pricingModule = []
        ),
        suppliers = None,
        isTaxExemptWhenPurchase = None,
        isEnabled = None
      ),
      inventories = None,
      kpis = KpisDTO(
        totalRevenue = 0,
        totalOrders = 0,
        activeOrders = 3345,
        totalCollected = 0,
        totalOutstanding = 0,
        totalOverdue = 0
      ),
      invoiceNote = "ITEM_INVOICE_NOTE",
      pricingLevels = None,
      accountingCode = None,
      defaultSalePrice = None,
      isTaxExemptWhenSold = None,
      pricing_method = None,
      pricing_schedules = None,
      charge = None,
      paymentProperties = None,
      pricing = None,
      isUsedForSale = None,
      isDefaultForSale = None,
      isUsedForPurchase = None,
      isDefaultForPurchase = None,
      isEnabled = None,
      isLinked = None
    )
  ],
  pagination = PaginationDTO(
    records = 8,
    limit = 20,
    offset = 0,
    previousPage = "PREVIOUS_PAGE",
    nextPage = "NEXT_PAGE"
  )
)

Getting Item Purchase Details

Function: item_purchase_details()

Purpose

This endpoint retrieves detailed purchase-related information for a specific item. It provides insights into the item’s purchase configuration, such as whether purchasing is enabled, supplier management status, applicable tax codes, pricing profiles, and purchase properties. This information helps businesses understand how an item is managed during procurement, including its default purchase price, purchase currency, and associated tax configurations. The endpoint can be accessed using the Python or PHP SDK to easily fetch purchase details by providing the unique item ID.

Parameters

Parameter Type Description
item_id string Unique identifier of the item for which purchase details need to be retrieved.

Use Case

This endpoint is useful when an organization wants to review or validate the purchase configuration of a specific item before creating purchase orders or performing supplier management operations. For example, an administrator might use it to check whether purchasing is enabled, confirm the applicable tax rate, and review the current purchase pricing settings. By using the SDK, developers can quickly retrieve this information to display in internal dashboards, validate procurement rules, or ensure synchronization between systems.

def item_purchase_details():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "{{TOKEN_FILE_PATH}}"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.item.purchase(id="{{ITEM_ID}}")
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

A successful response returns detailed purchase configuration data for the specified item. This includes whether purchasing is enabled, the default purchase price, supplier management settings, and applicable tax codes. It also provides pricing information such as pricing type, version, and currency, along with purchase properties that define how items are received (for example, manually or immediately). The SDK automatically structures this data for easy access and readability within your application.

{
  "item": {
    "purchase": {
      "enabled": "{{ENABLED_STATUS}}",
      "supplier_management_enabled": "{{SUPPLIER_MANAGEMENT_STATUS}}",
      "accounting_code": {},
      "purchase_order_note": "{{PURCHASE_ORDER_NOTE}}",
      "default_purchase_price": "{{DEFAULT_PURCHASE_PRICE}}",
      "tax_configuration": {
        "purchase_price_entered_inclusive_of_tax": "{{INCLUSIVE_TAX_STATUS}}",
        "tax_code": {
          "uuid": "{{TAX_CODE_UUID}}",
          "code": "{{TAX_CODE}}",
          "rate": "{{TAX_RATE}}",
          "link": "{{TAX_CODE_LINK}}"
        }
      },
      "pricing_profile": {},
      "purchase_properties": [
        {
          "name": "{{PURCHASE_PROPERTY_NAME_1}}",
          "value": "{{PURCHASE_PROPERTY_VALUE_1}}"
        },
        {
          "name": "{{PURCHASE_PROPERTY_NAME_2}}",
          "value": "{{PURCHASE_PROPERTY_VALUE_2}}"
        }
      ],
      "pricing": {
        "type": "{{PRICING_TYPE}}",
        "version": "{{PRICING_VERSION}}",
        "latest_used_pricing_version": "{{LATEST_USED_PRICING_VERSION}}",
        "pricing_module": [
          {
            "price": "{{PRICE_VALUE}}",
            "price_type": "{{PRICE_TYPE}}",
            "currency": "{{CURRENCY}}"
          }
        ]
      }
    }
  }
}

Getting All Item Notes

Function: item_notes()

Purpose

This endpoint retrieves all notes associated with a specific item, including metadata such as the note’s UUID, version, HTML-supported content, attached files (if any), creator details, timestamps, and custom attributes. Pagination details are also included to handle large result sets. The SDK functions provide a convenient wrapper around the API, ensuring authentication, error handling, and data mapping into structured DTOs or arrays.

Parameters

Parameter Type Description
item_id string The unique identifier of the item for which notes need to be retrieved.

Use Case

When you need to retrieve all notes tied to a particular item—for example, a warehouse manager pulling maintenance records, or a field inspector checking previous annotations before updating an inspection—you can use this endpoint. It returns not just the content of notes but also who created them, when they were created, and any attachments. This helps ensure a full audit trail and context for decision-making. Pagination ensures performance and scalability when dealing with many notes. Using the SDK, you can access this data seamlessly in both Python and PHP.

def item_notes():
    from exsited_sdk import ExsitedSDK, SDKConfig, FileTokenManager, CommonData
    from exsited_sdk.exceptions import ABException

    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "{{TOKEN_FILE_PATH}}"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.notes.item_note_details(id="{{ITEM_ID}}")
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

The response provides an item object containing a list of notes and pagination metadata. Each note entry includes a unique identifier, version number, note content (with HTML support), optional file attachments, and details of who created or updated it and when. Pagination ensures that only the requested number of records is returned at once, with links to previous and next pages if applicable. The SDK parses this into well-defined DTOs in Python or associative arrays in PHP, making the data easier to manipulate in your application.

ItemNoteDetailsDTO(
    item=ItemNoteDataDTO(
        notes=[
            NoteDataDTO(
                uuid="{{NOTE_UUID}}",
                version="{{NOTE_VERSION}}",
                content="{{NOTE_CONTENT}}",
                files=[],
                createdBy="{{CREATED_BY}}",
                createdOn="{{CREATED_ON}}",
                lastUpdatedBy="{{LAST_UPDATED_BY}}",
                lastUpdatedOn="{{LAST_UPDATED_ON}}"
            )
        ],
        pagination=PaginationDTO(
            records={{TOTAL_RECORDS}},
            limit={{LIMIT}},
            offset={{OFFSET}},
            previousPage="{{PREVIOUS_PAGE}}",
            nextPage="{{NEXT_PAGE}}"
        )
    )
)

Getting Specific Note for a Specific Item

Function: item_note_details()

Purpose

This endpoint allows you to retrieve details of a specific note associated with an item by providing both the item_id and the unique note_uuid. It is typically used when you need to access or display the full content, metadata, and any file attachments of a single note rather than fetching the entire notes list.

Parameters

Parameter Type Description
item_id string Unique identifier of the item to which the note belongs.
note_uuid string Unique identifier (UUID) of the note to retrieve.

Use Case

Suppose you have a system where users log notes on items (such as inspection records, comments, or audit history). If a user wants to view the full details of one specific note, you can use this endpoint by passing the item_id and note_uuid. The SDKs (Python and PHP) abstract the API call so you can fetch this information directly without manually building the HTTP request.

def item_note_details():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "shared_token.json"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.notes.item_note_uuid_details(
            id="{{ITEM_ID}}",
            uuid="{{NOTE_UUID}}"
        )
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

The response returns the details of the requested note, including its unique identifiers, content (HTML supported), version number, creator info, timestamps, attached files, and optional custom attributes. Pagination is not included here since this endpoint is for a single note. Both SDKs format the data into structured DTOs or JSON for easier consumption.

ItemNoteUuidDetailsDTO(
    item=ItemNoteUuidDataDTO(
        note=NoteDataDTO(
            uuid="{{NOTE_UUID}}",
            version="{{VERSION_NUMBER}}",
            content="{{NOTE_CONTENT_HTML}}",
            files=[],
            createdBy="{{CREATED_BY}}",
            createdOn="{{CREATED_ON_TIMESTAMP}}",
            lastUpdatedBy="{{LAST_UPDATED_BY}}",
            lastUpdatedOn="{{LAST_UPDATED_ON_TIMESTAMP}}"
        )
    )
)

Getting All Files of a Specific Note of a Specific Item

Function: item_note_files()

Purpose

This function retrieves the list of files attached to a specific note of an item. It allows developers to fetch metadata for each file, including UUID, file name, and version, as well as any custom attributes associated with the note. The SDK handles authentication, request building, and response parsing, making it easier to integrate file retrieval functionality into applications without directly interacting with the raw API.

Parameters

Parameter Type Description
id string Unique identifier of the item to which the note belongs.
uuid string Unique identifier (UUID) of the note whose files are being retrieved

Use Case

In a field service inspection or workflow management system, each item may have multiple notes with attached files such as images, PDFs, or documents. A developer can use this SDK function to programmatically retrieve these files and display them in a web or mobile application. This ensures users can access the latest files, track file versions, and utilize metadata for auditing or processing. Using the SDK abstracts away raw HTTP requests and authentication details, allowing developers to focus on business logic.

def item_note_files():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "<PATH_TO_TOKEN_FILE>"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.notes.item_note_uuid_files_details(
            id="<ITEM_ID>",
            uuid="<NOTE_UUID>"
        )
        print(response)
    except Exception as e:
        print("Error:", e)

Response

The SDK returns an object containing the requested note's file metadata. Each file object includes its UUID, file name, and version. The Python SDK returns strongly typed DTO objects, whereas the PHP SDK returns an associative array with the same structure. In addition, the PHP SDK may include an autobillCredential object containing token information and API URLs for internal SDK handling. The response can be used to display file lists, download files, or track versions programmatically.

ItemNoteUuidFileDetailsDTO(
    item=ItemNoteUuidFileDataDTO(
        note=NoteFileDataDTO(
            files=[
                FileDTO(
                    uuid='<FILE_UUID>',
                    name='<FILE_NAME>',
                    version='<FILE_VERSION>'
                )
            ]
        )
    )
)

Getting Item Note File Details

Function: item_note_file_details()

Purpose

This endpoint allows you to retrieve the details of a specific file attached to a note within an item. It is useful when you need to fetch file metadata (UUID, name, version) linked to a particular note on an item, rather than listing all files. This helps applications display, verify, or further process the exact file attached to a note.

Parameters

Parameter Type Description
item_id string Unique identifier of the item to which the note belongs.
note_uuid string Unique identifier (UUID) of the note that contains the file.
file_uuid string Unique identifier (UUID) of the file attached to the note.

Use Case

Consider a field service or inspection system where images or documents are uploaded as file attachments to notes. If a user needs to retrieve the metadata of one specific file — for example, to verify the uploaded image name, check the version, or prepare for download — this endpoint provides the structured file information. The SDK methods in both Python and PHP simplify calling this endpoint by accepting the required identifiers as parameters.

def item_note_file_details():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "shared_token.json"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.notes.item_note_uuid_files_uuid_details(
            id="{{ITEM_ID}}",
            uuid="{{NOTE_UUID}}",
            file_uuid="{{FILE_UUID}}"
        )
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

The response provides metadata of the requested file. This includes its unique identifier (uuid), the original filename, and the file’s version number. In addition, custom attributes may be present if defined in your implementation. The SDKs return the response either as DTO objects (Python) or JSON objects (PHP), making it easy to process or display file details.

ItemNoteUuidFileUuidDetailsDTO(
    item=ItemNoteUuidFileUuidDataDTO(
        note=NoteFileUuidDataDTO(
            file=FileDTO(
                uuid="{{FILE_UUID}}",
                name="{{FILE_NAME}}",
                version="{{FILE_VERSION}}"
            )
        )
    )
)

Retrieve Standard Item

Function: item_standard()

Purpose

This SDK function retrieves the full details of a specific standard item using the standard() method of the ExsitedSDK. It is typically used to view all configurations associated with a single item.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-001"

Use Case

This function is used when the user needs to fetch and view all configuration details of a particular item by referencing its ID. It provides complete visibility into the item's properties including unit of measurement, sales and purchase settings, tax information, inventory structure, and accounting configuration. This is useful for product management, pricing analysis, and ensuring data consistency across modules.

def item_standard():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False
    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(request_token_dto=CommonData.get_request_token_dto())
    try:
        response = exsited_sdk.item.standard(id='ITEM-001')
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response contains full information about the specified item, including its identifier, type, name, base unit of measurement, and all associated configurations. These may include pricing details, sale and purchase charge types, tax structures, inventory handling options, and related warehouse or accounting codes. This information allows users to verify or update item definitions, review compliance with pricing or inventory policies, and support integration with sales or procurement systems. If the item ID is invalid or access is restricted, the function raises an ABException with relevant error messages and raw backend response.

ItemResponseDTO(
  item = ItemDataDTO(
    status = "ITEM_STATUS",
    id = "ITEM_ID",
    name = "ITEM_NAME",
    displayName = "ITEM_DISPLAY_NAME",
    description = "ITEM_DESCRIPTION",
    type = "ITEM_TYPE",
    baseUom = "BASE_UOM",
    parentItemId = None,
    origin = "ITEM_ORIGIN",
    createdBy = "CREATED_BY",
    createdOn = "CREATED_ON",
    lastUpdatedBy = "LAST_UPDATED_BY",
    lastUpdatedOn = "LAST_UPDATED_ON",
    uuid = "ITEM_UUID",
    version = "ITEM_VERSION",
    imageUri = "IMAGE_URI",
    group = None,
    manager = "ITEM_MANAGER",
    customForm = CustomFormDTO(
      name = "CUSTOM_FORM_NAME",
      uuid = "CUSTOM_FORM_UUID"
    ),
    customAttributes = [
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_1", value = "ATTRIBUTE_VALUE_1"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_2", value = "ATTRIBUTE_VALUE_2"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_3", value = "ATTRIBUTE_VALUE_3")
    ],
    customObjects = [],
    codes = [
      CodesDTO(name = "CODE_NAME_1", value = "CODE_VALUE_1"),
      CodesDTO(name = "CODE_NAME_2", value = "CODE_VALUE_2")
    ],
    uoms = [],
    currencies = [],
    sale = None,
    purchase = None,
    inventories = None,
    kpis = KpisDTO(
      totalRevenue = 0,
      totalOrders = 0,
      activeOrders = 0,
      totalCollected = 0,
      totalOutstanding = 0,
      totalOverdue = 0
    ),
    invoiceNote = "INVOICE_NOTE",
    pricingLevels = None,
    accountingCode = None,
    defaultSalePrice = None,
    isTaxExemptWhenSold = None,
    pricing_method = None,
    pricing_schedules = None,
    charge = None,
    paymentProperties = None,
    pricing = None,
    isUsedForSale = None,
    isDefaultForSale = None,
    isUsedForPurchase = None,
    isDefaultForPurchase = None,
    isEnabled = None,
    isLinked = None
  )
)

Create Standard Item

Function: create_item()

Purpose

This SDK function creates a new standard item in the system by using the create() method of the ExsitedSDK. It allows configuration of multiple item attributes such as sales settings, pricing, dimensions, charge and payment details, and default accounting mappings.

Parameters

Parameter
Type
Description
name
String
Internal name of the item (e.g., "SDK Item").
displayName
String
Display name for UI (e.g., "from SDK").
description
String
Description of the item.
type
String
Item type, typically "STANDARD".
origin
String
Origin of the item, such as "NET_SUITE".
invoiceNote
String
Optional note for invoices.
currencies
List of CurrenciesDTO
Currency definitions for sale and purchase, including flags like isUsedForSale, isDefaultForSale, etc.
sale
SaleDTO
Contains sale configuration, pricing, charge type, tax, dimensions, and accounting code.
sale.enabled
String
Indicates if the item is available for sale ("true" or "false").
sale.defaultSalePrice
Float
Default price of the item when sold.
sale.pricingMethod
String
Method used to calculate pricing (e.g., "STANDARD").
sale.charge
SaleChargeDTO
Charge type and related properties such as fulfillment_mode and term.
sale.paymentProperties
List of SaleChargePropertiesDTO
Payment settings like payment_processor, payment_mode, and payment_term.
sale.accountingCode
AccountingCodeDTO
Sales revenue account name.
sale.width / height / length / weight
DimensionDTO
Item physical attributes (UOM and value).
sale.pricing
PricingDTO
Sale pricing strategy and versioning.
sale.pricing.pricingModule
List of PricingModuleDTO
Pricing details by currency and unit of measurement.
sale.pricingLevels
List of PricingLevelDTO
Optional pricing levels (e.g., "Wholesale").

Use Case

The create_item() function is typically used when a new product needs to be programmatically registered in the system with a full set of definitions. For instance, an organization integrating its ERP or e-commerce system may use this function to bulk import catalog items with structured data. By allowing detailed input including currency configurations, sale charge types, fulfillment terms, and dimensional data, this method ensures the item is accurately represented for downstream processes such as pricing, taxation, order fulfillment, and financial reporting. This function helps streamline catalog onboarding, automate product provisioning, and maintain consistency across systems without relying on manual input.

def create_item():
    SDKConfig.PRINT_REQUEST_DATA = False
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto()
    )

    try:
        # Currency setup
        currency = CurrenciesDTO(
            name = "CURRENCY_CODE",  # e.g., "AUD"
            isUsedForSale = "true",
            isDefaultForSale = "true",
            isUsedForPurchase = "true",
            isDefaultForPurchase = "true"
        )

        # Sale charge properties
        sale_charge = SaleChargeDTO(
            type = "CHARGE_TYPE",  # e.g., "ONE_OFF"
            properties = [
                SaleChargePropertiesDTO(name = "fulfillment_mode", value = "FULFILLMENT_MODE"),  # e.g., "MANUAL"
                SaleChargePropertiesDTO(name = "fulfillment_term", value = "FULFILLMENT_TERM")   # e.g., "Net 14"
            ]
        )

        # Pricing module
        pricing_module = PricingModuleDTO(
            price = "ITEM_PRICE",           # e.g., "15.000100"
            currency = "CURRENCY_CODE",     # e.g., "AUD"
            uom = "UOM"                     # e.g., "Grams"
        )
        pricing = PricingDTO(
            type = "PRICING_TYPE",          # e.g., "PER_UNIT_PRICING"
            version = "VERSION",            # e.g., "1"
            latestUsedPricingVersion = "",
            pricingModule = [pricing_module]
        )

        # Sale configuration
        sale_dto = SaleDTO(
            enabled = "true",
            invoiceNote = "SALE_INVOICE_NOTE",
            width = DimensionDTO(uom = "centimeter", value = "ITEM_WIDTH"),
            height = DimensionDTO(uom = "centimeter", value = "ITEM_HEIGHT"),
            length = DimensionDTO(uom = "centimeter", value = "ITEM_LENGTH"),
            weight = DimensionDTO(uom = "kilogram", value = "ITEM_WEIGHT"),
            accountingCode = AccountingCodeDTO(salesRevenue = "REVENUE_ACCOUNT"),
            defaultSalePrice = "DEFAULT_SALE_PRICE",  # e.g., "100.0"
            taxExemptWhenSold = "true",
            pricingMethod = "PRICING_METHOD",         # e.g., "STANDARD"
            pricingSchedules = ["true"],
            charge = sale_charge,
            paymentProperties = [
                SaleChargePropertiesDTO(name = "payment_processor", value = "PAYMENT_PROCESSOR"),
                SaleChargePropertiesDTO(name = "payment_mode", value = "PAYMENT_MODE"),          # e.g., "MANUAL"
                SaleChargePropertiesDTO(name = "payment_term", value = "PAYMENT_TERM")           # e.g., "Net 30"
            ],
            pricing = pricing,
            pricingLevels = [PricingLevelDTO(name = "PRICING_LEVEL")]  # e.g., "Wholesale"
        )

        # Item object
        item = ItemDataDTO(
            name = "ITEM_NAME",                     
            displayName = "ITEM_DISPLAY_NAME",          
            description = "ITEM_DESCRIPTION",
            type = "ITEM_TYPE",                         
            origin = "ITEM_ORIGIN",                     
            invoiceNote = "ITEM_INVOICE_NOTE",
            currencies = [currency],
            sale = sale_dto
        )

        request_obj = ItemActionDTO(items = item)
        response = exsited_sdk.item.create(request_data = request_obj)
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)
Response 

The response returns confirmation of item creation along with metadata such as id, status, uuid, type, name, customForm, and other item properties. On success, the response can be used to retrieve or update the item using its ID. If validation fails (e.g., missing fields, invalid UOM, or pricing errors), an ABException is raised, containing structured error messages and raw server response for debugging. This output helps developers to trace data issues and take corrective actions accordingly. 

ItemResponseDTO(
  item = ItemDataDTO(
    status = "ITEM_STATUS",
    id = "ITEM_ID",
    name = "ITEM_NAME",
    displayName = "ITEM_DISPLAY_NAME",
    description = "ITEM_DESCRIPTION",
    type = "ITEM_TYPE",
    baseUom = "BASE_UOM",
    parentItemId = None,
    origin = "ITEM_ORIGIN",
    createdBy = "CREATED_BY",
    createdOn = "CREATED_ON",
    lastUpdatedBy = "LAST_UPDATED_BY",
    lastUpdatedOn = "LAST_UPDATED_ON",
    uuid = "ITEM_UUID",
    version = "ITEM_VERSION",
    imageUri = "IMAGE_URI",
    group = None,
    manager = "ITEM_MANAGER",
    customForm = CustomFormDTO(
      name = "CUSTOM_FORM_NAME",
      uuid = "CUSTOM_FORM_UUID"
    ),
    customAttributes = [
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_1", value = "ATTRIBUTE_VALUE_1"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_2", value = "ATTRIBUTE_VALUE_2"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_3", value = "ATTRIBUTE_VALUE_3"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_4", value = "ATTRIBUTE_VALUE_4"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_5", value = "ATTRIBUTE_VALUE_5"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_6", value = "ATTRIBUTE_VALUE_6"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_7", value = "ATTRIBUTE_VALUE_7")
    ],
    customObjects = [],
    codes = [
      CodesDTO(name = "CODE_TYPE_1", value = "CODE_VALUE_1"),
      CodesDTO(name = "CODE_TYPE_2", value = "CODE_VALUE_2")
    ],
    uoms = [],
    currencies = [],
    sale = None,
    purchase = None,
    inventories = None,
    kpis = KpisDTO(
      totalRevenue = 0,
      totalOrders = 0,
      activeOrders = 0,
      totalCollected = 0,
      totalOutstanding = 0,
      totalOverdue = 0
    ),
    invoiceNote = "INVOICE_NOTE",
    pricingLevels = None,
    accountingCode = None,
    defaultSalePrice = None,
    isTaxExemptWhenSold = None,
    pricing_method = None,
    pricing_schedules = None,
    charge = None,
    paymentProperties = None,
    pricing = None,
    isUsedForSale = None,
    isDefaultForSale = None,
    isUsedForPurchase = None,
    isDefaultForPurchase = None,
    isEnabled = None,
    isLinked = None
  )
)

Creating Item Sale

Function: create_item_sale()

Purpose

This endpoint is used to create or configure the sale-related details of a specific item. It allows users to define how an item is sold, including its pricing, charge type, applicable tax configurations, and sale properties such as currency, pricing type, and accounting code. Using this endpoint, businesses can manage the sales structure of their items programmatically, ensuring consistent setup across systems. The endpoint can be accessed via the Python or PHP SDK to streamline item sale setup operations.

Parameters

ParameterTypeDescription
item_idstringUnique identifier of the item for which purchase details need to be retrieved.

Use Case

This endpoint is typically used when an organization wants to set up or update how an item is sold in the system. For instance, before launching a new product or updating its sales configuration, an administrator can define all sale-related settings, such as enabling sales, setting default sale prices, choosing applicable tax codes, and specifying charge and pricing modules. This ensures the item is correctly configured for order processing, invoicing, and accounting. The SDK allows developers to automate this process as part of product catalog setup or integration workflows.

def create_item_sale():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "{{TOKEN_FILE_PATH}}"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        currencies = [
            CurrenciesDTO(
                name="{{CURRENCY_NAME}}",
                usedForSale="true",
                defaultForSale="true"
            )
        ]

        uoms = []

        sale_charge = SaleChargeDTO(type="{{CHARGE_TYPE}}")

        sale_pricing_module = PricingModuleDTO(
            price="{{PRICE_VALUE}}",
            currency="{{CURRENCY_NAME}}"
        )

        sale_pricing = PricingDTO(
            type="{{PRICING_TYPE}}",
            pricingModule=[sale_pricing_module]
        )

        sale_tax_config = SaleTaxConfigurationDTO(
            salePriceEnteredIsInclusiveOfTax="true",
            salePriceIsBasedOn="SPECIFIC_TAX_CODE",
            taxCode=TaxCodeDTO(
                uuid="{{TAX_CODE_UUID}}",
                code="{{TAX_CODE}}",
                rate="{{TAX_RATE}}"
            )
        )

        sale_dto = SaleDTO(
            enabled="true",
            invoiceNote="{{INVOICE_NOTE}}",
            accountingCode="{{ACCOUNTING_CODE}}",
            defaultSaleCurrency="{{DEFAULT_CURRENCY}}",
            defaultSalePrice="{{DEFAULT_SALE_PRICE}}",
            taxExemptWhenSold="false",
            pricingMethod="{{PRICING_METHOD}}",
            charge=sale_charge,
            pricing=sale_pricing,
            useOnSalePrice="true",
            salePriceVariant="{{SALE_PRICE_VARIANT}}",
            salePrice="{{SALE_PRICE}}",
            startDate="{{START_DATE}}",
            endDate="{{END_DATE}}",
            taxConfiguration=sale_tax_config
        )

        item_data_dto = ItemDataDTO(
            name="{{ITEM_NAME}}",
            displayName="{{DISPLAY_NAME}}",
            description="{{ITEM_DESCRIPTION}}",
            type="{{ITEM_TYPE}}",
            origin="{{ITEM_ORIGIN}}",
            invoiceNote="{{ITEM_INVOICE_NOTE}}",
            currencies=currencies,
            uoms=uoms,
            sale=sale_dto
        )

        request_obj = ItemActionDTO(items=item_data_dto)
        response = exsited_sdk.item.sale_create(id="{{ITEM_ID}}", request_data=request_obj)
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

A successful response confirms that the sale configuration for the item has been successfully created or updated. The response includes details of the item, such as its name, type, description, and sale configuration parameters including pricing, charge, and tax details. It also includes the configured currencies, sale price, and validity dates. This response helps verify that all sale settings have been applied correctly for the item.

{
  "items": {
    "name": "{{ITEM_NAME}}",
    "display_name": "{{DISPLAY_NAME}}",
    "description": "{{ITEM_DESCRIPTION}}",
    "type": "{{ITEM_TYPE}}",
    "origin": "{{ITEM_ORIGIN}}",
    "uoms": [],
    "currencies": [
      {
        "name": "{{CURRENCY_NAME}}",
        "used_for_sale": "true",
        "default_for_sale": "true"
      }
    ],
    "sale": {
      "enabled": "true",
      "invoice_note": "{{INVOICE_NOTE}}",
      "accounting_code": "{{ACCOUNTING_CODE}}",
      "default_sale_currency": "{{DEFAULT_CURRENCY}}",
      "default_sale_price": "{{DEFAULT_SALE_PRICE}}",
      "tax_exempt_when_sold": "false",
      "pricing_method": "{{PRICING_METHOD}}",
      "tax_configuration": {
        "sale_price_entered_is_inclusive_of_tax": "true",
        "sale_price_is_based_on": "SPECIFIC_TAX_CODE",
        "tax_code": {
          "uuid": "{{TAX_CODE_UUID}}",
          "code": "{{TAX_CODE}}",
          "rate": "{{TAX_RATE}}"
        }
      },
      "charge": {
        "type": "{{CHARGE_TYPE}}"
      },
      "pricing": {
        "type": "{{PRICING_TYPE}}",
        "pricing_module": [
          {
            "price": "{{PRICE_VALUE}}",
            "currency": "{{CURRENCY_NAME}}"
          }
        ]
      },
      "use_on_sale_price": "true",
      "sale_price_variant": "{{SALE_PRICE_VARIANT}}",
      "sale_price": "{{SALE_PRICE}}",
      "start_date": "{{START_DATE}}",
      "end_date": "{{END_DATE}}"
    },
    "invoice_note": "{{ITEM_INVOICE_NOTE}}"
  }
}

Creating Item Inventory

Function: create_item_inventory()

Purpose

This endpoint is used to create or configure inventory details for a specific item in the system. It allows users to enable inventory tracking, associate the item with one or more warehouses, define inventory-related rules such as reordering thresholds, low-stock alerts, and warehouse defaults, and control how stock quantities are managed across the business. This API is crucial for setting up items that require stock management and warehouse-level tracking to ensure operational accuracy in sales, purchases, and reordering workflows.

Parameters

ParameterTypeDescription
item_idstringUnique identifier of the item for which purchase details need to be retrieved.

Use Case

This endpoint is typically used when adding or configuring inventory settings for a new or existing item. For example, when a business introduces a new product to be tracked across multiple warehouses, the administrator can define where it will be stored, whether inventory tracking is enabled, the default warehouse for transactions, and rules for low-stock notifications or automatic reordering. Using this API through the SDK allows seamless automation of warehouse setup and inventory management for large product catalogs or integrations with ERP systems.

def create_item_inventory():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "{{TOKEN_FILE_PATH}}"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        request_obj = ItemInventoryResponseDTO(
            item=InventoryResponseDTO(
                inventories=InventoriesDTO(
                    isEnabled="true",
                    warehouseIsEnabled="true",
                    warehouses=[InventoryWarehouseDTO(
                        name="{{WAREHOUSE_NAME}}"
                    )],
                    defaultWarehouse="{{DEFAULT_WAREHOUSE_NAME}}",
                    inventoryProperties=InventoryPropertiesDTO(
                        enableLowStockNotification="true",
                        lowStockThresholdIsBasedOn="ALL_WAREHOUSE",
                        lowStockThreshold="{{LOW_STOCK_THRESHOLD}}",
                        enableReordering="true",
                        reorderingThresholdIsBasedOn="ALL_WAREHOUSE",
                        quantityAvailableForSaleDetermination=[
                            "QUANTITY_ON_HAND",
                            "QUANTITY_PROMISED",
                            "QUANTITY_ON_ORDER",
                            "QUANTITY_ON_RETURN"
                        ],
                        stockRequiredForSale="QUANTITY_AVAILABLE",
                        useLastPurchasePrice="true",
                        reorderingThreshold="{{REORDER_THRESHOLD}}",
                        enablePreordering="false",
                        enableSerialization="true",
                        enableBatchTracking="false",
                        useAtpAsQuantityAvailableForWebhook="true"
                    )
                )
            )
        )

        response = exsited_sdk.item.inventories(
            id="{{ITEM_ID}}",
            request_data=request_obj
        )
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

A successful response confirms that the inventory setup for the specified item has been successfully created or updated. The response contains detailed information about the item’s inventory configuration, including its enabled status, associated warehouses, default warehouse, and inventory properties such as thresholds, reordering rules, and quantity calculation methods. This information verifies that the item is correctly configured for warehouse-level stock management and ready for operational use.

{
  "item": {
    "inventories": {
      "isEnabled": "true",
      "warehouse_isEnabled": "true",
      "warehouses": [
        {
          "name": "{{WAREHOUSE_NAME}}",
          "uuid": "{{WAREHOUSE_UUID}}",
          "link": "{{WAREHOUSE_LINK}}",
          "quantity_on_hand": "0",
          "quantity_promised": "0",
          "quantity_on_order": "0",
          "quantity_on_return": "0",
          "quantity_on_purchase_return": "0",
          "quantity_available": "0",
          "uom": ""
        }
      ],
      "inventory_properties": {
        "quantity_available_for_sale_determination": [
          "QUANTITY_ON_HAND",
          "QUANTITY_PROMISED",
          "QUANTITY_ON_ORDER",
          "QUANTITY_ON_RETURN"
        ],
        "quantity_available_for_sale": "UNLIMITED",
        "enable_low_stock_notification": "true",
        "low_stock_threshold_is_based_on": "ALL_WAREHOUSE",
        "enable_reordering": "true",
        "reordering_threshold_is_based_on": "ALL_WAREHOUSE",
        "low_stock_threshold": "{{LOW_STOCK_THRESHOLD}}",
        "use_last_purchase_price": "true",
        "preferred_supplier": "",
        "reordering_threshold": "{{REORDER_THRESHOLD}}"
      }
    }
  }
}

Retrieve Item Information by ID

Function: item_information()

Purpose

This SDK function retrieves general information about a specific item using the information() method of the ExsitedSDK. It returns a summarized view of the item, including key identifiers, display metadata, origin, type, and other core attributes.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-0012"

Use Case

The item_information() function is typically used to obtain a concise overview of an item for display, validation, or quick reference in other workflows. This function is useful in dashboards, item selection menus, catalog views, or summary reports where only the core item metadata is required without the deeper configuration layers such as sales, purchase, or tax settings. It helps validate that the item exists, confirm naming and origin, and retrieve base-level identifiers to feed into other SDK or UI components. This improves performance and usability in systems where full item data is not immediately necessary.

def item_information():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto = CommonData.get_request_token_dto()
    )

    try:
        response = exsited_sdk.item.information(id = "ITEM_ID")  # e.g., "ITEM-0012"
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response returns high-level item information such as id, name, displayName, description, type, and origin. It may also include status, creation timestamps, or other reference fields useful for identifying and working with the item. This streamlined payload is especially suitable for lightweight queries or applications that only need an item’s basic definition. If the specified id does not match any item, or the user lacks access rights, an ABException is raised containing error details and the original server response to aid in debugging.

ItemResponseDTO(
  item = ItemDataDTO(
    status = "ITEM_STATUS",
    id = "ITEM_ID",
    name = "ITEM_NAME",
    displayName = "ITEM_DISPLAY_NAME",
    description = "ITEM_DESCRIPTION",
    type = "ITEM_TYPE",
    baseUom = "BASE_UOM",
    parentItemId = "PARENT_ITEM_ID",
    origin = "ITEM_ORIGIN",
    createdBy = "CREATED_BY",
    createdOn = "CREATED_ON",
    lastUpdatedBy = "LAST_UPDATED_BY",
    lastUpdatedOn = "LAST_UPDATED_ON",
    uuid = "ITEM_UUID",
    version = "ITEM_VERSION",
    imageUri = "IMAGE_URI",
    group = None,
    manager = "ITEM_MANAGER",
    customForm = CustomFormDTO(
      name = "CUSTOM_FORM_NAME",
      uuid = "CUSTOM_FORM_UUID"
    ),
    customAttributes = [
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_1", value = "ATTRIBUTE_VALUE_1"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_2", value = "ATTRIBUTE_VALUE_2"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_3", value = "ATTRIBUTE_VALUE_3"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_4", value = "ATTRIBUTE_VALUE_4"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_5", value = "ATTRIBUTE_VALUE_5"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_6", value = "ATTRIBUTE_VALUE_6"),
      CustomAttributesDTO(name = "ATTRIBUTE_NAME_7", value = "ATTRIBUTE_VALUE_7")
    ],
    customObjects = [],
    codes = [
      CodesDTO(name = "CODE_TYPE_1", value = "CODE_VALUE_1"),
      CodesDTO(name = "CODE_TYPE_2", value = "CODE_VALUE_2")
    ],
    uoms = [],
    currencies = [
      CurrenciesDTO(
        name = "CURRENCY_NAME",
        suppliers = None,
        usedForSale = "USED_FOR_SALE",
        defaultForSale = "DEFAULT_FOR_SALE",
        usedForPurchase = "USED_FOR_PURCHASE",
        defaultForPurchase = "DEFAULT_FOR_PURCHASE",
        isUsedForSale = None,
        isDefaultForSale = None,
        isUsedForPurchase = None,
        isDefaultForPurchase = None
      )
    ],
    sale = None,
    purchase = None,
    inventories = None,
    kpis = KpisDTO(
      totalRevenue = 0,
      totalOrders = 0,
      activeOrders = 0,
      totalCollected = 0,
      totalOutstanding = 0,
      totalOverdue = 0
    ),
    invoiceNote = "INVOICE_NOTE",
    pricingLevels = None,
    accountingCode = None,
    defaultSalePrice = None,
    isTaxExemptWhenSold = None,
    pricing_method = None,
    pricing_schedules = None,
    charge = None,
    paymentProperties = None,
    pricing = None,
    isUsedForSale = None,
    isDefaultForSale = None,
    isUsedForPurchase = None,
    isDefaultForPurchase = None,
    isEnabled = None,
    isLinked = None
  )
)

Get Item Sale Configuration by ID

Function: item_sale()

Purpose

This SDK function fetches the complete sales configuration of a specific item by using the sale() method of the ExsitedSDK. It returns detailed information related to pricing, taxes, payment terms, physical attributes, fulfillment charges, and accounting codes related to item sales.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-0012"

Use Case

The item_sale() function is used when a business process or user interface requires a detailed breakdown of how an item is configured for sale. This includes viewing pricing strategies, dimensions, applicable tax rules, default sale price, fulfillment charge types, and accounting mappings. For instance, in a pricing analysis or quote generation system, this function can be used to dynamically pull pricing modules and levels configured for a product. It is also helpful in administrative tools for validating correct configuration before enabling items for customer-facing platforms. This function plays a key role in maintaining pricing integrity and operational accuracy in sales workflows.

def get_item_sale():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto = CommonData.get_request_token_dto()
    )

    try:
        response = exsited_sdk.item.sale(id = "ITEM_ID")  # e.g., "ITEM-0012"
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response contains the full sales configuration of the specified item. This includes enabled flags, defaultSalePrice, taxExemptWhenSold, pricingMethod, pricingSchedules, pricing modules, charge details, paymentProperties, and physical dimensions (such as width, height, length, and weight). It also includes accountingCode settings to map revenue accounts. If the item ID is invalid or access is denied, an ABException will be raised, returning both structured error details and the raw backend response for diagnostic purposes.

ItemSaleResponseDTO(
  item = SaleResponseDTO(
    sale = SaleDTO(
      isEnable = True,
      enabled = "SALE_ENABLED",
      invoiceNote = "INVOICE_NOTE",
      accountingCode = AccountingCodeDTO(
        salesRevenue = None
      ),
      defaultSalePrice = "DEFAULT_SALE_PRICE",
      shippingProfile = "SHIPPING_PROFILE",
      taxExemptWhenSold = "TAX_EXEMPT_WHEN_SOLD",
      pricingMethod = "PRICING_METHOD",
      taxConfiguration = SaleTaxConfigurationDTO(
        salePriceEnteredIsInclusiveOfTax = None,
        salePriceIsBasedOn = None,
        taxCode = None
      ),
      pricingProfile = {},
      pricingSchedules = None,
      pricingLevels = None,
      charge = SaleChargeDTO(
        type = "CHARGE_TYPE",
        pricePeriod = "PRICE_PERIOD",
        properties = [
          SaleChargePropertiesDTO(name = "FULFILLMENT_MODE", value = "FULFILLMENT_MODE_VALUE"),
          SaleChargePropertiesDTO(name = "FULFILLMENT_TERM", value = "FULFILLMENT_TERM_VALUE")
        ]
      ),
      paymentProperties = [
        SaleChargePropertiesDTO(name = "PAYMENT_PROCESSOR", value = "PAYMENT_PROCESSOR_VALUE"),
        SaleChargePropertiesDTO(name = "PAYMENT_MODE", value = "PAYMENT_MODE_VALUE"),
        SaleChargePropertiesDTO(name = "PAYMENT_TERM", value = "PAYMENT_TERM_VALUE"),
        SaleChargePropertiesDTO(name = "PAYMENT_TERM_ALIGNMENT", value = "PAYMENT_TERM_ALIGNMENT_VALUE")
      ],
      discountProfile = {},
      pricing = PricingDTO(
        type = "PRICING_TYPE",
        version = "PRICING_VERSION",
        latestUsedPricingVersion = "LATEST_USED_PRICING_VERSION",
        pricingModule = []
      ),
      width = DimensionDTO(uom = "WIDTH_UOM", value = "WIDTH_VALUE"),
      height = DimensionDTO(uom = "HEIGHT_UOM", value = "HEIGHT_VALUE"),
      length = DimensionDTO(uom = "LENGTH_UOM", value = "LENGTH_VALUE"),
      weight = DimensionDTO(uom = "WEIGHT_UOM", value = "WEIGHT_VALUE"),
      useOnSalePrice = "USE_ON_SALE_PRICE",
      salePriceVariant = "SALE_PRICE_VARIANT",
      salePrice = "SALE_PRICE",
      startDate = "START_DATE",
      endDate = "END_DATE"
    )
  )
)

Getting Item Inventory Configuration by ID

Function: item_inventory()

Purpose

This SDK function retrieves inventory-related information for a specific item using the inventory() method of the ExsitedSDK. It provides visibility into how the item is managed within the inventory system, including inventory policies, default warehouses, UOM conversions, and related controls.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-0010"

Use Case

The item_inventory() function is primarily used to access inventory control information for an item. This is crucial when managing warehouse operations, syncing with third-party inventory systems, or auditing item availability logic. For example, warehouse managers may rely on this function to determine which units of measure are supported, whether the item is tracked in inventory, and what the default warehouse assignments are. It is also useful in validation processes before allowing transactions such as stock movement, order picking, or goods receipt. By ensuring accurate inventory settings are available, this function supports streamlined operations and better stock traceability across systems.

def get_item_inventories():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto = CommonData.get_request_token_dto()
    )

    try:
        response = exsited_sdk.item.inventory(id = "ITEM_ID")  # e.g., "ITEM-0010"
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response contains inventory-related configuration for the item, which may include whether the item is inventory tracked, the base unit of measure, supported UOM conversions, default warehouse settings, and inventory valuation controls. This data is essential for stock management, movement automation, and integration with ERP or fulfillment platforms. If the item does not exist or the application lacks proper access, the function raises an ABException that includes the structured error list and raw backend response for troubleshooting.

ItemInventoryResponseDTO(
  item = InventoryResponseDTO(
    inventories = InventoriesDTO(
      isEnabled = None,
      enabled = "INVENTORY_ENABLED",
      preorderPeriod = "PREORDER_PERIOD",
      warehouseIsEnabled = None,
      warehouseEnabled = None,
      enableWarehouseManagement = "ENABLE_WAREHOUSE_MANAGEMENT",
      warehouses = [
        InventoryWarehouseDTO(
          name = "WAREHOUSE_NAME",
          uuid = "WAREHOUSE_UUID",
          link = "WAREHOUSE_LINK",
          quantityOnHand = "QUANTITY_ON_HAND",
          quantityOnHandValue = "QUANTITY_ON_HAND_VALUE",
          quantityPromised = "QUANTITY_PROMISED",
          quantityOnOrder = "QUANTITY_ON_ORDER",
          quantityOnReturn = "QUANTITY_ON_RETURN",
          quantityOnPurchaseReturn = "QUANTITY_ON_PURCHASE_RETURN",
          quantityAvailable = "QUANTITY_AVAILABLE",
          quantityAvailableValue = "QUANTITY_AVAILABLE_VALUE",
          uom = "UNIT_OF_MEASURE",
          quantity = None,
          serialNumber = None,
          batchNumber = None,
          expiryDate = None,
          accountingCode = None
        )
      ],
      inventoryProperties = InventoryPropertiesDTO(
        quantityAvailableForSaleDetermination = ["QUANTITY_METRIC"],
        quantityAvailableForSale = "QUANTITY_AVAILABILITY_SETTING",
        enableLowStockNotification = "ENABLE_LOW_STOCK_NOTIFICATION",
        lowStockThresholdIsBasedOn = None,
        enableReordering = "ENABLE_REORDERING",
        reorderingThresholdIsBasedOn = None,
        lowStockThreshold = None,
        stockRequiredForSale = None,
        useLastPurchasePrice = None,
        preferredSupplier = None,
        reorderingThreshold = None,
        enablePreordering = None,
        enableSerialization = "ENABLE_SERIALIZATION",
        enableBatchTracking = "ENABLE_BATCH_TRACKING",
        useAtpAsQuantityAvailableForWebhook = None,
        reorderingThresholdForIndividualWarehouses = None,
        lowStockThresholdForIndividualWarehouses = None,
        preorderPeriod = None,
        preorderConfiguration = None
      ),
      quantity = None,
      serialNumber = None,
      batchNumber = None,
      expiryDate = None,
      accountingCode = None,
      defaultWarehouse = "DEFAULT_WAREHOUSE",
      isBase = None,
      saleConversionRate = None,
      purchaseConversionRate = None,
      isUsedForSale = None,
      isUsedForPurchase = None
    )
  )
)

Deactivate an Item by ID

Function:item_deactivate()

Purpose

This SDK function deactivates an existing item by calling the deactivate() method of the ExsitedSDK. It changes the status of the item so that it is no longer considered active in catalogs, transactions, or workflows where active items are required.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-0011"

Use Case

The function is typically used when an item is discontinued,longer sold or used, or should be temporarily removed from operations without deleting it. For example, a retail system may use this function to mark seasonal or out-of-stock products as inactive. Deactivating an item helps maintain historical data for reporting while ensuring that it is no longer available for selection in transactions or product listings. It supports better data hygiene, prevents operational errors due to obsolete products, and aligns with product lifecycle management practices.

def item_deactivate():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto = CommonData.get_request_token_dto()
    )

    try:
        response = exsited_sdk.item.deactivate(id = "ITEM_ID")  # e.g., "ITEM-0011"
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response confirms that the item has been successfully deactivated. It may include fields such as id, status, or a success message indicating the update was applied. If the item ID is not found, is already inactive, or if the user lacks sufficient permissions, an ABException will be raised with detailed error messages and the backend response to help diagnose the issue.

{'SUCCESS': TRUE, 'STATUS_CODE': 204}

Reactivate an Item by ID

Function: item_reactivate()

Purpose

This SDK function reactivates a previously deactivated item using the reactivate() method of the ExsitedSDK. It restores the item to active status, making it eligible for use in catalogs, sales, inventory, and other workflows.

Parameters

Parameter
Type
Description
id
String
Unique identifier of the item. Example: "ITEM-0011"

Use Case

The item_reactivate() function is used when an item that was previously deactivated—due to discontinuation, seasonality, or stock issues—needs to be brought back into operational use. For example, if a discontinued product becomes available again or a temporarily paused item is ready for resale, this function allows systems to quickly reinstate its active status. This supports lifecycle flexibility and helps prevent the need to recreate item records from scratch. It is particularly useful in retail, manufacturing, and ERP systems where items may go in and out of active circulation due to business dynamics.

def item_reactivate():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto = CommonData.get_request_token_dto()
    )

    try:
        response = exsited_sdk.item.reactivate(id = "ITEM_ID")  # e.g., "ITEM-0011"
        print(response)

    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response 

The response confirms the item's status has been updated from inactive to active. It may include fields such as id, status, or a message confirming successful reactivation. If the item does not exist, is already active, or if permissions are insufficient, the function raises an ABException with validation errors and the raw backend response to help diagnose and resolve the issue.

{'SUCCESS': TRUE, 'STATUS_CODE': 204}

Create Item Note

Function: item_add_note()

Purpose

This endpoint allows you to add a new note to an item, optionally including file attachments. Notes are often used for adding comments, instructions, inspection details, or media references to an item record. By using this method, users can capture both text and supporting documents/images under an item, enabling better traceability and collaboration.

Parameters

Parameter Type Description
item_id string Unique identifier of the item to which the note will be added.
datas string Content of the note (plain text or HTML-formatted string).
file_urls array List of file paths or URLs pointing to files to attach to the note. Optional.

Use Case

Suppose an engineer or inspector needs to document additional details about an item during a field visit. They may add a textual note describing the condition of the item and attach supporting images for verification. Instead of manually uploading files and linking them separately, this API endpoint streamlines the process by saving both the note and file(s) in a single operation. The SDK abstracts away the complexity, allowing developers to pass in note text and file paths directly to attach the note to the item.

def item_add_note():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "shared_token.json"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        datas = "Sample note from Python SDK"
        file_urls = [
            "C:\\Path\\To\\Your\\File.png"
        ]

        response = exsited_sdk.notes.item_add_notes(
            file_urls=file_urls,
            datas=datas,
            item_id="{{ITEM_ID}}"
        )
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

The response returns the UUID of the newly created note under the specified item. This UUID can later be used to retrieve, update, or delete the note, or to access its associated files. The Python SDK represents the response as a DTO object, while the PHP SDK returns a JSON structure along with authentication metadata.

ItemNoteResponseDetailsDTO(
    item=ItemNoteResponseDataDTO(
        notes=NoteDataDTO(
            uuid="{{NOTE_UUID}}",
            version=None,
            content=None,
            files=None,
            createdBy=None,
            createdOn=None,
            lastUpdatedBy=None,
            lastUpdatedOn=None
        )
    )
)

Deleting an Item

Function: item_delete()

Purpose

This API allows you to permanently delete an existing item from the system by providing its unique item ID. Once deleted, the item and its associated data (including pricing, sale, or inventory configurations) will no longer be accessible through the platform. This operation is typically used for cleanup, correction of test data, or removal of items that are no longer valid for sale or inventory tracking.

Parameters

ParameterTypeDescription
item_idstringUnique identifier of the item for which purchase details need to be retrieved.

Use Case

When an item is created for testing, discontinued from sale, or no longer required in the inventory records, users can remove it completely using this API. For example, an organization may have mistakenly added duplicate items or created sample data during integration testing. To maintain clean and accurate records, the SDK’s delete function can be used to remove the specific item by its ID. Both the Python and PHP SDKs provide methods to perform this action easily by calling the corresponding delete function with the item ID as input.

def item_delete():
    SDKConfig.PRINT_REQUEST_DATA = True
    SDKConfig.PRINT_RAW_RESPONSE = False

    token_file_path = "shared_token.json"
    file_token_mgr = FileTokenManager(token_file_path)

    exsited_sdk: ExsitedSDK = ExsitedSDK().init_sdk(
        request_token_dto=CommonData.get_request_token_dto(),
        file_token_mgr=file_token_mgr
    )

    try:
        response = exsited_sdk.item.delete(id='{{item_id_placeholder}}')
        print(response)
    except ABException as ab:
        print(ab)
        print(ab.get_errors())
        print(ab.raw_response)

Response

Upon successful deletion, the API returns a success confirmation with an HTTP status code of 204 (No Content). This indicates that the item was found and successfully removed from the system. There is no content body in the response when deletion succeeds. If the item does not exist or the request is invalid, the system will return an appropriate error message.

{
    "success": true,
    "status_code": 204
}
APIs
SDK
Help Center
Community
Contact Us

©2025 Exsited. All rights reserved.

Terms and Conditions | Privacy Policy

Follow Us: