diff --git a/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp b/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
index 26d4e19c45a..5974e32ea27 100644
--- a/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
+++ b/Plugins/Json/include/Acts/Plugins/Json/GridJsonConverter.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "Acts/Plugins/Json/ActsJson.hpp"
+#include "Acts/Utilities/GridAccessHelpers.hpp"
 #include "Acts/Utilities/IAxis.hpp"
 #include "Acts/Utilities/detail/AxisFwd.hpp"
 
@@ -35,6 +36,40 @@ nlohmann::json toJsonDetray(const IAxis& ia);
 
 }  // namespace AxisJsonConverter
 
+namespace GridAccessJsonConverter {
+
+/// Convert a global to local access to json
+///
+/// @param globalToGridLocal the global to grid local access
+///
+/// @return a json object to represent global class
+nlohmann::json toJson(const GridAccess::IGlobalToGridLocal& globalToGridLocal);
+
+/// Create a global grid to local instance
+///
+/// @param jGlobalToGridLocal the json snippet
+///
+/// @return a newly created object
+std::unique_ptr<GridAccess::IGlobalToGridLocal> globalToGridLocalFromJson(
+    const nlohmann::json& jGlobalToGridLocal);
+
+/// Convert a local to local access to json
+///
+/// @param boundToGridLocal the local to local access
+///
+/// @return a json object to represent local class
+nlohmann::json toJson(const GridAccess::IBoundToGridLocal& boundToGridLocal);
+
+/// Create a local grid to local instance
+///
+/// @param jBoundToGridLocal the json snippet
+///
+/// @return a newly created object
+std::unique_ptr<GridAccess::IBoundToGridLocal> boundToGridLocalFromJson(
+    const nlohmann::json& jBoundToGridLocal);
+
+}  // namespace GridAccessJsonConverter
+
 namespace GridJsonConverter {
 
 /// @brief Templated grid conversion to json
diff --git a/Plugins/Json/src/GridJsonConverter.cpp b/Plugins/Json/src/GridJsonConverter.cpp
index e500c9de790..19ac9e85bbf 100644
--- a/Plugins/Json/src/GridJsonConverter.cpp
+++ b/Plugins/Json/src/GridJsonConverter.cpp
@@ -8,6 +8,7 @@
 
 #include "Acts/Plugins/Json/GridJsonConverter.hpp"
 
+#include "Acts/Plugins/Json/AlgebraJsonConverter.hpp"
 #include "Acts/Utilities/IAxis.hpp"
 
 nlohmann::json Acts::AxisJsonConverter::toJson(const IAxis& ia) {
@@ -42,3 +43,259 @@ nlohmann::json Acts::AxisJsonConverter::toJsonDetray(const IAxis& ia) {
   }
   return jAxis;
 }
+
+namespace {
+
+template <typename Subspace>
+void encodeSubspace(
+    nlohmann::json& jGlobalToGridLocal,
+    const Acts::GridAccess::IGlobalToGridLocal& globalToGridLocal,
+    const Subspace& /*unused*/) {
+  const Subspace* subspace = dynamic_cast<const Subspace*>(&globalToGridLocal);
+  if (subspace != nullptr) {
+    jGlobalToGridLocal["type"] = "subspace";
+    jGlobalToGridLocal["accessors"] = subspace->bValues;
+  }
+}
+
+template <typename Subspace>
+void encodeTransformedSubspace(
+    nlohmann::json& jGlobalToGridLocal,
+    const Acts::GridAccess::IGlobalToGridLocal& globalToGridLocal,
+    const Subspace& subscpace) {
+  const Acts::GridAccess::Affine3Transformed<Subspace>* tsubspace =
+      dynamic_cast<const Acts::GridAccess::Affine3Transformed<Subspace>*>(
+          &globalToGridLocal);
+  if (tsubspace != nullptr) {
+    encodeSubspace(jGlobalToGridLocal, tsubspace->globalToGridLocal, subscpace);
+    jGlobalToGridLocal["transform"] =
+        Acts::Transform3JsonConverter::toJson(tsubspace->transform);
+  }
+}
+
+template <typename... Args>
+void encodeSubspaces(
+    nlohmann::json& jGlobalToGridLocal,
+    const Acts::GridAccess::IGlobalToGridLocal& globalToGridLocal,
+    bool transformed, const std::tuple<Args...>& tAcessors) {
+  if (transformed) {
+    std::apply(
+        [&](auto&&... vals) {
+          (encodeTransformedSubspace(jGlobalToGridLocal, globalToGridLocal,
+                                     vals),
+           ...);
+        },
+        tAcessors);
+  } else {
+    std::apply(
+        [&](auto&&... vals) {
+          (encodeSubspace(jGlobalToGridLocal, globalToGridLocal, vals), ...);
+        },
+        tAcessors);
+  }
+}
+
+template <Acts::BinningValue... Args>
+std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal> decodeSubspace(
+    const nlohmann::json& jGlobalToGridLocal) {
+  std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal> globalToGridLocal =
+      nullptr;
+  if (jGlobalToGridLocal.find("transform") != jGlobalToGridLocal.end()) {
+    Acts::Transform3 transform = Acts::Transform3JsonConverter::fromJson(
+        jGlobalToGridLocal.at("transform"));
+    Acts::GridAccess::GlobalSubspace<Args...> globalSubspace;
+    globalToGridLocal = std::make_unique<Acts::GridAccess::Affine3Transformed<
+        Acts::GridAccess::GlobalSubspace<Args...>>>(std::move(globalSubspace),
+                                                    transform);
+  } else {
+    globalToGridLocal =
+        std::make_unique<Acts::GridAccess::GlobalSubspace<Args...>>();
+  }
+  return globalToGridLocal;
+}
+
+}  // namespace
+
+nlohmann::json Acts::GridAccessJsonConverter::toJson(
+    const GridAccess::IGlobalToGridLocal& globalToGridLocal) {
+  nlohmann::json jGlobalToGridLocal;
+
+  std::array<bool, 2u> transformOptions = {false, true};
+
+  // One dimensional sub spaces
+  const std::tuple<
+      GridAccess::GlobalSubspace<binX>, GridAccess::GlobalSubspace<binY>,
+      GridAccess::GlobalSubspace<binZ>, GridAccess::GlobalSubspace<binR>,
+      GridAccess::GlobalSubspace<binPhi>, GridAccess::GlobalSubspace<binEta>>
+      oneDimSubspaces = {};
+
+  for (bool transform : transformOptions) {
+    encodeSubspaces(jGlobalToGridLocal, globalToGridLocal, transform,
+                    oneDimSubspaces);
+    if (!jGlobalToGridLocal.empty()) {
+      return jGlobalToGridLocal;
+    }
+  }
+
+  // Useful two dimensional sub spaces
+  const std::tuple<GridAccess::GlobalSubspace<binX, binY>,
+                   GridAccess::GlobalSubspace<binY, binX>,
+                   GridAccess::GlobalSubspace<binX, binZ>,
+                   GridAccess::GlobalSubspace<binZ, binX>,
+                   GridAccess::GlobalSubspace<binY, binZ>,
+                   GridAccess::GlobalSubspace<binZ, binY>,
+                   GridAccess::GlobalSubspace<binR, binPhi>,
+                   GridAccess::GlobalSubspace<binPhi, binR>,
+                   GridAccess::GlobalSubspace<binZ, binPhi>,
+                   GridAccess::GlobalSubspace<binPhi, binZ>>
+      twoDimSubspaces = {};
+
+  for (bool transform : transformOptions) {
+    encodeSubspaces(jGlobalToGridLocal, globalToGridLocal, transform,
+                    twoDimSubspaces);
+    if (!jGlobalToGridLocal.empty()) {
+      return jGlobalToGridLocal;
+    }
+  }
+  return jGlobalToGridLocal;
+}
+
+std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal>
+Acts::GridAccessJsonConverter::globalToGridLocalFromJson(
+    const nlohmann::json& jGlobalToGridLocal) {
+  std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal> globalToGridLocal =
+      nullptr;
+
+  std::vector<BinningValue> accessors =
+      jGlobalToGridLocal.at("accessors").get<std::vector<BinningValue>>();
+
+  // Switch and fill for 1D
+  if (accessors.size() == 1u) {
+    switch (accessors[0]) {
+      case binX:
+        globalToGridLocal = decodeSubspace<binX>(jGlobalToGridLocal);
+        break;
+      case binY:
+        globalToGridLocal = decodeSubspace<binY>(jGlobalToGridLocal);
+        break;
+      case binZ:
+        globalToGridLocal = decodeSubspace<binZ>(jGlobalToGridLocal);
+        break;
+      case binR:
+        globalToGridLocal = decodeSubspace<binR>(jGlobalToGridLocal);
+        break;
+      case binPhi:
+        globalToGridLocal = decodeSubspace<binPhi>(jGlobalToGridLocal);
+        break;
+      case binEta:
+        globalToGridLocal = decodeSubspace<binEta>(jGlobalToGridLocal);
+        break;
+      default:
+        // globalToGridLocal = nullptr;
+        break;
+    }
+  }
+
+  // Switch and fill for 2D
+  if (accessors.size() == 2u) {
+    if (accessors == std::vector<BinningValue>{binX, binY}) {
+      globalToGridLocal = decodeSubspace<binX, binY>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binY, binX}) {
+      globalToGridLocal = decodeSubspace<binY, binX>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binX, binZ}) {
+      globalToGridLocal = decodeSubspace<binX, binZ>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binZ, binX}) {
+      globalToGridLocal = decodeSubspace<binZ, binX>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binY, binZ}) {
+      globalToGridLocal = decodeSubspace<binY, binZ>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binZ, binY}) {
+      globalToGridLocal = decodeSubspace<binZ, binY>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binR, binPhi}) {
+      globalToGridLocal = decodeSubspace<binR, binPhi>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binPhi, binR}) {
+      globalToGridLocal = decodeSubspace<binPhi, binR>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binZ, binPhi}) {
+      globalToGridLocal = decodeSubspace<binZ, binPhi>(jGlobalToGridLocal);
+    } else if (accessors == std::vector<BinningValue>{binPhi, binZ}) {
+      globalToGridLocal = decodeSubspace<binPhi, binZ>(jGlobalToGridLocal);
+    }
+    // else globalToGridLocal = nullptr;
+  }
+  return globalToGridLocal;
+}
+
+nlohmann::json Acts::GridAccessJsonConverter::toJson(
+    const GridAccess::IBoundToGridLocal& boundToGridLocal) {
+  nlohmann::json jBoundtoGridLocal;
+
+  auto localSubSpace0 =
+      dynamic_cast<const GridAccess::LocalSubspace<0u>*>(&boundToGridLocal);
+  if (localSubSpace0 != nullptr) {
+    jBoundtoGridLocal["type"] = "subspace";
+    jBoundtoGridLocal["accessors"] = localSubSpace0->accessors;
+  }
+
+  auto localSubSpace1 =
+      dynamic_cast<const GridAccess::LocalSubspace<1u>*>(&boundToGridLocal);
+  if (localSubSpace1 != nullptr) {
+    jBoundtoGridLocal["type"] = "subspace";
+    jBoundtoGridLocal["accessors"] = localSubSpace1->accessors;
+  }
+
+  auto localSubSpace01 =
+      dynamic_cast<const GridAccess::LocalSubspace<0u, 1u>*>(&boundToGridLocal);
+  if (localSubSpace01 != nullptr) {
+    jBoundtoGridLocal["type"] = "subspace";
+    jBoundtoGridLocal["accessors"] = localSubSpace01->accessors;
+  }
+
+  auto localSubSpace10 =
+      dynamic_cast<const GridAccess::LocalSubspace<1u, 0u>*>(&boundToGridLocal);
+  if (localSubSpace10 != nullptr) {
+    jBoundtoGridLocal["type"] = "subspace";
+    jBoundtoGridLocal["accessors"] = localSubSpace10->accessors;
+  }
+
+  auto boundCylinderToZPhi =
+      dynamic_cast<const GridAccess::BoundCylinderToZPhi*>(&boundToGridLocal);
+  if (boundCylinderToZPhi != nullptr) {
+    jBoundtoGridLocal["type"] = "cylinder_to_zphi";
+    jBoundtoGridLocal["radius"] = boundCylinderToZPhi->radius;
+    jBoundtoGridLocal["shift"] = boundCylinderToZPhi->shift;
+  }
+
+  return jBoundtoGridLocal;
+}
+
+std::unique_ptr<Acts::GridAccess::IBoundToGridLocal>
+Acts::GridAccessJsonConverter::boundToGridLocalFromJson(
+    const nlohmann::json& jBoundtoGridLocal) {
+  std::unique_ptr<Acts::GridAccess::IBoundToGridLocal> boundToGridLocal =
+      nullptr;
+  std::string type = jBoundtoGridLocal.at("type").get<std::string>();
+  if (type == "subspace") {
+    std::vector<std::size_t> accessors =
+        jBoundtoGridLocal.at("accessors").get<std::vector<std::size_t>>();
+    if (accessors.size() == 1 && accessors[0] == 0) {
+      boundToGridLocal =
+          std::make_unique<Acts::GridAccess::LocalSubspace<0u>>();
+    } else if (accessors.size() == 1 && accessors[0] == 1) {
+      boundToGridLocal =
+          std::make_unique<Acts::GridAccess::LocalSubspace<1u>>();
+    } else if (accessors.size() == 2 && accessors[0] == 0 &&
+               accessors[1] == 1) {
+      boundToGridLocal =
+          std::make_unique<Acts::GridAccess::LocalSubspace<0u, 1u>>();
+    } else if (accessors.size() == 2 && accessors[0] == 1 &&
+               accessors[1] == 0) {
+      boundToGridLocal =
+          std::make_unique<Acts::GridAccess::LocalSubspace<1u, 0u>>();
+    }
+  } else if (type == "cylinder_to_zphi") {
+    ActsScalar radius = jBoundtoGridLocal.at("radius").get<ActsScalar>();
+    ActsScalar shift = jBoundtoGridLocal.at("shift").get<ActsScalar>();
+    boundToGridLocal =
+        std::make_unique<Acts::GridAccess::BoundCylinderToZPhi>(radius, shift);
+  }
+  return boundToGridLocal;
+}
diff --git a/Tests/UnitTests/Plugins/Json/GridJsonConverterTests.cpp b/Tests/UnitTests/Plugins/Json/GridJsonConverterTests.cpp
index 3c3b3f24185..ffe4b8ed2e4 100644
--- a/Tests/UnitTests/Plugins/Json/GridJsonConverterTests.cpp
+++ b/Tests/UnitTests/Plugins/Json/GridJsonConverterTests.cpp
@@ -9,6 +9,8 @@
 #include <boost/test/unit_test.hpp>
 
 #include "Acts/Plugins/Json/GridJsonConverter.hpp"
+#include "Acts/Tests/CommonHelpers/FloatComparisons.hpp"
+#include "Acts/Utilities/GridAccessHelpers.hpp"
 #include "Acts/Utilities/GridAxisGenerators.hpp"
 
 #include <array>
@@ -249,4 +251,197 @@ BOOST_AUTO_TEST_CASE(Grid2DSingleEntryBoundClosed) {
   BOOST_CHECK_EQUAL(eqBoundEqClosedJsonRead.atPosition(p33), 33u);
 }
 
+namespace {
+template <typename ReferenceType, typename CheckTypeUniquePtr>
+bool checkType(const ReferenceType& /**unused*/,
+               const CheckTypeUniquePtr& g2l) {
+  return (dynamic_cast<const ReferenceType*>(g2l.get()) != nullptr);
+}
+
+template <typename SubspactTuple>
+void checkGlobalSubspaceTuple(const SubspactTuple& sstuple) {
+  // Test without transform
+  std::vector<nlohmann::json> jsspace;
+  std::apply(
+      [&](auto&&... vals) {
+        (jsspace.push_back(Acts::GridAccessJsonConverter::toJson(vals)), ...);
+      },
+      sstuple);
+
+  // Test that none of them are empty
+  for (auto& jss : jsspace) {
+    BOOST_CHECK(!jss.empty());
+  }
+
+  // Read back in
+  std::vector<std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal>> sspaceRead;
+  for (auto& jss : jsspace) {
+    sspaceRead.push_back(
+        Acts::GridAccessJsonConverter::globalToGridLocalFromJson(jss));
+  }
+
+  // Test that none of them are empty
+  for (auto& ssp : sspaceRead) {
+    BOOST_CHECK(ssp != nullptr);
+  }
+
+  // Check that the type is correct
+  std::size_t irn = 0;
+  bool good = true;
+  std::apply(
+      [&](auto&&... vals) {
+        ((good = good && checkType(vals, sspaceRead[irn++])), ...);
+      },
+      sstuple);
+  BOOST_CHECK(good);
+
+  Acts::Transform3 tTransform;
+  tTransform.pretranslate(Acts::Vector3{0., 0., 100.});
+
+  // Test with transform
+  std::vector<nlohmann::json> jsspaceTransform;
+  std::apply(
+      [&](auto... vals) {
+        (jsspaceTransform.push_back(Acts::GridAccessJsonConverter::toJson(
+             Acts::GridAccess::Affine3Transformed<decltype(vals)>(vals,
+                                                                  tTransform))),
+         ...);
+      },
+      sstuple);
+
+  // Test that none of them are empty & everyone has a stransform
+  for (auto& jss : jsspaceTransform) {
+    BOOST_CHECK(!jss.empty());
+    BOOST_CHECK(jss.find("transform") != jss.end());
+  }
+
+  // Read back in
+  std::vector<std::unique_ptr<Acts::GridAccess::IGlobalToGridLocal>>
+      sspaceTransformRead;
+  for (auto& jss : jsspaceTransform) {
+    sspaceTransformRead.push_back(
+        Acts::GridAccessJsonConverter::globalToGridLocalFromJson(jss));
+  }
+
+  // Test that none of them are empty
+  for (auto& ssp : sspaceTransformRead) {
+    BOOST_CHECK(ssp != nullptr);
+  }
+
+  // Check that the type is correct
+  irn = 0;
+  good = true;
+  std::apply(
+      [&](auto... vals) {
+        ((good = good &&
+                 checkType(Acts::GridAccess::Affine3Transformed<decltype(vals)>(
+                               vals, tTransform),
+                           sspaceTransformRead[irn++])),
+         ...);
+      },
+      sstuple);
+  BOOST_CHECK(good);
+}
+
+}  // namespace
+
+BOOST_AUTO_TEST_CASE(GlobalSubSpaceTests1D) {
+  // One dimensional sub spaces
+  const std::tuple<Acts::GridAccess::GlobalSubspace<Acts::binX>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binY>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binZ>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binR>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binPhi>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binEta>>
+      sspace1D;
+
+  // Check the tuple for 1D
+  checkGlobalSubspaceTuple(sspace1D);
+}
+
+BOOST_AUTO_TEST_CASE(GlobalSubSpaceTests2D) {
+  // Two dimensional sub spaces
+  const std::tuple<Acts::GridAccess::GlobalSubspace<Acts::binX, Acts::binY>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binY, Acts::binX>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binX, Acts::binZ>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binZ, Acts::binX>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binY, Acts::binZ>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binZ, Acts::binY>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binR, Acts::binPhi>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binPhi, Acts::binR>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binZ, Acts::binPhi>,
+                   Acts::GridAccess::GlobalSubspace<Acts::binPhi, Acts::binZ>>
+      sspace2D = {};
+
+  // Check the tuple for 2D
+  checkGlobalSubspaceTuple(sspace2D);
+}
+
+BOOST_AUTO_TEST_CASE(LocalSubspace1D) {
+  const std::tuple<Acts::GridAccess::LocalSubspace<0u>,
+                   Acts::GridAccess::LocalSubspace<1u>,
+                   Acts::GridAccess::LocalSubspace<0u, 1u>,
+                   Acts::GridAccess::LocalSubspace<1u, 0u>>
+      lspace1D;
+
+  // Write them to json
+  std::vector<nlohmann::json> jlspace;
+  std::apply(
+      [&](auto&&... vals) {
+        (jlspace.push_back(Acts::GridAccessJsonConverter::toJson(vals)), ...);
+      },
+      lspace1D);
+
+  // Check that none of them is empty
+  for (auto& jls : jlspace) {
+    BOOST_CHECK(!jls.empty());
+  }
+
+  std::vector<std::unique_ptr<Acts::GridAccess::IBoundToGridLocal>> lspaceRead;
+  for (auto& jls : jlspace) {
+    lspaceRead.push_back(
+        Acts::GridAccessJsonConverter::boundToGridLocalFromJson(jls));
+  }
+
+  // Test that none of them are empty
+  for (auto& lsp : lspaceRead) {
+    BOOST_CHECK(lsp != nullptr);
+  }
+
+  // Check that the type is correct
+  std::size_t irn = 0;
+  bool good = true;
+  std::apply(
+      [&](auto&&... vals) {
+        ((good = good && checkType(vals, lspaceRead[irn++])), ...);
+      },
+      lspace1D);
+  BOOST_CHECK(good);
+}
+
+BOOST_AUTO_TEST_CASE(BoundCylinderToZPhiTest) {
+  Acts::GridAccess::BoundCylinderToZPhi boundCylinderToZPhi(100., 10.);
+
+  nlohmann::json jboundCylinderToZPhi =
+      Acts::GridAccessJsonConverter::toJson(boundCylinderToZPhi);
+
+  // Check it is not empty
+  BOOST_CHECK(!jboundCylinderToZPhi.empty());
+
+  auto boundCylinderToZPhiRead =
+      Acts::GridAccessJsonConverter::boundToGridLocalFromJson(
+          jboundCylinderToZPhi);
+
+  // Check that it is not empty
+  BOOST_REQUIRE(boundCylinderToZPhiRead != nullptr);
+
+  const Acts::GridAccess::BoundCylinderToZPhi* bct =
+      dynamic_cast<const Acts::GridAccess::BoundCylinderToZPhi*>(
+          boundCylinderToZPhiRead.get());
+
+  BOOST_REQUIRE(bct != nullptr);
+  CHECK_CLOSE_ABS(bct->radius, 100., 1e-5);
+  CHECK_CLOSE_ABS(bct->shift, 10., 1e-5);
+}
+
 BOOST_AUTO_TEST_SUITE_END()