diff --git a/src/App.tsx b/src/App.tsx
index aef94e5db3..07ed53530a 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -218,6 +218,14 @@ const App: FC = () => {
             />
           }
         />
+        <Route
+          path="/ui/project/:project/member/:member/network/:name"
+          element={
+            <ProtectedRoute
+              outlet={<ProjectLoader outlet={<NetworkDetail />} />}
+            />
+          }
+        />
         <Route
           path="/ui/project/:project/network/:name/:activeTab"
           element={
diff --git a/src/api/networks.tsx b/src/api/networks.tsx
index 230cda6525..f0f736783d 100644
--- a/src/api/networks.tsx
+++ b/src/api/networks.tsx
@@ -1,12 +1,21 @@
 import { handleEtagResponse, handleResponse } from "util/helpers";
-import type { LxdNetwork, LxdNetworkState } from "types/network";
+import type {
+  LxdNetwork,
+  LXDNetworkOnClusterMember,
+  LxdNetworkState,
+} from "types/network";
 import type { LxdApiResponse } from "types/apiResponse";
-import type { LxdClusterMember } from "types/cluster";
 import { areNetworksEqual } from "util/networks";
+import type { ClusterSpecificValues } from "components/ClusterSpecificSelect";
+import type { LxdClusterMember } from "types/cluster";
 
-export const fetchNetworks = (project: string): Promise<LxdNetwork[]> => {
+export const fetchNetworks = (
+  project: string,
+  target?: string,
+): Promise<LxdNetwork[]> => {
+  const targetParam = target ? `&target=${target}` : "";
   return new Promise((resolve, reject) => {
-    fetch(`/1.0/networks?project=${project}&recursion=1`)
+    fetch(`/1.0/networks?project=${project}&recursion=1${targetParam}`)
       .then(handleResponse)
       .then((data: LxdApiResponse<LxdNetwork[]>) => {
         const filteredNetworks = data.metadata.filter(
@@ -20,24 +29,97 @@ export const fetchNetworks = (project: string): Promise<LxdNetwork[]> => {
   });
 };
 
+export const fetchNetworksFromClusterMembers = (
+  project: string,
+  clusterMembers: LxdClusterMember[],
+): Promise<LXDNetworkOnClusterMember[]> => {
+  return new Promise((resolve, reject) => {
+    Promise.allSettled(
+      clusterMembers.map((member) => {
+        return fetchNetworks(project, member.server_name);
+      }),
+    )
+      .then((results) => {
+        const error = results.find((res) => res.status === "rejected")
+          ?.reason as Error | undefined;
+
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        const result: LXDNetworkOnClusterMember[] = [];
+
+        for (let i = 0; i < clusterMembers.length; i++) {
+          const memberName = clusterMembers[i].server_name;
+          const networks = results[i] as PromiseFulfilledResult<LxdNetwork[]>;
+          networks.value.forEach((network) =>
+            result.push({ ...network, memberName }),
+          );
+        }
+
+        resolve(result);
+      })
+      .catch(reject);
+  });
+};
+
 export const fetchNetwork = (
   name: string,
   project: string,
+  target?: string,
 ): Promise<LxdNetwork> => {
+  const targetParam = target ? `&target=${target}` : "";
   return new Promise((resolve, reject) => {
-    fetch(`/1.0/networks/${name}?project=${project}`)
+    fetch(`/1.0/networks/${name}?project=${project}${targetParam}`)
       .then(handleEtagResponse)
       .then((data) => resolve(data as LxdNetwork))
       .catch(reject);
   });
 };
 
+export const fetchNetworkFromClusterMembers = (
+  name: string,
+  project: string,
+  clusterMembers: LxdClusterMember[],
+): Promise<LXDNetworkOnClusterMember[]> => {
+  return new Promise((resolve, reject) => {
+    Promise.allSettled(
+      clusterMembers.map((member) => {
+        return fetchNetwork(name, project, member.server_name);
+      }),
+    )
+      .then((results) => {
+        const error = results.find((res) => res.status === "rejected")
+          ?.reason as Error | undefined;
+
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        const result: LXDNetworkOnClusterMember[] = [];
+
+        for (let i = 0; i < clusterMembers.length; i++) {
+          const name = clusterMembers[i].server_name;
+          const promise = results[i] as PromiseFulfilledResult<LxdNetwork>;
+          result.push({ ...promise.value, memberName: name });
+        }
+
+        resolve(result);
+      })
+      .catch(reject);
+  });
+};
+
 export const fetchNetworkState = (
   name: string,
   project: string,
+  target?: string,
 ): Promise<LxdNetworkState> => {
+  const targetParam = target ? `&target=${target}` : "";
   return new Promise((resolve, reject) => {
-    fetch(`/1.0/networks/${name}/state?project=${project}`)
+    fetch(`/1.0/networks/${name}/state?project=${project}${targetParam}`)
       .then(handleResponse)
       .then((data: LxdApiResponse<LxdNetworkState>) => resolve(data.metadata))
       .catch(reject);
@@ -48,20 +130,21 @@ export const createClusterNetwork = (
   network: Partial<LxdNetwork>,
   project: string,
   clusterMembers: LxdClusterMember[],
+  parentsPerClusterMember?: ClusterSpecificValues,
 ): Promise<void> => {
   return new Promise((resolve, reject) => {
-    const memberNetwork = {
-      name: network.name,
-      description: network.description,
-      type: network.type,
-      config: {
-        parent: network.config?.parent,
-      },
-    };
-
     Promise.allSettled(
-      clusterMembers.map(async (member) => {
-        await createNetwork(memberNetwork, project, member.server_name);
+      clusterMembers.map((member) => {
+        const memberNetwork = {
+          name: network.name,
+          type: network.type,
+          config: {
+            parent: parentsPerClusterMember?.[member.server_name],
+          },
+        };
+        createNetwork(memberNetwork, project, member.server_name).catch(
+          (e: Error) => Promise.reject(e),
+        );
       }),
     )
       .then((results) => {
@@ -72,6 +155,7 @@ export const createClusterNetwork = (
           reject(error);
           return;
         }
+
         // The network parent is cluster member specific, so we omit it on the cluster wide network configuration.
         delete network.config?.parent;
         createNetwork(network, project).then(resolve).catch(reject);
@@ -110,15 +194,20 @@ export const createNetwork = (
 export const updateNetwork = (
   network: Partial<LxdNetwork> & Required<Pick<LxdNetwork, "config">>,
   project: string,
+  target?: string,
 ): Promise<void> => {
   return new Promise((resolve, reject) => {
-    fetch(`/1.0/networks/${network.name ?? ""}?project=${project}`, {
-      method: "PUT",
-      body: JSON.stringify(network),
-      headers: {
-        "If-Match": network.etag ?? "invalid-etag",
+    const targetParam = target ? `&target=${target}` : "";
+    fetch(
+      `/1.0/networks/${network.name ?? ""}?project=${project}${targetParam}`,
+      {
+        method: "PUT",
+        body: JSON.stringify(network),
+        headers: {
+          "If-Match": network.etag ?? "",
+        },
       },
-    })
+    )
       .then(handleResponse)
       .then(resolve)
       .catch(async (e: Error) => {
@@ -135,6 +224,52 @@ export const updateNetwork = (
   });
 };
 
+export const updateClusterNetwork = (
+  network: Partial<LxdNetwork> & Required<Pick<LxdNetwork, "config">>,
+  project: string,
+  parentsPerClusterMember?: ClusterSpecificValues,
+): Promise<void> => {
+  if (!parentsPerClusterMember) {
+    return updateNetwork(network, project);
+  }
+
+  return new Promise((resolve, reject) => {
+    Promise.allSettled(
+      Object.keys(parentsPerClusterMember).map((memberName) => {
+        const memberNetwork = {
+          name: network.name,
+          type: network.type,
+          config: {
+            parent: parentsPerClusterMember[memberName],
+          },
+          etag: "",
+        };
+        return updateNetwork(memberNetwork, project, memberName).catch(
+          (e: Error) =>
+            Promise.reject(
+              new Error(
+                `Error on network update on cluster member ${memberName}. ${e.message}`,
+              ),
+            ),
+        );
+      }),
+    )
+      .then((results) => {
+        const error = results.find((res) => res.status === "rejected")
+          ?.reason as Error | undefined;
+
+        if (error) {
+          reject(error);
+          return;
+        }
+        updateNetwork({ ...network, etag: "" }, project)
+          .then(resolve)
+          .catch(reject);
+      })
+      .catch(reject);
+  });
+};
+
 export const renameNetwork = (
   oldName: string,
   newName: string,
diff --git a/src/components/ClusterSpecificSelect.tsx b/src/components/ClusterSpecificSelect.tsx
new file mode 100644
index 0000000000..416315a423
--- /dev/null
+++ b/src/components/ClusterSpecificSelect.tsx
@@ -0,0 +1,181 @@
+import { FC, Fragment, type OptionHTMLAttributes, useState } from "react";
+import {
+  Button,
+  CheckboxInput,
+  Icon,
+  Select,
+} from "@canonical/react-components";
+import ResourceLink from "components/ResourceLink";
+import { useParams } from "react-router-dom";
+import { intersection } from "util/intersection";
+
+export type ClusterSpecificValues = Record<string, string>;
+
+export interface ClusterSpecificSelectOption {
+  memberName: string;
+  values: string[];
+}
+
+interface Props {
+  id: string;
+  isReadOnly: boolean;
+  onChange: (value: ClusterSpecificValues) => void;
+  toggleReadOnly: () => void;
+  options: ClusterSpecificSelectOption[];
+  values?: ClusterSpecificValues;
+  canToggleSpecific?: boolean;
+  isDefaultSpecific?: boolean;
+}
+
+const ClusterSpecificSelect: FC<Props> = ({
+  id,
+  isReadOnly,
+  options,
+  values,
+  onChange,
+  toggleReadOnly,
+  canToggleSpecific = true,
+  isDefaultSpecific = false,
+}) => {
+  const { project } = useParams<{ project: string }>();
+
+  const [isSpecific, setIsSpecific] = useState(isDefaultSpecific);
+
+  const toSelectOption = (
+    value: string,
+  ): OptionHTMLAttributes<HTMLOptionElement> => {
+    return {
+      label: value,
+      value: value,
+    };
+  };
+
+  const allMemberOptions: OptionHTMLAttributes<HTMLOptionElement>[] = [];
+  if (options.length > 0) {
+    const optionsPerMember = options.map((item) => item.values);
+    const optionsOnAllMembers = intersection(optionsPerMember);
+    optionsOnAllMembers.forEach((value) => {
+      const option = toSelectOption(value);
+      allMemberOptions.push(option);
+    });
+  }
+  allMemberOptions.unshift({
+    label:
+      allMemberOptions.length === 0 ? "No option available" : "Select option",
+    value: "",
+  });
+
+  const firstValue = Object.values(values ?? {})[0];
+
+  const setValueForAllMembers = (value: string) => {
+    const update: ClusterSpecificValues = {};
+    options.map((item) => (update[item.memberName] = value));
+    onChange(update);
+  };
+
+  const setValueForMember = (value: string, member: string) => {
+    const update = {
+      ...values,
+      [member]: value,
+    };
+    onChange(update);
+  };
+
+  const editButton = (
+    <Button
+      onClick={toggleReadOnly}
+      className="u-no-margin--bottom"
+      type="button"
+      appearance="base"
+      title="Edit"
+      hasIcon
+    >
+      <Icon name="edit" />
+    </Button>
+  );
+
+  return (
+    <div className="u-sv3">
+      {canToggleSpecific && !isReadOnly && (
+        <CheckboxInput
+          id={`${id}-same-for-all-toggle`}
+          label="Same for all cluster members"
+          checked={!isSpecific}
+          onChange={() => {
+            if (isSpecific) {
+              setValueForAllMembers(allMemberOptions?.[1].value as string);
+            }
+            setIsSpecific((val) => !val);
+          }}
+        />
+      )}
+      {isSpecific && (
+        <div className="cluster-specific-input">
+          {options.map((item) => {
+            const activeValue = values?.[item.memberName];
+            const selectOptions = item.values.map(toSelectOption);
+            selectOptions.unshift({
+              label:
+                selectOptions.length === 0 ? "None available" : "Select option",
+              value: "",
+            });
+
+            return (
+              <Fragment key={item.memberName}>
+                <div className="cluster-specific-member">
+                  <ResourceLink
+                    type="cluster-member"
+                    value={item.memberName}
+                    to={`/ui/project/${project}/networks?member=${item.memberName}`}
+                  />
+                </div>
+                <div className="cluster-specific-value">
+                  {isReadOnly ? (
+                    <>
+                      {activeValue}
+                      {editButton}
+                    </>
+                  ) : (
+                    <Select
+                      id={
+                        item.memberName === options[0].memberName
+                          ? id
+                          : `${id}-${item.memberName}`
+                      }
+                      className="u-no-margin--bottom"
+                      options={selectOptions}
+                      onChange={(e) =>
+                        setValueForMember(e.target.value, item.memberName)
+                      }
+                      value={activeValue}
+                    />
+                  )}
+                </div>
+              </Fragment>
+            );
+          })}
+        </div>
+      )}
+      {!isSpecific && (
+        <div>
+          {isReadOnly ? (
+            <>
+              {firstValue}
+              {editButton}
+            </>
+          ) : (
+            <Select
+              id={id}
+              className="u-no-margin--bottom"
+              options={allMemberOptions}
+              onChange={(e) => setValueForAllMembers(e.target.value)}
+              value={firstValue}
+            />
+          )}
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default ClusterSpecificSelect;
diff --git a/src/components/RenameHeader.tsx b/src/components/RenameHeader.tsx
index 036c7048df..3c1bf4c783 100644
--- a/src/components/RenameHeader.tsx
+++ b/src/components/RenameHeader.tsx
@@ -15,6 +15,7 @@ export interface RenameHeaderValues {
 
 interface Props {
   name: string;
+  relatedChip?: ReactNode;
   titleClassName?: string;
   parentItems: ReactNode[];
   centerControls?: ReactNode;
@@ -26,6 +27,7 @@ interface Props {
 
 const RenameHeader: FC<Props> = ({
   name,
+  relatedChip,
   titleClassName,
   parentItems,
   centerControls,
@@ -56,7 +58,10 @@ const RenameHeader: FC<Props> = ({
           className="p-breadcrumbs p-breadcrumbs--large"
           aria-label="Breadcrumbs"
         >
-          <ol className="p-breadcrumbs__items">
+          <ol
+            className="p-breadcrumbs__items"
+            style={{ display: "inline-block" }}
+          >
             {parentItems.map((item, key) => (
               <li
                 className="p-heading--4 u-no-margin--bottom continuous-breadcrumb"
@@ -112,6 +117,9 @@ const RenameHeader: FC<Props> = ({
               </li>
             )}
           </ol>
+          {relatedChip && (
+            <span style={{ marginLeft: "-1rem" }}>{relatedChip}</span>
+          )}
         </nav>
         {!formik?.values.isRenaming && centerControls}
       </div>
diff --git a/src/pages/networks/CreateNetwork.tsx b/src/pages/networks/CreateNetwork.tsx
index d3fe583481..e2458253df 100644
--- a/src/pages/networks/CreateNetwork.tsx
+++ b/src/pages/networks/CreateNetwork.tsx
@@ -7,7 +7,7 @@ import {
 } from "@canonical/react-components";
 import { useFormik } from "formik";
 import * as Yup from "yup";
-import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import { useNavigate, useParams } from "react-router-dom";
 import { checkDuplicateName } from "util/helpers";
@@ -22,7 +22,6 @@ import Loader from "components/Loader";
 import { yamlToObject } from "util/yaml";
 import { dump as dumpYaml } from "js-yaml";
 import { isClusteredServer, supportsOvnNetwork } from "util/settings";
-import { fetchClusterMembers } from "api/cluster";
 import BaseLayout from "components/BaseLayout";
 import {
   GENERAL,
@@ -34,6 +33,7 @@ import { useToastNotification } from "context/toastNotificationProvider";
 import YamlSwitch from "components/forms/YamlSwitch";
 import ResourceLink from "components/ResourceLink";
 import { scrollToElement } from "util/scroll";
+import { useClusterMembers } from "context/useClusterMembers";
 
 const CreateNetwork: FC = () => {
   const navigate = useNavigate();
@@ -46,12 +46,7 @@ const CreateNetwork: FC = () => {
   const { data: settings, isLoading } = useSettings();
   const isClustered = isClusteredServer(settings);
   const hasOvn = supportsOvnNetwork(settings);
-
-  const { data: clusterMembers = [] } = useQuery({
-    queryKey: [queryKeys.cluster, queryKeys.members],
-    queryFn: fetchClusterMembers,
-    enabled: isClustered,
-  });
+  const { data: clusterMembers = [] } = useClusterMembers();
 
   if (!project) {
     return <>Missing project</>;
@@ -94,7 +89,13 @@ const CreateNetwork: FC = () => {
 
       const mutation =
         isClustered && values.networkType !== "ovn"
-          ? () => createClusterNetwork(network, project, clusterMembers)
+          ? () =>
+              createClusterNetwork(
+                network,
+                project,
+                clusterMembers,
+                values.parentPerClusterMember,
+              )
           : () => createNetwork(network, project);
 
       mutation()
@@ -180,7 +181,11 @@ const CreateNetwork: FC = () => {
             !formik.isValid ||
             !formik.values.name ||
             (formik.values.networkType === "ovn" && !formik.values.network) ||
-            (formik.values.networkType === "physical" && !formik.values.parent)
+            (formik.values.networkType === "physical" &&
+              !formik.values.parent &&
+              Object.values(formik.values.parentPerClusterMember ?? {}).filter(
+                (item) => item.length > 0,
+              ).length !== clusterMembers.length)
           }
           onClick={() => void formik.submitForm()}
         >
diff --git a/src/pages/networks/EditNetwork.tsx b/src/pages/networks/EditNetwork.tsx
index 43988780ec..c0aa610e99 100644
--- a/src/pages/networks/EditNetwork.tsx
+++ b/src/pages/networks/EditNetwork.tsx
@@ -2,10 +2,14 @@ import { FC, useEffect, useState } from "react";
 import { Button, useNotify } from "@canonical/react-components";
 import { useFormik } from "formik";
 import * as Yup from "yup";
-import { useQueryClient } from "@tanstack/react-query";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import { checkDuplicateName } from "util/helpers";
-import { updateNetwork } from "api/networks";
+import {
+  fetchNetworkFromClusterMembers,
+  updateNetwork,
+  updateClusterNetwork,
+} from "api/networks";
 import NetworkForm, {
   NetworkFormValues,
   toNetwork,
@@ -27,6 +31,7 @@ import YamlSwitch from "components/forms/YamlSwitch";
 import FormSubmitBtn from "components/forms/FormSubmitBtn";
 import ResourceLink from "components/ResourceLink";
 import { scrollToElement } from "util/scroll";
+import { useClusterMembers } from "context/useClusterMembers";
 
 interface Props {
   network: LxdNetwork;
@@ -44,6 +49,21 @@ const EditNetwork: FC<Props> = ({ network, project }) => {
   const queryClient = useQueryClient();
   const controllerState = useState<AbortController | null>(null);
   const [version, setVersion] = useState(0);
+  const { data: clusterMembers = [] } = useClusterMembers();
+  const isClustered = clusterMembers.length > 0;
+
+  const { data: networkOnMembers = [] } = useQuery({
+    queryKey: [
+      queryKeys.projects,
+      project,
+      queryKeys.networks,
+      network.name,
+      queryKeys.cluster,
+    ],
+    queryFn: () =>
+      fetchNetworkFromClusterMembers(network.name, project, clusterMembers),
+    enabled: isClustered && network.managed && network.type === "physical",
+  });
 
   const NetworkSchema = Yup.object().shape({
     name: Yup.string()
@@ -65,16 +85,27 @@ const EditNetwork: FC<Props> = ({ network, project }) => {
   });
 
   const formik = useFormik<NetworkFormValues>({
-    initialValues: toNetworkFormValues(network),
+    initialValues: toNetworkFormValues(network, networkOnMembers),
     validationSchema: NetworkSchema,
     enableReinitialize: true,
     onSubmit: (values) => {
       const yaml = values.yaml ? values.yaml : getYaml();
-      const saveNetwork = yamlToObject(yaml) as LxdNetwork;
-      updateNetwork({ ...saveNetwork, etag: network.etag }, project)
+      const yamlNetwork = yamlToObject(yaml) as LxdNetwork;
+      const saveNetwork = { ...yamlNetwork, etag: network.etag };
+
+      const mutation = isClustered
+        ? () =>
+            updateClusterNetwork(
+              saveNetwork,
+              project,
+              values.parentPerClusterMember,
+            )
+        : () => updateNetwork(saveNetwork, project);
+
+      mutation()
         .then(() => {
           formik.resetForm({
-            values: toNetworkFormValues(saveNetwork),
+            values: toNetworkFormValues(yamlNetwork, networkOnMembers),
           });
 
           void queryClient.invalidateQueries({
@@ -85,6 +116,17 @@ const EditNetwork: FC<Props> = ({ network, project }) => {
               network.name,
             ],
           });
+
+          void queryClient.invalidateQueries({
+            queryKey: [
+              queryKeys.projects,
+              project,
+              queryKeys.networks,
+              network.name,
+              queryKeys.cluster,
+            ],
+          });
+
           toastNotify.success(
             <>
               Network{""}
@@ -166,7 +208,9 @@ const EditNetwork: FC<Props> = ({ network, project }) => {
               appearance="base"
               onClick={() => {
                 setVersion((old) => old + 1);
-                void formik.setValues(toNetworkFormValues(network));
+                void formik.setValues(
+                  toNetworkFormValues(network, networkOnMembers),
+                );
               }}
             >
               Cancel
@@ -174,7 +218,15 @@ const EditNetwork: FC<Props> = ({ network, project }) => {
             <FormSubmitBtn
               formik={formik}
               isYaml={section === slugify(YAML_CONFIGURATION)}
-              disabled={!formik.values.name}
+              disabled={
+                !formik.values.name ||
+                (formik.values.networkType === "physical" &&
+                  !formik.values.parent &&
+                  Object.values(
+                    formik.values.parentPerClusterMember ?? {},
+                  ).filter((item) => item.length > 0).length !==
+                    clusterMembers.length)
+              }
             />
           </>
         )}
diff --git a/src/pages/networks/NetworkDetail.tsx b/src/pages/networks/NetworkDetail.tsx
index 1ac834327f..85503e2a67 100644
--- a/src/pages/networks/NetworkDetail.tsx
+++ b/src/pages/networks/NetworkDetail.tsx
@@ -13,9 +13,10 @@ import TabLinks from "components/TabLinks";
 import NetworkForwards from "pages/networks/NetworkForwards";
 
 const NetworkDetail: FC = () => {
-  const { name, project, activeTab } = useParams<{
+  const { name, project, member, activeTab } = useParams<{
     name: string;
     project: string;
+    member: string;
     activeTab?: string;
   }>();
 
@@ -28,8 +29,15 @@ const NetworkDetail: FC = () => {
   }
 
   const { data: network, isLoading } = useQuery({
-    queryKey: [queryKeys.projects, project, queryKeys.networks, name],
-    queryFn: () => fetchNetwork(name, project),
+    queryKey: [
+      queryKeys.projects,
+      project,
+      queryKeys.networks,
+      name,
+      queryKeys.members,
+      member,
+    ],
+    queryFn: () => fetchNetwork(name, project, member),
   });
 
   if (isLoading) {
diff --git a/src/pages/networks/NetworkDetailHeader.tsx b/src/pages/networks/NetworkDetailHeader.tsx
index 630866d553..a8fa6a6480 100644
--- a/src/pages/networks/NetworkDetailHeader.tsx
+++ b/src/pages/networks/NetworkDetailHeader.tsx
@@ -1,5 +1,5 @@
 import { FC, useState } from "react";
-import { Link, useNavigate } from "react-router-dom";
+import { Link, useNavigate, useParams } from "react-router-dom";
 import RenameHeader, { RenameHeaderValues } from "components/RenameHeader";
 import { useFormik } from "formik";
 import * as Yup from "yup";
@@ -18,6 +18,10 @@ interface Props {
 }
 
 const NetworkDetailHeader: FC<Props> = ({ name, network, project }) => {
+  const { member } = useParams<{
+    member: string;
+  }>();
+
   const navigate = useNavigate();
   const notify = useNotify();
   const toastNotify = useToastNotification();
@@ -69,14 +73,26 @@ const NetworkDetailHeader: FC<Props> = ({ name, network, project }) => {
   const isUsed = (network?.used_by?.length ?? 0) > 0;
   const isManaged = network?.managed;
 
+  const parentItems = [];
+  parentItems.push(
+    <Link to={`/ui/project/${project}/networks`} key={1}>
+      Networks
+    </Link>,
+  );
+
   return (
     <RenameHeader
       name={name}
-      parentItems={[
-        <Link to={`/ui/project/${project}/networks`} key={1}>
-          Networks
-        </Link>,
-      ]}
+      relatedChip={
+        member && (
+          <ResourceLink
+            type="cluster-member"
+            value={member}
+            to={`/ui/project/${project}/networks?member=${member}`}
+          />
+        )
+      }
+      parentItems={parentItems}
       renameDisabledReason={
         !isManaged
           ? "Can not rename, network is not managed"
diff --git a/src/pages/networks/NetworkForwardCount.tsx b/src/pages/networks/NetworkForwardCount.tsx
index 99ec69d070..192706420d 100644
--- a/src/pages/networks/NetworkForwardCount.tsx
+++ b/src/pages/networks/NetworkForwardCount.tsx
@@ -10,7 +10,7 @@ interface Props {
 }
 
 const NetworkForwardCount: FC<Props> = ({ network, project }) => {
-  if (network.managed === false) {
+  if (network.managed === false || network.type === "physical") {
     return <>-</>;
   }
 
diff --git a/src/pages/networks/NetworkList.tsx b/src/pages/networks/NetworkList.tsx
index 71256ed32f..340a1ee7ec 100644
--- a/src/pages/networks/NetworkList.tsx
+++ b/src/pages/networks/NetworkList.tsx
@@ -7,18 +7,35 @@ import {
   Row,
   useNotify,
 } from "@canonical/react-components";
-import { fetchNetworks } from "api/networks";
-import BaseLayout from "components/BaseLayout";
+import { fetchNetworksFromClusterMembers, fetchNetworks } from "api/networks";
 import { useQuery } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import Loader from "components/Loader";
-import { Link, useNavigate, useParams } from "react-router-dom";
+import {
+  Link,
+  useNavigate,
+  useParams,
+  useSearchParams,
+} from "react-router-dom";
 import NotificationRow from "components/NotificationRow";
 import HelpLink from "components/HelpLink";
 import { useDocs } from "context/useDocs";
 import NetworkForwardCount from "pages/networks/NetworkForwardCount";
 import { useSmallScreen } from "context/useSmallScreen";
 import { renderNetworkType } from "util/networks";
+import ResourceLink from "components/ResourceLink";
+import { useClusterMembers } from "context/useClusterMembers";
+import PageHeader from "components/PageHeader";
+import CustomLayout from "components/CustomLayout";
+import NetworkSearchFilter, {
+  MANAGED,
+  NetworkFilters,
+  MEMBER,
+  STATE,
+  TYPE,
+  QUERY,
+} from "pages/networks/NetworkSearchFilter";
+import { LXDNetworkOnClusterMember } from "types/network";
 
 const NetworkList: FC = () => {
   const docBaseLink = useDocs();
@@ -26,6 +43,17 @@ const NetworkList: FC = () => {
   const notify = useNotify();
   const { project } = useParams<{ project: string }>();
   const isSmallScreen = useSmallScreen();
+  const { data: clusterMembers = [] } = useClusterMembers();
+  const isClustered = clusterMembers.length > 0;
+  const [searchParams] = useSearchParams();
+
+  const filters: NetworkFilters = {
+    queries: searchParams.getAll("query"),
+    type: searchParams.getAll(TYPE).map((value) => value.toLowerCase()),
+    managed: searchParams.getAll(MANAGED).map((value) => value.toLowerCase()),
+    member: searchParams.getAll(MEMBER),
+    state: searchParams.getAll(STATE),
+  };
 
   if (!project) {
     return <>Missing project</>;
@@ -40,16 +68,40 @@ const NetworkList: FC = () => {
     queryFn: () => fetchNetworks(project),
   });
 
+  const {
+    data: networksOnClusterMembers = [],
+    isLoading: isClusterNetworksLoading,
+  } = useQuery({
+    queryKey: [queryKeys.networks, project, queryKeys.cluster],
+    queryFn: () => fetchNetworksFromClusterMembers(project, clusterMembers),
+    enabled: clusterMembers.length > 0,
+  });
+
   if (error) {
     notify.failure("Loading networks failed", error);
   }
 
-  const hasNetworks = networks.length > 0;
+  const renderNetworks: LXDNetworkOnClusterMember[] = networks
+    .filter((network) => !isClustered || network.managed)
+    .map((network) => {
+      return {
+        ...network,
+        memberName: "Cluster-wide",
+      };
+    });
+  networksOnClusterMembers.forEach((network) => {
+    if (!network.managed) {
+      renderNetworks.push(network);
+    }
+  });
+
+  const hasNetworks = renderNetworks.length > 0;
 
   const headers = [
     { content: "Name", sortKey: "name" },
     { content: "Type", sortKey: "type" },
     { content: "Managed", sortKey: "managed" },
+    ...(isClustered ? [{ content: "Cluster member", sortKey: "member" }] : []),
     { content: "IPV4", className: "u-align--right" },
     { content: "IPV6" },
     { content: "Description", sortKey: "description" },
@@ -58,106 +110,170 @@ const NetworkList: FC = () => {
     { content: "State", sortKey: "state" },
   ];
 
-  const rows = networks.map((network) => {
-    return {
-      columns: [
-        {
-          content: (
-            <Link to={`/ui/project/${project}/network/${network.name}`}>
-              {network.name}
-            </Link>
-          ),
-          role: "rowheader",
-          "aria-label": "Name",
-        },
-        {
-          content: renderNetworkType(network.type),
-          role: "rowheader",
-          "aria-label": "Type",
-        },
-        {
-          content: network.managed ? "Yes" : "No",
-          role: "rowheader",
-          "aria-label": "Managed",
-        },
-        {
-          content: network.config["ipv4.address"],
-          className: "u-align--right",
-          role: "rowheader",
-          "aria-label": "IPV4",
-        },
-        {
-          content: network.config["ipv6.address"],
-          role: "rowheader",
-          "aria-label": "IPV6",
-        },
-        {
-          content: (
-            <div className="table-description" title={network.description}>
-              {network.description}
-            </div>
-          ),
-          role: "rowheader",
-          "aria-label": "Description",
-        },
-        {
-          content: <NetworkForwardCount network={network} project={project} />,
-          role: "rowheader",
-          className: "u-align--right",
-          "aria-label": "Forwards",
-        },
-        {
-          content: network.used_by?.length ?? "0",
-          role: "rowheader",
-          className: "u-align--right",
-          "aria-label": "Used by",
-        },
-        {
-          content: network.status,
-          role: "rowheader",
-          "aria-label": "State",
+  const rows = renderNetworks
+    .filter((network) => {
+      if (
+        !filters.queries.every(
+          (q) =>
+            network.name.toLowerCase().includes(q) ||
+            network.description?.toLowerCase().includes(q),
+        )
+      ) {
+        return false;
+      }
+      if (filters.type.length > 0 && !filters.type.includes(network.type)) {
+        return false;
+      }
+      if (
+        filters.managed.length > 0 &&
+        !filters.managed.includes(network.managed ? "yes" : "no")
+      ) {
+        return false;
+      }
+      if (
+        filters.member.length > 0 &&
+        !filters.member.includes(network.memberName)
+      ) {
+        return false;
+      }
+      if (
+        filters.state.length > 0 &&
+        !filters.state.includes(network.status ?? "")
+      ) {
+        return false;
+      }
+      return true;
+    })
+    .map((network) => {
+      const href =
+        network.memberName === "Cluster-wide"
+          ? `/ui/project/${project}/network/${network.name}`
+          : `/ui/project/${project}/member/${network.memberName}/network/${network.name}`;
+
+      let memberBaseUrl = `/ui/project/${project}/networks?search=${Number(searchParams.get("search")) + 1}`;
+      const appendExistingSearchParams = (field: string) => {
+        searchParams
+          .getAll(field)
+          .forEach((item) => (memberBaseUrl += `&${field}=${item}`));
+      };
+      appendExistingSearchParams(STATE);
+      appendExistingSearchParams(TYPE);
+      appendExistingSearchParams(MANAGED);
+      appendExistingSearchParams(QUERY);
+
+      return {
+        columns: [
+          {
+            content: <Link to={href}>{network.name}</Link>,
+            role: "rowheader",
+            "aria-label": "Name",
+          },
+          {
+            content: renderNetworkType(network.type),
+            role: "rowheader",
+            "aria-label": "Type",
+          },
+          {
+            content: network.managed ? "Yes" : "No",
+            role: "rowheader",
+            "aria-label": "Managed",
+          },
+          ...(isClustered
+            ? [
+                {
+                  content:
+                    network.memberName === "Cluster-wide" ? (
+                      <ResourceLink
+                        type="cluster-group"
+                        value="Cluster wide"
+                        to={`${memberBaseUrl}&member=Cluster-wide`}
+                      />
+                    ) : (
+                      <ResourceLink
+                        type="cluster-member"
+                        value={network.memberName}
+                        to={`${memberBaseUrl}&member=${network.memberName}`}
+                      />
+                    ),
+                  role: "rowheader",
+                  "aria-label": "Cluster member",
+                },
+              ]
+            : []),
+          {
+            content: network.config["ipv4.address"],
+            className: "u-align--right",
+            role: "rowheader",
+            "aria-label": "IPV4",
+          },
+          {
+            content: network.config["ipv6.address"],
+            role: "rowheader",
+            "aria-label": "IPV6",
+          },
+          {
+            content: (
+              <div className="table-description" title={network.description}>
+                {network.description}
+              </div>
+            ),
+            role: "rowheader",
+            "aria-label": "Description",
+          },
+          {
+            content: (
+              <NetworkForwardCount network={network} project={project} />
+            ),
+            role: "rowheader",
+            className: "u-align--right",
+            "aria-label": "Forwards",
+          },
+          {
+            content: network.used_by?.length ?? "0",
+            role: "rowheader",
+            className: "u-align--right",
+            "aria-label": "Used by",
+          },
+          {
+            content: network.status,
+            role: "rowheader",
+            "aria-label": "State",
+          },
+        ],
+        sortData: {
+          name: network.name.toLowerCase(),
+          type: network.type,
+          managed: network.managed,
+          description: network.description?.toLowerCase(),
+          state: network.status,
+          usedBy: network.used_by?.length ?? 0,
+          member: network.memberName,
         },
-      ],
-      sortData: {
-        name: network.name.toLowerCase(),
-        type: network.type,
-        managed: network.managed,
-        description: network.description?.toLowerCase(),
-        state: network.status,
-        usedBy: network.used_by?.length ?? 0,
-      },
-    };
-  });
+      };
+    });
 
-  if (isLoading) {
+  if (isLoading || isClusterNetworksLoading) {
     return <Loader />;
   }
 
   return (
-    <>
-      <BaseLayout
-        title={
-          <HelpLink
-            href={`${docBaseLink}/explanation/networks/`}
-            title="Learn more about networking"
-          >
-            Networks
-          </HelpLink>
-        }
-        controls={
-          <>
-            {hasNetworks && (
-              <Button
-                className="u-no-margin--bottom"
-                onClick={() =>
-                  void navigate(`/ui/project/${project}/networks/map`)
-                }
-                hasIcon={!isSmallScreen}
+    <CustomLayout
+      header={
+        <PageHeader>
+          <PageHeader.Left>
+            <PageHeader.Title>
+              <HelpLink
+                href={`${docBaseLink}/explanation/networks/`}
+                title="Learn more about networking"
               >
-                {!isSmallScreen && <Icon name="map" />}
-                <span>See network map</span>
-              </Button>
-            )}
+                Networks
+              </HelpLink>
+            </PageHeader.Title>
+            <PageHeader.Search>
+              <NetworkSearchFilter key={searchParams.get("search")} />
+            </PageHeader.Search>
+          </PageHeader.Left>
+          <PageHeader.BaseActions>
             <Button
               appearance="positive"
               className="u-no-margin--bottom"
@@ -169,44 +285,44 @@ const NetworkList: FC = () => {
               {!isSmallScreen && <Icon name="plus" light />}
               <span>Create network</span>
             </Button>
-          </>
-        }
-      >
-        <NotificationRow />
-        <Row>
-          {hasNetworks && (
-            <MainTable
-              headers={headers}
-              rows={rows}
-              paginate={30}
-              responsive
-              sortable
-              className="u-table-layout--auto"
-              emptyStateMsg="No data to display"
-            />
-          )}
-          {!isLoading && !hasNetworks && (
-            <EmptyState
-              className="empty-state"
-              image={<Icon className="empty-state-icon" name="exposed" />}
-              title="No networks found"
-            >
-              <p>There are no networks in this project.</p>
-              <p>
-                <a
-                  href={`${docBaseLink}/explanation/networks/`}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                >
-                  Learn more about networks
-                  <Icon className="external-link-icon" name="external-link" />
-                </a>
-              </p>
-            </EmptyState>
-          )}
-        </Row>
-      </BaseLayout>
-    </>
+          </PageHeader.BaseActions>
+        </PageHeader>
+      }
+    >
+      <NotificationRow />
+      <Row>
+        {hasNetworks && (
+          <MainTable
+            headers={headers}
+            rows={rows}
+            paginate={30}
+            responsive
+            sortable
+            className="u-table-layout--auto"
+            emptyStateMsg="No data to display"
+          />
+        )}
+        {!isLoading && !hasNetworks && (
+          <EmptyState
+            className="empty-state"
+            image={<Icon className="empty-state-icon" name="exposed" />}
+            title="No networks found"
+          >
+            <p>There are no networks in this project.</p>
+            <p>
+              <a
+                href={`${docBaseLink}/explanation/networks/`}
+                target="_blank"
+                rel="noopener noreferrer"
+              >
+                Learn more about networks
+                <Icon className="external-link-icon" name="external-link" />
+              </a>
+            </p>
+          </EmptyState>
+        )}
+      </Row>
+    </CustomLayout>
   );
 };
 
diff --git a/src/pages/networks/NetworkSearchFilter.tsx b/src/pages/networks/NetworkSearchFilter.tsx
new file mode 100644
index 0000000000..db311d433b
--- /dev/null
+++ b/src/pages/networks/NetworkSearchFilter.tsx
@@ -0,0 +1,107 @@
+import { FC, memo } from "react";
+import { SearchAndFilter } from "@canonical/react-components";
+import type {
+  SearchAndFilterChip,
+  SearchAndFilterData,
+} from "@canonical/react-components/dist/components/SearchAndFilter/types";
+import { useSearchParams } from "react-router-dom";
+import {
+  paramsFromSearchData,
+  searchParamsToChips,
+} from "util/searchAndFilter";
+import { useClusterMembers } from "context/useClusterMembers";
+
+export const QUERY = "query";
+export const TYPE = "type";
+export const MANAGED = "managed";
+export const MEMBER = "member";
+export const STATE = "state";
+
+const QUERY_PARAMS = [QUERY, TYPE, MANAGED, MEMBER, STATE];
+
+export interface NetworkFilters {
+  queries: string[];
+  type: string[];
+  managed: string[];
+  member: string[];
+  state: string[];
+}
+
+const NetworkSearchFilter: FC = () => {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const { data: clusterMembers = [] } = useClusterMembers();
+
+  const locationSet = [
+    ...new Set(clusterMembers.map((member) => member.server_name)),
+  ];
+
+  const searchAndFilterData: SearchAndFilterData[] = [
+    {
+      id: 1,
+      heading: "Type",
+      chips: ["OVN", "Bridge", "Physical"].map((type) => {
+        return { lead: TYPE, value: type };
+      }),
+    },
+    {
+      id: 2,
+      heading: "Managed",
+      chips: ["Yes", "No"].map((managed) => {
+        return { lead: MANAGED, value: managed };
+      }),
+    },
+    {
+      id: 3,
+      heading: "State",
+      chips: ["Created", "Pending", "Unknown", "Unavailable", "Errored"].map(
+        (state) => {
+          return { lead: STATE, value: state };
+        },
+      ),
+    },
+    ...(clusterMembers.length > 0
+      ? [
+          {
+            id: 4,
+            heading: "Cluster member",
+            chips: ["Cluster-wide"].concat(locationSet).map((location) => {
+              return { lead: MEMBER, value: location };
+            }),
+          },
+        ]
+      : []),
+  ];
+
+  const onSearchDataChange = (searchData: SearchAndFilterChip[]) => {
+    const newParams = paramsFromSearchData(
+      searchData,
+      searchParams,
+      QUERY_PARAMS,
+    );
+
+    if (newParams.toString() !== searchParams.toString()) {
+      setSearchParams(newParams);
+    }
+  };
+
+  return (
+    <>
+      <h2 className="u-off-screen">Search and filter</h2>
+      <SearchAndFilter
+        existingSearchData={searchParamsToChips(searchParams, QUERY_PARAMS)}
+        filterPanelData={searchAndFilterData}
+        returnSearchData={onSearchDataChange}
+        onExpandChange={() => {
+          window.dispatchEvent(
+            new CustomEvent("resize", { detail: "search-and-filter" }),
+          );
+        }}
+        onPanelToggle={() => {
+          window.dispatchEvent(new CustomEvent("sfp-toggle"));
+        }}
+      />
+    </>
+  );
+};
+
+export default memo(NetworkSearchFilter);
diff --git a/src/pages/networks/NetworkTopology.tsx b/src/pages/networks/NetworkTopology.tsx
index c22f06e1d6..25d41e8c55 100644
--- a/src/pages/networks/NetworkTopology.tsx
+++ b/src/pages/networks/NetworkTopology.tsx
@@ -11,13 +11,19 @@ import { useQuery } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import { fetchNetworks } from "api/networks";
 import classnames from "classnames";
+import { useParams } from "react-router-dom";
 
 interface Props {
   formik: FormikProps<NetworkFormValues>;
   project: string;
+  isServerClustered: boolean;
 }
 
-const NetworkTopology: FC<Props> = ({ formik, project }) => {
+const NetworkTopology: FC<Props> = ({ formik, project, isServerClustered }) => {
+  const { member } = useParams<{
+    member: string;
+  }>();
+
   const [isNetworksCollapsed, setNetworksCollapsed] = useState(true);
   const [isInstancesCollapsed, setInstancesCollapsed] = useState(true);
   const network = formik.values.bareNetwork;
@@ -26,44 +32,94 @@ const NetworkTopology: FC<Props> = ({ formik, project }) => {
     return;
   }
 
+  const hasClusteredUplinks =
+    isServerClustered && ["physical", "bridge"].includes(network.type);
+
   const { data: networks = [] } = useQuery({
-    queryKey: [queryKeys.projects, project, queryKeys.networks],
+    queryKey: [queryKeys.networks, project],
     queryFn: () => fetchNetworks(project),
   });
 
-  const downstreamNetworks = networks.filter(
-    (network) =>
-      network.config.network === formik.values.name ||
-      network.config.parent === formik.values.name,
-  );
+  const downstreamNetworks = networks.filter((downStreamCandidate) => {
+    return (
+      downStreamCandidate.config.network === formik.values.name ||
+      downStreamCandidate.config.parent === formik.values.name ||
+      network.used_by?.includes(`/1.0/networks/${downStreamCandidate.name}`)
+    );
+  });
 
   const instances = filterUsedByType("instance", network.used_by);
   const uplink = formik.values.parent ?? formik.values.network;
 
+  const clusterUplinks = Object.keys(
+    formik.values.parentPerClusterMember ?? {},
+  ).map((clusterMember) => {
+    const memberUplink = formik.values.parentPerClusterMember?.[clusterMember];
+
+    if (!memberUplink) {
+      return null;
+    }
+
+    return (
+      <div className="uplink-item" key={clusterMember}>
+        <ResourceLink
+          type="cluster-member"
+          value={clusterMember}
+          to={`/ui/project/${project}/networks?member=${clusterMember}`}
+        />
+        ——
+        <ResourceLink
+          type="network"
+          value={memberUplink}
+          to={`/ui/project/${project}/member/${clusterMember}/network/${memberUplink}`}
+        />
+      </div>
+    );
+  });
+
+  const hasUplink =
+    uplink ?? clusterUplinks.filter((item) => item !== null).length > 0;
+
   return (
     <>
       <h2 className="p-heading--4" id={slugify(CONNECTIONS)}>
         Connections
       </h2>
       <div className="u-sv3 network-topology">
-        {uplink && (
+        {hasUplink && (
           <div className="uplink">
-            <ResourceLink
-              type="network"
-              value={uplink}
-              to={`/ui/project/default/network/${uplink}`}
-            />
+            {hasClusteredUplinks
+              ? clusterUplinks
+              : uplink && (
+                  <div className="uplink-item">
+                    <ResourceLink
+                      type="network"
+                      value={uplink}
+                      to={`/ui/project/default/network/${uplink}`}
+                    />
+                  </div>
+                )}
           </div>
         )}
         <div
           className={classNames("current-network", {
             "has-descendents":
               instances.length > 0 || downstreamNetworks.length > 0,
-            "has-parent": !!uplink,
+            "has-parent": hasUplink,
           })}
         >
+          {member && (
+            <>
+              <ResourceLink
+                type="cluster-member"
+                value={member}
+                to={`/ui/project/${project}/networks?member=${member}`}
+              />
+              ——
+            </>
+          )}
           <div
-            className="p-chip is-inline is-dense resource-link"
+            className="p-chip is-inline is-dense resource-link active-chip"
             title={network.name}
           >
             <span className="p-chip__value">
diff --git a/src/pages/networks/forms/NetworkAddresses.tsx b/src/pages/networks/forms/NetworkAddresses.tsx
index ce1f14af46..162ef983e4 100644
--- a/src/pages/networks/forms/NetworkAddresses.tsx
+++ b/src/pages/networks/forms/NetworkAddresses.tsx
@@ -1,10 +1,11 @@
-import { FC } from "react";
+import { FC, Fragment } from "react";
 import { FormikProps } from "formik/dist/types";
 import { NetworkFormValues } from "pages/networks/forms/NetworkForm";
 import { useQuery } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import { fetchNetworkState } from "api/networks";
 import { MainTable } from "@canonical/react-components";
+import { useParams } from "react-router-dom";
 
 interface Props {
   formik: FormikProps<NetworkFormValues>;
@@ -12,18 +13,24 @@ interface Props {
 }
 
 const NetworkAddresses: FC<Props> = ({ formik, project }) => {
+  const { member } = useParams<{
+    member: string;
+  }>();
+
+  const networkName = formik.values.bareNetwork?.name ?? "";
+
   const { data: networkState } = useQuery({
     queryKey: [
       queryKeys.projects,
       project,
       queryKeys.networks,
-      formik.values.bareNetwork?.name,
+      networkName,
+      queryKeys.members,
+      member,
       queryKeys.state,
     ],
     retry: 0, // physical managed networks can sometimes 404, show error right away and don't retry
-    queryFn: () =>
-      fetchNetworkState(formik.values.bareNetwork?.name ?? "", project),
-    enabled: !formik.values.isCreating,
+    queryFn: () => fetchNetworkState(networkName, project, member),
   });
 
   return (
diff --git a/src/pages/networks/forms/NetworkForm.tsx b/src/pages/networks/forms/NetworkForm.tsx
index 94715065e7..131a2d445f 100644
--- a/src/pages/networks/forms/NetworkForm.tsx
+++ b/src/pages/networks/forms/NetworkForm.tsx
@@ -35,6 +35,7 @@ import ScrollableContainer from "components/ScrollableContainer";
 import NetworkTopology from "pages/networks/NetworkTopology";
 import { debounce } from "util/debounce";
 import { MainTableRow } from "@canonical/react-components/dist/components/MainTable/MainTable";
+import { ClusterSpecificValues } from "components/ClusterSpecificSelect";
 
 export interface NetworkFormValues {
   readOnly: boolean;
@@ -75,6 +76,7 @@ export interface NetworkFormValues {
   network?: string;
   ovn_ingress_mode?: string;
   parent?: string;
+  parentPerClusterMember?: ClusterSpecificValues;
   yaml?: string;
   entityType: "network";
   bareNetwork?: LxdNetwork;
@@ -237,7 +239,11 @@ const NetworkForm: FC<Props> = ({
         {!formik.values.isCreating &&
           query.length < 1 &&
           section !== slugify(YAML_CONFIGURATION) && (
-            <NetworkTopology formik={formik} project={project} />
+            <NetworkTopology
+              formik={formik}
+              project={project}
+              isServerClustered={isClustered}
+            />
           )}
         <Form className="sections" onSubmit={formik.handleSubmit}>
           {section !== slugify(YAML_CONFIGURATION) && (
diff --git a/src/pages/networks/forms/NetworkFormMain.tsx b/src/pages/networks/forms/NetworkFormMain.tsx
index 592c7c741d..f72409975a 100644
--- a/src/pages/networks/forms/NetworkFormMain.tsx
+++ b/src/pages/networks/forms/NetworkFormMain.tsx
@@ -94,14 +94,13 @@ const NetworkFormMain: FC<Props> = ({ formik, project, isClustered }) => {
             formik={formik}
           />
         )}
-        {formik.values.networkType === "physical" &&
-          isManagedNetwork &&
-          (formik.values.isCreating || !isClustered) && (
-            <NetworkParentSelector
-              props={getFormProps("parent")}
-              formik={formik}
-            />
-          )}
+        {formik.values.networkType === "physical" && isManagedNetwork && (
+          <NetworkParentSelector
+            props={getFormProps("parent")}
+            formik={formik}
+            isClustered={isClustered}
+          />
+        )}
         {formik.values.networkType !== "physical" && isManagedNetwork && (
           <>
             <IpAddress
diff --git a/src/pages/networks/forms/NetworkParentSelector.tsx b/src/pages/networks/forms/NetworkParentSelector.tsx
index 6080158029..ac67a6ddda 100644
--- a/src/pages/networks/forms/NetworkParentSelector.tsx
+++ b/src/pages/networks/forms/NetworkParentSelector.tsx
@@ -3,20 +3,26 @@ import { Button, Icon, Label, Select } from "@canonical/react-components";
 import Loader from "components/Loader";
 import { useQuery } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
-import { fetchNetworks } from "api/networks";
+import { fetchNetworksFromClusterMembers, fetchNetworks } from "api/networks";
 import { useParams } from "react-router-dom";
 import { FormikProps } from "formik/dist/types";
 import { NetworkFormValues } from "pages/networks/forms/NetworkForm";
 import { ensureEditMode } from "util/instanceEdit";
 import { focusField } from "util/formFields";
+import ClusterSpecificSelect, {
+  ClusterSpecificSelectOption,
+} from "components/ClusterSpecificSelect";
+import { useClusterMembers } from "context/useClusterMembers";
 
 interface Props {
   props?: Record<string, unknown>;
   formik: FormikProps<NetworkFormValues>;
+  isClustered: boolean;
 }
 
-const NetworkParentSelector: FC<Props> = ({ props, formik }) => {
+const NetworkParentSelector: FC<Props> = ({ props, formik, isClustered }) => {
   const { project } = useParams<{ project: string }>();
+  const { data: clusterMembers = [] } = useClusterMembers();
 
   if (!project) {
     return <>Missing project</>;
@@ -25,6 +31,16 @@ const NetworkParentSelector: FC<Props> = ({ props, formik }) => {
   const { data: networks = [], isLoading: isNetworkLoading } = useQuery({
     queryKey: [queryKeys.networks, project],
     queryFn: () => fetchNetworks(project),
+    enabled: !isClustered,
+  });
+
+  const {
+    data: networksOnClusterMembers = [],
+    isLoading: isClusterNetworksLoading,
+  } = useQuery({
+    queryKey: [queryKeys.networks, "default", queryKeys.cluster],
+    queryFn: () => fetchNetworksFromClusterMembers("default", clusterMembers),
+    enabled: clusterMembers.length > 0,
   });
 
   const options = networks
@@ -40,10 +56,57 @@ const NetworkParentSelector: FC<Props> = ({ props, formik }) => {
     value: "",
   });
 
-  if (isNetworkLoading) {
+  if (isNetworkLoading || isClusterNetworksLoading) {
     return <Loader />;
   }
 
+  if (isClustered) {
+    const currentValues = Object.values(
+      formik.values.parentPerClusterMember ?? {},
+    );
+
+    const options: ClusterSpecificSelectOption[] = [];
+    clusterMembers.forEach((member) =>
+      options.push({
+        memberName: member.server_name,
+        values: networksOnClusterMembers
+          .filter(
+            (item) =>
+              item.memberName === member.server_name && item.managed === false,
+          )
+          .map((item) => item.name),
+      }),
+    );
+
+    return (
+      <div className="general-field">
+        <div className="general-field-label can-edit">
+          <Label forId="parent" required={formik.values.isCreating}>
+            Parent
+          </Label>
+        </div>
+        <div className="general-field-content">
+          <ClusterSpecificSelect
+            id="parent"
+            options={options}
+            values={formik.values.parentPerClusterMember}
+            onChange={(value) => {
+              void formik.setFieldValue("parentPerClusterMember", value);
+            }}
+            isReadOnly={formik.values.readOnly}
+            toggleReadOnly={() => {
+              ensureEditMode(formik);
+              focusField("parent");
+            }}
+            isDefaultSpecific={currentValues.some(
+              (item) => item !== currentValues[0],
+            )}
+          />
+        </div>
+      </div>
+    );
+  }
+
   return (
     <div className="general-field">
       <div className="general-field-label can-edit">
diff --git a/src/pages/networks/forms/NetworkStatistics.tsx b/src/pages/networks/forms/NetworkStatistics.tsx
index fcc9baba93..96aa9f958b 100644
--- a/src/pages/networks/forms/NetworkStatistics.tsx
+++ b/src/pages/networks/forms/NetworkStatistics.tsx
@@ -5,6 +5,7 @@ import { humanFileSize } from "util/helpers";
 import { useQuery } from "@tanstack/react-query";
 import { queryKeys } from "util/queryKeys";
 import { fetchNetworkState } from "api/networks";
+import { useParams } from "react-router-dom";
 
 interface Props {
   formik: FormikProps<NetworkFormValues>;
@@ -12,17 +13,23 @@ interface Props {
 }
 
 const NetworkStatistics: FC<Props> = ({ formik, project }) => {
+  const { member } = useParams<{
+    member: string;
+  }>();
+
   const { data: networkState } = useQuery({
     queryKey: [
       queryKeys.projects,
       project,
       queryKeys.networks,
       formik.values.bareNetwork?.name,
+      queryKeys.members,
+      member,
       queryKeys.state,
     ],
     retry: 0, // physical managed networks can sometimes 404, show error right away and don't retry
     queryFn: () =>
-      fetchNetworkState(formik.values.bareNetwork?.name ?? "", project),
+      fetchNetworkState(formik.values.bareNetwork?.name ?? "", project, member),
     enabled: !formik.values.isCreating,
   });
 
diff --git a/src/sass/_network_topology.scss b/src/sass/_network_topology.scss
index 6e63d67424..98c85e9bd2 100644
--- a/src/sass/_network_topology.scss
+++ b/src/sass/_network_topology.scss
@@ -3,7 +3,7 @@
   margin-bottom: $spv--x-large;
 
   .current-network {
-    .p-chip {
+    .active-chip {
       background-color: $colors--dark-theme--background-active !important;
 
       * {
@@ -16,7 +16,11 @@
     max-width: 13vw !important;
   }
 
-  .uplink::after,
+  .uplink {
+    text-align: right;
+  }
+
+  .uplink-item::after,
   .has-parent::before,
   .has-descendents::after,
   .downstream-item::before {
@@ -29,12 +33,12 @@
     width: 2rem;
   }
 
-  .uplink::after,
   .has-parent::before,
   .has-descendents::after {
     clip-path: polygon(100% 80%, 0 80%, 0 83%, 100% 83%);
   }
 
+  .uplink-item::after,
   .downstream-item::before {
     clip-path: polygon(
       100% 80%,
@@ -54,14 +58,21 @@
     display: contents;
   }
 
+  .uplink-item::after {
+    transform: scale(-1, 1);
+  }
+
+  .uplink-item:first-child::after,
   .downstream-item:first-child::before {
     clip-path: polygon(100% 80%, 0 80%, 0 100%, 4% 100%, 4% 83%, 100% 83%);
   }
 
+  .uplink-item:last-child::after,
   .downstream-item:last-child::before {
     clip-path: polygon(100% 80%, 4% 80%, 4% 0, 0 0, 0 83%, 100% 83%);
   }
 
+  .uplink-item:only-child::after,
   .downstream-item:only-child::before {
     clip-path: polygon(100% 80%, 0 80%, 0 83%, 100% 83%);
   }
@@ -69,9 +80,10 @@
   .downstream {
     display: flex;
     flex-direction: column;
+  }
 
-    .downstream-item {
-      height: 2rem;
-    }
+  .uplink-item,
+  .downstream-item {
+    height: 2rem;
   }
 }
diff --git a/src/sass/cluster-specific-input.scss b/src/sass/cluster-specific-input.scss
new file mode 100644
index 0000000000..1b035a6e25
--- /dev/null
+++ b/src/sass/cluster-specific-input.scss
@@ -0,0 +1,11 @@
+.cluster-specific-input {
+  align-items: center;
+  display: grid;
+  gap: $sp-medium;
+  grid-template-columns: fit-content(20%) 1fr;
+  padding-bottom: $spv--large;
+
+  .cluster-specific-member {
+    overflow: hidden;
+  }
+}
diff --git a/src/sass/styles.scss b/src/sass/styles.scss
index 02d1202250..c6ff6e4a3d 100644
--- a/src/sass/styles.scss
+++ b/src/sass/styles.scss
@@ -70,6 +70,7 @@
 $border-thin: 1px solid $color-mid-light !default;
 
 @import "certificates";
+@import "cluster-specific-input";
 @import "cluster_group_form";
 @import "cluster_list";
 @import "configuration_table";
diff --git a/src/types/network.d.ts b/src/types/network.d.ts
index 91d46b105b..b35f0010fc 100644
--- a/src/types/network.d.ts
+++ b/src/types/network.d.ts
@@ -72,6 +72,10 @@ export interface LxdNetwork {
   etag?: string;
 }
 
+export type LXDNetworkOnClusterMember = LxdNetwork & {
+  memberName: string;
+};
+
 export interface LxdNetworkStateAddress {
   family: string;
   address: string;
diff --git a/src/util/intersection.tsx b/src/util/intersection.tsx
new file mode 100644
index 0000000000..15b719cda7
--- /dev/null
+++ b/src/util/intersection.tsx
@@ -0,0 +1,21 @@
+// returns array of items present in all lists
+export const intersection = (lists: string[][]): string[] => {
+  const result = [];
+
+  for (let i = 0; i < lists.length; i++) {
+    const currentList = lists[i];
+    for (let y = 0; y < currentList.length; y++) {
+      const currentValue = currentList[y];
+      if (result.indexOf(currentValue) === -1) {
+        if (
+          lists.filter(function (obj) {
+            return obj.indexOf(currentValue) == -1;
+          }).length == 0
+        ) {
+          result.push(currentValue);
+        }
+      }
+    }
+  }
+  return result;
+};
diff --git a/src/util/networkForm.tsx b/src/util/networkForm.tsx
index ab718fdc98..c999cacf17 100644
--- a/src/util/networkForm.tsx
+++ b/src/util/networkForm.tsx
@@ -1,12 +1,23 @@
-import {
+import type {
   LxdNetwork,
   LxdNetworkBridgeDriver,
   LxdNetworkDnsMode,
+  LXDNetworkOnClusterMember,
 } from "types/network";
 import { NetworkFormValues } from "pages/networks/forms/NetworkForm";
 import { getNetworkKey } from "util/networks";
+import { ClusterSpecificValues } from "components/ClusterSpecificSelect";
+
+export const toNetworkFormValues = (
+  network: LxdNetwork,
+  networkOnMembers?: LXDNetworkOnClusterMember[],
+): NetworkFormValues => {
+  const parentPerClusterMember: ClusterSpecificValues = {};
+  networkOnMembers?.map(
+    (item) =>
+      (parentPerClusterMember[item.memberName] = item.config.parent ?? ""),
+  );
 
-export const toNetworkFormValues = (network: LxdNetwork): NetworkFormValues => {
   return {
     readOnly: true,
     isCreating: false,
@@ -48,6 +59,7 @@ export const toNetworkFormValues = (network: LxdNetwork): NetworkFormValues => {
     ovn_ingress_mode: network.config[getNetworkKey("ovn_ingress_mode")],
     network: network.config.network,
     parent: network.config.parent,
+    parentPerClusterMember,
     entityType: "network",
     bareNetwork: network,
   };