Updating your ERP's prices and availability by hand is slow

When a project is quoted in Luminovo and then confirmed, someone usually has to move the numbers into the ERP by hand — opening each sourcing scenario, reading the selected offer per line, and re-typing the unit price, price breaks, lead time, stock and supplier data into the material master and purchasing records. It is slow, it is easy to get wrong, and by the time it is done the prices may already be stale.

Throughout this flow the ERP stays the system of record: the purchase order is created and executed in the ERP, not in Luminovo. Luminovo's job is to hold the priced sourcing data and hand it back on request, so the ERP can update its prices and availability and place the order itself.

This guide covers the following scenario:

Sync prices, availability and supplier data into the ERP when a project is confirmed.

This document is about automating that sync. Everything below can already be done manually in the Luminovo UI — a user can open the sourcing scenario, read the selected offers, and type the prices, lead times and supplier data into the ERP line by line. The point here is the automated path: exchanging that data directly between the ERP and Luminovo over the API, so a confirmed project updates the ERP without re-keying.

API package required: Full API. This use case calls endpoints (purchase options, offers), which are not part of the Standard package. If you're not sure which API package your account has, align with your CSM.

How the data exchange works

The whole exchange runs through Luminovo's public API, and it only ever runs on request. There is always an initiator — your ERP, or a middleware sitting in front of it — that makes the call.

Luminovo never actively pushes data into your ERP. It keeps the priced sourcing data ready and returns it whenever the ERP asks.

So when a project is confirmed, the ERP sends a request — a GET for the purchase options, then a POST to look up the offers by ID — and Luminovo responds with the selected offers, their prices, availability and supplier details. The ERP decides what to write, when to write it, and whether to raise a purchase order off the back of it.

Scenario — sync prices and availability when a project is confirmed

Workflow

A BOM is imported into a project (an RfQ) in Luminovo — typically when a customer asks for a quote.
The user works the BOM, runs sourcing and creates the quote. Luminovo's sourcing engine selects an offer for each line in the sourcing scenario.
The project is confirmed. This is the trigger: the ERP (or middleware) calls Luminovo to pull the current prices and availability for the confirmed sourcing scenario.
The ERP reads the selected purchase options for the scenario, then looks up the full offer detail for each returned offer_id.
The ERP writes the prices, availability, lead times and supplier data back into its own records — updating the material master and info records, and creating purchase orders where needed.

Freshness. Purchase options reflect the moment sourcing was last run. If time has passed since the quote, re-run the offer update with POST /offers/refresh and selection with POST /sourcing-scenarios/run-selection before reading, so the selected offers are current.

Endpoints

Called in order. The optional freshness call comes first, then the two reads.

(Optional)

Use POST /offers/refresh to re-pull live supplier offers first.
POST /sourcing-scenarios/run-selection — re-run the sourcing selection so the selected offers are current before you read them.

Send one of two request shapes. All scenarios must belong to the same project.

GET /sourcing-scenarios/{id}/purchase-options — the selected offers and order quantities for the sourcing scenario.

This response is designed for ERP systems to create purchase orders. The path parameter id is the UUID of the sourcing scenario (obtained from the project/RfQ the quote was built on). The response is a purchase_options array with one entry per selected offer.

Field	Meaning — why the caller needs it
`purchase_options.offer_id`	The selected offer. Use it with `POST /offers/bulk` or `GET /offers/{id}` to fetch full supplier, pricing and availability detail.
`purchase_options.quantity`	Number of offer units to order.
`purchase_options.unit_of_measurement`	What one offer unit represents (e.g. 1 piece, or 5 meters of cable).
`purchase_options.purchase_quantity`	Total order quantity in base units — computed as `quantity` × `unit_of_measurement.value`.
`purchase_options.minimum_order_quantity`	MOQ from the selected price break, in offer units.
`purchase_options.minimum_packaging_quantity`	MPQ (order multiple) from the selected price break, in offer units — orders must be a multiple of this.
`purchase_options.unit_price`	Price per offer unit — `amount` + `currency`, in the offer's original currency (no conversion applied).

POST /offers/bulk — full detail for many offers in one request, looked up by their IDs.

Pass the offer_id values from purchase options. For a single offer, use GET /offers/{id} instead. The response is an items array (each offer is a StandardPart or a CustomPart) plus a not_found_ids array.

Field	Meaning — why the caller needs it
`ids` (request)	The array of offer IDs to look up (the `offer_id` values from purchase options).
`id`	The offer's opaque identifier — matches the `offer_id` you requested.
`linked_part`	The part the offer is for: `mpn` + `manufacturer.name` for off-the-shelf, or `ipn` (+ `revision`) for an internal part number. Use it to match the offer to your ERP material.
`linked_location`	Where to buy: a `Supplier` (`name`, plus `number` = your ERP vendor number if maintained, and `stock_location`) or an `InventorySite`.
`supplier_part_number`	The supplier's own part number (SPN / vendor part number).
`offer_number`	The supplier's quote/offer reference, for reconciling against their records.
`price_type`	The kind of pricing this offer represents (e.g. list, contract, quote, or customer-negotiated).
`price_breaks`	Quantity tiers: `minimum_order_quantity` (MOQ), `minimum_packaging_quantity` (MPQ) and `unit_price` (`amount` + `currency`, original currency). Custom-part tiers also carry a per-tier `lead_time` and `description`.
`one_time_costs`	Non-recurring costs.
`packaging`	How the part ships (Reel, Tape, Tray, Tube, …).
`availability`	`stock` on hand, `factory_lead_time`, and `factory_quantity`.
`valid_from` / `valid_until`	The offer's validity window — respect it before ordering.
`cancellation_policy`	`cancellation_window` and the `is_non_cancellable_non_returnable` (NCNR) flag.
`notes`	Free-text notes (e.g. "EOL announced — last-time-buy only").
`creation_date`	When the offer was created in Luminovo.
`kind`	`StandardPart` or `CustomPart`.
`not_found_ids` (response)	Offer IDs that could not be resolved — returned explicitly rather than dropped, so you can reconcile.

Behaviour to handle:

Prices are always in the offer's original currency — no conversion is applied. Convert ERP-side if you need a single reporting currency.
Offer IDs are opaque colon-separated strings (e.g. PublicOffTheShelf:550e8400-…). Treat them as opaque; do not parse them.
The order of price_breaks is not guaranteed — sort by minimum_order_quantity if order matters.

What the ERP writes back — and where it comes from

Target field in the ERP	Source in the Luminovo API	Notes
Material / part	`purchase-options.offer_id` → offer `linked_part` (`mpn` + `manufacturer.name`, or `ipn` + `revision`)	Match to your ERP material via IPN or MPN.
Vendor / supplier	offer `linked_location` → `Supplier.name` and `Supplier.number`	`number` is your own ERP vendor number if it is maintained in Luminovo.
Supplier / vendor part number	offer `supplier_part_number`	The SPN, which may differ from the MPN.
Order quantity	`purchase-options.quantity` (offer units) or `purchase_quantity` (base units)	Use base units when your ERP works in base UoM.
Unit price / purchasing condition	`purchase-options.unit_price` (`amount` + `currency`), or offer `price_breaks[].unit_price`	Original currency; no conversion — convert ERP-side if needed.
Scaled prices / quantity discounts	offer `price_breaks` (`minimum_order_quantity`, `minimum_packaging_quantity`, `unit_price`)	For scaled purchasing conditions.
MOQ / order multiple	`purchase-options.minimum_order_quantity` / `minimum_packaging_quantity`	Also available per tier in offer `price_breaks`.
Delivery / lead time	offer `availability.factory_lead_time`; for custom parts, `price_breaks[].lead_time`
Available stock	offer `availability.stock`, `availability.factory_quantity`
Packaging	offer `packaging`
One-time costs (tooling / NRE)	offer `one_time_costs`
Price validity	offer `valid_from` / `valid_until`	Check before ordering.
NCNR / cancellation terms	offer `cancellation_policy` (`is_non_cancellable_non_returnable`, `cancellation_window`)
Account assignment / cost center	—	ERP-side only; not provided by Luminovo.
Demand / delivery date	—	ERP-side only; comes from the ERP's demand.
Plant / site	—	ERP-side only.

Constraints to be explicit about

The purchase order is created and executed in the ERP. Goods receipt, invoice receipt and approvals stay there. Luminovo supplies the priced offer data only.
Nothing is ordered or emailed to suppliers from Luminovo on this path. These endpoints are read-only; the buying decision and the PO are always the ERP's.
Freshness matters. Purchase options reflect the last sourcing run. Refresh the offers before sending out purchase requests.
Prices are in the offer's original currency — no conversion. Check is_non_cancellable_non_returnable (NCNR), minimum_order_quantity and minimum_packaging_quantity before committing.
Treat offer IDs as opaque, and reconcile any IDs returned in not_found_ids.

Endpoint quick-reference

#	Endpoint	Method	Role
1	`/offers/refresh`	POST	Optional freshness — refresh offers for MPNs.
2	`/sourcing-scenarios/run-selection`	POST	Optional freshness — re-run the selection before reading
3	`/sourcing-scenarios/{id}/purchase-options`	GET	The selected offers, quantities and prices for the scenario
4	`/offers/bulk`	POST	Full offer detail (supplier, price breaks, availability) for many offer IDs
5	`/offers/{id}`	GET	Full offer detail for a single offer ID

Migrating from the Costed BOM API to Luminovo's new endpoints

Use Luminovo API to speed up your purchasing processes

Sync confirmed prices, availability and supplier data from a quoted project into your ERP