> ## Documentation Index
> Fetch the complete documentation index at: https://docs.joinluminous.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Close or reopen a purchase-order line

> Close a single purchase-order line **short** — mark the rest of it as no longer expected — or
reopen a previously closed line. Ordered and received quantities are **not** rewritten, so the
purchase order keeps an accurate record of what was ordered versus what actually arrived.

- **Close** — send `closed: true` with a `reason`. The line's `open_quantity` and
  `available_to_allocate` drop to `0`, incoming stock is recounted, and any open allocation pegs
  against the undelivered remainder are shrunk. A reason is required when closing, and a line
  with nothing left to receive cannot be closed.
- **Reopen** — send `closed: false`. The close timestamp and reason are cleared and incoming
  stock is recounted. Allocation pegs removed on close are **not** restored.

While a line is closed, `POST /receiving-reports` refuses any receipt that references it with
`400`; reopen the line first.

Both operations are idempotent: closing an already-closed line or reopening an open one returns
the line's current state unchanged.

`remaining_to_receive` is unaffected by closing; read `open_quantity` for what is still expected.
The full-replace `PUT /purchase-orders/{id}` does not accept a closed flag, so resubmitting a line
there can never close or reopen it by accident.




## OpenAPI

````yaml /api-reference/build.yaml patch /purchase-orders/{purchaseOrderId}/items/{lineItemId}/closed
openapi: 3.0.0
info:
  title: Luminous API
  version: 1.0.0
  description: API documentation for Luminous
servers:
  - url: https://{companyName}.api.joinluminous.com/external/api/v1
    variables:
      companyName:
        default: companyName
        description: Your company-specific subdomain
security: []
tags:
  - name: Products
    description: Get and manage products
  - name: Pricing
    description: Manage price schedules, levels, and customizations
  - name: BOMs
    description: Manage Bills of Materials (BOMs)
  - name: Labels
    description: Label rendering via Labelary ZPL service
  - name: Companies
    description: Manage business accounts and their associated data
  - name: Contacts
    description: Manage contact information for individuals
  - name: Suppliers
    description: Manage suppliers (factories) — vendors used on purchase orders
  - name: Supplier SKUs
    description: Manage per-supplier SKU and unit-cost overrides for products
  - name: Locations
    description: Manage warehouses and locations
  - name: Inventory
    description: Get and adjust product stock levels
  - name: Lots
    description: Create, update, and delete product lots (batches)
  - name: Transfer Orders
    description: Manage transfer orders
  - name: Fulfillment Orders
    description: Manage fulfillment orders and picklists
  - name: Freight
    description: >-
      Freightview LTL freight — quotes, booking and documents for fulfillment
      orders
  - name: Fulfillment Priority Lists
    description: Configure fulfillment routing priority lists
  - name: Purchase Orders
    description: Get and modify purchase orders
  - name: Supplier Portal
    description: >-
      Read a supplier's response to a purchase order and control the one-click
      portal link
  - name: Receiving Reports
    description: Manage receiving reports
  - name: Payment Obligations
    description: Manage payment obligations for purchase orders
  - name: Sales Orders
    description: Manage sales orders and sales order shipments
  - name: Purgatory
    description: >-
      Inspect and resolve non-posted sales orders in the purgatory staging
      workflow
  - name: PickFlow Warehouse
    description: >-
      Warehouse-floor lookups for PickFlow — barcode resolution, bin and product
      stock, bin search, and receivables
  - name: PickFlow Shipping
    description: >-
      Provider-agnostic shipping rates, services, packages, and label purchase
      for PickFlow
  - name: Cycle Counts
    description: >-
      Create, drive, and post PickFlow cycle counts — batches, per-warehouse
      sessions, and CSV import/export
  - name: Print Stations
    description: List paired print stations and enqueue print jobs to them
  - name: Invoices
    description: Get and manage invoices
  - name: Work Orders
    description: >-
      Manage work orders — production lifecycle, steps, materials, links,
      shipments, and comments
  - name: Production Batches
    description: Group and manage work orders as production batches
  - name: Bills
    description: >-
      Accounts payable bill management, payments, attachments, allocations, and
      variance
  - name: Prepayments
    description: Manage vendor prepayments and applications
  - name: Vendor Credits
    description: Manage vendor credits and applications
  - name: Vendor Returns
    description: Manage vendor returns and credit generation
  - name: Customer Returns
    description: Manage customer returns (sales returns), receiving, and restock behavior
  - name: Stock Snapshot
    description: Point-in-time stock snapshots with export support
  - name: Consumption
    description: Consumption reports and exports
  - name: Inventory Aging
    description: Cost-layer-based inventory aging reports
  - name: Bills Reports
    description: Accounts payable bills aging reports
  - name: Forecast
    description: Materialized forecast data
  - name: Reports
    description: Close the books, inventory discrepancy, transaction COGS, and EDI reports
  - name: Tags
    description: Add/remove tags across various resources
  - name: Custom Fields
    description: Get and set custom fields across various resources
  - name: Currency
    description: Currency configuration, exchange rates, and conversion
  - name: Drive
    description: >
      Browse, upload, tag and manage files in your Luminous Drive. An API token
      sees the shared

      drive only, never My Files or restricted folders and files. Every write
      and download made

      through the API is recorded in the file's activity log (`GET
      /file-cabinet/files/{id}/activity`)

      with `actor_kind: api_token`.
  - name: Integration Mappings
    description: Manage integration mappings for external systems
  - name: Integration Field Mappings
    description: Manage field-level mappings between Luminous and external systems
  - name: Automations
    description: Create, test, and inspect automation rules and their runs
paths:
  /purchase-orders/{purchaseOrderId}/items/{lineItemId}/closed:
    patch:
      tags:
        - Purchase Orders
      summary: Close or reopen a purchase-order line
      description: >
        Close a single purchase-order line **short** — mark the rest of it as no
        longer expected — or

        reopen a previously closed line. Ordered and received quantities are
        **not** rewritten, so the

        purchase order keeps an accurate record of what was ordered versus what
        actually arrived.


        - **Close** — send `closed: true` with a `reason`. The line's
        `open_quantity` and
          `available_to_allocate` drop to `0`, incoming stock is recounted, and any open allocation pegs
          against the undelivered remainder are shrunk. A reason is required when closing, and a line
          with nothing left to receive cannot be closed.
        - **Reopen** — send `closed: false`. The close timestamp and reason are
        cleared and incoming
          stock is recounted. Allocation pegs removed on close are **not** restored.

        While a line is closed, `POST /receiving-reports` refuses any receipt
        that references it with

        `400`; reopen the line first.


        Both operations are idempotent: closing an already-closed line or
        reopening an open one returns

        the line's current state unchanged.


        `remaining_to_receive` is unaffected by closing; read `open_quantity`
        for what is still expected.

        The full-replace `PUT /purchase-orders/{id}` does not accept a closed
        flag, so resubmitting a line

        there can never close or reopen it by accident.
      operationId: updatePurchaseOrderItemClosed
      parameters:
        - in: path
          name: purchaseOrderId
          required: true
          schema:
            type: integer
          description: ID of the purchase order the line item belongs to
        - in: path
          name: lineItemId
          required: true
          schema:
            type: integer
          description: ID of the purchase-order line item to close or reopen
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - closed
              properties:
                closed:
                  type: boolean
                  description: '`true` to close the line short, `false` to reopen it.'
                  example: true
                reason:
                  type: string
                  maxLength: 2000
                  nullable: true
                  description: >
                    Why the line is being closed. **Required (non-blank) when
                    `closed` is `true`**;

                    ignored when reopening.
                  example: >-
                    Supplier discontinued the item; remaining units will not
                    ship.
            examples:
              close_line:
                summary: Close a line short
                value:
                  closed: true
                  reason: >-
                    Supplier discontinued the item; remaining units will not
                    ship.
              reopen_line:
                summary: Reopen a closed line
                value:
                  closed: false
      responses:
        '200':
          description: Line closed or reopened (or already in the requested state)
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: object
                    properties:
                      id:
                        type: integer
                        description: ID of the purchase-order line item
                        example: 78001
                      purchase_order_id:
                        type: integer
                        description: ID of the purchase order the line belongs to
                        example: 9001
                      closed:
                        type: boolean
                        description: Whether the line is now closed
                        example: true
                      closed_at:
                        type: string
                        format: date-time
                        nullable: true
                        description: When the line was closed (ISO-8601), or `null` if open
                        example: '2026-10-02T14:30:00+00:00'
                      close_reason:
                        type: string
                        nullable: true
                        description: >-
                          Reason recorded when the line was closed, or `null` if
                          open
                        example: >-
                          Supplier discontinued the item; remaining units will
                          not ship.
                      open_quantity:
                        type: number
                        format: float
                        description: >
                          Still-expected quantity in the **ordered** unit of
                          measure. `0` when closed;

                          otherwise `remaining_to_receive` floored at 0.
                        example: 0
                      remaining_to_receive:
                        type: number
                        format: float
                        description: >-
                          Ordered minus received (ordered unit of measure). Not
                          changed by closing.
                        example: 40
                      quantity:
                        type: number
                        format: float
                        description: Ordered quantity (ordered unit of measure)
                        example: 100
                      quantity_received:
                        type: number
                        format: float
                        description: >-
                          Received quantity, expressed in the **ordered** unit
                          of measure
                        example: 60
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                type: object
                properties:
                  message:
                    type: string
        '404':
          description: >-
            Purchase order line item not found, or it does not belong to this
            purchase order
          content:
            application/json:
              schema:
                type: object
                properties:
                  message:
                    type: string
        '422':
          description: >
            Unprocessable entity — `closed` missing or not a boolean, `reason`
            too long, closing without a

            reason, or closing a line that has nothing left to receive.
          content:
            application/json:
              schema:
                type: object
                properties:
                  message:
                    type: string
      security:
        - BearerAuth: []
components:
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        Authenticate using a bearer token. To create a token, navigate to
        /settings/api-tokens and click Create API Token.

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.