diff --git a/flexmeasures/data/models/planning/__init__.py b/flexmeasures/data/models/planning/__init__.py
index 997df93e4d..2eab59bd9d 100644
--- a/flexmeasures/data/models/planning/__init__.py
+++ b/flexmeasures/data/models/planning/__init__.py
@@ -289,14 +289,27 @@ class Commitment:
     quantity: pd.Series = 0
     upwards_deviation_price: pd.Series = 0
     downwards_deviation_price: pd.Series = 0
+    commodity: str | pd.Series | None = None
 
     def __post_init__(self):
         # device_group is a device→label lookup table, not a time series;
         # exclude it from automatic time-series index coercion.
+        if (
+            isinstance(self, FlowCommitment)
+            and isinstance(self.commodity, pd.Series)
+            and self.device is not None
+        ):
+            devices = extract_devices(self.device)
+            missing = set(devices) - set(self.commodity.index)
+            if missing:
+                raise ValueError(f"commodity mapping missing for devices: {missing}")
+
         series_attributes = [
             attr
             for attr, _type in self.__annotations__.items()
-            if _type == "pd.Series" and hasattr(self, attr) and attr != "device_group"
+            if _type == "pd.Series"
+            and hasattr(self, attr)
+            and attr not in ("device_group", "commodity")
         ]
         for series_attr in series_attributes:
             val = getattr(self, series_attr)
@@ -389,6 +402,10 @@ def _init_device_group(self):
                 range(len(devices)), index=devices, name="device_group"
             )
         else:
+            if not isinstance(self.device_group, pd.Series):
+                self.device_group = pd.Series(
+                    self.device_group, index=devices, name="device_group"
+                )
             # Validate custom grouping
             missing = set(devices) - set(self.device_group.index)
             if missing:
@@ -450,6 +467,19 @@ def to_frame(self) -> pd.DataFrame:
                 np.nan
             )  # EMS-level: handled by ems_flow_commitment_equalities
 
+        # commodity
+        if getattr(self, "commodity", None) is None:
+            df["commodity"] = None
+        elif isinstance(self.commodity, pd.Series):
+            # commodity is a device→commodity mapping, like device_group
+            if self.device is None:
+                df["commodity"] = None
+            else:
+                df["commodity"] = map_device_to_group(self.device, self.commodity)
+        else:
+            # scalar commodity
+            df["commodity"] = self.commodity
+
         return df
 
 
diff --git a/flexmeasures/data/models/planning/linear_optimization.py b/flexmeasures/data/models/planning/linear_optimization.py
index 1b85452f9d..b9b6c5430e 100644
--- a/flexmeasures/data/models/planning/linear_optimization.py
+++ b/flexmeasures/data/models/planning/linear_optimization.py
@@ -135,6 +135,20 @@ def device_scheduler(  # noqa C901
             df["group"] = group
             commitments.append(df)
 
+    # commodity → set(device indices)
+    commodity_devices = {}
+
+    for df in commitments:
+        if "commodity" not in df.columns or "device" not in df.columns:
+            continue
+
+        for _, row in df[["commodity", "device"]].dropna().iterrows():
+            devices = row["device"]
+            if not isinstance(devices, (list, tuple, set)):
+                devices = [devices]
+
+            commodity_devices.setdefault(row["commodity"], set()).update(devices)
+
     # Check if commitments have the same time window and resolution as the constraints
     for commitment in commitments:
         start_c = commitment.index.to_pydatetime()[0]
@@ -593,45 +607,30 @@ def device_stock_commitment_equalities(m, c, j, d):
         )
 
     def ems_flow_commitment_equalities(m, c, j):
-        """Couple EMS flows (sum over devices) to each commitment.
+        """Couple EMS flow commitments to device flows, optionally filtered by commodity."""
 
-        - Creates an inequality for one-sided commitments.
-        - Creates an equality for two-sided commitments and for groups of size 1.
-        """
-        if (
-            "device" in commitments[c].columns
-            and not pd.isnull(commitments[c]["device"]).all()
-        ) or m.commitment_quantity[c, j] == -infinity:
-            # Commitment c does not concern EMS
+        if commitments[c]["class"].iloc[0] != FlowCommitment:
             return Constraint.Skip
-        if (
-            "class" in commitments[c].columns
-            and not (
-                commitments[c]["class"].apply(lambda cl: cl == FlowCommitment)
-            ).all()
-        ):
-            raise NotImplementedError(
-                "StockCommitment on an EMS level has not been implemented. Please file a GitHub ticket explaining your use case."
-            )
+
+        # Legacy behavior: no commodity → sum over all devices
+        if "commodity" not in commitments[c].columns:
+            devices = m.d
+        else:
+            commodity = commitments[c]["commodity"].iloc[0]
+            if pd.isna(commodity):
+                devices = m.d
+            else:
+                devices = commodity_devices.get(commodity, set())
+                if not devices:
+                    return Constraint.Skip
+
         return (
-            (
-                0
-                if len(commitments[c]) == 1
-                or "upwards deviation price" in commitments[c].columns
-                else None
-            ),
-            # 0 if "upwards deviation price" in commitments[c].columns else None,  # todo: possible simplification
+            None,
             m.commitment_quantity[c, j]
             + m.commitment_downwards_deviation[c]
             + m.commitment_upwards_deviation[c]
-            - sum(m.ems_power[:, j]),
-            (
-                0
-                if len(commitments[c]) == 1
-                or "downwards deviation price" in commitments[c].columns
-                else None
-            ),
-            # 0 if "downwards deviation price" in commitments[c].columns else None,  # todo: possible simplification
+            - sum(m.ems_power[d, j] for d in devices),
+            None,
         )
 
     def device_derivative_equalities(m, d, j):
@@ -751,6 +750,22 @@ def cost_function(m):
         )
 
     model.commitment_costs = commitment_costs
+    commodity_costs = {}
+    for c in model.c:
+        commodity = None
+        if "commodity" in commitments[c].columns:
+            commodity = commitments[c]["commodity"].iloc[0]
+        if commodity is None or (isinstance(commodity, float) and np.isnan(commodity)):
+            continue
+
+        cost = value(
+            model.commitment_downwards_deviation[c] * model.down_price[c]
+            + model.commitment_upwards_deviation[c] * model.up_price[c]
+        )
+        commodity_costs[commodity] = commodity_costs.get(commodity, 0) + cost
+
+    model.commodity_costs = commodity_costs
+
     # model.pprint()
     # model.display()
     # print(results.solver.termination_condition)
diff --git a/flexmeasures/data/models/planning/storage.py b/flexmeasures/data/models/planning/storage.py
index c23e9e09d2..e57d577246 100644
--- a/flexmeasures/data/models/planning/storage.py
+++ b/flexmeasures/data/models/planning/storage.py
@@ -160,12 +160,15 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
         # Get info from flex-context
         consumption_price_sensor = self.flex_context.get("consumption_price_sensor")
         production_price_sensor = self.flex_context.get("production_price_sensor")
+        gas_price_sensor = self.flex_context.get("gas_price_sensor")
+
         consumption_price = self.flex_context.get(
             "consumption_price", consumption_price_sensor
         )
         production_price = self.flex_context.get(
             "production_price", production_price_sensor
         )
+        gas_price = self.flex_context.get("gas_price", gas_price_sensor)
         # fallback to using the consumption price, for backwards compatibility
         if production_price is None:
             production_price = consumption_price
@@ -176,6 +179,23 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
         # Fetch the device's power capacity (required Sensor attribute)
         power_capacity_in_mw = self._get_device_power_capacity(flex_model, assets)
 
+        gas_deviation_prices = None
+        if gas_price is not None:
+            gas_deviation_prices = get_continuous_series_sensor_or_quantity(
+                variable_quantity=gas_price,
+                unit=self.flex_context["shared_currency_unit"] + "/MWh",
+                query_window=(start, end),
+                resolution=resolution,
+                beliefs_before=belief_time,
+                fill_sides=True,
+            ).to_frame(name="event_value")
+            ensure_prices_are_not_empty(gas_deviation_prices, gas_price)
+            gas_deviation_prices = (
+                gas_deviation_prices.loc[start : end - resolution]["event_value"]
+                * resolution
+                / pd.Timedelta("1h")
+            )
+
         # Check for known prices or price forecasts
         up_deviation_prices = get_continuous_series_sensor_or_quantity(
             variable_quantity=consumption_price,
@@ -229,7 +249,10 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
 
         # Set up commitments to optimise for
         commitments = self.convert_to_commitments(
-            query_window=(start, end), resolution=resolution, beliefs_before=belief_time
+            query_window=(start, end),
+            resolution=resolution,
+            beliefs_before=belief_time,
+            flex_model=flex_model,
         )
 
         index = initialize_index(start, end, resolution)
@@ -247,189 +270,252 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
             / pd.Timedelta("1h")
         )
 
-        # Set up commitments DataFrame
-        commitment = FlowCommitment(
-            name="energy",
-            quantity=commitment_quantities,
-            upwards_deviation_price=commitment_upwards_deviation_price,
-            downwards_deviation_price=commitment_downwards_deviation_price,
-            index=index,
-        )
-        commitments.append(commitment)
+        def _device_list_series(
+            devices: list[int], index: pd.DatetimeIndex
+        ) -> pd.Series:
+            return pd.Series([tuple(devices)] * len(index), index=index, name="device")
 
-        # Set up peak commitments
-        if self.flex_context.get("ems_peak_consumption_price") is not None:
-            ems_peak_consumption = get_continuous_series_sensor_or_quantity(
-                variable_quantity=self.flex_context.get("ems_peak_consumption_in_mw"),
-                unit="MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
-                fill_sides=True,
-            )
-            ems_peak_consumption_price = self.flex_context.get(
-                "ems_peak_consumption_price"
-            )
-            ems_peak_consumption_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_peak_consumption_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
+        commodity_to_devices = {}
 
-            # Set up commitments DataFrame
-            commitment = FlowCommitment(
-                name="consumption peak",
-                quantity=ems_peak_consumption,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=ems_peak_consumption_price,
-                _type="any",
-                index=index,
-            )
-            commitments.append(commitment)
-        if self.flex_context.get("ems_peak_production_price") is not None:
-            ems_peak_production = get_continuous_series_sensor_or_quantity(
-                variable_quantity=self.flex_context.get("ems_peak_production_in_mw"),
-                unit="MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
-                fill_sides=True,
-            )
-            ems_peak_production_price = self.flex_context.get(
-                "ems_peak_production_price"
-            )
-            ems_peak_production_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_peak_production_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
+        # Set up commitments DataFrame
+        for d, flex_model_d in enumerate(flex_model):
+            commodity = flex_model_d.get("commodity", "electricity")
+            commodity_to_devices.setdefault(commodity, []).append(d)
+
+        for commodity, devices in commodity_to_devices.items():
+            commodity_devices = _device_list_series(devices, index)
+            if commodity == "electricity":
+                up_price = commitment_upwards_deviation_price
+                down_price = commitment_downwards_deviation_price
+            elif commodity == "gas":
+                if gas_deviation_prices is None:
+                    raise ValueError(
+                        "Gas prices are required in the flex-context to set up gas flow commitments."
+                    )
+                up_price = gas_deviation_prices
+                down_price = gas_deviation_prices
+            else:
+                raise ValueError(
+                    f"Unsupported commodity {commodity} in flex-model. Only 'electricity' and 'gas' are supported."
+                )
 
-            # Set up commitments DataFrame
-            commitment = FlowCommitment(
-                name="production peak",
-                quantity=-ems_peak_production,  # production is negative quantity
-                # negative price because peaking in the downwards (production) direction is penalized
-                downwards_deviation_price=-ems_peak_production_price,
-                _type="any",
-                index=index,
+            commitments.append(
+                FlowCommitment(
+                    name=f"{commodity} net energy",
+                    quantity=commitment_quantities,
+                    upwards_deviation_price=up_price,
+                    downwards_deviation_price=down_price,
+                    commodity=commodity,
+                    index=index,
+                    device=commodity_devices,
+                    device_group=commodity,
+                )
             )
-            commitments.append(commitment)
 
-        # Set up capacity breach commitments and EMS capacity constraints
-        ems_consumption_breach_price = self.flex_context.get(
-            "ems_consumption_breach_price"
-        )
+            # Set up peak commitments
+            if self.flex_context.get("ems_peak_consumption_price") is not None:
+                ems_peak_consumption = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=self.flex_context.get(
+                        "ems_peak_consumption_in_mw"
+                    ),
+                    unit="MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
+                    fill_sides=True,
+                )
+                ems_peak_consumption_price = self.flex_context.get(
+                    "ems_peak_consumption_price"
+                )
+                ems_peak_consumption_price = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=ems_peak_consumption_price,
+                    unit=self.flex_context["shared_currency_unit"] + "/MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    fill_sides=True,
+                )
 
-        ems_production_breach_price = self.flex_context.get(
-            "ems_production_breach_price"
-        )
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} consumption peak",
+                        quantity=ems_peak_consumption,
+                        upwards_deviation_price=ems_peak_consumption_price,
+                        _type="any",
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
+            if self.flex_context.get("ems_peak_production_price") is not None:
+                ems_peak_production = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=self.flex_context.get(
+                        "ems_peak_production_in_mw"
+                    ),
+                    unit="MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    max_value=np.inf,  # np.nan -> np.inf to ignore commitment if no quantity is given
+                    fill_sides=True,
+                )
+                ems_peak_production_price = self.flex_context.get(
+                    "ems_peak_production_price"
+                )
+                ems_peak_production_price = get_continuous_series_sensor_or_quantity(
+                    variable_quantity=ems_peak_production_price,
+                    unit=self.flex_context["shared_currency_unit"] + "/MW",
+                    query_window=(start, end),
+                    resolution=resolution,
+                    beliefs_before=belief_time,
+                    fill_sides=True,
+                )
 
-        ems_constraints = initialize_df(
-            StorageScheduler.COLUMNS, start, end, resolution
-        )
-        if ems_consumption_breach_price is not None:
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} production peak",
+                        quantity=-ems_peak_production,  # production is negative quantity
+                        # negative price because peaking in the downwards (production) direction is penalized
+                        downwards_deviation_price=-ems_peak_production_price,
+                        _type="any",
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
 
-            # Convert to Series
-            any_ems_consumption_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_consumption_breach_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
-            all_ems_consumption_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_consumption_breach_price,
-                unit=self.flex_context["shared_currency_unit"]
-                + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
+            # Set up capacity breach commitments and EMS capacity constraints
+            ems_consumption_breach_price = self.flex_context.get(
+                "ems_consumption_breach_price"
             )
 
-            # Set up commitments DataFrame to penalize any breach
-            commitment = FlowCommitment(
-                name="any consumption breach",
-                quantity=ems_consumption_capacity,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=any_ems_consumption_breach_price,
-                _type="any",
-                index=index,
+            ems_production_breach_price = self.flex_context.get(
+                "ems_production_breach_price"
             )
-            commitments.append(commitment)
-
-            # Set up commitments DataFrame to penalize each breach
-            commitment = FlowCommitment(
-                name="all consumption breaches",
-                quantity=ems_consumption_capacity,
-                # positive price because breaching in the upwards (consumption) direction is penalized
-                upwards_deviation_price=all_ems_consumption_breach_price,
-                index=index,
+
+            ems_constraints = initialize_df(
+                StorageScheduler.COLUMNS, start, end, resolution
             )
-            commitments.append(commitment)
+            if ems_consumption_breach_price is not None:
 
-            # Take the physical capacity as a hard constraint
-            ems_constraints["derivative max"] = ems_power_capacity_in_mw
-        else:
-            # Take the contracted capacity as a hard constraint
-            ems_constraints["derivative max"] = ems_consumption_capacity
+                # Convert to Series
+                any_ems_consumption_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_consumption_breach_price,
+                        unit=self.flex_context["shared_currency_unit"] + "/MW",
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+                all_ems_consumption_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_consumption_breach_price,
+                        unit=self.flex_context["shared_currency_unit"]
+                        + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
 
-        if ems_production_breach_price is not None:
+                # Set up commitments DataFrame to penalize any breach
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} any consumption breach",
+                        quantity=ems_consumption_capacity,
+                        # positive price because breaching in the upwards (consumption) direction is penalized
+                        upwards_deviation_price=any_ems_consumption_breach_price,
+                        _type="any",
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
 
-            # Convert to Series
-            any_ems_production_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_production_breach_price,
-                unit=self.flex_context["shared_currency_unit"] + "/MW",
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
-            all_ems_production_breach_price = get_continuous_series_sensor_or_quantity(
-                variable_quantity=ems_production_breach_price,
-                unit=self.flex_context["shared_currency_unit"]
-                + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
-                query_window=(start, end),
-                resolution=resolution,
-                beliefs_before=belief_time,
-                fill_sides=True,
-            )
+                # Set up commitments DataFrame to penalize each breach
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} all consumption breaches",
+                        quantity=ems_consumption_capacity,
+                        # positive price because breaching in the upwards (consumption) direction is penalized
+                        upwards_deviation_price=all_ems_consumption_breach_price,
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
 
-            # Set up commitments DataFrame to penalize any breach
-            commitment = FlowCommitment(
-                name="any production breach",
-                quantity=ems_production_capacity,
-                # negative price because breaching in the downwards (production) direction is penalized
-                downwards_deviation_price=-any_ems_production_breach_price,
-                _type="any",
-                index=index,
-            )
-            commitments.append(commitment)
-
-            # Set up commitments DataFrame to penalize each breach
-            commitment = FlowCommitment(
-                name="all production breaches",
-                quantity=ems_production_capacity,
-                # negative price because breaching in the downwards (production) direction is penalized
-                downwards_deviation_price=-all_ems_production_breach_price,
-                index=index,
-            )
-            commitments.append(commitment)
+                # Take the physical capacity as a hard constraint
+                ems_constraints["derivative max"] = ems_power_capacity_in_mw
+            else:
+                # Take the contracted capacity as a hard constraint
+                ems_constraints["derivative max"] = ems_consumption_capacity
 
-            # Take the physical capacity as a hard constraint
-            ems_constraints["derivative min"] = -ems_power_capacity_in_mw
-        else:
-            # Take the contracted capacity as a hard constraint
-            ems_constraints["derivative min"] = ems_production_capacity
+            if ems_production_breach_price is not None:
+
+                # Convert to Series
+                any_ems_production_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_production_breach_price,
+                        unit=self.flex_context["shared_currency_unit"] + "/MW",
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+                all_ems_production_breach_price = (
+                    get_continuous_series_sensor_or_quantity(
+                        variable_quantity=ems_production_breach_price,
+                        unit=self.flex_context["shared_currency_unit"]
+                        + "/MW*h",  # from EUR/MWh to EUR/MW/resolution
+                        query_window=(start, end),
+                        resolution=resolution,
+                        beliefs_before=belief_time,
+                        fill_sides=True,
+                    )
+                )
+
+                # Set up commitments DataFrame to penalize any breach
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} any production breach",
+                        quantity=ems_production_capacity,
+                        # negative price because breaching in the downwards (production) direction is penalized
+                        downwards_deviation_price=-any_ems_production_breach_price,
+                        _type="any",
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
+                # Set up commitments DataFrame to penalize each breach
+                commitments.append(
+                    FlowCommitment(
+                        name=f"{commodity} all production breaches",
+                        quantity=ems_production_capacity,
+                        # negative price because breaching in the downwards (production) direction is penalized
+                        downwards_deviation_price=-all_ems_production_breach_price,
+                        index=index,
+                        device=commodity_devices,
+                        device_group=commodity,
+                        commodity=commodity,
+                    )
+                )
+                # Take the physical capacity as a hard constraint
+                ems_constraints["derivative min"] = -ems_power_capacity_in_mw
+            else:
+                # Take the contracted capacity as a hard constraint
+                ems_constraints["derivative min"] = ems_production_capacity
 
         # Commitments per device
 
@@ -944,6 +1030,7 @@ def _prepare(self, skip_validation: bool = False) -> tuple:  # noqa: C901
 
     def convert_to_commitments(
         self,
+        flex_model,
         **timing_kwargs,
     ) -> list[FlowCommitment | StockCommitment]:
         """Convert list of commitment specifications (dicts) to a list of FlowCommitments."""
@@ -981,7 +1068,13 @@ def convert_to_commitments(
             commitment_spec["index"] = initialize_index(
                 start, end, timing_kwargs["resolution"]
             )
-            commitments.append(FlowCommitment(**commitment_spec))
+            for d, flex_model_d in enumerate(flex_model):
+                commitment = FlowCommitment(
+                    device=d,
+                    device_group=flex_model_d["commodity"],
+                    **commitment_spec,
+                )
+                commitments.append(commitment)
 
         return commitments
 
diff --git a/flexmeasures/data/models/planning/tests/test_commitments.py b/flexmeasures/data/models/planning/tests/test_commitments.py
index 195409afc5..ee4204b8f3 100644
--- a/flexmeasures/data/models/planning/tests/test_commitments.py
+++ b/flexmeasures/data/models/planning/tests/test_commitments.py
@@ -2,6 +2,7 @@
 import pandas as pd
 import numpy as np
 
+from flexmeasures.data.services.utils import get_or_create_model
 from flexmeasures.data.models.planning import (
     Commitment,
     StockCommitment,
@@ -10,7 +11,10 @@
 from flexmeasures.data.models.planning.utils import (
     initialize_index,
 )
+from flexmeasures.data.models.planning.storage import StorageScheduler
+from flexmeasures.data.models.time_series import Sensor
 from flexmeasures.data.models.planning.linear_optimization import device_scheduler
+from flexmeasures.data.models.generic_assets import GenericAsset, GenericAssetType
 
 
 def test_multi_feed_device_scheduler_shared_buffer():
@@ -121,6 +125,7 @@ def test_multi_feed_device_scheduler_shared_buffer():
                 downwards_deviation_price=prices[device_commodity[d]],
                 device=pd.Series(d, index=index),
                 device_group=device_commodity,
+                commodity=device_commodity[d],
             )
         )
 
@@ -132,6 +137,8 @@ def test_multi_feed_device_scheduler_shared_buffer():
                 upwards_deviation_price=0,
                 downwards_deviation_price=-penalty,
                 device=pd.Series(d, index=index),
+                device_group=device_commodity,
+                commodity=device_commodity[d],
             )
         )
 
@@ -526,3 +533,346 @@ def test_each_type_assigns_unique_group_per_slot():
         device=pd.Series("dev", index=idx),
     )
     assert list(c.group) == list(range(len(idx)))
+
+
+def test_two_flexible_assets_with_commodity(app, db):
+    """
+    Test scheduling two flexible assets (battery + heat pump)
+    with explicit electricity commodity.
+    """
+    # ---- asset types
+    battery_type = get_or_create_model(GenericAssetType, name="battery")
+    hp_type = get_or_create_model(GenericAssetType, name="heat-pump")
+
+    # ---- time setup
+    start = pd.Timestamp("2024-01-01T00:00:00+01:00")
+    end = pd.Timestamp("2024-01-02T00:00:00+01:00")
+    resolution = pd.Timedelta("1h")
+
+    # ---- assets
+    battery = GenericAsset(
+        name="Battery",
+        generic_asset_type=battery_type,
+        attributes={"energy-capacity": "100 kWh"},
+    )
+    heat_pump = GenericAsset(
+        name="Heat Pump",
+        generic_asset_type=hp_type,
+        attributes={"energy-capacity": "50 kWh"},
+    )
+    db.session.add_all([battery, heat_pump])
+    db.session.commit()
+
+    # ---- sensors
+    battery_power = Sensor(
+        name="battery power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=battery,
+    )
+    hp_power = Sensor(
+        name="heat pump power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=heat_pump,
+    )
+    db.session.add_all([battery_power, hp_power])
+    db.session.commit()
+
+    # ---- flex-model (list = multi-asset)
+    flex_model = [
+        {
+            # Battery as storage
+            "sensor": battery_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 20.0,
+            "soc-min": 0.0,
+            "soc-max": 100.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 80.0}],
+            "power-capacity": "20 kW",
+            "charging-efficiency": 0.95,
+            "discharging-efficiency": 0.95,
+        },
+        {
+            # Heat pump modeled as storage
+            "sensor": hp_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 10.0,
+            "soc-min": 0.0,
+            "soc-max": 50.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 40.0}],
+            "power-capacity": "10 kW",
+            "production-capacity": "0 kW",
+            "charging-efficiency": 0.95,
+        },
+    ]
+
+    # ---- flex-context (single electricity market)
+    flex_context = {
+        "consumption-price": "100 EUR/MWh",
+        "production-price": "100 EUR/MWh",
+    }
+
+    # ---- run scheduler (use one asset as entry point)
+    scheduler = StorageScheduler(
+        asset_or_sensor=battery,
+        start=start,
+        end=end,
+        resolution=resolution,
+        belief_time=start,
+        flex_model=flex_model,
+        flex_context=flex_context,
+        return_multiple=True,
+    )
+
+    schedules = scheduler.compute(skip_validation=True)
+
+    assert isinstance(schedules, list)
+    assert len(schedules) == 3  # 2 storage schedules + 1 commitment costs
+
+    # Extract schedules by type
+    storage_schedules = [
+        entry for entry in schedules if entry.get("name") == "storage_schedule"
+    ]
+    commitment_costs = [
+        entry for entry in schedules if entry.get("name") == "commitment_costs"
+    ]
+
+    assert len(storage_schedules) == 2
+    assert len(commitment_costs) == 1
+
+    # Get battery schedule
+    battery_schedule = next(
+        entry for entry in storage_schedules if entry["sensor"] == battery_power
+    )
+    battery_data = battery_schedule["data"]
+
+    # Get heat pump schedule
+    hp_schedule = next(
+        entry for entry in storage_schedules if entry["sensor"] == hp_power
+    )
+    hp_data = hp_schedule["data"]
+
+    # Verify both devices charge to meet their targets
+    assert (battery_data > 0).any(), "Battery should charge at some point"
+    assert (hp_data > 0).any(), "Heat pump should charge at some point"
+
+    costs_data = commitment_costs[0]["data"]
+
+    # With net commodity-level results, energy costs are aggregated per commodity
+    # Battery: 60kWh Δ (20→80) / 0.95 eff × 100 EUR/MWh ≈ 6.32 EUR (charge) + discharge loss ≈ 4.32 EUR
+    # Heat pump: 30kWh Δ (10→40) / 0.95 eff × 100 EUR/MWh ≈ 3.16 EUR (no discharge, prod-cap=0)
+    # Total: 4.32 + 3.16 = 7.47 EUR
+    electricity_net_energy_cost = costs_data.get("electricity net energy", 0)
+    assert electricity_net_energy_cost == pytest.approx(7.47, rel=1e-2), (
+        f"Total electricity net energy cost (battery 4.32 + heat pump 3.16): "
+        f"= 7.47 EUR, got {electricity_net_energy_cost}"
+    )
+
+    # Battery prefers to charge as early as possible (3h @20kW, 1h@>0kW, then 0kW until the last slot with full discharge)
+    assert all(battery_data[:3] == 20)
+    assert battery_data[3] > 0
+    assert all(battery_data[4:-1] == 0)
+    assert battery_data[-1] == -20
+
+    # HP prefers to charge as early as possible (3h @10kW, 1h@>0kW, then 0kW)
+    assert all(hp_data[:3] == 10)
+    assert hp_data[3] > 0
+    assert all(hp_data[4:] == 0)
+
+    # ---- RELATIVE COSTS: Battery vs Heat Pump
+    # Battery moves 60 kWh, Heat Pump moves 30 kWh (2:1 ratio)
+    # Preference costs should reflect this energy ratio
+    battery_total_pref = costs_data.get("prefer a full storage 0 sooner", 0)
+    hp_total_pref = costs_data.get("prefer a full storage 1 sooner", 0)
+    assert battery_total_pref == pytest.approx(2 * hp_total_pref, rel=1e-2), (
+        f"Battery preference costs ({battery_total_pref:.2e}) should be twice the "
+        f"heat pump ({hp_total_pref:.2e}) preference costs, since battery moves more energy (60 kWh vs 30 kWh)"
+    )
+
+
+def test_mixed_gas_and_electricity_assets(app, db):
+    """
+    Test scheduling with mixed commodities: battery (electricity) and boiler (gas).
+    Verify cost calculations for both commodity types.
+    """
+
+    battery_type = get_or_create_model(GenericAssetType, name="battery")
+    boiler_type = get_or_create_model(GenericAssetType, name="gas-boiler")
+
+    start = pd.Timestamp("2024-01-01T00:00:00+01:00")
+    end = pd.Timestamp("2024-01-02T00:00:00+01:00")
+    resolution = pd.Timedelta("1h")
+
+    battery = GenericAsset(
+        name="Battery",
+        generic_asset_type=battery_type,
+        attributes={"energy-capacity": "100 kWh"},
+    )
+
+    gas_boiler = GenericAsset(
+        name="Gas Boiler",
+        generic_asset_type=boiler_type,
+    )
+
+    db.session.add_all([battery, gas_boiler])
+    db.session.commit()
+
+    battery_power = Sensor(
+        name="battery power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=battery,
+    )
+
+    boiler_power = Sensor(
+        name="boiler power",
+        unit="kW",
+        event_resolution=resolution,
+        generic_asset=gas_boiler,
+    )
+
+    db.session.add_all([battery_power, boiler_power])
+    db.session.commit()
+
+    flex_model = [
+        {
+            # Electricity battery
+            "sensor": battery_power.id,
+            "commodity": "electricity",
+            "soc-at-start": 20.0,
+            "soc-min": 0.0,
+            "soc-max": 100.0,
+            "soc-targets": [{"datetime": "2024-01-01T23:00:00+01:00", "value": 80.0}],
+            "power-capacity": "20 kW",
+            "charging-efficiency": 0.95,
+            "discharging-efficiency": 0.95,
+        },
+        {
+            # Gas-powered device (no storage behavior)
+            "sensor": boiler_power.id,
+            "commodity": "gas",
+            "power-capacity": "30 kW",
+            "consumption-capacity": "30 kW",
+            "production-capacity": "0 kW",
+            "soc-usage": ["1 kW"],
+            "soc-min": 0.0,
+            "soc-max": 0.0,
+            "soc-at-start": 0.0,
+        },
+    ]
+
+    flex_context = {
+        "consumption-price": "100 EUR/MWh",  # electricity price
+        "production-price": "100 EUR/MWh",
+        "gas-price": "50 EUR/MWh",  # gas price
+    }
+
+    scheduler = StorageScheduler(
+        asset_or_sensor=battery,
+        start=start,
+        end=end,
+        resolution=resolution,
+        belief_time=start,
+        flex_model=flex_model,
+        flex_context=flex_context,
+        return_multiple=True,
+    )
+
+    schedules = scheduler.compute(skip_validation=True)
+
+    assert isinstance(schedules, list)
+    assert len(schedules) == 3  # 2 storage schedules + 1 commitment costs
+
+    # Extract schedules by type
+    storage_schedules = [
+        entry for entry in schedules if entry.get("name") == "storage_schedule"
+    ]
+    commitment_costs = [
+        entry for entry in schedules if entry.get("name") == "commitment_costs"
+    ]
+
+    assert len(storage_schedules) == 2
+    assert len(commitment_costs) == 1
+
+    # Get battery schedule
+    battery_schedule = next(
+        entry for entry in storage_schedules if entry["sensor"] == battery_power
+    )
+    battery_data = battery_schedule["data"]
+
+    early_charging_hours = battery_data.iloc[:3]
+    assert (early_charging_hours > 0).all(), "Battery should charge early"
+
+    assert battery_data.iloc[-1] < 0, "Battery should discharge at the end"
+
+    middle_hours = battery_data.iloc[4:-2]
+    assert (middle_hours == 0).all(), "Battery should be idle during middle hours"
+
+    boiler_schedule = next(
+        entry for entry in storage_schedules if entry["sensor"] == boiler_power
+    )
+    boiler_data = boiler_schedule["data"]
+
+    # ---- Verify both devices operate as expected
+    assert (battery_data > 0).any(), "Battery should charge at some point"
+    assert (boiler_data == 1.0).all(), "Boiler should have constant 1 kW consumption"
+
+    costs_data = commitment_costs[0]["data"]
+
+    # Battery: 60kWh Δ (20→80) / 0.95 eff × 100 EUR/MWh + discharge loss ≈ 4.32 EUR
+    # Boiler: constant 1kW × 24h = 24 kWh = 0.024 MWh × 50 EUR/MWh = 1.20 EUR (no efficiency loss)
+    # Total: 4.32 + 1.20 = 5.52 EUR
+    # With net commodity aggregation, we have separate "electricity net energy" and "gas net energy"
+    electricity_net_energy = costs_data.get("electricity net energy", 0)
+    gas_net_energy = costs_data.get("gas net energy", 0)
+
+    assert electricity_net_energy == pytest.approx(4.32, rel=1e-2), (
+        f"Electricity net energy cost (battery charging phase ~3h at 20kW with 95% efficiency "
+        f"+ discharge at end): 60kWh/0.95 × (100 EUR/MWh) = 4.32 EUR, "
+        f"got {electricity_net_energy}"
+    )
+
+    assert gas_net_energy == pytest.approx(1.20, rel=1e-2), (
+        f"Gas net energy cost (boiler constant 1kW for 24h): "
+        f"1 kW × 24h = 24 kWh = 0.024 MWh × 50 EUR/MWh = 1.20 EUR, "
+        f"got {gas_net_energy}"
+    )
+
+    # Total electricity + gas energy costs: battery (4.32) + boiler (1.20) = 5.52 EUR
+    total_energy_cost = electricity_net_energy + gas_net_energy
+    assert total_energy_cost == pytest.approx(5.52, rel=1e-2), (
+        f"Total energy cost (electricity 4.32 + gas 1.20): "
+        f"= 5.52 EUR, got {total_energy_cost}"
+    )
+
+    # Battery prefers to charge as early as possible (3h @20kW, 1h@>0kW, then 0kW until the last slot with full discharge)
+    assert all(battery_data[:3] == 20)
+    assert battery_data[3] > 0
+    assert all(battery_data[4:-1] == 0)
+    assert battery_data[-1] == -20
+
+    # ---- RELATIVE COSTS: Battery vs Boiler (different commodities)
+    # Battery has storage flexibility; Boiler is pass-through with constant load
+    # Battery preference costs should be higher than boiler's due to flexibility
+    battery_total_pref = costs_data.get("prefer a full storage 0 sooner", 0)
+    boiler_total_pref = costs_data.get("prefer a full storage 1 sooner", 0)
+
+    assert battery_total_pref > boiler_total_pref, (
+        f"Battery preference costs ({battery_total_pref:.2e}) should be greater than "
+        f"boiler ({boiler_total_pref:.2e}) preference costs, since battery has storage flexibility "
+        f"(can shift charging) while boiler has constant load (no flexibility). "
+        f"Ratio: {battery_total_pref / boiler_total_pref:.1f}× (if boiler > 0)"
+    )
+
+    # Verify boiler has zero preference cost since it has no flexibility (constant 1 kW)
+    assert boiler_total_pref == pytest.approx(0, abs=1e-8), (
+        f"Boiler preference cost should be ~0 since it has constant load with no flexibility, "
+        f"got {boiler_total_pref:.2e}"
+    )
+
+    # Verify battery has positive preference cost from optimizing early fill
+    assert battery_total_pref > 0, (
+        f"Battery preference cost should be positive since it can optimize charging timing, "
+        f"got {battery_total_pref:.2e}"
+    )
diff --git a/flexmeasures/data/models/planning/tests/test_storage.py b/flexmeasures/data/models/planning/tests/test_storage.py
index dbb5d792f7..47e1ae1e0c 100644
--- a/flexmeasures/data/models/planning/tests/test_storage.py
+++ b/flexmeasures/data/models/planning/tests/test_storage.py
@@ -108,20 +108,20 @@ def test_battery_solver_multi_commitment(add_battery_assets, db):
 
     # Check costs are correct
     # 60 EUR for 600 kWh consumption priced at 100 EUR/MWh
-    np.testing.assert_almost_equal(costs["energy"], 100 * (1 - 0.4))
+    np.testing.assert_almost_equal(costs["electricity energy 0"], 100 * (1 - 0.4))
     # 24000 EUR for any 24 kW consumption breach priced at 1000 EUR/kW
-    np.testing.assert_almost_equal(costs["any consumption breach"], 1000 * (25 - 1))
+    np.testing.assert_almost_equal(costs["any consumption breach 0"], 1000 * (25 - 1))
     # 24000 EUR for each 24 kW consumption breach per hour priced at 1000 EUR/kWh
     np.testing.assert_almost_equal(
-        costs["all consumption breaches"], 1000 * (25 - 1) * 96 / 4
+        costs["all consumption breaches 0"], 1000 * (25 - 1) * 96 / 4
     )
     # No production breaches
-    np.testing.assert_almost_equal(costs["any production breach"], 0)
-    np.testing.assert_almost_equal(costs["all production breaches"], 0 * 96)
+    np.testing.assert_almost_equal(costs["any production breach 0"], 0)
+    np.testing.assert_almost_equal(costs["all production breaches 0"], 0 * 96)
     # 1.3 EUR for the 5 kW extra consumption peak priced at 260 EUR/MW
-    np.testing.assert_almost_equal(costs["consumption peak"], 260 / 1000 * (25 - 20))
+    np.testing.assert_almost_equal(costs["consumption peak 0"], 260 / 1000 * (25 - 20))
     # No production peak
-    np.testing.assert_almost_equal(costs["production peak"], 0)
+    np.testing.assert_almost_equal(costs["production peak 0"], 0)
 
     # Sample commitments
     np.testing.assert_almost_equal(
diff --git a/flexmeasures/data/schemas/scheduling/__init__.py b/flexmeasures/data/schemas/scheduling/__init__.py
index 239b7f4af2..f6f5a97a45 100644
--- a/flexmeasures/data/schemas/scheduling/__init__.py
+++ b/flexmeasures/data/schemas/scheduling/__init__.py
@@ -303,6 +303,13 @@ class FlexContextSchema(Schema):
         required=False,
         metadata=metadata.AGGREGATE_POWER.to_dict(),
     )
+    gas_price = VariableQuantityField(
+        "/MWh",
+        data_key="gas-price",
+        required=False,
+        return_magnitude=False,
+        metadata=metadata.GAS_PRICE.to_dict(),
+    )
 
     def set_default_breach_prices(
         self, data: dict, fields: list[str], price: ur.Quantity
@@ -579,6 +586,11 @@ def _to_currency_per_mwh(price_unit: str) -> str:
         "description": rst_to_openapi(metadata.AGGREGATE_POWER.description),
         "example-units": EXAMPLE_UNIT_TYPES["power"],
     },
+    "gas-price": {
+        "default": None,
+        "description": rst_to_openapi(metadata.GAS_PRICE.description),
+        "example-units": EXAMPLE_UNIT_TYPES["energy-price"],
+    },
 }
 
 UI_FLEX_MODEL_SCHEMA: Dict[str, Dict[str, Any]] = {
@@ -735,6 +747,15 @@ def _to_currency_per_mwh(price_unit: str) -> str:
         },
         "example-units": EXAMPLE_UNIT_TYPES["power"],
     },
+    "commodity": {
+        "default": "electricity",
+        "description": rst_to_openapi(metadata.COMMODITY.description),
+        "types": {
+            "backend": "typeOne",
+            "ui": "One fixed value only.",
+        },
+        "options": ["electricity", "gas"],
+    },
 }
 
 
diff --git a/flexmeasures/data/schemas/scheduling/metadata.py b/flexmeasures/data/schemas/scheduling/metadata.py
index 5852d6d286..164bdaaccf 100644
--- a/flexmeasures/data/schemas/scheduling/metadata.py
+++ b/flexmeasures/data/schemas/scheduling/metadata.py
@@ -52,6 +52,11 @@ def to_dict(self):
     description="The electricity price applied to the site's aggregate production. Can be (a sensor recording) market prices, but also CO₂ intensity—whatever fits your optimization problem, as long as the unit matches the ``consumption-price`` unit. [#old_production_price_field]_",
     example="0.12 EUR/kWh",
 )
+GAS_PRICE = MetaData(
+    description="The gas price applied to the site's aggregate gas consumption. Can be (a sensor recording) market prices, but also CO₂ intensity—whatever fits your optimization problem",
+    example={"sensor": 6},
+    # example="0.09 EUR/kWh",
+)
 SITE_POWER_CAPACITY = MetaData(
     description="""Maximum achievable power at the site's grid connection point, in either direction.
 Becomes a hard constraint in the optimization problem, which is especially suitable for physical limitations. [#asymmetric]_ [#minimum_capacity_overlap]_
@@ -184,7 +189,13 @@ def to_dict(self):
 
 # FLEX-MODEL
 
-
+COMMODITY = MetaData(
+    description="""Commodity type for this storage flex-model.
+Allowed values are ``electricity`` and ``gas``.
+Defaults to ``electricity``.
+""",
+    example="electricity",
+)
 STATE_OF_CHARGE = MetaData(
     description="Sensor used to record the scheduled state of charge. If ``soc-at-start`` is omitted, FlexMeasures will also use this field to infer the starting state of charge. For this use case, the field may also contain a time series specification instead. When a sensor is used, its unit may be an energy unit (e.g. MWh or kWh) or a percentage (%). For sensors with a % unit, the ``soc-max`` flex-model field must be set to a non-zero value to allow converting between the energy-based schedule and a percentage.",
     example={"sensor": 12},
diff --git a/flexmeasures/data/schemas/scheduling/storage.py b/flexmeasures/data/schemas/scheduling/storage.py
index 807774fe5a..fea47b76e9 100644
--- a/flexmeasures/data/schemas/scheduling/storage.py
+++ b/flexmeasures/data/schemas/scheduling/storage.py
@@ -25,6 +25,8 @@
     is_energy_unit,
 )
 
+ALLOWED_COMMODITIES = {"electricity", "gas"}
+
 #  Telling type hints what to expect after schema parsing
 SoCTarget = TypedDict(
     "SoCTarget",
@@ -223,6 +225,13 @@ class StorageFlexModelSchema(Schema):
         validate=validate.Length(min=1),
         metadata=metadata.SOC_USAGE.to_dict(),
     )
+    commodity = fields.Str(
+        required=False,
+        data_key="commodity",
+        load_default="electricity",
+        validate=OneOf(["electricity", "gas"]),
+        metadata=dict(description="Commodity label for this device/asset."),
+    )
 
     def __init__(
         self,
@@ -343,6 +352,11 @@ def check_redundant_efficiencies(self, data: dict, **kwargs):
                     f"Fields `{field}` and `roundtrip_efficiency` are mutually exclusive."
                 )
 
+    @validates("commodity")
+    def validate_commodity(self, commodity: str, **kwargs):
+        if not isinstance(commodity, str) or not commodity.strip():
+            raise ValidationError("commodity must be a non-empty string.")
+
     @post_load
     def post_load_sequence(self, data: dict, **kwargs) -> dict:
         """Perform some checks and corrections after we loaded."""
@@ -493,6 +507,14 @@ class DBStorageFlexModelSchema(Schema):
         metadata={"deprecated field": "production_capacity"},
     )
 
+    commodity = fields.Str(
+        required=False,
+        data_key="commodity",
+        load_default="electricity",
+        validate=OneOf(["electricity", "gas"]),
+        metadata=dict(description="Commodity label for this device/asset."),
+    )
+
     mapped_schema_keys: dict
 
     def __init__(self, *args, **kwargs):
diff --git a/flexmeasures/data/tests/test_scheduling_simultaneous.py b/flexmeasures/data/tests/test_scheduling_simultaneous.py
index d58d6ab4c8..6f307360c5 100644
--- a/flexmeasures/data/tests/test_scheduling_simultaneous.py
+++ b/flexmeasures/data/tests/test_scheduling_simultaneous.py
@@ -107,6 +107,8 @@ def test_create_simultaneous_jobs(
     total_cost = ev_costs + battery_costs
 
     # Define expected costs based on resolution
+    expected_ev_costs = 2.3125
+    expected_battery_costs = -5.59
     expected_total_cost = -3.2775
     expected_ev_costs = 2.3125
     expected_battery_costs = expected_total_cost - expected_ev_costs
diff --git a/flexmeasures/ui/static/openapi-specs.json b/flexmeasures/ui/static/openapi-specs.json
index 596e7bb990..27d2a127d5 100644
--- a/flexmeasures/ui/static/openapi-specs.json
+++ b/flexmeasures/ui/static/openapi-specs.json
@@ -7,7 +7,7 @@
     },
     "termsOfService": null,
     "title": "FlexMeasures",
-    "version": "0.32.0"
+    "version": "0.31.0"
   },
   "externalDocs": {
     "description": "FlexMeasures runs on the open source FlexMeasures technology. Read the docs here.",
@@ -4183,7 +4183,6 @@
     },
     "/api/v3_0": {},
     "/api/v3_0/sensors/data": {},
-    "/api/v3_0/docs/dist/{filename}": {},
     "/api/v3_0/docs/{path}": {},
     "/api/dev/sensor/{id}": {},
     "/api/dev/sensor/{id}/chart": {},
@@ -4410,6 +4409,13 @@
               "sensor": 9
             },
             "$ref": "#/components/schemas/SensorReference"
+          },
+          "gas-price": {
+            "description": "The gas price applied to the site's aggregate gas consumption. Can be (a sensor recording) market prices, but also CO\u2082 intensity\u2014whatever fits your optimization problem",
+            "example": {
+              "sensor": 6
+            },
+            "$ref": "#/components/schemas/VariableQuantityOpenAPI"
           }
         },
         "additionalProperties": false
@@ -5891,6 +5897,15 @@
               }
             ],
             "items": {}
+          },
+          "commodity": {
+            "type": "string",
+            "default": "electricity",
+            "enum": [
+              "electricity",
+              "gas"
+            ],
+            "description": "Commodity label for this device/asset."
           }
         },
         "additionalProperties": false