diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/gen_getters.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/gen_getters.hpp
index 4275e061a..636f8582c 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/gen_getters.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/meta_gen/gen_getters.hpp
@@ -74,8 +74,13 @@ template <class StructType> constexpr MetaComponent get_meta_component(char cons
                 auto ptr = reinterpret_cast<StructType*>(buffer_ptr);
                 std::fill(ptr + pos, ptr + pos + size, StructType{});
             },
-        .create_buffer = [](Idx size) -> RawDataPtr { return new StructType[size]; },
-        .destroy_buffer = [](RawDataConstPtr buffer_ptr) { delete[] reinterpret_cast<StructType const*>(buffer_ptr); },
+        .create_buffer = [](Idx size) -> RawDataPtr {
+            return new StructType[size]; // NOSONAR(S5025)
+        },
+        .destroy_buffer =
+            [](RawDataConstPtr buffer_ptr) {
+                delete[] reinterpret_cast<StructType const*>(buffer_ptr); // NOSONAR(S5025)
+            },
     };
 };
 
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp
index 2a2dd44d7..c38a65877 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/job_dispatch.hpp
@@ -63,9 +63,9 @@ class JobDispatch {
             std::exception_ptr const ex_ptr = std::current_exception();
             try {
                 std::rethrow_exception(ex_ptr);
-            } catch (std::exception const& ex) {
+            } catch (std::exception const& ex) { // NOSONAR(S1181)
                 messages[scenario_idx] = ex.what();
-            } catch (...) {
+            } catch (...) { // NOSONAR(S2738)
                 messages[scenario_idx] = "unknown exception";
             }
         };
@@ -178,11 +178,11 @@ class JobDispatch {
                 setup_(args...);
                 run_(args...);
                 winddown_();
-            } catch (...) {
+            } catch (...) { // NOSONAR(S2738)
                 handle_exception_(args...);
                 try {
                     winddown_();
-                } catch (...) {
+                } catch (...) { // NOSONAR(S2738)
                     recover_from_bad_();
                 }
             }
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp
index 75deca599..2a7893d8b 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver.hpp
@@ -32,7 +32,9 @@ template <symmetry_tag sym> class MathSolver : public MathSolverBase<sym> {
           all_const_y_{std::all_of(topo_ptr->load_gen_type.cbegin(), topo_ptr->load_gen_type.cend(),
                                    [](LoadGenType x) { return x == LoadGenType::const_y; })} {}
 
-    MathSolver<sym>* clone() const final { return new MathSolver<sym>(*this); }
+    MathSolver<sym>* clone() const final {
+        return new MathSolver<sym>(*this); // NOSONAR(S5025)
+    }
 
     SolverOutput<sym> run_power_flow(PowerFlowInput<sym> const& input, double err_tol, Idx max_iter, Logger& log,
                                      CalculationMethod calculation_method, YBus<sym> const& y_bus) final {
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver_dispatch.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver_dispatch.hpp
index 19cbe7d3e..37569de4a 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver_dispatch.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/math_solver/math_solver_dispatch.hpp
@@ -58,7 +58,7 @@ class MathSolverDispatcher {
         template <template <class> class MathSolverType>
         constexpr Config(math_solver_tag<MathSolverType> /* unused */)
             : create{[](std::shared_ptr<MathModelTopology const> const& topo_ptr) -> MathSolverBase<sym>* {
-                  return new MathSolverType<sym>{topo_ptr};
+                  return new MathSolverType<sym>{topo_ptr}; // NOSONAR(S5025)
               }} {}
 
         std::add_pointer_t<MathSolverBase<sym>*(std::shared_ptr<MathModelTopology const> const&)> create;
diff --git a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
index 7d9673967..9256e974d 100644
--- a/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
+++ b/power_grid_model_c/power_grid_model/include/power_grid_model/optimizer/tap_position_optimizer.hpp
@@ -916,7 +916,7 @@ class TapPositionOptimizerImpl<std::tuple<TransformerTypes...>, StateCalculator,
             auto result = optimize(state, order, method);
             update_state(cache);
             return result;
-        } catch (...) {
+        } catch (...) { // NOSONAR(S2738)
             update_state(cache);
             throw;
         }
diff --git a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
index 1986f35dd..3e60e67f1 100644
--- a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
+++ b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/basics.h
@@ -181,10 +181,10 @@ enum PGM_SymmetryType {
  *
  */
 enum PGM_ErrorCode {
-    PGM_no_error = 0,           /**< no error occurred */
-    PGM_regular_error = 1,      /**< some error occurred which is not in the batch calculation */
-    PGM_batch_error = 2,        /**< some error occurred which is in the batch calculation */
-    PGM_serialization_error = 3 /**< some error occurred which is in the (de)serialization process */
+    PGM_no_error = 0,            /**< no error occurred */
+    PGM_regular_error = 1,       /**< some error occurred which is not in the batch calculation */
+    PGM_batch_error = 2,         /**< some error occurred which is in the batch calculation */
+    PGM_serialization_error = 3, /**< some error occurred which is in the (de)serialization process */
 };
 
 /**
diff --git a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/handle.h b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/handle.h
index 6946d6ef8..c06b5f43d 100644
--- a/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/handle.h
+++ b/power_grid_model_c/power_grid_model_c/include/power_grid_model_c/handle.h
@@ -38,6 +38,8 @@ PGM_API void PGM_destroy_handle(PGM_Handle* handle);
 /**
  * @brief Get error code of last operation.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle you just used for an operation.
  * @return The error code, see #PGM_ErrorCode .
  */
@@ -49,6 +51,8 @@ PGM_API PGM_Idx PGM_error_code(PGM_Handle const* handle);
  * If the error code is PGM_batch_error.
  * Use PGM_n_failed_scenarios(), PGM_failed_scenarios(), and PGM_batch_errors() to retrieve the detail.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle you just used for an operation.
  * @return A char const* poiner to a zero terminated string.
  * The pointer is not valid if you execute another operation.
@@ -59,6 +63,8 @@ PGM_API char const* PGM_error_message(PGM_Handle const* handle);
 /**
  * @brief Get the number of failed scenarios. Only applicable when you just executed a batch calculation.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle you just used for a batch calculation.
  * @return The number of failed scenarios.
  */
@@ -67,6 +73,8 @@ PGM_API PGM_Idx PGM_n_failed_scenarios(PGM_Handle const* handle);
 /**
  * @brief Get the list of failed scenarios, Only applicable when you just execute a batch calculation.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle you just used for a batch calculation.
  * @return A pointer to a PGM_Idx array with length returned by PGM_n_failed_scenarios().
  * The pointer is not valid if you execute another operation.
@@ -77,6 +85,8 @@ PGM_API PGM_Idx const* PGM_failed_scenarios(PGM_Handle const* handle);
 /**
  * @brief Get the list of batch errors. Only applicable when you just execute a batch calculation.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle you just used for a batch calculation.
  * @return A pointer to a char const* array with length returned by PGM_n_failed_scenarios().
  * Each entry is a zero terminated string.
@@ -88,6 +98,8 @@ PGM_API char const** PGM_batch_errors(PGM_Handle const* handle);
 /**
  * @brief Clear and reset the handle.
  *
+ * The behavior is implementation-defined if the handle is NULL.
+ *
  * @param handle The pointer to the handle.
  */
 PGM_API void PGM_clear_error(PGM_Handle* handle);
diff --git a/power_grid_model_c/power_grid_model_c/src/buffer.cpp b/power_grid_model_c/power_grid_model_c/src/buffer.cpp
index 8679f8274..4df924640 100644
--- a/power_grid_model_c/power_grid_model_c/src/buffer.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/buffer.cpp
@@ -7,6 +7,9 @@
 
 #include "power_grid_model_c/buffer.h"
 
+#include "handle.hpp"
+#include "input_sanitization.hpp"
+
 #include <power_grid_model/auxiliary/meta_data.hpp>
 
 #include <cstdlib>
@@ -16,20 +19,29 @@ using namespace power_grid_model;
 
 using meta_data::RawDataConstPtr;
 using meta_data::RawDataPtr;
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::safe_ptr;
+using power_grid_model_c::safe_ptr_get;
+using power_grid_model_c::safe_ptr_maybe_nullptr;
+using power_grid_model_c::to_c_size;
 } // namespace
 
 // buffer control
-RawDataPtr PGM_create_buffer(PGM_Handle* /* handle */, PGM_MetaComponent const* component, PGM_Idx size) {
-    // alignment should be maximum of alignment of the component and alignment of void*
-    size_t const alignment = std::max(component->alignment, sizeof(void*));
-    // total bytes should be multiple of alignment
-    size_t const requested_bytes = component->size * size;
-    size_t const rounded_bytes = ((requested_bytes + alignment - 1) / alignment) * alignment;
+RawDataPtr PGM_create_buffer(PGM_Handle* handle, PGM_MetaComponent const* component, PGM_Idx size) {
+    return call_with_catch(handle, [component, size] {
+        auto const& safe_component = safe_ptr_get(component);
+
+        // alignment should be maximum of alignment of the component and alignment of void*
+        size_t const alignment = std::max(safe_component.alignment, sizeof(void*));
+        // total bytes should be multiple of alignment
+        size_t const requested_bytes = safe_component.size * size;
+        size_t const rounded_bytes = ((requested_bytes + alignment - 1) / alignment) * alignment;
 #ifdef _WIN32
-    return _aligned_malloc(rounded_bytes, alignment);
+        return _aligned_malloc(rounded_bytes, alignment);
 #else
-    return std::aligned_alloc(alignment, rounded_bytes);
+        return std::aligned_alloc(alignment, rounded_bytes);
 #endif
+    });
 }
 void PGM_destroy_buffer(RawDataPtr ptr) {
 #ifdef _WIN32
@@ -38,36 +50,54 @@ void PGM_destroy_buffer(RawDataPtr ptr) {
     std::free(ptr); // NOLINT(hicpp-no-malloc)
 #endif
 }
-void PGM_buffer_set_nan(PGM_Handle* /* handle */, PGM_MetaComponent const* component, void* ptr, PGM_Idx buffer_offset,
+
+void PGM_buffer_set_nan(PGM_Handle* handle, PGM_MetaComponent const* component, void* ptr, PGM_Idx buffer_offset,
                         PGM_Idx size) {
-    component->set_nan(ptr, buffer_offset, size);
+    call_with_catch(handle, [component, ptr, buffer_offset, size] {
+        safe_ptr_get(component).set_nan(safe_ptr(ptr), buffer_offset, size);
+    });
 }
 
 namespace {
 // template for get and set attribute
 template <bool is_get, class BufferPtr, class ValuePtr>
-void buffer_get_set_value(PGM_MetaAttribute const* attribute, BufferPtr buffer_ptr, ValuePtr value_ptr,
+void buffer_get_set_value(PGM_MetaAttribute const& attribute, BufferPtr buffer_ptr, ValuePtr value_ptr,
                           PGM_Idx buffer_offset, PGM_Idx size, PGM_Idx stride) {
+    using RawValuePtr = std::conditional_t<is_get, char*, char const*>;
+
+    if (size <= 0) {
+        return;
+    }
+
     // if stride is negative, use the size of the attributes as stride
     if (stride < 0) {
-        stride = static_cast<PGM_Idx>(attribute->size);
+        stride = to_c_size(attribute.size);
     }
+
+    auto const raw_value_ptr = reinterpret_cast<RawValuePtr>(safe_ptr(value_ptr));
+    auto const safe_buffer_ptr = safe_ptr(buffer_ptr);
+
     for (Idx i = buffer_offset; i != size + buffer_offset; ++i) {
-        ValuePtr const shifted_value_ptr =
-            reinterpret_cast<std::conditional_t<is_get, char*, char const*>>(value_ptr) + stride * i;
+        ValuePtr const shifted_value_ptr = raw_value_ptr + stride * i;
         if constexpr (is_get) {
-            attribute->get_value(buffer_ptr, shifted_value_ptr, i);
+            attribute.get_value(safe_buffer_ptr, shifted_value_ptr, i);
         } else {
-            attribute->set_value(buffer_ptr, shifted_value_ptr, i);
+            attribute.set_value(safe_buffer_ptr, shifted_value_ptr, i);
         }
     }
 }
 } // namespace
-void PGM_buffer_set_value(PGM_Handle* /* handle */, PGM_MetaAttribute const* attribute, RawDataPtr buffer_ptr,
+void PGM_buffer_set_value(PGM_Handle* handle, PGM_MetaAttribute const* attribute, RawDataPtr buffer_ptr,
                           RawDataConstPtr src_ptr, PGM_Idx buffer_offset, PGM_Idx size, PGM_Idx src_stride) {
-    buffer_get_set_value<false>(attribute, buffer_ptr, src_ptr, buffer_offset, size, src_stride);
+    call_with_catch(handle, [attribute, buffer_ptr, src_ptr, buffer_offset, size, src_stride] {
+        buffer_get_set_value<false>(safe_ptr_get(attribute), safe_ptr_maybe_nullptr(buffer_ptr),
+                                    safe_ptr_maybe_nullptr(src_ptr), buffer_offset, size, src_stride);
+    });
 }
-void PGM_buffer_get_value(PGM_Handle* /* handle */, PGM_MetaAttribute const* attribute, RawDataConstPtr buffer_ptr,
+void PGM_buffer_get_value(PGM_Handle* handle, PGM_MetaAttribute const* attribute, RawDataConstPtr buffer_ptr,
                           RawDataPtr dest_ptr, PGM_Idx buffer_offset, PGM_Idx size, PGM_Idx dest_stride) {
-    buffer_get_set_value<true>(attribute, buffer_ptr, dest_ptr, buffer_offset, size, dest_stride);
+    call_with_catch(handle, [attribute, buffer_ptr, dest_ptr, buffer_offset, size, dest_stride] {
+        buffer_get_set_value<true>(safe_ptr_get(attribute), safe_ptr_maybe_nullptr(buffer_ptr),
+                                   safe_ptr_maybe_nullptr(dest_ptr), buffer_offset, size, dest_stride);
+    });
 }
diff --git a/power_grid_model_c/power_grid_model_c/src/dataset.cpp b/power_grid_model_c/power_grid_model_c/src/dataset.cpp
index 13c24c563..15d15f5dc 100644
--- a/power_grid_model_c/power_grid_model_c/src/dataset.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/dataset.cpp
@@ -5,165 +5,188 @@
 #define PGM_DLL_EXPORTS
 #include "forward_declarations.hpp"
 
+#include "power_grid_model_c/dataset.h"
+
 #include "get_meta_data.hpp"
 #include "handle.hpp"
-#include "power_grid_model_c/dataset.h"
+#include "input_sanitization.hpp"
 
 #include <power_grid_model/auxiliary/dataset.hpp>
 #include <power_grid_model/auxiliary/meta_data.hpp>
+#include <power_grid_model/common/typing.hpp>
 
 using namespace power_grid_model;
 using namespace power_grid_model::meta_data;
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::safe_bool;
+using power_grid_model_c::safe_ptr;
+using power_grid_model_c::safe_ptr_get;
+using power_grid_model_c::safe_ptr_maybe_nullptr;
+using power_grid_model_c::safe_str_view;
+using power_grid_model_c::to_c_bool;
+using power_grid_model_c::to_c_size;
 
 // dataset info
 
-char const* PGM_dataset_info_name(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info) { return info->dataset->name; }
+char const* PGM_dataset_info_name(PGM_Handle* handle, PGM_DatasetInfo const* info) {
+    return call_with_catch(handle, [info] { return safe_ptr_get(safe_ptr(info)->dataset).name; });
+}
 
-PGM_Idx PGM_dataset_info_is_batch(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info) {
-    return static_cast<PGM_Idx>(info->is_batch);
+PGM_Idx PGM_dataset_info_is_batch(PGM_Handle* handle, PGM_DatasetInfo const* info) {
+    return call_with_catch(handle, [info] { return to_c_bool<PGM_Idx>(safe_ptr_get(info).is_batch); });
 }
 
-PGM_Idx PGM_dataset_info_batch_size(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info) { return info->batch_size; }
+PGM_Idx PGM_dataset_info_batch_size(PGM_Handle* handle, PGM_DatasetInfo const* info) {
+    return call_with_catch(handle, [info] { return safe_ptr_get(info).batch_size; });
+}
 
-PGM_Idx PGM_dataset_info_n_components(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info) {
-    return static_cast<PGM_Idx>(info->component_info.size());
+PGM_Idx PGM_dataset_info_n_components(PGM_Handle* handle, PGM_DatasetInfo const* info) {
+    return call_with_catch(handle, [info] { return to_c_size(std::ssize(safe_ptr_get(info).component_info)); });
 }
 
-char const* PGM_dataset_info_component_name(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info,
-                                            PGM_Idx component_idx) {
-    return info->component_info[component_idx].component->name;
+char const* PGM_dataset_info_component_name(PGM_Handle* handle, PGM_DatasetInfo const* info, PGM_Idx component_idx) {
+    return call_with_catch(handle, [info, component_idx] {
+        return safe_ptr_get(safe_ptr_get(info).component_info.at(component_idx).component).name;
+    });
 }
 
-PGM_Idx PGM_dataset_info_elements_per_scenario(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info,
-                                               PGM_Idx component_idx) {
-    return info->component_info[component_idx].elements_per_scenario;
+PGM_Idx PGM_dataset_info_elements_per_scenario(PGM_Handle* handle, PGM_DatasetInfo const* info, PGM_Idx component_idx) {
+    return call_with_catch(handle, [info, component_idx] {
+        return safe_ptr_get(info).component_info.at(component_idx).elements_per_scenario;
+    });
 }
 
-PGM_Idx PGM_dataset_info_total_elements(PGM_Handle* /*unused*/, PGM_DatasetInfo const* info, PGM_Idx component_idx) {
-    return info->component_info[component_idx].total_elements;
+PGM_Idx PGM_dataset_info_total_elements(PGM_Handle* handle, PGM_DatasetInfo const* info, PGM_Idx component_idx) {
+    return call_with_catch(
+        handle, [info, component_idx] { return safe_ptr_get(info).component_info.at(component_idx).total_elements; });
 }
 
-PGM_Idx PGM_dataset_info_has_attribute_indications(PGM_Handle* /* handle */, PGM_DatasetInfo const* info,
+PGM_Idx PGM_dataset_info_has_attribute_indications(PGM_Handle* handle, PGM_DatasetInfo const* info,
                                                    PGM_Idx component_idx) {
-    return static_cast<PGM_Idx>(info->component_info[component_idx].has_attribute_indications);
+    return call_with_catch(handle, [info, component_idx] {
+        return to_c_bool<PGM_Idx>(safe_ptr_get(info).component_info.at(component_idx).has_attribute_indications);
+    });
 }
 
-PGM_Idx PGM_dataset_info_n_attribute_indications(PGM_Handle* /* handle */, PGM_DatasetInfo const* info,
+PGM_Idx PGM_dataset_info_n_attribute_indications(PGM_Handle* handle, PGM_DatasetInfo const* info,
                                                  PGM_Idx component_idx) {
-    return static_cast<PGM_Idx>(info->component_info[component_idx].attribute_indications.size());
+    return call_with_catch(handle, [info, component_idx] {
+        return to_c_size(std::ssize(safe_ptr_get(info).component_info.at(component_idx).attribute_indications));
+    });
 }
 
-char const* PGM_dataset_info_attribute_name(PGM_Handle* /* handle */, PGM_DatasetInfo const* info,
-                                            PGM_Idx component_idx, PGM_Idx attribute_idx) {
-    return info->component_info[component_idx].attribute_indications[attribute_idx]->name;
+char const* PGM_dataset_info_attribute_name(PGM_Handle* handle, PGM_DatasetInfo const* info, PGM_Idx component_idx,
+                                            PGM_Idx attribute_idx) {
+    return call_with_catch(handle, [info, component_idx, attribute_idx] {
+        return safe_ptr_get(safe_ptr_get(info).component_info.at(component_idx).attribute_indications.at(attribute_idx))
+            .name;
+    });
 }
 
 // const dataset
 
 PGM_ConstDataset* PGM_create_dataset_const(PGM_Handle* handle, char const* dataset, PGM_Idx is_batch,
                                            PGM_Idx batch_size) {
-    return call_with_catch(
-        handle,
-        [dataset, is_batch, batch_size]() {
-            return new ConstDataset{static_cast<bool>(is_batch), batch_size, dataset, get_meta_data()};
-        },
-        PGM_regular_error);
+    return call_with_catch(handle, [dataset, is_batch, batch_size] {
+        return new ConstDataset{// NOSONAR(S5025)
+                                safe_bool(is_batch), batch_size, safe_str_view(dataset), get_meta_data()};
+    });
 }
 
 PGM_ConstDataset* PGM_create_dataset_const_from_writable(PGM_Handle* handle,
                                                          PGM_WritableDataset const* writable_dataset) {
-    return call_with_catch(
-        handle, [writable_dataset]() { return new ConstDataset{*writable_dataset}; }, PGM_regular_error);
+    return call_with_catch(handle, [writable_dataset] {
+        return new ConstDataset{safe_ptr_get(writable_dataset)}; // NOSONAR(S5025)
+    });
 }
 
 PGM_ConstDataset* PGM_create_dataset_const_from_mutable(PGM_Handle* handle, PGM_MutableDataset const* mutable_dataset) {
-    return call_with_catch(
-        handle, [mutable_dataset]() { return new ConstDataset{*mutable_dataset}; }, PGM_regular_error);
+    return call_with_catch(handle, [mutable_dataset] {
+        return new ConstDataset{safe_ptr_get(mutable_dataset)}; // NOSONAR(S5025)
+    });
 }
 
-void PGM_destroy_dataset_const(PGM_ConstDataset* dataset) { delete dataset; }
+void PGM_destroy_dataset_const(PGM_ConstDataset* dataset) {
+    delete dataset; // NOSONAR(S5025)
+}
 
 void PGM_dataset_const_add_buffer(PGM_Handle* handle, PGM_ConstDataset* dataset, char const* component,
                                   PGM_Idx elements_per_scenario, PGM_Idx total_elements, PGM_Idx const* indptr,
                                   void const* data) {
-    call_with_catch(
-        handle,
-        [dataset, component, elements_per_scenario, total_elements, indptr, data]() {
-            dataset->add_buffer(component, elements_per_scenario, total_elements, indptr, data);
-        },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, elements_per_scenario, total_elements, indptr, data] {
+        safe_ptr_get(dataset).add_buffer(safe_str_view(component), elements_per_scenario, total_elements,
+                                         safe_ptr_maybe_nullptr(indptr), safe_ptr_maybe_nullptr(data));
+    });
 }
 
 void PGM_dataset_const_add_attribute_buffer(PGM_Handle* handle, PGM_ConstDataset* dataset, char const* component,
                                             char const* attribute, void const* data) {
-    call_with_catch(
-        handle, [dataset, component, attribute, data]() { dataset->add_attribute_buffer(component, attribute, data); },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, attribute, data] {
+        safe_ptr_get(dataset).add_attribute_buffer(safe_str_view(component), safe_str_view(attribute), safe_ptr(data));
+    });
 }
-
 void PGM_dataset_const_set_next_cartesian_product_dimension(PGM_Handle* handle, PGM_ConstDataset* dataset,
                                                             PGM_ConstDataset const* next_dataset) {
-    call_with_catch(
-        handle, [dataset, next_dataset]() { dataset->set_next_cartesian_product_dimension(next_dataset); },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, next_dataset] {
+        safe_ptr_get(dataset).set_next_cartesian_product_dimension(safe_ptr(next_dataset));
+    });
 }
 
-PGM_DatasetInfo const* PGM_dataset_const_get_info(PGM_Handle* /*unused*/, PGM_ConstDataset const* dataset) {
-    return &dataset->get_description();
+PGM_DatasetInfo const* PGM_dataset_const_get_info(PGM_Handle* handle, PGM_ConstDataset const* dataset) {
+    return call_with_catch(handle, [dataset] { return &safe_ptr_get(dataset).get_description(); });
 }
 
 // writable dataset
 
-PGM_DatasetInfo const* PGM_dataset_writable_get_info(PGM_Handle* /*unused*/, PGM_WritableDataset const* dataset) {
-    return &dataset->get_description();
+PGM_DatasetInfo const* PGM_dataset_writable_get_info(PGM_Handle* handle, PGM_WritableDataset const* dataset) {
+    return call_with_catch(handle, [dataset] { return &safe_ptr_get(dataset).get_description(); });
 }
 
 void PGM_dataset_writable_set_buffer(PGM_Handle* handle, PGM_WritableDataset* dataset, char const* component,
                                      PGM_Idx* indptr, void* data) {
-    call_with_catch(
-        handle, [dataset, component, indptr, data]() { dataset->set_buffer(component, indptr, data); },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, indptr, data] {
+        safe_ptr_get(dataset).set_buffer(safe_str_view(component), safe_ptr_maybe_nullptr(indptr),
+                                         safe_ptr_maybe_nullptr(data));
+    });
 }
 
 void PGM_dataset_writable_set_attribute_buffer(PGM_Handle* handle, PGM_WritableDataset* dataset, char const* component,
                                                char const* attribute, void* data) {
-    call_with_catch(
-        handle, [dataset, component, attribute, data]() { dataset->set_attribute_buffer(component, attribute, data); },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, attribute, data] {
+        safe_ptr_get(dataset).set_attribute_buffer(safe_str_view(component), safe_str_view(attribute), safe_ptr(data));
+    });
 }
 
 // mutable dataset
 
 PGM_MutableDataset* PGM_create_dataset_mutable(PGM_Handle* handle, char const* dataset, PGM_Idx is_batch,
                                                PGM_Idx batch_size) {
-    return call_with_catch(
-        handle,
-        [dataset, is_batch, batch_size]() {
-            return new MutableDataset{static_cast<bool>(is_batch), batch_size, dataset, get_meta_data()};
-        },
-        PGM_regular_error);
+    return call_with_catch(handle, [dataset, is_batch, batch_size] {
+        return new MutableDataset{// NOSONAR(S5025)
+                                  safe_bool(is_batch), batch_size, safe_str_view(dataset), get_meta_data()};
+    });
 }
 
-void PGM_destroy_dataset_mutable(PGM_MutableDataset* dataset) { delete dataset; }
+void PGM_destroy_dataset_mutable(PGM_MutableDataset* dataset) {
+    delete dataset; // NOSONAR(S5025)
+}
 
 void PGM_dataset_mutable_add_buffer(PGM_Handle* handle, PGM_MutableDataset* dataset, char const* component,
                                     PGM_Idx elements_per_scenario, PGM_Idx total_elements, PGM_Idx const* indptr,
                                     void* data) {
-    call_with_catch(
-        handle,
-        [dataset, component, elements_per_scenario, total_elements, indptr, data]() {
-            dataset->add_buffer(component, elements_per_scenario, total_elements, indptr, data);
-        },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, elements_per_scenario, total_elements, indptr, data] {
+        safe_ptr_get(dataset).add_buffer(safe_str_view(component), elements_per_scenario, total_elements,
+                                         safe_ptr_maybe_nullptr(indptr), safe_ptr_maybe_nullptr(data));
+    });
 }
 
 void PGM_dataset_mutable_add_attribute_buffer(PGM_Handle* handle, PGM_MutableDataset* dataset, char const* component,
                                               char const* attribute, void* data) {
-    call_with_catch(
-        handle, [dataset, component, attribute, data]() { dataset->add_attribute_buffer(component, attribute, data); },
-        PGM_regular_error);
+    call_with_catch(handle, [dataset, component, attribute, data] {
+        safe_ptr_get(dataset).add_attribute_buffer(safe_str_view(component), safe_str_view(attribute), safe_ptr(data));
+    });
 }
 
-PGM_DatasetInfo const* PGM_dataset_mutable_get_info(PGM_Handle* /*unused*/, PGM_MutableDataset const* dataset) {
-    return &dataset->get_description();
+PGM_DatasetInfo const* PGM_dataset_mutable_get_info(PGM_Handle* handle, PGM_MutableDataset const* dataset) {
+    return call_with_catch(handle, [dataset] { return &safe_ptr_get(dataset).get_description(); });
 }
diff --git a/power_grid_model_c/power_grid_model_c/src/handle.cpp b/power_grid_model_c/power_grid_model_c/src/handle.cpp
index faf479aeb..1bfb5e376 100644
--- a/power_grid_model_c/power_grid_model_c/src/handle.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/handle.cpp
@@ -8,26 +8,47 @@
 #include "power_grid_model_c/handle.h"
 
 #include "handle.hpp"
+#include "input_sanitization.hpp"
 
 #include <algorithm>
+#include <type_traits>
 
 namespace {
 using namespace power_grid_model;
+
+using power_grid_model_c::clear_error;
+using power_grid_model_c::compile_time_safe_cast;
 } // namespace
 
 // create and destroy handle
-PGM_Handle* PGM_create_handle() { return new PGM_Handle{}; }
-void PGM_destroy_handle(PGM_Handle* handle) { delete handle; }
+PGM_Handle* PGM_create_handle() {
+    return new PGM_Handle{}; // NOSONAR(S5025)
+}
+void PGM_destroy_handle(PGM_Handle* handle) {
+    delete handle; // NOSONAR(S5025)
+}
 
 // error handling
-PGM_Idx PGM_error_code(PGM_Handle const* handle) { return handle->err_code; }
-char const* PGM_error_message(PGM_Handle const* handle) { return handle->err_msg.c_str(); }
-PGM_Idx PGM_n_failed_scenarios(PGM_Handle const* handle) { return static_cast<Idx>(handle->failed_scenarios.size()); }
-PGM_Idx const* PGM_failed_scenarios(PGM_Handle const* handle) { return handle->failed_scenarios.data(); }
+PGM_Idx PGM_error_code(PGM_Handle const* handle) {
+    return handle != nullptr ? compile_time_safe_cast<PGM_Idx>(handle->err_code) : PGM_Idx{0};
+}
+char const* PGM_error_message(PGM_Handle const* handle) {
+    return handle != nullptr ? handle->err_msg.c_str() : nullptr;
+}
+PGM_Idx PGM_n_failed_scenarios(PGM_Handle const* handle) {
+    return handle != nullptr ? compile_time_safe_cast<PGM_Idx>(std::ssize(handle->failed_scenarios)) : PGM_Idx{0};
+}
+PGM_Idx const* PGM_failed_scenarios(PGM_Handle const* handle) {
+    return handle != nullptr ? compile_time_safe_cast<PGM_Idx const*>(handle->failed_scenarios.data()) : nullptr;
+}
 char const** PGM_batch_errors(PGM_Handle const* handle) {
-    handle->batch_errs_c_str.clear();
-    std::ranges::transform(handle->batch_errs, std::back_inserter(handle->batch_errs_c_str),
+    if (handle == nullptr) {
+        return nullptr;
+    }
+    auto const& handle_ref = *handle;
+    handle_ref.batch_errs_c_str.clear();
+    std::ranges::transform(handle_ref.batch_errs, std::back_inserter(handle_ref.batch_errs_c_str),
                            [](auto const& x) { return x.c_str(); });
-    return handle->batch_errs_c_str.data();
+    return handle_ref.batch_errs_c_str.data();
 }
-void PGM_clear_error(PGM_Handle* handle) { *handle = PGM_Handle{}; }
+void PGM_clear_error(PGM_Handle* handle) { clear_error(handle); }
diff --git a/power_grid_model_c/power_grid_model_c/src/handle.hpp b/power_grid_model_c/power_grid_model_c/src/handle.hpp
index 54c58a6c4..b3c4f9a0a 100644
--- a/power_grid_model_c/power_grid_model_c/src/handle.hpp
+++ b/power_grid_model_c/power_grid_model_c/src/handle.hpp
@@ -15,6 +15,7 @@
 #include <power_grid_model/batch_parameter.hpp>
 #include <power_grid_model/common/common.hpp>
 
+#include <exception>
 #include <string_view>
 
 // context handle
@@ -27,21 +28,65 @@ struct PGM_Handle {
     [[no_unique_address]] power_grid_model::BatchParameter batch_parameter;
 };
 
-template <class Exception = std::exception, class Functor>
-inline auto call_with_catch(PGM_Handle* handle, Functor func, PGM_Idx error_code,
-                            std::string_view extra_msg = {}) -> std::invoke_result_t<Functor> {
-    if (handle) {
-        PGM_clear_error(handle);
+namespace power_grid_model_c {
+constexpr void clear_error(PGM_Handle* handle) {
+    if (handle != nullptr) {
+        *handle = PGM_Handle{};
     }
+}
+
+struct DefaultExceptionHandler {
+    void operator()(PGM_Handle& handle) const noexcept { handle_all_errors(handle, PGM_regular_error); }
+
+    static void handle_all_errors(PGM_Handle& handle, PGM_Idx error_code,
+                                  std::string_view extra_message = "") noexcept {
+        std::exception_ptr const ex_ptr = std::current_exception();
+        try {
+            std::rethrow_exception(ex_ptr);
+        } catch (std::exception const& ex) { // NOSONAR(S1181)
+            handle_regular_error(handle, ex, error_code, extra_message);
+        } catch (...) { // NOSONAR(S2738)
+            handle_unkown_error(handle);
+        }
+    }
+
+    static void handle_regular_error(PGM_Handle& handle, std::exception const& ex, PGM_Idx error_code,
+                                     std::string_view extra_message = "") noexcept {
+        handle.err_code = error_code;
+        handle.err_msg = ex.what();
+        if (!extra_message.empty()) {
+            handle.err_msg += extra_message;
+        }
+    }
+
+    static void handle_unkown_error(PGM_Handle& handle) noexcept {
+        handle.err_code = PGM_regular_error;
+        handle.err_msg = "Unknown error!\n";
+    }
+};
+
+// Call function with exception handling using Lippincott pattern
+//
+// The handle itself is inherently unsafe, as checking for safety would then raise, which in turn would require another
+// handle, etc. Therefore, only a nullptr check can be done here.
+template <class Functor, class ExceptionHandler = DefaultExceptionHandler>
+    requires std::invocable<Functor> && std::invocable<ExceptionHandler const&, PGM_Handle&>
+inline auto call_with_catch(PGM_Handle* handle, Functor func, ExceptionHandler const& exception_handler = {}) noexcept(
+    noexcept(exception_handler(std::declval<PGM_Handle&>()))) -> std::invoke_result_t<Functor> {
     using ReturnValueType = std::remove_cvref_t<std::invoke_result_t<Functor>>;
-    static std::conditional_t<std::is_void_v<ReturnValueType>, int, ReturnValueType> const empty{};
+
+    static constexpr std::conditional_t<std::is_void_v<ReturnValueType>, int, ReturnValueType> empty{};
+
     try {
+        if (handle != nullptr) {
+            clear_error(handle);
+        }
         return func();
-    } catch (Exception const& e) {
-        if (handle) {
-            handle->err_code = error_code;
-            handle->err_msg = std::string{e.what()} + std::string{extra_msg};
+    } catch (...) { // NOSONAR(S2738) // Lippincott pattern handles all exceptions if the handle is provided
+        if (handle != nullptr) {
+            exception_handler(*handle);
         }
         return static_cast<ReturnValueType>(empty);
     }
 }
+} // namespace power_grid_model_c
diff --git a/power_grid_model_c/power_grid_model_c/src/input_sanitization.hpp b/power_grid_model_c/power_grid_model_c/src/input_sanitization.hpp
new file mode 100644
index 000000000..72d1aeb56
--- /dev/null
+++ b/power_grid_model_c/power_grid_model_c/src/input_sanitization.hpp
@@ -0,0 +1,94 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include <exception>
+#include <format>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace power_grid_model_c {
+class IllegalOperationError : public std::exception {
+  public:
+    explicit IllegalOperationError(std::string_view message) : msg_{std::format("Illegal operation: {}\n", message)} {}
+
+    char const* what() const noexcept final { return msg_.c_str(); }
+
+  private:
+    std::string msg_;
+};
+
+template <typename T, typename U> constexpr T compile_time_safe_cast(U const& value) noexcept {
+    static_assert(std::convertible_to<U, T>,
+                  "Type U is not convertible to type T; compile-time safe cast not possible");
+    static_assert(std::same_as<T, std::common_type_t<T, U>>,
+                  "Loss of precision during conversion possible; common type differs from target type");
+
+    if constexpr (std::same_as<T, U>) {
+        return value;
+    } else {
+        return static_cast<T>(value);
+    }
+}
+
+template <std::integral T, std::integral U>
+    requires std::convertible_to<U, T>
+constexpr auto safe_cast(U value) {
+    if constexpr (std::same_as<T, U>) {
+        return value;
+    } else {
+        if (std::in_range<T>(value)) {
+            return static_cast<T>(value);
+        }
+        throw IllegalOperationError{"Value out of range for target type"};
+    }
+}
+
+template <std::integral T> constexpr T safe_int(PGM_Idx value) { return safe_cast<T>(value); }
+template <std::integral T> constexpr T safe_size(PGM_Idx value) {
+    if (value >= 0) {
+        return safe_cast<T>(value);
+    }
+    throw IllegalOperationError{"Received negative value for size"};
+}
+template <std::integral T> constexpr PGM_Idx to_c_size(T value) {
+    assert(value >= 0);
+    return safe_cast<PGM_Idx>(value);
+}
+
+template <std::integral T> constexpr bool safe_bool(T value) { return value != T{0}; }
+template <std::integral T> constexpr T to_c_bool(bool value) { return value ? T{1} : T{0}; }
+
+// safe enum conversion from C integer type to C++ enum type.
+//
+// Just like that. It does not (and cannot) check if the value is one of the pre-defined names.
+// However, it does ensure that there is no unexpected behavior like wrap-arounds during the conversion.
+// E.g.: for an enum class with underlying type uint8_t, passing 256 would wrap around to 0 without this check.
+template <typename T>
+    requires std::is_enum_v<T>
+constexpr T safe_enum(PGM_Idx value) {
+    return static_cast<T>(safe_cast<std::underlying_type_t<T>>(value));
+}
+template <typename T>
+    requires std::is_enum_v<T>
+constexpr PGM_Idx to_c_enum(T value) {
+    return safe_cast<PGM_Idx>(std::to_underlying(value));
+}
+
+// no-op sanitization for clarity that we did think about input sanitization but we deliberately allow nullptr
+template <typename T> constexpr T* safe_ptr_maybe_nullptr(T* ptr) { return ptr; }
+
+template <typename T> constexpr T* safe_ptr(T* ptr) {
+    if (ptr) {
+        return safe_ptr_maybe_nullptr(ptr);
+    }
+    throw IllegalOperationError{"Received null pointer when not allowed"};
+}
+
+template <typename T> constexpr T& safe_ptr_get(T* ptr) { return *safe_ptr(ptr); }
+
+constexpr std::string_view safe_str_view(char const* str) { return std::string_view{safe_ptr(str)}; }
+} // namespace power_grid_model_c
diff --git a/power_grid_model_c/power_grid_model_c/src/math_solver.cpp b/power_grid_model_c/power_grid_model_c/src/math_solver.cpp
index 93b4d8201..09f198430 100644
--- a/power_grid_model_c/power_grid_model_c/src/math_solver.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/math_solver.cpp
@@ -8,11 +8,11 @@
 
 #include <power_grid_model/math_solver/math_solver.hpp>
 
-namespace power_grid_model {
+namespace power_grid_model_c {
+using namespace power_grid_model;
 
 MathSolverDispatcher const& get_math_solver_dispatcher() {
     static constexpr MathSolverDispatcher math_solver_dispatcher{math_solver::math_solver_tag<MathSolver>{}};
     return math_solver_dispatcher;
 }
-
-} // namespace power_grid_model
+} // namespace power_grid_model_c
diff --git a/power_grid_model_c/power_grid_model_c/src/math_solver.hpp b/power_grid_model_c/power_grid_model_c/src/math_solver.hpp
index 8bbd95d49..eae90ec1a 100644
--- a/power_grid_model_c/power_grid_model_c/src/math_solver.hpp
+++ b/power_grid_model_c/power_grid_model_c/src/math_solver.hpp
@@ -12,8 +12,8 @@
 
 #include <power_grid_model/math_solver/math_solver_dispatch.hpp>
 
-namespace power_grid_model {
+namespace power_grid_model_c {
+using power_grid_model::MathSolverDispatcher;
 
 MathSolverDispatcher const& get_math_solver_dispatcher();
-
-} // namespace power_grid_model
+} // namespace power_grid_model_c
diff --git a/power_grid_model_c/power_grid_model_c/src/meta_data.cpp b/power_grid_model_c/power_grid_model_c/src/meta_data.cpp
index ba8c2e095..bc31abdcd 100644
--- a/power_grid_model_c/power_grid_model_c/src/meta_data.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/meta_data.cpp
@@ -9,6 +9,7 @@
 
 #include "get_meta_data.hpp"
 #include "handle.hpp"
+#include "input_sanitization.hpp"
 
 #include <power_grid_model/auxiliary/meta_data_gen.hpp>
 #include <power_grid_model/auxiliary/static_asserts/input.hpp>
@@ -18,16 +19,34 @@
 namespace {
 using namespace power_grid_model;
 
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::safe_ptr_get;
+using power_grid_model_c::safe_str_view;
+using power_grid_model_c::to_c_bool;
+using power_grid_model_c::to_c_enum;
+
 // assert index type
 static_assert(std::is_same_v<PGM_Idx, Idx>);
 static_assert(std::is_same_v<PGM_ID, ID>);
 
-constexpr std::string_view bound_error_msg = "\n You supplied wrong name and/or index!\n";
+struct RangedExceptionHandler : public power_grid_model_c::DefaultExceptionHandler {
+    void operator()(PGM_Handle& handle) const noexcept {
+        using namespace std::string_literals;
 
-auto const meta_catch = [](PGM_Handle* handle, auto func) -> decltype(auto) {
-    return call_with_catch<std::out_of_range>(handle, func, PGM_regular_error, bound_error_msg);
+        std::exception_ptr const ex_ptr = std::current_exception();
+        try {
+            std::rethrow_exception(ex_ptr);
+        } catch (std::out_of_range const& ex) {
+            handle_regular_error(handle, ex, PGM_regular_error, "\n You supplied wrong name and/or index!\n");
+        } catch (std::exception const& ex) {
+            handle_regular_error(handle, ex, PGM_regular_error);
+        } catch (...) { // NOSONAR(S2738)
+            handle_unkown_error(handle);
+        }
+    }
 };
 
+constexpr RangedExceptionHandler ranged_exception_handler{};
 } // namespace
 
 // retrieve meta data
@@ -38,68 +57,94 @@ power_grid_model::meta_data::MetaData const& get_meta_data() {
 // dataset
 PGM_Idx PGM_meta_n_datasets(PGM_Handle* /* handle */) { return get_meta_data().n_datasets(); }
 PGM_MetaDataset const* PGM_meta_get_dataset_by_idx(PGM_Handle* handle, PGM_Idx idx) {
-    return meta_catch(handle, [idx]() {
-        if (idx >= get_meta_data().n_datasets()) {
-            throw std::out_of_range{"Index out of range!\n"};
-        }
-        return &get_meta_data().datasets[idx];
-    });
+    return call_with_catch(
+        handle,
+        [idx] {
+            if (idx < 0 || idx >= get_meta_data().n_datasets()) {
+                throw std::out_of_range{"Index out of range!\n"};
+            }
+            return &get_meta_data().datasets[idx];
+        },
+        ranged_exception_handler);
 }
 PGM_MetaDataset const* PGM_meta_get_dataset_by_name(PGM_Handle* handle, char const* dataset) {
-    return meta_catch(handle, [dataset]() { return &get_meta_data().get_dataset(dataset); });
+    return call_with_catch(
+        handle, [dataset] { return &get_meta_data().get_dataset(safe_str_view(dataset)); }, ranged_exception_handler);
+}
+char const* PGM_meta_dataset_name(PGM_Handle* handle, PGM_MetaDataset const* dataset) {
+    return call_with_catch(handle, [dataset] { return safe_ptr_get(dataset).name; });
 }
-char const* PGM_meta_dataset_name(PGM_Handle* /* handle */, PGM_MetaDataset const* dataset) { return dataset->name; }
 // component
-PGM_Idx PGM_meta_n_components(PGM_Handle* /* handle */, PGM_MetaDataset const* dataset) {
-    return dataset->n_components();
+PGM_Idx PGM_meta_n_components(PGM_Handle* handle, PGM_MetaDataset const* dataset) {
+    return call_with_catch(handle, [dataset] { return safe_ptr_get(dataset).n_components(); });
 }
 PGM_MetaComponent const* PGM_meta_get_component_by_idx(PGM_Handle* handle, PGM_MetaDataset const* dataset,
                                                        PGM_Idx idx) {
-    return meta_catch(handle, [idx, dataset]() {
-        if (idx >= dataset->n_components()) {
-            throw std::out_of_range{"Index out of range!\n"};
-        }
-        return &dataset->components[idx];
-    });
+    return call_with_catch(
+        handle,
+        [idx, dataset] {
+            auto const& safe_dataset = safe_ptr_get(dataset);
+            if (idx < 0 || idx >= safe_dataset.n_components()) {
+                throw std::out_of_range{"Index out of range!\n"};
+            }
+            return &safe_dataset.components[idx];
+        },
+        ranged_exception_handler);
 }
 PGM_MetaComponent const* PGM_meta_get_component_by_name(PGM_Handle* handle, char const* dataset,
                                                         char const* component) {
-    return meta_catch(
-        handle, [component, dataset]() { return &get_meta_data().get_dataset(dataset).get_component(component); });
+    return call_with_catch(
+        handle,
+        [component, dataset] {
+            return &get_meta_data().get_dataset(safe_str_view(dataset)).get_component(safe_str_view(component));
+        },
+        ranged_exception_handler);
+}
+char const* PGM_meta_component_name(PGM_Handle* handle, PGM_MetaComponent const* component) {
+    return call_with_catch(handle, [component] { return safe_ptr_get(component).name; });
 }
-char const* PGM_meta_component_name(PGM_Handle* /* handle */, PGM_MetaComponent const* component) {
-    return component->name;
+size_t PGM_meta_component_size(PGM_Handle* handle, PGM_MetaComponent const* component) {
+    return call_with_catch(handle, [component] { return safe_ptr_get(component).size; });
 }
-size_t PGM_meta_component_size(PGM_Handle* /* handle */, PGM_MetaComponent const* component) { return component->size; }
-size_t PGM_meta_component_alignment(PGM_Handle* /* handle */, PGM_MetaComponent const* component) {
-    return component->alignment;
+size_t PGM_meta_component_alignment(PGM_Handle* handle, PGM_MetaComponent const* component) {
+    return call_with_catch(handle, [component] { return safe_ptr_get(component).alignment; });
 }
 // attributes
-PGM_Idx PGM_meta_n_attributes(PGM_Handle* /* handle */, PGM_MetaComponent const* component) {
-    return component->n_attributes();
+PGM_Idx PGM_meta_n_attributes(PGM_Handle* handle, PGM_MetaComponent const* component) {
+    return call_with_catch(handle, [component] { return safe_ptr_get(component).n_attributes(); });
 }
 PGM_MetaAttribute const* PGM_meta_get_attribute_by_idx(PGM_Handle* handle, PGM_MetaComponent const* component,
                                                        PGM_Idx idx) {
-    return meta_catch(handle, [idx, component]() {
-        if (idx >= component->n_attributes()) {
-            throw std::out_of_range{"Index out of range!\n"};
-        }
-        return &component->attributes[idx];
-    });
+    return call_with_catch(
+        handle,
+        [idx, component] {
+            auto const& safe_component = safe_ptr_get(component);
+            if (idx < 0 || idx >= safe_component.n_attributes()) {
+                throw std::out_of_range{"Index out of range!\n"};
+            }
+            return &safe_component.attributes[idx];
+        },
+        ranged_exception_handler);
 }
 PGM_MetaAttribute const* PGM_meta_get_attribute_by_name(PGM_Handle* handle, char const* dataset, char const* component,
                                                         char const* attribute) {
-    return meta_catch(handle, [component, dataset, attribute]() {
-        return &get_meta_data().get_dataset(dataset).get_component(component).get_attribute(attribute);
-    });
+    return call_with_catch(
+        handle,
+        [component, dataset, attribute] {
+            return &get_meta_data()
+                        .get_dataset(safe_str_view(dataset))
+                        .get_component(safe_str_view(component))
+                        .get_attribute(safe_str_view(attribute));
+        },
+        ranged_exception_handler);
 }
-char const* PGM_meta_attribute_name(PGM_Handle* /* handle */, PGM_MetaAttribute const* attribute) {
-    return attribute->name;
+char const* PGM_meta_attribute_name(PGM_Handle* handle, PGM_MetaAttribute const* attribute) {
+    return call_with_catch(handle, [attribute] { return safe_ptr_get(attribute).name; });
 }
-PGM_Idx PGM_meta_attribute_ctype(PGM_Handle* /* handle */, PGM_MetaAttribute const* attribute) {
-    return static_cast<PGM_Idx>(attribute->ctype);
+PGM_Idx PGM_meta_attribute_ctype(PGM_Handle* handle, PGM_MetaAttribute const* attribute) {
+    return call_with_catch(handle, [attribute] { return to_c_enum(safe_ptr_get(attribute).ctype); });
 }
-size_t PGM_meta_attribute_offset(PGM_Handle* /* handle */, PGM_MetaAttribute const* attribute) {
-    return attribute->offset;
+size_t PGM_meta_attribute_offset(PGM_Handle* handle, PGM_MetaAttribute const* attribute) {
+    return call_with_catch(handle, [attribute] { return safe_ptr_get(attribute).offset; });
 }
-int PGM_is_little_endian(PGM_Handle* /* handle */) { return static_cast<int>(meta_data::is_little_endian()); }
+int PGM_is_little_endian(PGM_Handle* /* handle */) { return to_c_bool<int>(meta_data::is_little_endian()); }
diff --git a/power_grid_model_c/power_grid_model_c/src/model.cpp b/power_grid_model_c/power_grid_model_c/src/model.cpp
index 4579648f8..00ab5bee3 100644
--- a/power_grid_model_c/power_grid_model_c/src/model.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/model.cpp
@@ -8,6 +8,7 @@
 #include "power_grid_model_c/model.h"
 
 #include "handle.hpp"
+#include "input_sanitization.hpp"
 #include "math_solver.hpp"
 #include "options.hpp"
 
@@ -20,6 +21,14 @@
 
 namespace {
 using namespace power_grid_model;
+
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::get_math_solver_dispatcher;
+using power_grid_model_c::safe_enum;
+using power_grid_model_c::safe_ptr;
+using power_grid_model_c::safe_ptr_get;
+using power_grid_model_c::safe_ptr_maybe_nullptr;
+using power_grid_model_c::safe_str_view;
 } // namespace
 
 // aliases main class
@@ -30,32 +39,32 @@ struct PGM_PowerGridModel : public MainModel {
 // create model
 PGM_PowerGridModel* PGM_create_model(PGM_Handle* handle, double system_frequency,
                                      PGM_ConstDataset const* input_dataset) {
-    return call_with_catch(
-        handle,
-        [system_frequency, input_dataset] {
-            return new PGM_PowerGridModel{system_frequency, *input_dataset, get_math_solver_dispatcher(), 0};
-        },
-        PGM_regular_error);
+    return call_with_catch(handle, [system_frequency, input_dataset] {
+        return new PGM_PowerGridModel{// NOSONAR(S5025)
+                                      system_frequency, safe_ptr_get(input_dataset), get_math_solver_dispatcher(), 0};
+    });
 }
 
 // update model
 void PGM_update_model(PGM_Handle* handle, PGM_PowerGridModel* model, PGM_ConstDataset const* update_dataset) {
-    call_with_catch(
-        handle, [model, update_dataset] { model->update_components<permanent_update_t>(*update_dataset); },
-        PGM_regular_error);
+    call_with_catch(handle, [model, update_dataset] {
+        model->update_components<permanent_update_t>(safe_ptr_get(update_dataset));
+    });
 }
 
 // copy model
 PGM_PowerGridModel* PGM_copy_model(PGM_Handle* handle, PGM_PowerGridModel const* model) {
-    return call_with_catch(handle, [model] { return new PGM_PowerGridModel{*model}; }, PGM_regular_error);
+    return call_with_catch(handle, [model] {
+        return new PGM_PowerGridModel{safe_ptr_get(model)}; // NOSONAR(S5025)
+    });
 }
 
 // get indexer
 void PGM_get_indexer(PGM_Handle* handle, PGM_PowerGridModel const* model, char const* component, PGM_Idx size,
                      PGM_ID const* ids, PGM_Idx* indexer) {
-    call_with_catch(
-        handle, [model, component, size, ids, indexer] { model->get_indexer(component, ids, size, indexer); },
-        PGM_regular_error);
+    call_with_catch(handle, [model, component, size, ids, indexer] {
+        safe_ptr_get(model).get_indexer(safe_str_view(component), safe_ptr(ids), size, safe_ptr(indexer));
+    });
 }
 
 // helper functions
@@ -76,9 +85,7 @@ void check_calculate_valid_options(PGM_Options const& opt) {
     }
 }
 
-constexpr auto get_calculation_type(PGM_Options const& opt) {
-    return static_cast<CalculationType>(opt.calculation_type);
-}
+constexpr auto get_calculation_type(PGM_Options const& opt) { return safe_enum<CalculationType>(opt.calculation_type); }
 
 constexpr auto get_calculation_symmetry(PGM_Options const& opt) {
     switch (opt.symmetric) {
@@ -92,7 +99,7 @@ constexpr auto get_calculation_symmetry(PGM_Options const& opt) {
 }
 
 constexpr auto get_calculation_method(PGM_Options const& opt) {
-    return static_cast<CalculationMethod>(opt.calculation_method);
+    return safe_enum<CalculationMethod>(opt.calculation_method);
 }
 
 constexpr auto get_optimizer_type(PGM_Options const& opt) {
@@ -130,7 +137,7 @@ constexpr auto get_optimizer_strategy(PGM_Options const& opt) {
 }
 
 constexpr auto get_short_circuit_voltage_scaling(PGM_Options const& opt) {
-    return static_cast<ShortCircuitVoltageScaling>(opt.short_circuit_voltage_scaling);
+    return safe_enum<ShortCircuitVoltageScaling>(opt.short_circuit_voltage_scaling);
 }
 
 constexpr auto extract_calculation_options(PGM_Options const& opt) {
@@ -144,65 +151,94 @@ constexpr auto extract_calculation_options(PGM_Options const& opt) {
                               .threading = opt.threading,
                               .short_circuit_voltage_scaling = get_short_circuit_voltage_scaling(opt)};
 }
-} // namespace
 
-// calculation implementation
-namespace {
+class BadCalculationRequest : public PowerGridError {
+  public:
+    explicit BadCalculationRequest(std::string msg) : PowerGridError{std::move(msg)} {}
+};
 
-void calculate_impl(PGM_Handle* handle, PGM_PowerGridModel* model, PGM_Options const* opt,
-                    PGM_MutableDataset const* output_dataset, PGM_ConstDataset const* batch_dataset) {
-    PGM_clear_error(handle);
+void calculate_single_batch_dimension_impl(PGM_PowerGridModel& model, PGM_Options const& opt,
+                                           MutableDataset const& output_dataset, ConstDataset const* batch_dataset) {
     // check dataset integrity
-    if ((batch_dataset != nullptr) && (!batch_dataset->is_batch() || !output_dataset->is_batch())) {
-        handle->err_code = PGM_regular_error;
-        handle->err_msg = "If batch_dataset is provided. Both batch_dataset and output_dataset should be a batch!\n";
-        return;
+    if ((batch_dataset != nullptr) && (!batch_dataset->is_batch() || !output_dataset.is_batch())) {
+        throw BadCalculationRequest{
+            "If batch_dataset is provided. Both batch_dataset and output_dataset should be a batch!\n"};
     }
 
     ConstDataset const& exported_update_dataset =
-        batch_dataset != nullptr ? *batch_dataset : PGM_ConstDataset{false, 1, "update", output_dataset->meta_data()};
+        batch_dataset != nullptr ? safe_ptr_get(batch_dataset)
+                                 : PGM_ConstDataset{false, 1, "update", output_dataset.meta_data()};
 
-    // call calculation
-    try {
-        check_calculate_valid_options(*opt);
-        auto const options = extract_calculation_options(*opt);
+    check_calculate_valid_options(opt);
+    auto const options = extract_calculation_options(opt);
 
-        if (opt->experimental_features == PGM_experimental_features_disabled) {
-            check_no_experimental_features_used(*model, options);
-        }
+    if (opt.experimental_features == PGM_experimental_features_disabled) {
+        check_no_experimental_features_used(model, options);
+    }
 
-        model->calculate(options, *output_dataset, exported_update_dataset);
-    } catch (BatchCalculationError& e) {
-        handle->err_code = PGM_batch_error;
-        handle->err_msg = e.what();
-        handle->failed_scenarios = e.failed_scenarios();
-        handle->batch_errs = e.err_msgs();
-    } catch (std::exception& e) {
-        handle->err_code = PGM_regular_error;
-        handle->err_msg = e.what();
-    } catch (...) {
-        handle->err_code = PGM_regular_error;
-        handle->err_msg = "Unknown error!\n";
+    model.calculate(options, output_dataset, exported_update_dataset);
+}
+
+struct BatchExceptionHandler : public power_grid_model_c::DefaultExceptionHandler {
+    void operator()(PGM_Handle& handle) const {
+        std::exception_ptr const ex_ptr = std::current_exception();
+        try {
+            std::rethrow_exception(ex_ptr);
+        } catch (BatchCalculationError const& ex) {
+            handle_regular_error(handle, ex, PGM_batch_error);
+            handle.failed_scenarios = ex.failed_scenarios();
+            handle.batch_errs = ex.err_msgs();
+        } catch (std::exception& ex) { // NOSONAR(S1181)
+            handle_regular_error(handle, ex, PGM_regular_error);
+        } catch (...) { // NOSONAR(S2738)
+            handle_unkown_error(handle);
+        }
     }
+};
+
+constexpr BatchExceptionHandler batch_exception_handler{};
+
+template <typename T, std::ranges::input_range R>
+    requires std::convertible_to<std::ranges::range_value_t<R>, T>
+void append_range(std::vector<T>& vec, R&& range) {
+    std::ranges::move(std::forward<R>(range), std::back_inserter(vec));
 }
 
-void merge_batch_error_msgs(PGM_Handle* handle, PGM_Handle const& local_handle, Idx scenario_offset, Idx stride_size) {
-    if (local_handle.err_code == PGM_no_error) {
-        return;
+class MDBatchExceptionHandler : public power_grid_model_c::DefaultExceptionHandler {
+  public:
+    MDBatchExceptionHandler(Idx scenario_offset, Idx stride_size)
+        : scenario_offset_{scenario_offset}, stride_size_{stride_size} {
+        assert(scenario_offset_ >= 0);
+        assert(stride_size_ > 0);
     }
-    handle->err_code = PGM_batch_error;
-    if (local_handle.err_code == PGM_batch_error) {
-        for (auto&& [idx, err_msg] : std::views::zip(local_handle.failed_scenarios, local_handle.batch_errs)) {
-            handle->failed_scenarios.push_back(idx + scenario_offset);
-            handle->batch_errs.push_back(err_msg);
-        }
-    } else {
-        for (Idx i = 0; i < stride_size; ++i) {
-            handle->failed_scenarios.push_back(scenario_offset + i);
-            handle->batch_errs.push_back(local_handle.err_msg);
+
+    void operator()(PGM_Handle& handle) const noexcept {
+        using namespace std::string_literals;
+
+        std::exception_ptr const ex_ptr = std::current_exception();
+        try {
+            std::rethrow_exception(ex_ptr);
+        } catch (BatchCalculationError const& ex) {
+            handle_regular_error(handle, ex, PGM_batch_error);
+            append_range(handle.failed_scenarios,
+                         ex.failed_scenarios() | std::views::transform([scenario_offset = scenario_offset_](Idx idx) {
+                             return idx + scenario_offset;
+                         }));
+
+            append_range(handle.batch_errs, ex.err_msgs());
+        } catch (std::exception const& ex) {
+            handle_regular_error(handle, ex, PGM_batch_error);
+            append_range(handle.failed_scenarios, IdxRange{stride_size_});
+            append_range(handle.batch_errs, std::views::repeat(ex.what(), stride_size_));
+        } catch (...) { // NOSONAR(S2738)
+            handle_unkown_error(handle);
         }
     }
-}
+
+  private:
+    Idx scenario_offset_{};
+    Idx stride_size_{};
+};
 
 Idx get_batch_dimension(PGM_ConstDataset const* batch_dataset) {
     Idx dimension = 0;
@@ -223,51 +259,68 @@ Idx get_stride_size(PGM_ConstDataset const* batch_dataset) {
     return size;
 }
 
-} // namespace
-
 // run calculation
-void PGM_calculate(PGM_Handle* handle, PGM_PowerGridModel* model, PGM_Options const* opt,
-                   PGM_MutableDataset const* output_dataset, PGM_ConstDataset const* batch_dataset) {
+void calculate_multi_dimensional_impl(PGM_PowerGridModel& model, PGM_Options const& opt,
+                                      PGM_MutableDataset const& output_dataset, PGM_ConstDataset const* batch_dataset) {
     // for dimension < 2 (one-time or 1D batch), call implementation directly
     if (auto const batch_dimension = get_batch_dimension(batch_dataset); batch_dimension < 2) {
-        calculate_impl(handle, model, opt, output_dataset, batch_dataset);
+        calculate_single_batch_dimension_impl(model, opt, output_dataset, batch_dataset);
         return;
     }
 
+    auto const& safe_batch_dataset = safe_ptr_get(batch_dataset);
+
     // get stride size of the rest of dimensions
-    Idx const first_batch_size = batch_dataset->batch_size();
+    Idx const first_batch_size = safe_batch_dataset.batch_size();
     Idx const stride_size = get_stride_size(batch_dataset);
 
+    PGM_Handle local_handle{};
+
     // loop over the first dimension batch
     for (Idx i = 0; i < first_batch_size; ++i) {
         // a new handle
-        PGM_Handle local_handle{};
-        // create sliced datasets for the rest of dimensions
-        PGM_ConstDataset const single_update_dataset = batch_dataset->get_individual_scenario(i);
-        PGM_MutableDataset const sliced_output_dataset =
-            output_dataset->get_slice_scenario(i * stride_size, (i + 1) * stride_size);
-
-        // create a model copy
-        std::unique_ptr<PGM_PowerGridModel> const local_model{PGM_copy_model(&local_handle, model)};
-        if (local_handle.err_code != PGM_no_error) {
-            merge_batch_error_msgs(handle, local_handle, i * stride_size, stride_size);
-            continue;
-        }
-
-        // apply the update
-        PGM_update_model(&local_handle, local_model.get(), &single_update_dataset);
-        if (local_handle.err_code != PGM_no_error) {
-            merge_batch_error_msgs(handle, local_handle, i * stride_size, stride_size);
-            continue;
-        }
+        call_with_catch(
+            &local_handle,
+            [&model, &opt, &output_dataset, &safe_batch_dataset, i, stride_size] {
+                // create sliced datasets for the rest of dimensions
+                PGM_ConstDataset const single_update_dataset = safe_batch_dataset.get_individual_scenario(i);
+                PGM_MutableDataset const sliced_output_dataset =
+                    output_dataset.get_slice_scenario(i * stride_size, (i + 1) * stride_size);
+
+                // create a model copy
+                PGM_PowerGridModel local_model{model};
+
+                // apply the update
+                local_model.update_components<permanent_update_t>(single_update_dataset);
+
+                // recursive call
+                calculate_multi_dimensional_impl(local_model, opt, sliced_output_dataset,
+                                                 safe_batch_dataset.get_next_cartesian_product_dimension());
+            },
+            MDBatchExceptionHandler{i * stride_size, stride_size});
+    }
 
-        // recursive call
-        PGM_calculate(&local_handle, local_model.get(), opt, &sliced_output_dataset,
-                      batch_dataset->get_next_cartesian_product_dimension());
-        // merge errors
-        merge_batch_error_msgs(handle, local_handle, i * stride_size, stride_size);
+    if (local_handle.err_code != PGM_no_error) {
+        throw BatchCalculationError{std::move(local_handle.err_msg), std::move(local_handle.failed_scenarios),
+                                    std::move(local_handle.batch_errs)};
     }
 }
 
+} // namespace
+
+// run calculation
+void PGM_calculate(PGM_Handle* handle, PGM_PowerGridModel* model, PGM_Options const* opt,
+                   PGM_MutableDataset const* output_dataset, PGM_ConstDataset const* batch_dataset) {
+    call_with_catch(
+        handle,
+        [model, opt, output_dataset, batch_dataset] {
+            calculate_multi_dimensional_impl(safe_ptr_get(model), safe_ptr_get(opt), safe_ptr_get(output_dataset),
+                                             safe_ptr_maybe_nullptr(batch_dataset));
+        },
+        batch_exception_handler);
+}
+
 // destroy model
-void PGM_destroy_model(PGM_PowerGridModel* model) { delete model; }
+void PGM_destroy_model(PGM_PowerGridModel* model) {
+    delete model; // NOSONAR(S5025)
+}
diff --git a/power_grid_model_c/power_grid_model_c/src/options.cpp b/power_grid_model_c/power_grid_model_c/src/options.cpp
index 5c22d7aca..2dba36f95 100644
--- a/power_grid_model_c/power_grid_model_c/src/options.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/options.cpp
@@ -7,32 +7,53 @@
 
 #include "power_grid_model_c/options.h"
 
+#include "handle.hpp"
+#include "input_sanitization.hpp"
 #include "options.hpp"
 
 namespace {
 using namespace power_grid_model;
+
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::safe_ptr_get;
 } // namespace
 
 // options
-PGM_Options* PGM_create_options(PGM_Handle* /* handle */) { return new PGM_Options{}; }
-void PGM_destroy_options(PGM_Options* opt) { delete opt; }
-void PGM_set_calculation_type(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx type) {
-    opt->calculation_type = type;
-}
-void PGM_set_calculation_method(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx method) {
-    opt->calculation_method = method;
-}
-void PGM_set_symmetric(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx sym) { opt->symmetric = sym; }
-void PGM_set_err_tol(PGM_Handle* /* handle */, PGM_Options* opt, double err_tol) { opt->err_tol = err_tol; }
-void PGM_set_max_iter(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx max_iter) { opt->max_iter = max_iter; }
-void PGM_set_threading(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx threading) { opt->threading = threading; }
-void PGM_set_short_circuit_voltage_scaling(PGM_Handle* /* handle */, PGM_Options* opt,
+PGM_Options* PGM_create_options(PGM_Handle* /* handle */) {
+    return new PGM_Options{}; // NOSONAR(S5025)
+}
+void PGM_destroy_options(PGM_Options* opt) {
+    delete opt; // NOSONAR(S5025)
+}
+void PGM_set_calculation_type(PGM_Handle* handle, PGM_Options* opt, PGM_Idx type) {
+    call_with_catch(handle, [opt, type] { safe_ptr_get(opt).calculation_type = type; });
+}
+void PGM_set_calculation_method(PGM_Handle* handle, PGM_Options* opt, PGM_Idx method) {
+    call_with_catch(handle, [opt, method] { safe_ptr_get(opt).calculation_method = method; });
+}
+void PGM_set_symmetric(PGM_Handle* handle, PGM_Options* opt, PGM_Idx sym) {
+    call_with_catch(handle, [opt, sym] { safe_ptr_get(opt).symmetric = sym; });
+}
+void PGM_set_err_tol(PGM_Handle* handle, PGM_Options* opt, double err_tol) {
+    call_with_catch(handle, [opt, err_tol] { safe_ptr_get(opt).err_tol = err_tol; });
+}
+void PGM_set_max_iter(PGM_Handle* handle, PGM_Options* opt, PGM_Idx max_iter) {
+    call_with_catch(handle, [opt, max_iter] { safe_ptr_get(opt).max_iter = max_iter; });
+}
+void PGM_set_threading(PGM_Handle* handle, PGM_Options* opt, PGM_Idx threading) {
+    call_with_catch(handle, [opt, threading] { safe_ptr_get(opt).threading = threading; });
+}
+void PGM_set_short_circuit_voltage_scaling(PGM_Handle* handle, PGM_Options* opt,
                                            PGM_Idx short_circuit_voltage_scaling) {
-    opt->short_circuit_voltage_scaling = short_circuit_voltage_scaling;
+    call_with_catch(handle, [opt, short_circuit_voltage_scaling] {
+        safe_ptr_get(opt).short_circuit_voltage_scaling = short_circuit_voltage_scaling;
+    });
 }
-void PGM_set_tap_changing_strategy(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx tap_changing_strategy) {
-    opt->tap_changing_strategy = tap_changing_strategy;
+void PGM_set_tap_changing_strategy(PGM_Handle* handle, PGM_Options* opt, PGM_Idx tap_changing_strategy) {
+    call_with_catch(handle,
+                    [opt, tap_changing_strategy] { safe_ptr_get(opt).tap_changing_strategy = tap_changing_strategy; });
 }
-void PGM_set_experimental_features(PGM_Handle* /* handle */, PGM_Options* opt, PGM_Idx experimental_features) {
-    opt->experimental_features = experimental_features;
+void PGM_set_experimental_features(PGM_Handle* handle, PGM_Options* opt, PGM_Idx experimental_features) {
+    call_with_catch(handle,
+                    [opt, experimental_features] { safe_ptr_get(opt).experimental_features = experimental_features; });
 }
diff --git a/power_grid_model_c/power_grid_model_c/src/serialization.cpp b/power_grid_model_c/power_grid_model_c/src/serialization.cpp
index 89f9c1d57..44b2c8d07 100644
--- a/power_grid_model_c/power_grid_model_c/src/serialization.cpp
+++ b/power_grid_model_c/power_grid_model_c/src/serialization.cpp
@@ -5,28 +5,48 @@
 #define PGM_DLL_EXPORTS
 #include "forward_declarations.hpp"
 
+#include "power_grid_model_c/serialization.h"
+
 #include "get_meta_data.hpp"
 #include "handle.hpp"
+#include "input_sanitization.hpp"
+
 #include "power_grid_model_c/basics.h"
 #include "power_grid_model_c/handle.h"
-#include "power_grid_model_c/serialization.h"
 
 #include <power_grid_model/auxiliary/serialization/deserializer.hpp>
 #include <power_grid_model/auxiliary/serialization/serializer.hpp>
 
+namespace {
 using namespace power_grid_model::meta_data;
 
+using power_grid_model_c::call_with_catch;
+using power_grid_model_c::safe_bool;
+using power_grid_model_c::safe_enum;
+using power_grid_model_c::safe_ptr;
+using power_grid_model_c::safe_ptr_get;
+using power_grid_model_c::safe_size;
+using power_grid_model_c::to_c_size;
+
+struct SerializationExceptionHandler : public power_grid_model_c::DefaultExceptionHandler {
+    void operator()(PGM_Handle& handle) const noexcept { handle_all_errors(handle, PGM_serialization_error); }
+};
+
+constexpr SerializationExceptionHandler serialization_exception_handler{};
+} // namespace
+
 PGM_Deserializer* PGM_create_deserializer_from_binary_buffer(PGM_Handle* handle, char const* data, PGM_Idx size,
                                                              PGM_Idx serialization_format) {
     return call_with_catch(
         handle,
         [data, size, serialization_format] {
-            return new PGM_Deserializer{from_buffer,
-                                        {data, static_cast<size_t>(size)},
-                                        static_cast<power_grid_model::SerializationFormat>(serialization_format),
+            return new PGM_Deserializer{// NOSONAR(S5025)
+                                        from_buffer,
+                                        {safe_ptr(data), safe_size<size_t>(size)},
+                                        safe_enum<power_grid_model::SerializationFormat>(serialization_format),
                                         get_meta_data()};
         },
-        PGM_serialization_error);
+        serialization_exception_handler);
 }
 
 PGM_Deserializer* PGM_create_deserializer_from_null_terminated_string(PGM_Handle* handle, char const* data_string,
@@ -34,34 +54,38 @@ PGM_Deserializer* PGM_create_deserializer_from_null_terminated_string(PGM_Handle
     return call_with_catch(
         handle,
         [data_string, serialization_format] {
-            return new PGM_Deserializer{from_string, data_string,
-                                        static_cast<power_grid_model::SerializationFormat>(serialization_format),
+            return new PGM_Deserializer{// NOSONAR(S5025)
+                                        from_string, safe_ptr(data_string),
+                                        safe_enum<power_grid_model::SerializationFormat>(serialization_format),
                                         get_meta_data()};
         },
-        PGM_serialization_error);
+        serialization_exception_handler);
 }
 
-PGM_WritableDataset* PGM_deserializer_get_dataset(PGM_Handle* /*unused*/, PGM_Deserializer* deserializer) {
-    return &deserializer->get_dataset_info();
+PGM_WritableDataset* PGM_deserializer_get_dataset(PGM_Handle* handle, PGM_Deserializer* deserializer) {
+    return call_with_catch(handle, [deserializer] { return &safe_ptr_get(deserializer).get_dataset_info(); });
 }
 
 void PGM_deserializer_parse_to_buffer(PGM_Handle* handle, PGM_Deserializer* deserializer) {
-    call_with_catch(handle, [deserializer] { deserializer->parse(); }, PGM_serialization_error);
+    call_with_catch(handle, [deserializer] { safe_ptr_get(deserializer).parse(); }, serialization_exception_handler);
 }
 
 // false warning from clang-tidy
 // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDelete)
-void PGM_destroy_deserializer(PGM_Deserializer* deserializer) { delete deserializer; }
+void PGM_destroy_deserializer(PGM_Deserializer* deserializer) {
+    delete deserializer; // NOSONAR(S5025)
+}
 
 PGM_Serializer* PGM_create_serializer(PGM_Handle* handle, PGM_ConstDataset const* dataset,
                                       PGM_Idx serialization_format) {
     return call_with_catch(
         handle,
         [dataset, serialization_format] {
-            return new PGM_Serializer{*dataset,
-                                      static_cast<power_grid_model::SerializationFormat>(serialization_format)};
+            return new PGM_Serializer{// NOSONAR(S5025)
+                                      safe_ptr_get(dataset),
+                                      safe_enum<power_grid_model::SerializationFormat>(serialization_format)};
         },
-        PGM_serialization_error);
+        serialization_exception_handler);
 }
 
 void PGM_serializer_get_to_binary_buffer(PGM_Handle* handle, PGM_Serializer* serializer, PGM_Idx use_compact_list,
@@ -69,11 +93,11 @@ void PGM_serializer_get_to_binary_buffer(PGM_Handle* handle, PGM_Serializer* ser
     call_with_catch(
         handle,
         [serializer, use_compact_list, data, size] {
-            auto const buffer_data = serializer->get_binary_buffer(static_cast<bool>(use_compact_list));
+            auto const buffer_data = safe_ptr_get(serializer).get_binary_buffer(safe_bool(use_compact_list));
             *data = buffer_data.data();
-            *size = static_cast<PGM_Idx>(buffer_data.size());
+            *size = to_c_size<PGM_Idx>(std::ssize(buffer_data));
         },
-        PGM_serialization_error);
+        serialization_exception_handler);
 }
 
 char const* PGM_serializer_get_to_zero_terminated_string(PGM_Handle* handle, PGM_Serializer* serializer,
@@ -81,9 +105,11 @@ char const* PGM_serializer_get_to_zero_terminated_string(PGM_Handle* handle, PGM
     return call_with_catch(
         handle,
         [serializer, use_compact_list, indent] {
-            return serializer->get_string(static_cast<bool>(use_compact_list), indent).c_str();
+            return safe_ptr_get(serializer).get_string(safe_bool(use_compact_list), indent).c_str();
         },
-        PGM_serialization_error);
+        serialization_exception_handler);
 }
 
-void PGM_destroy_serializer(PGM_Serializer* serializer) { delete serializer; }
+void PGM_destroy_serializer(PGM_Serializer* serializer) {
+    delete serializer; // NOSONAR(S5025)
+}
diff --git a/src/power_grid_model/_core/error_handling.py b/src/power_grid_model/_core/error_handling.py
index 221fbbe10..fd5f0598f 100644
--- a/src/power_grid_model/_core/error_handling.py
+++ b/src/power_grid_model/_core/error_handling.py
@@ -7,6 +7,7 @@
 """
 
 import re
+from enum import IntEnum
 
 import numpy as np
 
@@ -33,6 +34,7 @@
     PowerGridBatchError,
     PowerGridDatasetError,
     PowerGridError,
+    PowerGridIllegalOperationError,
     PowerGridNotImplementedError,
     PowerGridSerializationError,
     PowerGridUnreachableHitError,
@@ -43,11 +45,14 @@
 from power_grid_model._core.power_grid_core import get_power_grid_core as get_pgc
 
 VALIDATOR_MSG = "\nTry validate_input_data() or validate_batch_data() to validate your data.\n"
-# error codes
-PGM_NO_ERROR = 0
-PGM_REGULAR_ERROR = 1
-PGM_BATCH_ERROR = 2
-PGM_SERIALIZATION_ERROR = 3
+
+
+class _PgmCErrorCode(IntEnum):
+    NO_ERROR = 0
+    REGULAR_ERROR = 1
+    BATCH_ERROR = 2
+    SERIALIZATION_ERROR = 3
+
 
 _MISSING_CASE_FOR_ENUM_RE = re.compile(r" is not implemented for (.+) #(-?\d+)!\n")
 _INVALID_ARGUMENTS_RE = re.compile(r" is not implemented for ")  # multiple different flavors
@@ -82,6 +87,7 @@
 _INVALID_SHORT_CIRCUIT_PHASE_OR_TYPE_RE = re.compile(r"short circuit type")  # multiple different flavors
 _TAP_STRATEGY_SEARCH_OPT_INCMPT_RE = re.compile(r"Search method is incompatible with optimization strategy: ")
 _POWER_GRID_DATASET_ERROR_RE = re.compile(r"Dataset error: ")  # multiple different flavors
+_POWER_GRID_ILLEGAL_OPERATION_ERROR_RE = re.compile(r"Illegal operation: ")  # multiple different flavors
 _POWER_GRID_UNREACHABLE_HIT_RE = re.compile(r"Unreachable code hit when executing ")  # multiple different flavors
 _POWER_GRID_NOT_IMPLEMENTED_ERROR_RE = re.compile(r"The functionality is either not supported or not yet implemented!")
 
@@ -108,6 +114,7 @@
     _INVALID_SHORT_CIRCUIT_PHASE_OR_TYPE_RE: InvalidShortCircuitPhaseOrType,
     _TAP_STRATEGY_SEARCH_OPT_INCMPT_RE: TapSearchStrategyIncompatibleError,
     _POWER_GRID_DATASET_ERROR_RE: PowerGridDatasetError,
+    _POWER_GRID_ILLEGAL_OPERATION_ERROR_RE: PowerGridIllegalOperationError,
     _POWER_GRID_UNREACHABLE_HIT_RE: PowerGridUnreachableHitError,
     _POWER_GRID_NOT_IMPLEMENTED_ERROR_RE: PowerGridNotImplementedError,
 }
@@ -134,29 +141,31 @@ def find_error(batch_size: int = 1, decode_error: bool = True) -> RuntimeError |
 
     """
     error_code: int = get_pgc().error_code()
-    if error_code == PGM_NO_ERROR:
-        return None
-    if error_code == PGM_REGULAR_ERROR:
-        error_message = get_pgc().error_message()
-        error_message += VALIDATOR_MSG
-        return _interpret_error(error_message, decode_error=decode_error)
-    if error_code == PGM_BATCH_ERROR:
-        error_message = "There are errors in the batch calculation." + VALIDATOR_MSG
-        error = PowerGridBatchError(error_message)
-        n_fails = get_pgc().n_failed_scenarios()
-        failed_idxptr = get_pgc().failed_scenarios()
-        failed_msgptr = get_pgc().batch_errors()
-        error.failed_scenarios = np.ctypeslib.as_array(failed_idxptr, shape=(n_fails,)).copy()
-        error.error_messages = [failed_msgptr[i].decode() for i in range(n_fails)]  # type: ignore
-        error.errors = [_interpret_error(message, decode_error=decode_error) for message in error.error_messages]
-        all_scenarios = np.arange(batch_size, dtype=IdxNp)
-        mask = np.ones(batch_size, dtype=np.bool_)
-        mask[error.failed_scenarios] = False
-        error.succeeded_scenarios = all_scenarios[mask]
-        return error
-    if error_code == PGM_SERIALIZATION_ERROR:
-        return PowerGridSerializationError(get_pgc().error_message())
-    return RuntimeError("Unknown error!")
+    match error_code:
+        case _PgmCErrorCode.NO_ERROR:
+            return None
+        case _PgmCErrorCode.REGULAR_ERROR:
+            error_message = get_pgc().error_message()
+            error_message += VALIDATOR_MSG
+            return _interpret_error(error_message, decode_error=decode_error)
+        case _PgmCErrorCode.BATCH_ERROR:
+            error_message = "There are errors in the batch calculation." + VALIDATOR_MSG
+            error = PowerGridBatchError(error_message)
+            n_fails = get_pgc().n_failed_scenarios()
+            failed_idxptr = get_pgc().failed_scenarios()
+            failed_msgptr = get_pgc().batch_errors()
+            error.failed_scenarios = np.ctypeslib.as_array(failed_idxptr, shape=(n_fails,)).copy()
+            error.error_messages = [failed_msgptr[i].decode() for i in range(n_fails)]  # type: ignore
+            error.errors = [_interpret_error(message, decode_error=decode_error) for message in error.error_messages]
+            all_scenarios = np.arange(batch_size, dtype=IdxNp)
+            mask = np.ones(batch_size, dtype=np.bool_)
+            mask[error.failed_scenarios] = False
+            error.succeeded_scenarios = all_scenarios[mask]
+            return error
+        case _PgmCErrorCode.SERIALIZATION_ERROR:
+            return PowerGridSerializationError(get_pgc().error_message())
+        case _:
+            return RuntimeError("Unknown error!")
 
 
 def assert_no_error(batch_size: int = 1, decode_error: bool = True):
diff --git a/src/power_grid_model/_core/errors.py b/src/power_grid_model/_core/errors.py
index 8b4330b90..52d0ca8e1 100644
--- a/src/power_grid_model/_core/errors.py
+++ b/src/power_grid_model/_core/errors.py
@@ -124,6 +124,10 @@ class PowerGridNotImplementedError(PowerGridError):
     """The functionality is either not supported or not yet implemented."""
 
 
+class PowerGridIllegalOperationError(PowerGridError):
+    """An illegal operation was attempted to the C API, such as accessing a null pointer."""
+
+
 class PowerGridUnreachableHitError(PowerGridError):
     """Supposedly unreachable code was hit.
 
diff --git a/tests/cpp_validation_tests/test_validation.cpp b/tests/cpp_validation_tests/test_validation.cpp
index 8dd01ff94..8b90d9600 100644
--- a/tests/cpp_validation_tests/test_validation.cpp
+++ b/tests/cpp_validation_tests/test_validation.cpp
@@ -137,7 +137,7 @@ class Subcase {
                 statement_(subcase);
                 throw RaisesFailed{std::format(
                     "Test case marked as raises with message '{}' but no exception was thrown", raises_.value())};
-            } catch (std::exception const& e) {
+            } catch (std::exception const& e) { // NOSONAR(S1181)
                 if (match_exception(e, raises_.value())) {
                     // correct exception raised => pass
                     subcase.has_failing_assertion = false; // assertions may fail when an exception is raised
@@ -159,7 +159,7 @@ class Subcase {
                 statement_(subcase);
                 bool const xfailed = subcase.has_failing_assertion;
                 CHECK_MESSAGE(xfailed, "XPASS");
-            } catch (std::exception const& e) {
+            } catch (std::exception const& e) { // NOSONAR(S1181)
                 subcase.check_message(match_exception(e, xfail_raises_.value()),
                                       std::format("Test case marked as xfail with message '{}' but got exception: {}",
                                                   xfail_raises_.value(), e.what()));
diff --git a/tests/native_api_tests/test_api_model.cpp b/tests/native_api_tests/test_api_model.cpp
index 1482b61b8..b1eee12f1 100644
--- a/tests/native_api_tests/test_api_model.cpp
+++ b/tests/native_api_tests/test_api_model.cpp
@@ -878,7 +878,7 @@ TEST_CASE("API Model") {
                 } else {
                     try {
                         model.calculate(options, output_dataset);
-                    } catch (std::exception const& e) {
+                    } catch (std::exception const& e) { // NOSONAR(S1181)
                         CHECK(e.what() != doctest::Contains(invalid_calculation_method_pattern));
                     }
                 }