diff --git a/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Initiator.bus.xml b/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Initiator.bus.xml
new file mode 120000
index 0000000000..ec1e9c8218
--- /dev/null
+++ b/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Initiator.bus.xml
@@ -0,0 +1 @@
+org.opensuse.Agama.Storage1.bus.xml
\ No newline at end of file
diff --git a/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Node.bus.xml b/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Node.bus.xml
new file mode 100644
index 0000000000..75c9267c19
--- /dev/null
+++ b/doc/dbus/bus/org.opensuse.Agama.Storage1.ISCSI.Node.bus.xml
@@ -0,0 +1,46 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node name="/org/opensuse/Agama/Storage1/iscsi_nodes/1">
+  <interface name="org.freedesktop.DBus.Properties">
+    <method name="Get">
+      <arg name="interface_name" direction="in" type="s"/>
+      <arg name="property_name" direction="in" type="s"/>
+      <arg name="value" direction="out" type="v"/>
+    </method>
+    <method name="Set">
+      <arg name="interface_name" direction="in" type="s"/>
+      <arg name="property_name" direction="in" type="s"/>
+      <arg name="val" direction="in" type="v"/>
+    </method>
+    <method name="GetAll">
+      <arg name="interface_name" direction="in" type="s"/>
+      <arg name="value" direction="out" type="a{sv}"/>
+    </method>
+    <signal name="PropertiesChanged">
+      <arg name="interface" type="s"/>
+      <arg name="changed_properties" type="a{sv}"/>
+      <arg name="invalidated_properties" type="as"/>
+    </signal>
+  </interface>
+  <interface name="org.freedesktop.DBus.Introspectable">
+    <method name="Introspect">
+      <arg name="xml_data" direction="out" type="s"/>
+    </method>
+  </interface>
+  <interface name="org.opensuse.Agama.Storage1.ISCSI.Node">
+    <method name="Login">
+      <arg name="options" direction="in" type="a{sv}"/>
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <method name="Logout">
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <property type="s" name="Target" access="read"/>
+    <property type="s" name="Address" access="read"/>
+    <property type="u" name="Port" access="read"/>
+    <property type="s" name="Interface" access="read"/>
+    <property type="b" name="IBFT" access="read"/>
+    <property type="b" name="Connected" access="read"/>
+    <property type="s" name="Startup" access="readwrite"/>
+  </interface>
+</node>
diff --git a/doc/dbus/bus/org.opensuse.Agama.Storage1.bus.xml b/doc/dbus/bus/org.opensuse.Agama.Storage1.bus.xml
index a0e96ad060..4b4e839ef5 100644
--- a/doc/dbus/bus/org.opensuse.Agama.Storage1.bus.xml
+++ b/doc/dbus/bus/org.opensuse.Agama.Storage1.bus.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <node name="/org/opensuse/Agama/Storage1">
+  <node name="iscsi_nodes" />
   <node name="zfcp_controllers" />
   <node name="zfcp_disks" />
   <interface name="org.freedesktop.DBus.Introspectable">
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Initiator.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Initiator.doc.xml
new file mode 100644
index 0000000000..16909f5447
--- /dev/null
+++ b/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Initiator.doc.xml
@@ -0,0 +1,21 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node name="/org/opensuse/Agama/Storage1">
+  <node name="iscsi_nodes" />
+  <node name="zfcp_controllers" />
+  <node name="zfcp_disks" />
+  <interface name="org.opensuse.Agama.Storage1.ISCSI.Initiator">
+    <method name="Discover">
+      <arg name="address" direction="in" type="s"/>
+      <arg name="port" direction="in" type="u"/>
+      <arg name="options" direction="in" type="a{sv}"/>
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <method name="Delete">
+      <arg name="node" direction="in" type="o"/>
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <property type="s" name="InitiatorName" access="readwrite"/>
+    <property type="b" name="IBFT" access="read"/>
+  </interface>
+</node>
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Node.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Node.doc.xml
new file mode 100644
index 0000000000..ec83237365
--- /dev/null
+++ b/doc/dbus/org.opensuse.Agama.Storage1.ISCSI.Node.doc.xml
@@ -0,0 +1,20 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node name="/org/opensuse/Agama/Storage1/iscsi_nodes/1">
+  <interface name="org.opensuse.Agama.Storage1.ISCSI.Node">
+    <method name="Login">
+      <arg name="options" direction="in" type="a{sv}"/>
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <method name="Logout">
+      <arg name="result" direction="out" type="u"/>
+    </method>
+    <property type="s" name="Target" access="read"/>
+    <property type="s" name="Address" access="read"/>
+    <property type="u" name="Port" access="read"/>
+    <property type="s" name="Interface" access="read"/>
+    <property type="b" name="IBFT" access="read"/>
+    <property type="b" name="Connected" access="read"/>
+    <property type="s" name="Startup" access="readwrite"/>
+  </interface>
+</node>
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
index ec60f49dcd..5d2d449095 100644
--- a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
+++ b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
@@ -1,6 +1,7 @@
 <!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
 "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 <node name="/org/opensuse/Agama/Storage1">
+  <node name="iscsi_nodes" />
   <node name="zfcp_controllers" />
   <node name="zfcp_disks" />
   <!--
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.doc.xml
index 2a51000dd2..3ccc384df7 100644
--- a/doc/dbus/org.opensuse.Agama.Storage1.doc.xml
+++ b/doc/dbus/org.opensuse.Agama.Storage1.doc.xml
@@ -1,6 +1,7 @@
 <!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
 "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
 <node name="/org/opensuse/Agama/Storage1">
+  <node name="iscsi_nodes" />
   <node name="zfcp_controllers" />
   <node name="zfcp_disks" />
   <interface name="org.opensuse.Agama.Storage1">
diff --git a/rust/agama-lib/src/dbus.rs b/rust/agama-lib/src/dbus.rs
index 822016d3c9..fa9c8e2ec2 100644
--- a/rust/agama-lib/src/dbus.rs
+++ b/rust/agama-lib/src/dbus.rs
@@ -1,5 +1,5 @@
 use std::collections::HashMap;
-use zbus::zvariant::{self, OwnedValue, Value};
+use zbus::zvariant::{self, OwnedObjectPath, OwnedValue, Value};
 
 /// Nested hash to send to D-Bus.
 pub type NestedHash<'a> = HashMap<&'a str, HashMap<&'a str, zvariant::Value<'a>>>;
@@ -43,3 +43,81 @@ where
         Ok(None)
     }
 }
+
+#[macro_export]
+macro_rules! property_from_dbus {
+    ($self:ident, $field:ident, $key:expr, $dbus:ident, $type:ty) => {
+        if let Some(v) = get_optional_property($dbus, $key)? {
+            $self.$field = v;
+        }
+    };
+}
+
+/// Converts a hash map containing zbus non-owned values to hash map with owned ones.
+///
+/// NOTE: we could follow a different approach like building our own type (e.g.
+/// using the newtype idiom) and offering a better API.
+///
+/// * `source`: hash map containing non-onwed values ([zbus::zvariant::Value]).
+pub fn to_owned_hash(source: &HashMap<&str, Value<'_>>) -> HashMap<String, OwnedValue> {
+    let mut owned = HashMap::new();
+    for (key, value) in source.iter() {
+        if let Ok(owned_value) = value.try_into() {
+            owned.insert(key.to_string(), owned_value);
+        }
+    }
+    owned
+}
+
+/// Extracts the object ID from the path.
+///
+/// TODO: should we merge this feature with the "DeviceSid"?
+pub fn extract_id_from_path(path: &OwnedObjectPath) -> Result<u32, zvariant::Error> {
+    path.as_str()
+        .rsplit_once("/")
+        .and_then(|(_, id)| id.parse::<u32>().ok())
+        .ok_or_else(|| {
+            zvariant::Error::Message(format!("Could not extract the ID from {}", path.as_str()))
+        })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use zbus::zvariant::{self, OwnedValue, Str};
+
+    use crate::dbus::{get_optional_property, get_property};
+
+    #[test]
+    fn test_get_property() {
+        let data: HashMap<String, OwnedValue> = HashMap::from([
+            ("Id".to_string(), (1 as u8).into()),
+            ("Device".to_string(), Str::from_static("/dev/sda").into()),
+        ]);
+        let id: u8 = get_property(&data, "Id").unwrap();
+        assert_eq!(id, 1);
+
+        let device: String = get_property(&data, "Device").unwrap();
+        assert_eq!(device, "/dev/sda".to_string());
+    }
+
+    #[test]
+    fn test_get_property_wrong_type() {
+        let data: HashMap<String, OwnedValue> =
+            HashMap::from([("Id".to_string(), (1 as u8).into())]);
+        let result: Result<u16, _> = get_property(&data, "Id");
+        assert_eq!(result, Err(zvariant::Error::IncorrectType));
+    }
+
+    #[test]
+    fn test_get_optional_property() {
+        let data: HashMap<String, OwnedValue> =
+            HashMap::from([("Id".to_string(), (1 as u8).into())]);
+        let id: Option<u8> = get_optional_property(&data, "Id").unwrap();
+        assert_eq!(id, Some(1));
+
+        let device: Option<String> = get_optional_property(&data, "Device").unwrap();
+        assert_eq!(device, None);
+    }
+}
diff --git a/rust/agama-lib/src/storage.rs b/rust/agama-lib/src/storage.rs
index 13e4ecc6b1..66940a3599 100644
--- a/rust/agama-lib/src/storage.rs
+++ b/rust/agama-lib/src/storage.rs
@@ -6,6 +6,9 @@ pub mod proxies;
 mod settings;
 mod store;
 
-pub use client::StorageClient;
+pub use client::{
+    iscsi::{ISCSIAuth, ISCSIClient, ISCSIInitiator, ISCSINode},
+    StorageClient,
+};
 pub use settings::StorageSettings;
 pub use store::StorageStore;
diff --git a/rust/agama-lib/src/storage/client.rs b/rust/agama-lib/src/storage/client.rs
index 4ed550c391..1e898406dd 100644
--- a/rust/agama-lib/src/storage/client.rs
+++ b/rust/agama-lib/src/storage/client.rs
@@ -15,6 +15,7 @@ use zbus::fdo::ObjectManagerProxy;
 use zbus::names::{InterfaceName, OwnedInterfaceName};
 use zbus::zvariant::{OwnedObjectPath, OwnedValue};
 use zbus::Connection;
+pub mod iscsi;
 
 type DBusObject = (
     OwnedObjectPath,
diff --git a/rust/agama-lib/src/storage/client/iscsi.rs b/rust/agama-lib/src/storage/client/iscsi.rs
new file mode 100644
index 0000000000..2a02588c2a
--- /dev/null
+++ b/rust/agama-lib/src/storage/client/iscsi.rs
@@ -0,0 +1,296 @@
+use core::fmt;
+use std::collections::HashMap;
+
+use crate::{
+    dbus::{extract_id_from_path, get_property},
+    error::ServiceError,
+    storage::proxies::{InitiatorProxy, NodeProxy},
+};
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+use zbus::{
+    fdo::ObjectManagerProxy,
+    zvariant::{self, ObjectPath, OwnedValue, Value},
+    Connection,
+};
+
+#[derive(Serialize, utoipa::ToSchema)]
+pub struct ISCSIInitiator {
+    name: String,
+    ibft: bool,
+}
+
+#[derive(Clone, Debug, Default, Serialize, utoipa::ToSchema)]
+/// ISCSI node
+pub struct ISCSINode {
+    /// Artificial ID to match it against the D-Bus backend.
+    pub id: u32,
+    /// Target name.
+    pub target: String,
+    /// Target IP address (in string-like form).
+    pub address: String,
+    /// Target port.
+    pub port: u32,
+    /// Interface name.
+    pub interface: String,
+    /// Whether the node was initiated by iBFT
+    pub ibft: bool,
+    /// Whether the node is connected (there is a session).
+    pub connected: bool,
+    /// Startup status (TODO: document better)
+    pub startup: String,
+}
+
+impl TryFrom<&HashMap<String, OwnedValue>> for ISCSINode {
+    type Error = ServiceError;
+
+    fn try_from(value: &HashMap<String, OwnedValue>) -> Result<Self, Self::Error> {
+        Ok(ISCSINode {
+            id: 0,
+            target: get_property(value, "Target")?,
+            address: get_property(value, "Address")?,
+            interface: get_property(value, "Interface")?,
+            port: get_property(value, "Port")?,
+            ibft: get_property(value, "IBFT")?,
+            connected: get_property(value, "Connected")?,
+            startup: get_property(value, "Startup")?,
+        })
+    }
+}
+
+#[derive(Clone, Default, Serialize, Deserialize, utoipa::ToSchema)]
+pub struct ISCSIAuth {
+    /// Username for authentication by target.
+    pub username: Option<String>,
+    /// Password for authentication by target.
+    pub password: Option<String>,
+    /// Username for authentication by initiator.
+    pub reverse_username: Option<String>,
+    /// Password for authentication by initiator.
+    pub reverse_password: Option<String>,
+}
+
+impl From<ISCSIAuth> for HashMap<String, OwnedValue> {
+    fn from(value: ISCSIAuth) -> Self {
+        let mut hash = HashMap::new();
+
+        if let Some(username) = value.username {
+            hash.insert("Username".to_string(), Value::new(username).to_owned());
+        }
+
+        if let Some(password) = value.password {
+            hash.insert("Password".to_string(), Value::new(password).to_owned());
+        }
+
+        if let Some(reverse_username) = value.reverse_username {
+            hash.insert(
+                "ReverseUsername".to_string(),
+                Value::new(reverse_username).to_owned(),
+            );
+        }
+
+        if let Some(reverse_password) = value.reverse_password {
+            hash.insert(
+                "ReversePassword".to_string(),
+                Value::new(reverse_password).to_owned(),
+            );
+        }
+
+        hash
+    }
+}
+
+/// D-Bus client for the ISCSI part of the storage service.
+#[derive(Clone)]
+pub struct ISCSIClient<'a> {
+    connection: zbus::Connection,
+    initiator_proxy: InitiatorProxy<'a>,
+    object_manager_proxy: ObjectManagerProxy<'a>,
+}
+
+impl<'a> ISCSIClient<'a> {
+    pub async fn new(connection: Connection) -> Result<ISCSIClient<'a>, ServiceError> {
+        let initiator_proxy = InitiatorProxy::builder(&connection)
+            .destination("org.opensuse.Agama.Storage1")?
+            .path("/org/opensuse/Agama/Storage1")?
+            .build()
+            .await?;
+
+        let object_manager_proxy = ObjectManagerProxy::builder(&connection)
+            .destination("org.opensuse.Agama.Storage1")?
+            .path("/org/opensuse/Agama/Storage1")?
+            .build()
+            .await?;
+
+        Ok(Self {
+            connection,
+            initiator_proxy,
+            object_manager_proxy,
+        })
+    }
+
+    /// Performs an iSCSI discovery.
+    ///
+    /// It returns true when the discovery was successful.
+    ///
+    /// * `address`: target address in string-like form.
+    /// * `port`: target port.
+    /// * `auth`: authentication options.
+    pub async fn discover<'b>(
+        &self,
+        address: &str,
+        port: u32,
+        auth: ISCSIAuth,
+    ) -> Result<bool, ServiceError> {
+        let mut options_hash: HashMap<&str, zvariant::Value> = HashMap::new();
+
+        if let (Some(ref username), Some(ref password)) = (auth.username, auth.password) {
+            options_hash.insert("Username", username.to_string().into());
+            options_hash.insert("Password", password.to_string().into());
+        }
+
+        if let (Some(ref username), Some(ref password)) =
+            (auth.reverse_username, auth.reverse_password)
+        {
+            options_hash.insert("ReverseUsername", username.to_string().into());
+            options_hash.insert("ReversePassword", password.to_string().into());
+        }
+
+        let mut options_ref: HashMap<&str, &zvariant::Value<'_>> = HashMap::new();
+        for (key, value) in options_hash.iter() {
+            options_ref.insert(key, value);
+        }
+
+        let result = self
+            .initiator_proxy
+            .discover(address, port as u32, options_ref)
+            .await?;
+        Ok(result == 0)
+    }
+
+    /// Returns the initiator data.
+    pub async fn get_initiator(&self) -> Result<ISCSIInitiator, ServiceError> {
+        let ibft = self.initiator_proxy.ibft().await?;
+        let name = self.initiator_proxy.initiator_name().await?;
+        Ok(ISCSIInitiator { name, ibft })
+    }
+
+    /// Sets the initiator name.
+    ///
+    /// * `name`: new name.
+    pub async fn set_initiator_name(&self, name: &str) -> Result<(), ServiceError> {
+        Ok(self.initiator_proxy.set_initiator_name(name).await?)
+    }
+
+    /// Returns the iSCSI nodes.
+    pub async fn get_nodes(&self) -> Result<Vec<ISCSINode>, ServiceError> {
+        let managed_objects = self.object_manager_proxy.get_managed_objects().await?;
+
+        let mut nodes: Vec<ISCSINode> = vec![];
+        for (path, ifaces) in managed_objects {
+            if let Some(properties) = ifaces.get("org.opensuse.Agama.Storage1.ISCSI.Node") {
+                let id = extract_id_from_path(&path).unwrap_or(0);
+                match ISCSINode::try_from(properties) {
+                    Ok(mut node) => {
+                        node.id = id;
+                        nodes.push(node);
+                    }
+                    Err(error) => {
+                        log::warn!("Not a valid iSCSI node: {}", error);
+                    }
+                }
+            }
+        }
+        Ok(nodes)
+    }
+
+    /// Sets the startup for a ISCSI node.
+    ///
+    /// * `id`: node ID.
+    /// * `startup`: new startup value.
+    pub async fn set_startup(&self, id: u32, startup: &str) -> Result<(), ServiceError> {
+        let proxy = self.get_node_proxy(id).await?;
+        Ok(proxy.set_startup(startup).await?)
+    }
+
+    pub async fn login(
+        &self,
+        id: u32,
+        auth: ISCSIAuth,
+        startup: String,
+    ) -> Result<LoginResult, ServiceError> {
+        let proxy = self.get_node_proxy(id).await?;
+
+        let mut options: HashMap<String, OwnedValue> = auth.into();
+        options.insert("Startup".to_string(), Value::new(startup).to_owned());
+
+        // FIXME: duplicated code (see discover)
+        let mut options_ref: HashMap<&str, &zvariant::Value<'_>> = HashMap::new();
+        for (key, value) in options.iter() {
+            options_ref.insert(key, value);
+        }
+        let result = proxy.login(options_ref).await?;
+        let result =
+            LoginResult::try_from(result).map_err(|e| zbus::fdo::Error::Failed(e.to_string()))?;
+        Ok(result)
+    }
+
+    pub async fn logout(&self, id: u32) -> Result<bool, ServiceError> {
+        let proxy = self.get_node_proxy(id).await?;
+        let result = proxy.logout().await?;
+        Ok(result == 0)
+    }
+
+    pub async fn delete_node(&self, id: u32) -> Result<(), ServiceError> {
+        let path = format!("/org/opensuse/Agama/Storage1/iscsi_nodes/{}", id);
+        let path = ObjectPath::from_string_unchecked(path);
+        self.initiator_proxy.delete(&path).await?;
+        Ok(())
+    }
+
+    pub async fn get_node_proxy(&self, id: u32) -> Result<NodeProxy, ServiceError> {
+        let proxy = NodeProxy::builder(&self.connection)
+            .path(format!("/org/opensuse/Agama/Storage1/iscsi_nodes/{}", id))?
+            .build()
+            .await?;
+        Ok(proxy)
+    }
+}
+
+#[derive(Serialize, utoipa::ToSchema)]
+pub enum LoginResult {
+    /// Successful login.
+    Success = 0,
+    /// Invalid startup value.
+    InvalidStartup = 1,
+    /// Failed login.
+    Failed = 2,
+}
+
+#[derive(Debug, Error, PartialEq)]
+#[error("Invalid iSCSI login result: {0}")]
+pub struct InvalidLoginResult(u32);
+
+impl TryFrom<u32> for LoginResult {
+    type Error = InvalidLoginResult;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            v if v == Self::Success as u32 => Ok(Self::Success),
+            v if v == Self::InvalidStartup as u32 => Ok(Self::InvalidStartup),
+            v if v == Self::Failed as u32 => Ok(Self::Failed),
+            _ => Err(InvalidLoginResult(value)),
+        }
+    }
+}
+
+// TODO: the error description should come from the backend (as in deregister)
+impl fmt::Display for LoginResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Success => write!(f, "Success"),
+            Self::InvalidStartup => write!(f, "Invalid startup value"),
+            Self::Failed => write!(f, "Could not login into the iSCSI node"),
+        }
+    }
+}
diff --git a/rust/agama-lib/src/storage/proxies.rs b/rust/agama-lib/src/storage/proxies.rs
index 052b4692da..02c87d3ebb 100644
--- a/rust/agama-lib/src/storage/proxies.rs
+++ b/rust/agama-lib/src/storage/proxies.rs
@@ -95,3 +95,77 @@ trait Device {
     #[dbus_proxy(property, name = "SID")]
     fn sid(&self) -> zbus::Result<u32>;
 }
+
+#[dbus_proxy(
+    interface = "org.opensuse.Agama.Storage1.ISCSI.Initiator",
+    default_service = "org.opensuse.Agama.Storage1",
+    assume_defaults = true
+)]
+trait Initiator {
+    /// Delete method
+    fn delete(&self, node: &zbus::zvariant::ObjectPath<'_>) -> zbus::Result<u32>;
+
+    /// Discover method
+    fn discover(
+        &self,
+        address: &str,
+        port: u32,
+        options: std::collections::HashMap<&str, &zbus::zvariant::Value<'_>>,
+    ) -> zbus::Result<u32>;
+
+    /// IBFT property
+    #[dbus_proxy(property, name = "IBFT")]
+    fn ibft(&self) -> zbus::Result<bool>;
+
+    /// InitiatorName property
+    #[dbus_proxy(property)]
+    fn initiator_name(&self) -> zbus::Result<String>;
+    #[dbus_proxy(property)]
+    fn set_initiator_name(&self, value: &str) -> zbus::Result<()>;
+}
+
+#[dbus_proxy(
+    interface = "org.opensuse.Agama.Storage1.ISCSI.Node",
+    default_service = "org.opensuse.Agama.Storage1",
+    assume_defaults = true
+)]
+trait Node {
+    /// Login method
+    fn login(
+        &self,
+        options: std::collections::HashMap<&str, &zbus::zvariant::Value<'_>>,
+    ) -> zbus::Result<u32>;
+
+    /// Logout method
+    fn logout(&self) -> zbus::Result<u32>;
+
+    /// Address property
+    #[dbus_proxy(property)]
+    fn address(&self) -> zbus::Result<String>;
+
+    /// Connected property
+    #[dbus_proxy(property)]
+    fn connected(&self) -> zbus::Result<bool>;
+
+    /// IBFT property
+    #[dbus_proxy(property, name = "IBFT")]
+    fn ibft(&self) -> zbus::Result<bool>;
+
+    /// Interface property
+    #[dbus_proxy(property)]
+    fn interface(&self) -> zbus::Result<String>;
+
+    /// Port property
+    #[dbus_proxy(property)]
+    fn port(&self) -> zbus::Result<u32>;
+
+    /// Startup property
+    #[dbus_proxy(property)]
+    fn startup(&self) -> zbus::Result<String>;
+    #[dbus_proxy(property)]
+    fn set_startup(&self, value: &str) -> zbus::Result<()>;
+
+    /// Target property
+    #[dbus_proxy(property)]
+    fn target(&self) -> zbus::Result<String>;
+}
diff --git a/rust/agama-server/src/dbus.rs b/rust/agama-server/src/dbus.rs
new file mode 100644
index 0000000000..2fcafa8f9a
--- /dev/null
+++ b/rust/agama-server/src/dbus.rs
@@ -0,0 +1,229 @@
+//! This module defines some reusable functions/structs related to D-Bus that might be useful when
+//! implementing agama-server features.
+
+use std::{
+    collections::{hash_map::Entry, HashMap},
+    pin::Pin,
+    sync::Arc,
+    task::{Context, Poll},
+};
+
+use agama_lib::{dbus::to_owned_hash, error::ServiceError};
+use futures_util::{ready, Stream};
+use pin_project::pin_project;
+use tokio_stream::StreamMap;
+use zbus::{
+    fdo::{InterfacesAdded, InterfacesRemoved, PropertiesChanged},
+    zvariant::{ObjectPath, OwnedObjectPath},
+    MatchRule, Message, MessageStream, MessageType,
+};
+
+#[derive(Debug)]
+pub enum DBusObjectChange {
+    Added(OwnedObjectPath, HashMap<String, zbus::zvariant::OwnedValue>),
+    Changed(OwnedObjectPath, HashMap<String, zbus::zvariant::OwnedValue>),
+    Removed(OwnedObjectPath),
+}
+
+const PROPERTIES_CHANGED: &str = "properties_changed";
+const OBJECTS_MANAGER: &str = "objects_manager";
+
+/// This stream listens for changes in a collection of D-Bus objects and emits
+/// an [DBusObjectChange] when an object is added, updated or removed. It is required
+/// that the collection implements the ObjectManager interface.
+///
+/// Initially, it was intended to emit the proxy representing the object. However, as
+/// retrieving the proxy is an async operation too, it might lead to a deadlock.
+/// See the [zbus::MessageStream](https://docs.rs/zbus/4.2.0/zbus/struct.MessageStream.html)
+/// and [issue#350](https://github.com/dbus2/zbus/issues/350).
+///
+/// TODO: allow filtering by multiple D-Bus interfaces and properties.
+#[pin_project]
+pub struct DBusObjectChangesStream {
+    connection: zbus::Connection,
+    manager_path: OwnedObjectPath,
+    namespace: OwnedObjectPath,
+    interface: String,
+    #[pin]
+    inner: StreamMap<&'static str, MessageStream>,
+}
+
+impl DBusObjectChangesStream {
+    /// Creates a new stream.
+    ///
+    /// * `connection`: D-Bus connection to listen on.
+    /// * `manager_path`: D-Bus path of the object implementing the ObjectManager.
+    /// * `namespace`: namespace to watch (corresponds to a "path_namespace" in the MatchRule).
+    /// * `interface`: name of the interface to watch.
+    pub async fn new(
+        connection: &zbus::Connection,
+        manager_path: &ObjectPath<'_>,
+        namespace: &ObjectPath<'_>,
+        interface: &str,
+    ) -> Result<Self, ServiceError> {
+        let manager_path = OwnedObjectPath::from(manager_path.to_owned());
+        let namespace = OwnedObjectPath::from(namespace.to_owned());
+        let connection = connection.clone();
+        let mut inner = StreamMap::new();
+        inner.insert(
+            OBJECTS_MANAGER,
+            Self::build_added_and_removed_stream(&connection, &manager_path).await?,
+        );
+        inner.insert(
+            PROPERTIES_CHANGED,
+            Self::build_properties_changed_stream(&connection, &namespace).await?,
+        );
+
+        Ok(Self {
+            connection,
+            manager_path,
+            namespace,
+            interface: interface.to_string(),
+            inner,
+        })
+    }
+
+    /// Handles the case where a property changes.
+    ///
+    /// * message: property change message.
+    /// * interface: name of the interface to watch.
+    fn handle_properties_changed(
+        message: Result<Arc<Message>, zbus::Error>,
+        interface: &str,
+    ) -> Option<DBusObjectChange> {
+        let Ok(message) = message else {
+            return None;
+        };
+        let properties = PropertiesChanged::from_message(message)?;
+        let args = properties.args().ok()?;
+
+        if args.interface_name.as_str() == interface {
+            let path = OwnedObjectPath::from(properties.path().unwrap().clone());
+            let data = to_owned_hash(&args.changed_properties);
+            Some(DBusObjectChange::Changed(path, data))
+        } else {
+            None
+        }
+    }
+
+    /// Handles the addition or removal of an object.
+    ///
+    /// * message: add/remove message.
+    /// * interface: name of the interface to watch.
+    fn handle_added_or_removed(
+        message: Result<Arc<Message>, zbus::Error>,
+        interface: &str,
+    ) -> Option<DBusObjectChange> {
+        let Ok(message) = message else {
+            return None;
+        };
+
+        if let Some(added) = InterfacesAdded::from_message(message.clone()) {
+            let args = added.args().ok()?;
+            let data = args.interfaces_and_properties.get(&interface)?;
+            let data = to_owned_hash(data);
+            let path = OwnedObjectPath::from(args.object_path().clone());
+            return Some(DBusObjectChange::Added(path, data));
+        }
+
+        if let Some(removed) = InterfacesRemoved::from_message(message) {
+            let args = removed.args().ok()?;
+            if args.interfaces.contains(&interface) {
+                let path = OwnedObjectPath::from(args.object_path().clone());
+                return Some(DBusObjectChange::Removed(path));
+            }
+        }
+
+        None
+    }
+
+    /// Builds a stream of added/removed objects within the collection.
+    ///
+    /// * `connection`: D-Bus connection.
+    /// * `manager_path`: path of the object implementing the ObjectManager interface.
+    async fn build_added_and_removed_stream(
+        connection: &zbus::Connection,
+        manager_path: &OwnedObjectPath,
+    ) -> Result<MessageStream, ServiceError> {
+        let rule = MatchRule::builder()
+            .msg_type(MessageType::Signal)
+            .path(manager_path.clone())?
+            .interface("org.freedesktop.DBus.ObjectManager")?
+            .build();
+        let stream = MessageStream::for_match_rule(rule, &connection, None).await?;
+        Ok(stream)
+    }
+
+    /// Builds a stream of properties changed within the collection.
+    ///
+    /// * `connection`: D-Bus connection.
+    /// * `namespace`: namespace to watch for.
+    async fn build_properties_changed_stream(
+        connection: &zbus::Connection,
+        namespace: &OwnedObjectPath,
+    ) -> Result<MessageStream, ServiceError> {
+        let rule = MatchRule::builder()
+            .msg_type(MessageType::Signal)
+            .path_namespace(namespace.clone())?
+            .interface("org.freedesktop.DBus.Properties")?
+            .member("PropertiesChanged")?
+            .build();
+        let stream = MessageStream::for_match_rule(rule, &connection, None).await?;
+        Ok(stream)
+    }
+}
+
+impl Stream for DBusObjectChangesStream {
+    type Item = DBusObjectChange;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let mut pinned = self.project();
+        Poll::Ready(loop {
+            let item = ready!(pinned.inner.as_mut().poll_next(cx));
+            let next_value = match item {
+                Some((PROPERTIES_CHANGED, message)) => {
+                    Self::handle_properties_changed(message, &pinned.interface)
+                }
+                Some((OBJECTS_MANAGER, message)) => {
+                    Self::handle_added_or_removed(message, &pinned.interface)
+                }
+                _ => None,
+            };
+            if next_value.is_some() {
+                break next_value;
+            }
+        })
+    }
+}
+
+pub struct ObjectsCache<T> {
+    objects: HashMap<OwnedObjectPath, T>,
+}
+
+impl<T> ObjectsCache<T>
+where
+    T: Default,
+{
+    pub fn add(&mut self, path: OwnedObjectPath, object: T) {
+        _ = self.objects.insert(path, object)
+    }
+
+    pub fn find_or_create(&mut self, path: &OwnedObjectPath) -> &mut T {
+        match self.objects.entry(path.clone()) {
+            Entry::Vacant(entry) => entry.insert(T::default()),
+            Entry::Occupied(entry) => entry.into_mut(),
+        }
+    }
+
+    pub fn remove(&mut self, path: &OwnedObjectPath) -> Option<T> {
+        self.objects.remove(&path)
+    }
+}
+
+impl<T> Default for ObjectsCache<T> {
+    fn default() -> Self {
+        Self {
+            objects: HashMap::new(),
+        }
+    }
+}
diff --git a/rust/agama-server/src/lib.rs b/rust/agama-server/src/lib.rs
index 46f0cfc909..fe2efcdef8 100644
--- a/rust/agama-server/src/lib.rs
+++ b/rust/agama-server/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod cert;
+pub mod dbus;
 pub mod error;
 pub mod l10n;
 pub mod manager;
diff --git a/rust/agama-server/src/storage/web.rs b/rust/agama-server/src/storage/web.rs
index c9b9954bae..43f9321432 100644
--- a/rust/agama-server/src/storage/web.rs
+++ b/rust/agama-server/src/storage/web.rs
@@ -24,8 +24,11 @@ use axum::{
 use serde::Serialize;
 use tokio_stream::{Stream, StreamExt};
 
+pub mod iscsi;
+
 use crate::{
     error::Error,
+    storage::web::iscsi::{iscsi_service, iscsi_stream},
     web::{
         common::{issues_router, progress_router, service_status_router, EventStreams},
         Event,
@@ -33,10 +36,13 @@ use crate::{
 };
 
 pub async fn storage_streams(dbus: zbus::Connection) -> Result<EventStreams, Error> {
-    let result: EventStreams = vec![(
+    let mut result: EventStreams = vec![(
         "devices_dirty",
         Box::pin(devices_dirty_stream(dbus.clone()).await?),
-    )]; // TODO:
+    )];
+    let mut iscsi = iscsi_stream(&dbus).await?;
+
+    result.append(&mut iscsi);
     Ok(result)
 }
 
@@ -77,6 +83,7 @@ pub async fn storage_service(dbus: zbus::Connection) -> Result<Router, ServiceEr
     let status_router = service_status_router(&dbus, DBUS_SERVICE, DBUS_PATH).await?;
     let progress_router = progress_router(&dbus, DBUS_SERVICE, DBUS_PATH).await?;
     let issues_router = issues_router(&dbus, DBUS_SERVICE, DBUS_PATH).await?;
+    let iscsi_router = iscsi_service(&dbus).await?;
 
     let client = StorageClient::new(dbus.clone()).await?;
     let state = StorageState { client };
@@ -96,6 +103,7 @@ pub async fn storage_service(dbus: zbus::Connection) -> Result<Router, ServiceEr
         .merge(progress_router)
         .merge(status_router)
         .nest("/issues", issues_router)
+        .nest("/iscsi", iscsi_router)
         .with_state(state);
     Ok(router)
 }
diff --git a/rust/agama-server/src/storage/web/iscsi.rs b/rust/agama-server/src/storage/web/iscsi.rs
new file mode 100644
index 0000000000..e73f78683b
--- /dev/null
+++ b/rust/agama-server/src/storage/web/iscsi.rs
@@ -0,0 +1,306 @@
+//! This module implements the web API for the iSCSI handling of the storage service.
+//!
+//! The module offers two public functions:
+//!
+//! * `iscsi_service` which returns the Axum service.
+//! * `iscsi_stream` which offers an stream that emits the iSCSI-related events coming from D-Bus.
+
+use crate::{
+    error::Error,
+    web::{common::EventStreams, Event},
+};
+use agama_lib::{
+    dbus::{get_optional_property, to_owned_hash},
+    error::ServiceError,
+    storage::{
+        client::iscsi::{ISCSIAuth, ISCSIInitiator, ISCSINode, LoginResult},
+        ISCSIClient,
+    },
+};
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::IntoResponse,
+    routing::{delete, get, post},
+    Json, Router,
+};
+use serde::Deserialize;
+
+mod stream;
+use stream::ISCSINodeStream;
+use tokio_stream::{Stream, StreamExt};
+use zbus::fdo::{PropertiesChanged, PropertiesProxy};
+
+/// Returns the stream of iSCSI-related events.
+///
+/// The stream combines the following events:
+///
+/// * Changes on the iSCSI nodes collection.
+/// * Changes to the initiator (name or ibft).
+///
+/// * `dbus`: D-Bus connection to use.
+pub async fn iscsi_stream(dbus: &zbus::Connection) -> Result<EventStreams, Error> {
+    let stream: EventStreams = vec![
+        ("iscsi_nodes", Box::pin(ISCSINodeStream::new(dbus).await?)),
+        ("initiator", Box::pin(initiator_stream(dbus).await?)),
+    ];
+    Ok(stream)
+}
+
+async fn initiator_stream(
+    dbus: &zbus::Connection,
+) -> Result<impl Stream<Item = Event> + Send, Error> {
+    let proxy = PropertiesProxy::builder(dbus)
+        .destination("org.opensuse.Agama.Storage1")?
+        .path("/org/opensuse/Agama/Storage1")?
+        .build()
+        .await?;
+    let stream = proxy
+        .receive_properties_changed()
+        .await?
+        .filter_map(|change| match handle_initiator_change(change) {
+            Ok(event) => Some(event),
+            Err(error) => {
+                log::warn!("Could not read the initiator change: {}", error);
+                None
+            }
+        });
+    Ok(stream)
+}
+
+fn handle_initiator_change(change: PropertiesChanged) -> Result<Event, ServiceError> {
+    let args = change.args()?;
+    let changes = to_owned_hash(args.changed_properties());
+    let name = get_optional_property(&changes, "InitiatorName")?;
+    let ibft = get_optional_property(&changes, "IBFT")?;
+    Ok(Event::ISCSIInitiatorChanged { ibft, name })
+}
+
+#[derive(Clone)]
+struct ISCSIState<'a> {
+    client: ISCSIClient<'a>,
+}
+
+/// Sets up and returns the Axum service for the iSCSI part of the storage module.
+///
+/// It acts as a proxy to Agama D-Bus service.
+///
+/// * `dbus`: D-Bus connection to use.
+pub async fn iscsi_service<T>(dbus: &zbus::Connection) -> Result<Router<T>, ServiceError> {
+    let client = ISCSIClient::new(dbus.clone()).await?;
+    let state = ISCSIState { client };
+    let router = Router::new()
+        .route("/initiator", get(initiator).patch(update_initiator))
+        .route("/nodes", get(nodes))
+        .route("/nodes/:id", delete(delete_node).patch(update_node))
+        .route("/nodes/:id/login", post(login_node))
+        .route("/nodes/:id/logout", post(logout_node))
+        .route("/discover", post(discover))
+        .with_state(state);
+    Ok(router)
+}
+
+/// Returns the iSCSI initiator properties.
+///
+/// The iSCSI properties include the name and whether iBFT is enabled.
+#[utoipa::path(
+    get,
+    path="/initiator",
+    context_path="/api/storage/iscsi",
+    responses(
+        (status = OK, description = "iSCSI initiator properties.", body = ISCSIInitiator),
+        (status = BAD_REQUEST, description = "It could not read the iSCSI initiator properties."),
+    )
+)]
+async fn initiator(State(state): State<ISCSIState<'_>>) -> Result<Json<ISCSIInitiator>, Error> {
+    let initiator = state.client.get_initiator().await?;
+    Ok(Json(initiator))
+}
+
+#[derive(Deserialize, utoipa::ToSchema)]
+pub struct InitiatorParams {
+    /// iSCSI initiator name.
+    name: String,
+}
+
+/// Updates the iSCSI initiator properties.
+#[utoipa::path(
+    patch,
+    path="/initiator",
+    context_path="/api/storage/iscsi",
+    responses(
+        (status = NO_CONTENT, description = "The iSCSI initiator properties were succesfully updated."),
+        (status = BAD_REQUEST, description = "It could not update the iSCSI initiator properties."),
+    )
+)]
+async fn update_initiator(
+    State(state): State<ISCSIState<'_>>,
+    Json(params): Json<InitiatorParams>,
+) -> Result<impl IntoResponse, Error> {
+    state.client.set_initiator_name(&params.name).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+/// Returns the list of known iSCSI nodes.
+#[utoipa::path(
+    get,
+    path="/nodes",
+    context_path="/api/storage/iscsi",
+    responses(
+    (status = OK, description = "List of iSCSI nodes.", body = Vec<ISCSINode>),
+    (status = BAD_REQUEST, description = "It was not possible to get the list of iSCSI nodes."),
+  )
+)]
+async fn nodes(State(state): State<ISCSIState<'_>>) -> Result<Json<Vec<ISCSINode>>, Error> {
+    let nodes = state.client.get_nodes().await?;
+    Ok(Json(nodes))
+}
+
+#[derive(Deserialize, utoipa::ToSchema)]
+pub struct NodeParams {
+    /// Startup value.
+    startup: String,
+}
+
+/// Updates iSCSI node properties.
+///
+/// At this point, only the startup option can be changed.
+#[utoipa::path(
+    put,
+    path="/nodes/{id}",
+    context_path="/api/storage/iscsi",
+    params(
+        ("id" = u32, Path, description = "iSCSI artificial ID.")
+    ),
+    responses(
+        (status = NO_CONTENT, description = "The iSCSI node was updated.", body = NodeParams),
+        (status = BAD_REQUEST, description = "Could not update the iSCSI node."),
+    )
+)]
+async fn update_node(
+    State(state): State<ISCSIState<'_>>,
+    Path(id): Path<u32>,
+    Json(params): Json<NodeParams>,
+) -> Result<impl IntoResponse, Error> {
+    state.client.set_startup(id, &params.startup).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+/// Deletes the iSCSI node.
+#[utoipa::path(
+    delete,
+    path="/nodes/{id}",
+    context_path="/api/storage/iscsi",
+    params(
+        ("id" = u32, Path, description = "iSCSI artificial ID.")
+    ),
+    responses(
+        (status = NO_CONTENT, description = "The iSCSI node was deleted."),
+        (status = BAD_REQUEST, description = "Could not delete the iSCSI node."),
+    )
+)]
+async fn delete_node(
+    State(state): State<ISCSIState<'_>>,
+    Path(id): Path<u32>,
+) -> Result<impl IntoResponse, Error> {
+    state.client.delete_node(id).await?;
+    Ok(StatusCode::NO_CONTENT)
+}
+
+#[derive(Deserialize, utoipa::ToSchema)]
+pub struct LoginParams {
+    /// Authentication options.
+    #[serde(flatten)]
+    auth: ISCSIAuth,
+    /// Startup value.
+    startup: String,
+}
+
+#[utoipa::path(
+    post,
+    path="/nodes/{id}/login",
+    context_path="/api/storage/iscsi",
+    params(
+        ("id" = u32, Path, description = "iSCSI artificial ID.")
+    ),
+    responses(
+        (status = NO_CONTENT, description = "The login request was successful."),
+        (status = BAD_REQUEST, description = "Could not reach the iSCSI server."),
+        (status = UNPROCESSABLE_ENTITY, description = "The login request failed.",
+             body = LoginResult),
+    )
+)]
+async fn login_node(
+    State(state): State<ISCSIState<'_>>,
+    Path(id): Path<u32>,
+    Json(params): Json<LoginParams>,
+) -> Result<impl IntoResponse, Error> {
+    let result = state.client.login(id, params.auth, params.startup).await?;
+    match result {
+        LoginResult::Success => Ok((StatusCode::NO_CONTENT, ().into_response())),
+        error => Ok((
+            StatusCode::UNPROCESSABLE_ENTITY,
+            Json(error).into_response(),
+        )),
+    }
+}
+
+#[utoipa::path(
+    post,
+    path="/nodes/{id}/logout",
+    context_path="/api/storage/iscsi",
+    params(
+        ("id" = u32, Path, description = "iSCSI artificial ID.")
+    ),
+    responses(
+        (status = 204, description = "The logout request was successful."),
+        (status = 400, description = "Could not reach the iSCSI server."),
+        (status = 422, description = "The logout request failed."),
+    )
+)]
+async fn logout_node(
+    State(state): State<ISCSIState<'_>>,
+    Path(id): Path<u32>,
+) -> Result<impl IntoResponse, Error> {
+    if state.client.logout(id).await? {
+        Ok(StatusCode::NO_CONTENT)
+    } else {
+        Ok(StatusCode::UNPROCESSABLE_ENTITY)
+    }
+}
+
+#[derive(Deserialize, utoipa::ToSchema)]
+pub struct DiscoverParams {
+    /// iSCSI server address.
+    address: String,
+    /// iSCSI service port.
+    port: u32,
+    /// Authentication options.
+    #[serde(default)]
+    options: ISCSIAuth,
+}
+
+/// Performs an iSCSI discovery.
+#[utoipa::path(
+    post,
+    path="/discover",
+    context_path="/api/storage/iscsi",
+    responses(
+        (status = 204, description = "The iSCSI discovery request was successful."),
+        (status = 400, description = "The iSCSI discovery request failed."),
+    )
+)]
+async fn discover(
+    State(state): State<ISCSIState<'_>>,
+    Json(params): Json<DiscoverParams>,
+) -> Result<impl IntoResponse, Error> {
+    let result = state
+        .client
+        .discover(&params.address, params.port, params.options)
+        .await?;
+    if result {
+        Ok(StatusCode::NO_CONTENT)
+    } else {
+        Ok(StatusCode::BAD_REQUEST)
+    }
+}
diff --git a/rust/agama-server/src/storage/web/iscsi/stream.rs b/rust/agama-server/src/storage/web/iscsi/stream.rs
new file mode 100644
index 0000000000..4a235590aa
--- /dev/null
+++ b/rust/agama-server/src/storage/web/iscsi/stream.rs
@@ -0,0 +1,155 @@
+use std::{collections::HashMap, task::Poll};
+
+use agama_lib::{
+    dbus::{extract_id_from_path, get_optional_property},
+    error::ServiceError,
+    property_from_dbus,
+    storage::{ISCSIClient, ISCSINode},
+};
+use futures_util::{ready, Stream};
+use pin_project::pin_project;
+use thiserror::Error;
+use tokio::sync::mpsc::unbounded_channel;
+use tokio_stream::{wrappers::UnboundedReceiverStream, StreamExt};
+use zbus::zvariant::{ObjectPath, OwnedObjectPath, OwnedValue};
+
+use crate::{
+    dbus::{DBusObjectChange, DBusObjectChangesStream, ObjectsCache},
+    web::Event,
+};
+
+/// This stream listens for changes in the collection ISCSI nodes and emits
+/// the updated objects.
+///
+/// It relies on the [DBusObjectChangesStream] stream and uses a cache to avoid holding a bunch of
+/// proxy objects.
+#[pin_project]
+pub struct ISCSINodeStream {
+    dbus: zbus::Connection,
+    cache: ObjectsCache<ISCSINode>,
+    #[pin]
+    inner: UnboundedReceiverStream<DBusObjectChange>,
+}
+
+/// Internal stream error
+#[derive(Debug, Error)]
+enum ISCSINodeStreamError {
+    #[error("Service error: {0}")]
+    Service(#[from] ServiceError),
+    #[error("Unknown ISCSI node: {0}")]
+    UnknownNode(OwnedObjectPath),
+}
+
+impl ISCSINodeStream {
+    /// Creates a new stream.
+    ///
+    /// * `dbus`: D-Bus connection to listen on.
+    pub async fn new(dbus: &zbus::Connection) -> Result<Self, ServiceError> {
+        const MANAGER_PATH: &str = "/org/opensuse/Agama/Storage1";
+        const NAMESPACE: &str = "/org/opensuse/Agama/Storage1/iscsi_nodes";
+
+        let (tx, rx) = unbounded_channel();
+        let mut stream = DBusObjectChangesStream::new(
+            &dbus,
+            &ObjectPath::from_str_unchecked(MANAGER_PATH),
+            &ObjectPath::from_str_unchecked(NAMESPACE),
+            "org.opensuse.Agama.Storage1.ISCSI.Node",
+        )
+        .await?;
+
+        tokio::spawn(async move {
+            while let Some(change) = stream.next().await {
+                let _ = tx.send(change);
+            }
+        });
+        let rx = UnboundedReceiverStream::new(rx);
+
+        //  Populate the objects cache
+        let mut cache: ObjectsCache<ISCSINode> = Default::default();
+        let client = ISCSIClient::new(dbus.clone()).await?;
+        for node in client.get_nodes().await? {
+            let path = ObjectPath::from_string_unchecked(format!("{}/{}", NAMESPACE, node.id));
+            cache.add(path.into(), node);
+        }
+
+        Ok(Self {
+            dbus: dbus.clone(),
+            cache,
+            inner: rx,
+        })
+    }
+
+    fn update_node<'a>(
+        cache: &'a mut ObjectsCache<ISCSINode>,
+        path: &OwnedObjectPath,
+        values: &HashMap<String, OwnedValue>,
+    ) -> Result<&'a ISCSINode, ServiceError> {
+        let node = cache.find_or_create(&path);
+        node.id = extract_id_from_path(&path)?;
+        property_from_dbus!(node, target, "Target", values, str);
+        property_from_dbus!(node, address, "Address", values, str);
+        property_from_dbus!(node, interface, "Interface", values, str);
+        property_from_dbus!(node, startup, "Startup", values, str);
+        property_from_dbus!(node, port, "Port", values, u32);
+        property_from_dbus!(node, connected, "Connected", values, bool);
+        Ok(node)
+    }
+
+    fn remove_node(
+        cache: &mut ObjectsCache<ISCSINode>,
+        path: &OwnedObjectPath,
+    ) -> Result<ISCSINode, ISCSINodeStreamError> {
+        cache
+            .remove(&path)
+            .ok_or_else(|| ISCSINodeStreamError::UnknownNode(path.clone()))
+    }
+
+    fn handle_change(
+        cache: &mut ObjectsCache<ISCSINode>,
+        change: &DBusObjectChange,
+    ) -> Result<Event, ISCSINodeStreamError> {
+        match change {
+            DBusObjectChange::Added(path, values) => {
+                let node = Self::update_node(cache, path, &values)?;
+                Ok(Event::ISCSINodeAdded { node: node.clone() })
+            }
+            DBusObjectChange::Changed(path, updated) => {
+                let node = Self::update_node(cache, path, &updated)?;
+                Ok(Event::ISCSINodeChanged { node: node.clone() })
+            }
+            DBusObjectChange::Removed(path) => {
+                let node = Self::remove_node(cache, path)?;
+                Ok(Event::ISCSINodeRemoved { node })
+            }
+        }
+    }
+}
+
+impl Stream for ISCSINodeStream {
+    type Item = Event;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        let mut pinned = self.project();
+
+        Poll::Ready(loop {
+            let change = ready!(pinned.inner.as_mut().poll_next(cx));
+            let next_value = match change {
+                Some(change) => {
+                    if let Ok(event) = Self::handle_change(pinned.cache, &change) {
+                        Some(event)
+                    } else {
+                        log::warn!("Could not process change {:?}", &change);
+                        None
+                    }
+                }
+                None => break None,
+            };
+            if next_value.is_some() {
+                break next_value;
+            }
+        })
+    }
+}
diff --git a/rust/agama-server/src/web/docs.rs b/rust/agama-server/src/web/docs.rs
index 8d625b0c7e..e6d7d98f66 100644
--- a/rust/agama-server/src/web/docs.rs
+++ b/rust/agama-server/src/web/docs.rs
@@ -25,6 +25,12 @@ use utoipa::OpenApi;
         crate::users::web::remove_first_user,
         crate::users::web::patch_root,
         super::http::ping,
+        crate::storage::web::iscsi::initiator,
+        crate::storage::web::iscsi::update_initiator,
+        crate::storage::web::iscsi::nodes,
+        crate::storage::web::iscsi::update_node,
+        crate::storage::web::iscsi::delete_node,
+        crate::storage::web::iscsi::discover
     ),
     components(
         schemas(agama_lib::product::Product),
@@ -51,6 +57,14 @@ use utoipa::OpenApi;
         schemas(crate::users::web::RootConfig),
         schemas(crate::users::web::RootPatchSettings),
         schemas(super::http::PingResponse),
+        schemas(crate::storage::web::iscsi::InitiatorParams),
+        schemas(crate::storage::web::iscsi::DiscoverParams),
+        schemas(crate::storage::web::iscsi::NodeParams),
+        schemas(crate::storage::web::iscsi::LoginParams),
+        schemas(agama_lib::storage::client::iscsi::ISCSIInitiator),
+        schemas(agama_lib::storage::client::iscsi::ISCSINode),
+        schemas(agama_lib::storage::client::iscsi::ISCSIAuth),
+        schemas(agama_lib::storage::client::iscsi::LoginResult),
     )
 )]
 pub struct ApiDoc;
diff --git a/rust/agama-server/src/web/event.rs b/rust/agama-server/src/web/event.rs
index ffa15aa4b7..87a4c94787 100644
--- a/rust/agama-server/src/web/event.rs
+++ b/rust/agama-server/src/web/event.rs
@@ -1,7 +1,7 @@
 use crate::{l10n::web::LocaleConfig, network::model::NetworkChange};
 use agama_lib::{
     manager::InstallationPhase, product::RegistrationRequirement, progress::Progress,
-    software::SelectedBy, users::FirstUser,
+    software::SelectedBy, storage::ISCSINode, users::FirstUser,
 };
 use serde::Serialize;
 use std::collections::HashMap;
@@ -66,6 +66,19 @@ pub enum Event {
         path: String,
         errors: Vec<String>,
     },
+    ISCSINodeAdded {
+        node: ISCSINode,
+    },
+    ISCSINodeChanged {
+        node: ISCSINode,
+    },
+    ISCSINodeRemoved {
+        node: ISCSINode,
+    },
+    ISCSIInitiatorChanged {
+        name: Option<String>,
+        ibft: Option<bool>,
+    },
 }
 
 pub type EventsSender = Sender<Event>;
diff --git a/rust/package/agama.changes b/rust/package/agama.changes
index a860afb35e..2cf99b1725 100644
--- a/rust/package/agama.changes
+++ b/rust/package/agama.changes
@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Mon May 13 09:01:21 UTC 2024 - Imobach Gonzalez Sosa <igonzalezsosa@suse.com>
+
+- Extend the storage HTTP API to support handling the iSCSI
+  configuration (gh#openSUSE/agama#1187).
+
 -------------------------------------------------------------------
 Mon May 13 08:47:27 UTC 2024 - José Iván López González <jlopez@suse.com>
 
diff --git a/web/package/agama-web-ui.changes b/web/package/agama-web-ui.changes
index dd30487859..f8e1c87bfc 100644
--- a/web/package/agama-web-ui.changes
+++ b/web/package/agama-web-ui.changes
@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Mon May 13 09:01:29 UTC 2024 - Imobach Gonzalez Sosa <igonzalezsosa@suse.com>
+
+- Adapt the iSCSI UI to use the new HTTP API instead of D-Bus
+  (gh#openSUSE/agama#1187).
+
 -------------------------------------------------------------------
 Mon May 13 08:45:57 UTC 2024 - José Iván López González <jlopez@suse.com>
 
diff --git a/web/src/client/http.js b/web/src/client/http.js
index 96e1045637..fda36be371 100644
--- a/web/src/client/http.js
+++ b/web/src/client/http.js
@@ -173,7 +173,7 @@ class HTTPClient {
    * Registers a handler for a given type of events.
    *
    * @param {string} type - Event type (e.g., "LocaleChanged").
-   * @param {(object) => void} func - Handler function to register.
+   * @param {(event: Object) => void} func - Handler function to register.
    * @return {RemoveFn} - Function to remove the handler.
    */
   onEvent(type, func) {
diff --git a/web/src/client/software.js b/web/src/client/software.js
index 7bbf0d31cf..1a319a0b60 100644
--- a/web/src/client/software.js
+++ b/web/src/client/software.js
@@ -295,7 +295,7 @@ class ProductBaseClient {
 
     return {
       success: response.ok, // still we can fail 400 due to dbus issue or 500 if backend stop working. maybe some message for this case?
-      message: ""
+      message: "",
     };
   }
 
@@ -318,7 +318,7 @@ class ProductBaseClient {
 
     return {
       success: response.ok, // still we can fail 400 due to dbus issue or 500 if backend stop working. maybe some message for this case?
-      message: ""
+      message: "",
     };
   }
 
diff --git a/web/src/client/storage.js b/web/src/client/storage.js
index ee6050be30..c29c14bccf 100644
--- a/web/src/client/storage.js
+++ b/web/src/client/storage.js
@@ -23,14 +23,14 @@
 // cspell:ignore ptable
 
 import { compact, hex, uniq } from "~/utils";
-import { WithIssues, WithStatus, WithProgress } from "./mixins";
+import { WithIssues, WithProgress, WithStatus } from "./mixins";
 import { HTTPClient } from "./http";
 
 const STORAGE_OBJECT = "/org/opensuse/Agama/Storage1";
 const STORAGE_JOBS_NAMESPACE = "/org/opensuse/Agama/Storage1/jobs";
 const STORAGE_JOB_IFACE = "org.opensuse.Agama.Storage1.Job";
 const ISCSI_INITIATOR_IFACE = "org.opensuse.Agama.Storage1.ISCSI.Initiator";
-const ISCSI_NODES_NAMESPACE = "/org/opensuse/Agama/Storage1/iscsi_nodes";
+const ISCSI_NODES_NAMESPACE = "/storage/iscsi/nodes";
 const ISCSI_NODE_IFACE = "org.opensuse.Agama.Storage1.ISCSI.Node";
 const DASD_MANAGER_IFACE = "org.opensuse.Agama.Storage1.DASD.Manager";
 const DASD_DEVICES_NAMESPACE = "/org/opensuse/Agama/Storage1/dasds";
@@ -1305,40 +1305,28 @@ class ZFCPManager {
  */
 class ISCSIManager {
   /**
-   * @param {string} service - D-Bus service name
-   * @param {string} address - D-Bus address
+   * @param {import("./http").HTTPClient} client - HTTP client.
    */
-  constructor(service, address) {
-    this.service = service;
-    this.address = address;
-    this.proxies = {};
+  constructor(client) {
+    this.client = client;
   }
 
   /**
-   * @return {DBusClient} client
+   * Gets the iSCSI initiator
+   *
+   * @return {Promise<ISCSIInitiator>}
+   *
+   * @typedef {object} ISCSIInitiator
+   * @property {string} name
+   * @property {boolean} ibft
    */
-  client() {
-    // return this.assigned_client;
-    if (!this._client) {
-      this._client = new DBusClient(this.service, this.address);
+  async getInitiator() {
+    const response = await this.client.get("/storage/iscsi/initiator");
+    if (!response.ok) {
+      console.error("Failed to get the iSCSI initiator", response);
     }
 
-    return this._client;
-  }
-
-  async getInitiatorIbft() {
-    const proxy = await this.iscsiInitiatorProxy();
-    return proxy.IBFT;
-  }
-
-  /**
-   * Gets the iSCSI initiator name
-   *
-   * @returns {Promise<string>}
-   */
-  async getInitiatorName() {
-    const proxy = await this.iscsiInitiatorProxy();
-    return proxy.InitiatorName;
+    return response.json();
   }
 
   /**
@@ -1346,9 +1334,8 @@ class ISCSIManager {
    *
    * @param {string} value
    */
-  async setInitiatorName(value) {
-    const proxy = await this.iscsiInitiatorProxy();
-    proxy.InitiatorName = value;
+  setInitiatorName(value) {
+    return this.client.patch("/storage/iscsi/initiator", { name: value });
   }
 
   /**
@@ -1367,8 +1354,12 @@ class ISCSIManager {
    * @property {string} startup
    */
   async getNodes() {
-    const proxy = await this.iscsiNodesProxy();
-    return Object.values(proxy).map(this.buildNode);
+    const response = await this.client.get("/storage/iscsi/nodes");
+    if (!response.ok) {
+      console.error("Failed to get the list of iSCSI nodes", response);
+    }
+
+    return response.json();
   }
 
   /**
@@ -1384,18 +1375,16 @@ class ISCSIManager {
    * @property {string} [reverseUsername] - Username for authentication by initiator
    * @property {string} [reversePassword] - Password for authentication by initiator
    *
-   * @returns {Promise<number>} 0 on success, 1 on failure
+   * @returns {Promise<boolean>} true on success, false on failure
    */
   async discover(address, port, options = {}) {
-    const auth = removeUndefinedCockpitProperties({
-      Username: { t: "s", v: options.username },
-      Password: { t: "s", v: options.password },
-      ReverseUsername: { t: "s", v: options.reverseUsername },
-      ReversePassword: { t: "s", v: options.reversePassword }
-    });
-
-    const proxy = await this.iscsiInitiatorProxy();
-    return proxy.Discover(address, port, auth);
+    const data = {
+      address,
+      port,
+      options,
+    };
+    const response = await this.client.post("/storage/iscsi/discover", data);
+    return response.ok;
   }
 
   /**
@@ -1404,25 +1393,21 @@ class ISCSIManager {
    * @param {ISCSINode} node
    * @param {String} startup
    */
-  async setStartup(node, startup) {
-    const path = this.nodePath(node);
-
-    const proxy = await this.client().proxy(ISCSI_NODE_IFACE, path);
-    proxy.Startup = startup;
+  setStartup(node, startup) {
+    this.client.patch(this.nodePath(node), { startup });
   }
 
   /**
    * Deletes the given iSCSI node
    *
    * @param {ISCSINode} node
-   * @returns {Promise<number>} 0 on success, 1 on failure if the given path is not exported, 2 on
+   * @returns {Promise<boolean>} 0 on success, 1 on failure if the given path is not exported, 2 on
    *  failure because any other reason.
    */
   async delete(node) {
-    const path = this.nodePath(node);
-
-    const proxy = await this.iscsiInitiatorProxy();
-    return proxy.Delete(path);
+    // FIXME: return the proper error code
+    const response = await this.client.delete(this.nodePath(node));
+    return response.ok;
   }
 
   /**
@@ -1442,63 +1427,87 @@ class ISCSIManager {
    *  valid, and 2 on failure because any other reason
    */
   async login(node, options = {}) {
-    const path = this.nodePath(node);
-
-    const dbusOptions = removeUndefinedCockpitProperties({
-      Username: { t: "s", v: options.username },
-      Password: { t: "s", v: options.password },
-      ReverseUsername: { t: "s", v: options.reverseUsername },
-      ReversePassword: { t: "s", v: options.reversePassword },
-      Startup: { t: "s", v: options.startup }
-    });
+    const path = this.nodePath(node) + "/login";
+    const response = await this.client.post(path, options);
+    if (!response.ok) {
+      const reason = await response.json();
+      console.warn("Could not login into the iSCSI node", reason);
+      return reason === "InvalidStartup" ? 1 : 2;
+    }
 
-    const proxy = await this.client().proxy(ISCSI_NODE_IFACE, path);
-    return proxy.Login(dbusOptions);
+    return 0;
   }
 
   /**
    * Closes an iSCSI session
    *
    * @param {ISCSINode} node
-   * @returns {Promise<number>} 0 on success, 1 on failure
+   * @returns {Promise<boolean>} true on success, false on failure
    */
   async logout(node) {
-    const path = this.nodePath(node);
-    // const iscsiNode = new ISCSINodeObject(this.client, path);
-    // return await iscsiNode.iface.logout();
-    const proxy = await this.client().proxy(ISCSI_NODE_IFACE, path);
-    return proxy.Logout();
+    const path = this.nodePath(node) + "/logout";
+    const response = await this.client.post(path);
+    if (!response.ok) {
+      console.error("Could not logout from the iSCSI node", response);
+      return false;
+    }
+
+    return true;
   }
 
+  /**
+   * Registers a callback for initiator changes.
+   *
+   * @param {(event: object) => void} handler - Callback.
+   */
   onInitiatorChanged(handler) {
-    return this.client().onObjectChanged(STORAGE_OBJECT, ISCSI_INITIATOR_IFACE, (changes) => {
-      const data = {
-        name: changes.InitiatorName?.v,
-        ibft: changes.IBFT?.v
-      };
+    return this.client.onEvent("ISCSIInitiatorChanged", handler);
+  }
 
-      const filtered = Object.entries(data).filter(([, v]) => v !== undefined);
-      return handler(Object.fromEntries(filtered));
-    });
+  /**
+   * Registers a callback to run when an iSCSI node appears.
+   *
+   * @param {(node: ISCSINode) => void} handler - callback which receives the
+   *   ISCSINode object.
+   */
+  onNodeAdded(handler) {
+    return this.onNodeEvent("ISCSINodeAdded", handler);
   }
 
-  async onNodeAdded(handler) {
-    const proxy = await this.iscsiNodesProxy();
-    proxy.addEventListener("added", (_, proxy) => handler(this.buildNode(proxy)));
+  /**
+   * Registers a callback to run when an iSCSI node changes.
+   *
+   * @param {(node: ISCSINode) => void} handler - callback which receives the
+   *   ISCSINode object.
+   */
+  onNodeChanged(handler) {
+    return this.onNodeEvent("ISCSINodeChanged", handler);
   }
 
-  async onNodeChanged(handler) {
-    const proxy = await this.iscsiNodesProxy();
-    proxy.addEventListener("changed", (_, proxy) => handler(this.buildNode(proxy)));
+  /**
+   * Registers a callback to run when an iSCSI node disappears.
+   *
+   * @param {(node: ISCSINode) => void} handler - callback which receives the
+   *   ISCSINode object.
+   */
+  onNodeRemoved(handler) {
+    return this.onNodeEvent("ISCSINodeRemoved", handler);
   }
 
-  async onNodeRemoved(handler) {
-    const proxy = await this.iscsiNodesProxy();
-    proxy.addEventListener("removed", (_, proxy) => handler(this.buildNode(proxy)));
+  /**
+   * @private
+   * Registers a handler for the given iSCSI node event.
+   *
+   * @param {string} eventName - Event name.
+   * @param {(node: ISCSINode) => void} handler - callback which receives the
+   *   ISCSINode object.
+   */
+  onNodeEvent(eventName, handler) {
+    return this.client.onEvent(eventName, ({ node }) => handler(node));
   }
 
   buildNode(proxy) {
-    const id = path => path.split("/").slice(-1)[0];
+    const id = (path) => path.split("/").slice(-1)[0];
 
     return {
       id: id(proxy.path),
@@ -1508,39 +1517,10 @@ class ISCSIManager {
       interface: proxy.Interface,
       ibft: proxy.IBFT,
       connected: proxy.Connected,
-      startup: proxy.Startup
+      startup: proxy.Startup,
     };
   }
 
-  /**
-   * @private
-   * Proxy for org.opensuse.Agama.Storage1.ISCSI.Initiator iface
-   *
-   * @returns {Promise<object>}
-   */
-  async iscsiInitiatorProxy() {
-    if (!this.proxies.iscsiInitiator) {
-      this.proxies.iscsiInitiator = await this.client().proxy(ISCSI_INITIATOR_IFACE, STORAGE_OBJECT);
-    }
-
-    return this.proxies.iscsiInitiator;
-  }
-
-  /**
-   * @private
-   * Proxy for objects implementing org.opensuse.Agama.Storage1.ISCSI.Node iface
-   *
-   * @note The ISCSI nodes are dynamically exported.
-   *
-   * @returns {Promise<object>}
-   */
-  async iscsiNodesProxy() {
-    if (!this.proxies.iscsiNodes)
-      this.proxies.iscsiNodes = await this.client().proxies(ISCSI_NODE_IFACE, ISCSI_NODES_NAMESPACE);
-
-    return this.proxies.iscsiNodes;
-  }
-
   /**
    * @private
    * Builds the D-Bus path for the given iSCSI node
@@ -1569,7 +1549,7 @@ class StorageBaseClient {
     this.system = new DevicesManager(this.client, "system");
     this.staging = new DevicesManager(this.client, "result");
     this.proposal = new ProposalManager(this.client, this.system);
-    this.iscsi = new ISCSIManager(StorageBaseClient.SERVICE, client);
+    this.iscsi = new ISCSIManager(this.client);
     this.dasd = new DASDManager(StorageBaseClient.SERVICE, client);
     this.zfcp = new ZFCPManager(StorageBaseClient.SERVICE, client);
   }
diff --git a/web/src/client/storage.test.js b/web/src/client/storage.test.js
index d9ecd84825..6b4d2e73d9 100644
--- a/web/src/client/storage.test.js
+++ b/web/src/client/storage.test.js
@@ -22,6 +22,7 @@
 // @ts-check
 // cspell:ignore ECKD dasda ddgdcbibhd wwpns
 
+import { HTTPClient } from "./http";
 import DBusClient from "./dbus";
 import { HTTPClient } from "./http";
 import { StorageClient } from "./storage";
@@ -593,6 +594,28 @@ const contexts = {
       }
     };
   },
+  withISCSINodes: () => [
+    {
+      id: 1,
+      target: "iqn.2023-01.com.example:37dac",
+      address: "192.168.100.101",
+      port: 3260,
+      interface: "default",
+      ibft: false,
+      connected: false,
+      startup: "",
+    },
+    {
+      id: 2,
+      target: "iqn.2023-01.com.example:74afb",
+      address: "192.168.100.102",
+      port: 3260,
+      interface: "default",
+      ibft: true,
+      connected: true,
+      startup: "onboot",
+    },
+  ],
   withoutDASDDevices: () => {
     cockpitProxies.dasdDevices = {};
   },
@@ -2250,40 +2273,41 @@ describe.skip("#zfcp", () => {
 
 describe("#iscsi", () => {
   beforeEach(() => {
-    client = new StorageClient();
+    client = new StorageClient(new HTTPClient(new URL("http://localhost")));
   });
 
-  describe("#getInitiatorName", () => {
+  describe("#getInitiator", () => {
     beforeEach(() => {
-      cockpitProxies.iscsiInitiator = {
-        InitiatorName: "iqn.1996-04.com.suse:01:351e6d6249"
-      };
+      mockJsonFn.mockResolvedValue({
+        name: "iqn.1996-04.com.suse:01:351e6d6249",
+        ibft: false,
+      });
     });
 
-    it("returns the current initiator name", async () => {
-      const initiatorName = await client.iscsi.getInitiatorName();
-      expect(initiatorName).toEqual("iqn.1996-04.com.suse:01:351e6d6249");
+    it("returns the current initiator", async () => {
+      const { name, ibft } = await client.iscsi.getInitiator();
+      expect(name).toEqual("iqn.1996-04.com.suse:01:351e6d6249");
+      expect(ibft).toEqual(false);
     });
   });
 
   describe("#setInitiatorName", () => {
     beforeEach(() => {
       cockpitProxies.iscsiInitiator = {
-        InitiatorName: "iqn.1996-04.com.suse:01:351e6d6249"
+        InitiatorName: "iqn.1996-04.com.suse:01:351e6d6249",
       };
     });
 
     it("sets the given initiator name", async () => {
       await client.iscsi.setInitiatorName("test");
-      const initiatorName = await client.iscsi.getInitiatorName();
-      expect(initiatorName).toEqual("test");
+      expect(mockPatchFn).toHaveBeenCalledWith("/storage/iscsi/initiator", { name: "test" });
     });
   });
 
   describe("#getNodes", () => {
     describe("if there is no exported iSCSI nodes yet", () => {
       beforeEach(() => {
-        contexts.withoutISCSINodes();
+        mockJsonFn.mockResolvedValue([]);
       });
 
       it("returns an empty list", async () => {
@@ -2294,119 +2318,105 @@ describe("#iscsi", () => {
 
     describe("if there are exported iSCSI nodes", () => {
       beforeEach(() => {
-        contexts.withISCSINodes();
+        mockJsonFn.mockResolvedValue(contexts.withISCSINodes());
       });
 
       it("returns a list with the exported iSCSI nodes", async () => {
         const result = await client.iscsi.getNodes();
         expect(result.length).toEqual(2);
         expect(result).toContainEqual({
-          id: "1",
+          id: 1,
           target: "iqn.2023-01.com.example:37dac",
           address: "192.168.100.101",
-          port:  3260,
+          port: 3260,
           interface: "default",
           ibft: false,
           connected: false,
-          startup: ""
+          startup: "",
         });
         expect(result).toContainEqual({
-          id: "2",
+          id: 2,
           target: "iqn.2023-01.com.example:74afb",
           address: "192.168.100.102",
-          port:  3260,
+          port: 3260,
           interface: "default",
           ibft: true,
           connected: true,
-          startup: "onboot"
+          startup: "onboot",
         });
       });
     });
   });
 
   describe("#discover", () => {
-    beforeEach(() => {
-      cockpitProxies.iscsiInitiator = {
-        Discover: jest.fn()
-      };
-    });
-
     it("performs an iSCSI discovery with the given options", async () => {
-      await client.iscsi.discover("192.168.100.101", 3260, {
+      const options = {
         username: "test",
         password: "12345",
         reverseUsername: "target",
-        reversePassword: "nonsecret"
-      });
-
-      expect(cockpitProxies.iscsiInitiator.Discover).toHaveBeenCalledWith("192.168.100.101", 3260, {
-        Username: { t: "s", v: "test" },
-        Password: { t: "s", v: "12345" },
-        ReverseUsername: { t: "s", v: "target" },
-        ReversePassword: { t: "s", v: "nonsecret" }
-      });
-    });
-  });
-
-  describe("#Delete", () => {
-    beforeEach(() => {
-      cockpitProxies.iscsiInitiator = {
-        Delete: jest.fn()
+        reversePassword: "nonsecret",
       };
+      await client.iscsi.discover("192.168.100.101", 3260, options);
+      expect(mockPostFn).toHaveBeenCalledWith(
+        "/storage/iscsi/discover",
+        { address: "192.168.100.101", port: 3260, options },
+      );
     });
+  });
 
+  describe("#delete", () => {
     it("deletes the given iSCSI node", async () => {
       await client.iscsi.delete({ id: "1" });
-      expect(cockpitProxies.iscsiInitiator.Delete).toHaveBeenCalledWith(
-        "/org/opensuse/Agama/Storage1/iscsi_nodes/1"
+      expect(mockDeleteFn).toHaveBeenCalledWith(
+        "/storage/iscsi/nodes/1",
       );
     });
   });
 
   describe("#login", () => {
-    const nodeProxy = {
-      Login: jest.fn()
+    let auth = {
+      username: "test",
+      password: "12345",
+      reverseUsername: "target",
+      reversePassword: "nonsecret",
+      startup: "automatic",
     };
 
-    beforeEach(() => {
-      cockpitProxies.iscsiNode = {
-        "/org/opensuse/Agama/Storage1/iscsi_nodes/1": nodeProxy
-      };
+    it("performs an iSCSI login with the given options", async () => {
+      const result = await client.iscsi.login({ id: "1" }, auth);
+
+      expect(result).toEqual(0);
+      expect(mockPostFn).toHaveBeenCalledWith(
+        "/storage/iscsi/nodes/1/login",
+        auth,
+      );
     });
 
-    it("performs an iSCSI login with the given options", async () => {
-      await client.iscsi.login({ id: "1" }, {
-        username: "test",
-        password: "12345",
-        reverseUsername: "target",
-        reversePassword: "nonsecret",
-        startup: "automatic"
-      });
+    it("returns 1 when the startup is invalid", async () => {
+      mockPostFn.mockImplementation(() => (
+        { ok: false, json: mockJsonFn }
+      ));
+      mockJsonFn.mockResolvedValue("InvalidStartup");
 
-      expect(nodeProxy.Login).toHaveBeenCalledWith({
-        Username: { t: "s", v: "test" },
-        Password: { t: "s", v: "12345" },
-        ReverseUsername: { t: "s", v: "target" },
-        ReversePassword: { t: "s", v: "nonsecret" },
-        Startup: { t: "s", v: "automatic" }
-      });
+      const result = await client.iscsi.login({ id: "1" }, { ...auth, startup: "invalid" });
+      expect(result).toEqual(1);
     });
-  });
 
-  describe("#logout", () => {
-    const nodeProxy = {
-      Logout: jest.fn()
-    };
+    it("returns 2 in case of an error different from an invalid startup value", async () => {
+      mockPostFn.mockImplementation(() => (
+        { ok: false, json: mockJsonFn }
+      ));
+      mockJsonFn.mockResolvedValue("Failed");
 
-    beforeEach(() => {
-      cockpitProxies.iscsiNode = {
-        "/org/opensuse/Agama/Storage1/iscsi_nodes/1": nodeProxy
-      };
+      const result = await client.iscsi.login({ id: "1" }, { ...auth, startup: "invalid" });
+      expect(result).toEqual(2);
     });
+  });
 
+  describe("#logout", () => {
     it("performs an iSCSI logout of the given node", async () => {
       await client.iscsi.logout({ id: "1" });
-      expect(nodeProxy.Logout).toHaveBeenCalled();
+      expect(mockPostFn).toHaveBeenCalledWith("/storage/iscsi/nodes/1/logout");
     });
   });
 });
diff --git a/web/src/components/storage/iscsi/DiscoverForm.jsx b/web/src/components/storage/iscsi/DiscoverForm.jsx
index 02df383c92..e66574e60a 100644
--- a/web/src/components/storage/iscsi/DiscoverForm.jsx
+++ b/web/src/components/storage/iscsi/DiscoverForm.jsx
@@ -55,11 +55,12 @@ export default function DiscoverForm({ onSubmit: onSubmitProp, onCancel }) {
 
   useEffect(() => {
     // Scroll the alert into view
-    if (isFailed)
+    if (isFailed) {
       alertRef.current.scrollIntoView({
         behavior: "smooth",
-        block: "start"
+        block: "start",
       });
+    }
   });
 
   const updateData = (key, value) => setData({ ...data, [key]: value });
@@ -72,9 +73,9 @@ export default function DiscoverForm({ onSubmit: onSubmitProp, onCancel }) {
     setIsLoading(true);
     setSavedData(data);
 
-    const result = await onSubmitProp(data);
+    const success = await onSubmitProp(data);
 
-    if (result !== 0) {
+    if (!success) {
       setIsFailed(true);
       setIsLoading(false);
     }
@@ -100,16 +101,18 @@ export default function DiscoverForm({ onSubmit: onSubmitProp, onCancel }) {
     // TRANSLATORS: popup title
     <Popup isOpen title={_("Discover iSCSI Targets")}>
       <Form id={id} onSubmit={onSubmit}>
-        { isFailed &&
-          <div ref={alertRef}>
-            <Alert
-              variant="warning"
-              isInline
-              title={_("Something went wrong")}
-            >
-              <p>{_("Make sure you provide the correct values")}</p>
-            </Alert>
-          </div> }
+        {isFailed &&
+          (
+            <div ref={alertRef}>
+              <Alert
+                variant="warning"
+                isInline
+                title={_("Something went wrong")}
+              >
+                <p>{_("Make sure you provide the correct values")}</p>
+              </Alert>
+            </div>
+          )}
         <FormGroup
           fieldId="address"
           label={_("IP address")}
diff --git a/web/src/components/storage/iscsi/InitiatorPresenter.jsx b/web/src/components/storage/iscsi/InitiatorPresenter.jsx
index 214521f372..9c06f77ea9 100644
--- a/web/src/components/storage/iscsi/InitiatorPresenter.jsx
+++ b/web/src/components/storage/iscsi/InitiatorPresenter.jsx
@@ -21,10 +21,10 @@
 
 import React, { useEffect, useState } from "react";
 import { Skeleton } from "@patternfly/react-core";
-import { Table, Thead, Tr, Th, Tbody, Td } from '@patternfly/react-table';
+import { Table, Tbody, Td, Th, Thead, Tr } from "@patternfly/react-table";
 
 import { _ } from "~/i18n";
-import { RowActions } from '~/components/core';
+import { RowActions } from "~/components/core";
 import { InitiatorForm } from "~/components/storage/iscsi";
 
 export default function InitiatorPresenter({ initiator, client }) {
@@ -46,14 +46,14 @@ export default function InitiatorPresenter({ initiator, client }) {
 
   const initiatorActions = () => {
     const actions = {
-      edit: { title: _("Edit"), onClick: openForm }
+      edit: { title: _("Edit"), onClick: openForm },
     };
 
     return [actions.edit];
   };
 
   const Content = () => {
-    if (isLoading) {
+    if (isLoading || !initiator) {
       return (
         <Tr>
           <Td colSpan={4}>
@@ -92,12 +92,14 @@ export default function InitiatorPresenter({ initiator, client }) {
           <Content />
         </Tbody>
       </Table>
-      { isFormOpen &&
-        <InitiatorForm
-          initiator={initiator}
-          onSubmit={submitForm}
-          onCancel={closeForm}
-        /> }
+      {isFormOpen &&
+        (
+          <InitiatorForm
+            initiator={initiator}
+            onSubmit={submitForm}
+            onCancel={closeForm}
+          />
+        )}
     </>
   );
 }
diff --git a/web/src/components/storage/iscsi/InitiatorSection.jsx b/web/src/components/storage/iscsi/InitiatorSection.jsx
index e7728eaf11..ebe9c3eeb4 100644
--- a/web/src/components/storage/iscsi/InitiatorSection.jsx
+++ b/web/src/components/storage/iscsi/InitiatorSection.jsx
@@ -35,8 +35,7 @@ export default function InitiatorSection() {
   useEffect(() => {
     const loadInitiator = async () => {
       setInitiator(undefined);
-      const name = await cancellablePromise(client.iscsi.getInitiatorName());
-      const ibft = await cancellablePromise(client.iscsi.getInitiatorIbft());
+      const { name, ibft } = await cancellablePromise(client.iscsi.getInitiator());
       setInitiator({ name, ibft, offloadCard: "" });
     };
 
diff --git a/web/src/components/storage/iscsi/TargetsSection.jsx b/web/src/components/storage/iscsi/TargetsSection.jsx
index 442d51675c..982f4fd08b 100644
--- a/web/src/components/storage/iscsi/TargetsSection.jsx
+++ b/web/src/components/storage/iscsi/TargetsSection.jsx
@@ -121,13 +121,16 @@ export default function TargetsSection() {
 
   const submitDiscoverForm = async (data) => {
     const { username, password, reverseUsername, reversePassword } = data;
-    const result = await client.iscsi.discover(data.address, parseInt(data.port), {
-      username, password, reverseUsername, reversePassword
+    const success = await client.iscsi.discover(data.address, parseInt(data.port), {
+      username,
+      password,
+      reverseUsername,
+      reversePassword,
     });
 
-    if (result === 0) closeDiscoverForm();
+    if (success) closeDiscoverForm();
 
-    return result;
+    return success;
   };
 
   const SectionContent = () => {