diff --git a/services/backup/blob_client/src/get_client.rs b/services/backup/blob_client/src/get_client.rs
--- a/services/backup/blob_client/src/get_client.rs
+++ b/services/backup/blob_client/src/get_client.rs
@@ -6,15 +6,15 @@
 use proto::GetRequest;
 
 use crate::constants::{BLOB_ADDRESS, MPSC_CHANNEL_BUFFER_CAPACITY};
-use crate::tools::{check_error, report_error};
+use crate::tools::{check_error, report_error, c_char_pointer_to_string, string_to_c_char_pointer};
 use lazy_static::lazy_static;
 use libc;
 use libc::c_char;
-use std::ffi::CStr;
 use std::sync::{Arc, Mutex};
 use tokio::runtime::Runtime;
 use tokio::sync::mpsc;
 use tokio::task::JoinHandle;
+use std::collections::HashMap;
 
 struct ReadClient {
   rx: mpsc::Receiver<Vec<u8>>,
@@ -22,18 +22,18 @@
 }
 
 lazy_static! {
-  static ref CLIENT: Arc<Mutex<Option<ReadClient>>> =
-    Arc::new(Mutex::new(None));
+  // todo: we should consider limiting the clients size,
+  // if every client is able to allocate up to 4MB data at a time
+  static ref CLIENTS: Arc<Mutex<HashMap<String, ReadClient>>> =
+    Arc::new(Mutex::new(HashMap::new()));
   static ref RUNTIME: Runtime = Runtime::new().unwrap();
   static ref ERROR_MESSAGES: Arc<Mutex<Vec<String>>> =
     Arc::new(Mutex::new(Vec::new()));
 }
 
-fn is_initialized() -> bool {
-  if let Ok(client) = CLIENT.lock() {
-    if client.is_some() {
-      return true;
-    }
+fn is_initialized(holder: &String) -> bool {
+  if let Ok(clients) = CLIENTS.lock() {
+    return clients.contains_key(holder);
   } else {
     report_error(&ERROR_MESSAGES, "couldn't access client", Some("get"));
   }
@@ -43,14 +43,12 @@
 pub fn get_client_initialize_cxx(
   holder_char: *const c_char,
 ) -> Result<(), String> {
-  if is_initialized() {
-    get_client_terminate_cxx()?;
+  let holder = c_char_pointer_to_string(holder_char)?;
+  if is_initialized(&holder) {
+    get_client_terminate_cxx(string_to_c_char_pointer(&holder)?)?;
   }
 
-  assert!(!is_initialized(), "client cannot be initialized twice");
-
-  let holder_cstr: &CStr = unsafe { CStr::from_ptr(holder_char) };
-  let holder: String = holder_cstr.to_str().unwrap().to_owned();
+  assert!(!is_initialized(&holder), "client cannot be initialized twice");
 
   // grpc
   if let Ok(mut grpc_client) =
@@ -61,8 +59,9 @@
       mpsc::Sender<Vec<u8>>,
       mpsc::Receiver<Vec<u8>>,
     ) = mpsc::channel(MPSC_CHANNEL_BUFFER_CAPACITY);
+    let cloned_holder = holder.clone();
     let rx_handle = RUNTIME.spawn(async move {
-      if let Ok(response) = grpc_client.get(GetRequest { holder }).await {
+      if let Ok(response) = grpc_client.get(GetRequest { holder: cloned_holder }).await {
         let mut inner_response = response.into_inner();
         loop {
           match inner_response.message().await {
@@ -101,11 +100,12 @@
       }
     });
 
-    if let Ok(mut client) = CLIENT.lock() {
-      *client = Some(ReadClient {
+    if let Ok(mut clients) = CLIENTS.lock() {
+      let client = ReadClient {
         rx_handle,
         rx: response_thread_rx,
-      });
+      };
+      (*clients).insert(holder, client);
       return Ok(());
     }
     return Err("could not access client".to_string());
@@ -113,14 +113,15 @@
   Err("could not successfully connect to the blob server".to_string())
 }
 
-pub fn get_client_blocking_read_cxx() -> Result<Vec<u8>, String> {
+pub fn get_client_blocking_read_cxx(holder_char: *const c_char) -> Result<Vec<u8>, String> {
+  let holder = c_char_pointer_to_string(holder_char)?;
   check_error(&ERROR_MESSAGES)?;
   let response: Option<Vec<u8>> = RUNTIME.block_on(async {
-    if let Ok(mut maybe_client) = CLIENT.lock() {
-      if let Some(mut client) = (*maybe_client).take() {
+    if let Ok(mut clients) = CLIENTS.lock() {
+      let maybe_client = clients.get_mut(&holder);
+      if let Some(client) = maybe_client {
         let maybe_data = client.rx.recv().await;
         let response = Some(maybe_data.unwrap_or_else(|| vec![]));
-        *maybe_client = Some(client);
         return response;
       } else {
         report_error(&ERROR_MESSAGES, "no client present", Some("get"));
@@ -134,14 +135,16 @@
   response.ok_or("response could not be obtained".to_string())
 }
 
-pub fn get_client_terminate_cxx() -> Result<(), String> {
+pub fn get_client_terminate_cxx(holder_char: *const c_char) -> Result<(), String> {
+  let holder = c_char_pointer_to_string(holder_char)?;
   check_error(&ERROR_MESSAGES)?;
-  if !is_initialized() {
+  if !is_initialized(&holder) {
     check_error(&ERROR_MESSAGES)?;
     return Ok(());
   }
-  if let Ok(mut maybe_client) = CLIENT.lock() {
-    if let Some(client) = (*maybe_client).take() {
+  if let Ok(mut clients) = CLIENTS.lock() {
+    let maybe_client = clients.remove(&holder);
+    if let Some(client) = maybe_client {
       RUNTIME.block_on(async {
         if client.rx_handle.await.is_err() {
           report_error(
@@ -159,7 +162,7 @@
   }
 
   assert!(
-    !is_initialized(),
+    !is_initialized(&holder),
     "client transmitter handler released properly"
   );
   check_error(&ERROR_MESSAGES)?;
diff --git a/services/backup/blob_client/src/lib.rs b/services/backup/blob_client/src/lib.rs
--- a/services/backup/blob_client/src/lib.rs
+++ b/services/backup/blob_client/src/lib.rs
@@ -32,7 +32,7 @@
     unsafe fn get_client_initialize_cxx(
       holder_char: *const c_char,
     ) -> Result<()>;
-    fn get_client_blocking_read_cxx() -> Result<Vec<u8>>;
-    fn get_client_terminate_cxx() -> Result<()>;
+    unsafe fn get_client_blocking_read_cxx(holder_char: *const c_char) -> Result<Vec<u8>>;
+    unsafe fn get_client_terminate_cxx(holder_char: *const c_char) -> Result<()>;
   }
 }