Get Cost Breakdown

Request

Returns the cost breakdown of a sourcing scenario as a flat list of assembly entries — one for every path to each assembly in each demand's assembly hierarchy, so an assembly reachable by several paths appears once per path. Use hierarchy (parent_assembly, path) to reconstruct the assembly hierarchy.

Every assembly reference — the entry's assembly as well as hierarchy.parent_assembly and the elements of hierarchy.path — carries the assembly's id, its name (the assembly's designator), and its ipn: the assembly's internal part number (value plus optional revision), or null when the assembly has none.

The endpoint does not return a total cost for the whole scenario — only per-assembly and per-BOM-item figures. The closest aggregate is the rolled_up_costs of each demand-root entry, which covers that demand's whole assembly hierarchy.

Assembly hierarchy

Each demand starts at one root assembly, which may contain sub-assemblies, which may in turn contain further sub-assemblies. Every entry describes one assembly on one path through that hierarchy: hierarchy.parent_assembly is the assembly that directly contains it (null for the demand root), and hierarchy.path is the chain of assemblies from the demand root down to the parent.

A demand of assembly A1 with three levels produces these entries:

A1           →  parent_assembly: null,  path: []
└─ A2        →  parent_assembly: A1,    path: [A1]
   └─ A3     →  parent_assembly: A2,    path: [A1, A2]

When several assemblies share the same sub-assembly, it is split per path and appears once per path. Here C1 contains C2 and C3, and both contain the shared sub-assembly C4 — so C4 appears twice, with different parent assemblies and paths, and each entry carries the quantities and costs of its own path. The costs of both C4 entries are rolled up into their respective branches (and therefore both into C1):

C1           →  parent_assembly: null,  path: []
├─ C2        →  parent_assembly: C1,    path: [C1]
│  └─ C4     →  parent_assembly: C2,    path: [C1, C2]
└─ C3        →  parent_assembly: C1,    path: [C1]
   └─ C4     →  parent_assembly: C3,    path: [C1, C3]

Direct vs rolled-up costs

direct_costs are the costs for the assembly's own BOM items — nothing from its children.
rolled_up_costs add everything below the entry: assemblies with no sub-assemblies roll up only their own direct costs, and every level above adds its own direct costs to the sum of its children's rolled-up costs, accumulated bottom-up. For a demand-root assembly, rolled_up_costs is the full cost of the demand.

Scrap and excess material

All prices always include the cost of the extra material purchased to cover expected scrap. Prices may additionally include excess material — material bought beyond the required quantity, e.g. forced by supplier minimum order or packaging quantities: …excluding_excess is the cost of the required quantity, …including_excess is the cost of the quantity actually bought. The difference is the excess_material_cost. Assembly cost objects also break out scrap_cost, one_time_cost, and tco_cost (all already included in the totals).

BOM items

bom_items lists every BOM item of the assembly exactly once, identified by its designators (e.g. ["R1", "R2"]). sourcing_status says whether it was sourced:

Sourced items carry their two direct_costs totals and purchase_options (joinable to /purchase-options via offer_id).
Not (yet) sourced items — Consigned, NoOffer, Pending, Error — carry direct_costs: null and empty purchase_options; the status explains why there is no cost.
Items excluded from sourcing — DoNotPlace, NoPartOptions — likewise carry no cost.

For example, an assembly with a sourced resistor, a capacitor whose offer selection is still pending, and a do-not-place test point returns:

bom_items: [
  { bom_item: { designators: ["R1"] },  sourcing_status: "Sourced",     direct_costs: {…},  purchase_options: [{…}] },
  { bom_item: { designators: ["C7"] },  sourcing_status: "Pending",     direct_costs: null, purchase_options: [] },
  { bom_item: { designators: ["TP1"] }, sourcing_status: "DoNotPlace",  direct_costs: null, purchase_options: [] }
]

The endpoint reflects the currently persisted offer selection; it does not trigger a recalculation.

Security

BearerAuth

Path

idstringrequired

UUID of the sourcing scenario to get the cost breakdown for.

Acceptstring(SourcingScenarioAcceptHeader)required

Set this to application/api.luminovo.sourcing-scenario-v1+json.

Value:"application/api.luminovo.sourcing-scenario-v1+json"

GET

/sourcing-scenarios/{id}/cost-breakdown

curl -i -X GET \
  'https://api.luminovo.com/sourcing-scenarios/{id}/cost-breakdown' \
  -H 'Accept: application/api.luminovo.sourcing-scenario-v1+json' \
  -H 'Authorization: Bearer <YOUR_JWT_HERE>'

Responses

The sourcing scenario's cost breakdown: one entry for every path to each assembly in each demand's assembly hierarchy, with direct and rolled-up assembly costs plus per-BOM-item costs. The example shows a demand of 1000 pieces of a root assembly "Main Board" containing 2 pieces each of a sub-assembly "Power Supply".

Bodyapplication/json

assembly_costsArray of objects(AssemblyCostBreakdown)required

The cost breakdown of the sourcing scenario as a flat list of assembly entries — one for every path to each assembly in each demand's assembly hierarchy, so an assembly reachable by several paths appears once per path. Use hierarchy (parent_assembly, path) to reconstruct the assembly hierarchy.

Response

{
  "assembly_costs": [
    { … },
    { … }
  ]
}