diff --git a/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs b/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
index 328940d83ae..85c5fc8dc81 100644
--- a/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/deutschebank/transformers.rs
@@ -5,7 +5,7 @@ use common_utils::{ext_traits::ValueExt, pii::Email, types::MinorUnit};
 use error_stack::ResultExt;
 use hyperswitch_domain_models::{
     payment_method_data::{BankDebitData, PaymentMethodData},
-    router_data::{AccessToken, ConnectorAuthType, RouterData},
+    router_data::{AccessToken, ConnectorAuthType, ErrorResponse, RouterData},
     router_flow_types::{
         payments::{Authorize, Capture, CompleteAuthorize, PSync},
         refunds::{Execute, RSync},
@@ -263,6 +263,21 @@ pub struct DeutschebankMandatePostResponse {
     state: Option<DeutschebankSEPAMandateStatus>,
 }
 
+fn get_error_response(error_code: String, error_reason: String, status_code: u16) -> ErrorResponse {
+    ErrorResponse {
+        code: error_code.to_string(),
+        message: error_reason.clone(),
+        reason: Some(error_reason),
+        status_code,
+        attempt_status: None,
+        connector_transaction_id: None,
+    }
+}
+
+fn is_response_success(rc: &String) -> bool {
+    rc == "0"
+}
+
 impl
     TryFrom<
         ResponseRouterData<
@@ -286,16 +301,16 @@ impl
             Some(date) => date.chars().take(10).collect(),
             None => time::OffsetDateTime::now_utc().date().to_string(),
         };
-        match item.response.reference.clone() {
-            Some(reference) => Ok(Self {
-                status: if item.response.rc == "0" {
-                    match item.response.state.clone() {
-                        Some(state) => common_enums::AttemptStatus::from(state),
-                        None => common_enums::AttemptStatus::Failure,
-                    }
-                } else {
-                    common_enums::AttemptStatus::Failure
-                },
+        let response_code = item.response.rc.clone();
+        let is_response_success = is_response_success(&response_code);
+
+        match (
+            item.response.reference.clone(),
+            item.response.state.clone(),
+            is_response_success,
+        ) {
+            (Some(reference), Some(state), true) => Ok(Self {
+                status: common_enums::AttemptStatus::from(state),
                 response: Ok(PaymentsResponseData::TransactionResponse {
                     resource_id: ResponseId::NoResponseId,
                     redirection_data: Box::new(Some(RedirectForm::Form {
@@ -340,8 +355,13 @@ impl
                 }),
                 ..item.data
             }),
-            None => Ok(Self {
+            _ => Ok(Self {
                 status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
                 ..item.data
             }),
         }
@@ -367,27 +387,36 @@ impl
             PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            status: if item.response.rc == "0" {
-                match item.data.request.is_auto_capture()? {
+        let response_code = item.response.rc.clone();
+        if is_response_success(&response_code) {
+            Ok(Self {
+                status: match item.data.request.is_auto_capture()? {
                     true => common_enums::AttemptStatus::Charged,
                     false => common_enums::AttemptStatus::Authorized,
-                }
-            } else {
-                common_enums::AttemptStatus::Failure
-            },
-            response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
-                redirection_data: Box::new(None),
-                mandate_reference: Box::new(None),
-                connector_metadata: None,
-                network_txn_id: None,
-                connector_response_reference_id: None,
-                incremental_authorization_allowed: None,
-                charge_id: None,
-            }),
-            ..item.data
-        })
+                },
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
+                    redirection_data: Box::new(None),
+                    mandate_reference: Box::new(None),
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            })
+        } else {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            })
+        }
     }
 }
 
@@ -570,27 +599,36 @@ impl
             PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            status: if item.response.rc == "0" {
-                match item.data.request.is_auto_capture()? {
+        let response_code = item.response.rc.clone();
+        if is_response_success(&response_code) {
+            Ok(Self {
+                status: match item.data.request.is_auto_capture()? {
                     true => common_enums::AttemptStatus::Charged,
                     false => common_enums::AttemptStatus::Authorized,
-                }
-            } else {
-                common_enums::AttemptStatus::Failure
-            },
-            response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
-                redirection_data: Box::new(None),
-                mandate_reference: Box::new(None),
-                connector_metadata: None,
-                network_txn_id: None,
-                connector_response_reference_id: None,
-                incremental_authorization_allowed: None,
-                charge_id: None,
-            }),
-            ..item.data
-        })
+                },
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
+                    redirection_data: Box::new(None),
+                    mandate_reference: Box::new(None),
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            })
+        } else {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            })
+        }
     }
 }
 
@@ -637,24 +675,33 @@ impl
             PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: Ok(PaymentsResponseData::TransactionResponse {
-                resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
-                redirection_data: Box::new(None),
-                mandate_reference: Box::new(None),
-                connector_metadata: None,
-                network_txn_id: None,
-                connector_response_reference_id: None,
-                incremental_authorization_allowed: None,
-                charge_id: None,
-            }),
-            status: if item.response.rc == "0" {
-                common_enums::AttemptStatus::Charged
-            } else {
-                common_enums::AttemptStatus::Failure
-            },
-            ..item.data
-        })
+        let response_code = item.response.rc.clone();
+        if is_response_success(&response_code) {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Charged,
+                response: Ok(PaymentsResponseData::TransactionResponse {
+                    resource_id: ResponseId::ConnectorTransactionId(item.response.tx_id),
+                    redirection_data: Box::new(None),
+                    mandate_reference: Box::new(None),
+                    connector_metadata: None,
+                    network_txn_id: None,
+                    connector_response_reference_id: None,
+                    incremental_authorization_allowed: None,
+                    charge_id: None,
+                }),
+                ..item.data
+            })
+        } else {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            })
+        }
     }
 }
 
@@ -677,7 +724,8 @@ impl
             PaymentsResponseData,
         >,
     ) -> Result<Self, Self::Error> {
-        let status = if item.response.rc == "0" {
+        let response_code = item.response.rc.clone();
+        let status = if is_response_success(&response_code) {
             item.response
                 .tx_action
                 .and_then(|tx_action| match tx_action {
@@ -699,6 +747,15 @@ impl
             Some(common_enums::AttemptStatus::Failure)
         };
         match status {
+            Some(common_enums::AttemptStatus::Failure) => Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            }),
             Some(status) => Ok(Self {
                 status,
                 ..item.data
@@ -729,14 +786,23 @@ impl TryFrom<PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>>
     fn try_from(
         item: PaymentsCancelResponseRouterData<DeutschebankPaymentsResponse>,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            status: if item.response.rc == "0" {
-                common_enums::AttemptStatus::Voided
-            } else {
-                common_enums::AttemptStatus::VoidFailed
-            },
-            ..item.data
-        })
+        let response_code = item.response.rc.clone();
+        if is_response_success(&response_code) {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Voided,
+                ..item.data
+            })
+        } else {
+            Ok(Self {
+                status: common_enums::AttemptStatus::VoidFailed,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            })
+        }
     }
 }
 
@@ -763,17 +829,26 @@ impl TryFrom<RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>>
     fn try_from(
         item: RefundsResponseRouterData<Execute, DeutschebankPaymentsResponse>,
     ) -> Result<Self, Self::Error> {
-        Ok(Self {
-            response: Ok(RefundsResponseData {
-                connector_refund_id: item.response.tx_id,
-                refund_status: if item.response.rc == "0" {
-                    enums::RefundStatus::Success
-                } else {
-                    enums::RefundStatus::Failure
-                },
-            }),
-            ..item.data
-        })
+        let response_code = item.response.rc.clone();
+        if is_response_success(&response_code) {
+            Ok(Self {
+                response: Ok(RefundsResponseData {
+                    connector_refund_id: item.response.tx_id,
+                    refund_status: enums::RefundStatus::Success,
+                }),
+                ..item.data
+            })
+        } else {
+            Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            })
+        }
     }
 }
 
@@ -784,7 +859,8 @@ impl TryFrom<RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>>
     fn try_from(
         item: RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>,
     ) -> Result<Self, Self::Error> {
-        let status = if item.response.rc == "0" {
+        let response_code = item.response.rc.clone();
+        let status = if is_response_success(&response_code) {
             item.response
                 .tx_action
                 .and_then(|tx_action| match tx_action {
@@ -803,7 +879,17 @@ impl TryFrom<RefundsResponseRouterData<RSync, DeutschebankPaymentsResponse>>
         } else {
             Some(enums::RefundStatus::Failure)
         };
+
         match status {
+            Some(enums::RefundStatus::Failure) => Ok(Self {
+                status: common_enums::AttemptStatus::Failure,
+                response: Err(get_error_response(
+                    response_code.clone(),
+                    item.response.message.clone(),
+                    item.http_code,
+                )),
+                ..item.data
+            }),
             Some(refund_status) => Ok(Self {
                 response: Ok(RefundsResponseData {
                     refund_status,
diff --git a/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs b/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs
index f3c3685b5c1..4989af45167 100644
--- a/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/fiuu/transformers.rs
@@ -991,6 +991,8 @@ pub struct FiuuRefundSuccessResponse {
     #[serde(rename = "RefundID")]
     refund_id: i64,
     status: String,
+    #[serde(rename = "reason")]
+    reason: Option<String>,
 }
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -1017,20 +1019,40 @@ impl TryFrom<RefundsResponseRouterData<Execute, FiuuRefundResponse>>
                 }),
                 ..item.data
             }),
-            FiuuRefundResponse::Success(refund_data) => Ok(Self {
-                response: Ok(RefundsResponseData {
-                    connector_refund_id: refund_data.refund_id.to_string(),
-                    refund_status: match refund_data.status.as_str() {
-                        "00" => Ok(enums::RefundStatus::Success),
-                        "11" => Ok(enums::RefundStatus::Failure),
-                        "22" => Ok(enums::RefundStatus::Pending),
-                        other => Err(errors::ConnectorError::UnexpectedResponseError(
-                            bytes::Bytes::from(other.to_owned()),
-                        )),
-                    }?,
-                }),
-                ..item.data
-            }),
+            FiuuRefundResponse::Success(refund_data) => {
+                let refund_status = match refund_data.status.as_str() {
+                    "00" => Ok(enums::RefundStatus::Success),
+                    "11" => Ok(enums::RefundStatus::Failure),
+                    "22" => Ok(enums::RefundStatus::Pending),
+                    other => Err(errors::ConnectorError::UnexpectedResponseError(
+                        bytes::Bytes::from(other.to_owned()),
+                    )),
+                }?;
+                if refund_status == enums::RefundStatus::Failure {
+                    Ok(Self {
+                        response: Err(ErrorResponse {
+                            code: refund_data.status.clone(),
+                            message: refund_data
+                                .reason
+                                .clone()
+                                .unwrap_or(consts::NO_ERROR_MESSAGE.to_string()),
+                            reason: refund_data.reason.clone(),
+                            status_code: item.http_code,
+                            attempt_status: None,
+                            connector_transaction_id: None,
+                        }),
+                        ..item.data
+                    })
+                } else {
+                    Ok(Self {
+                        response: Ok(RefundsResponseData {
+                            connector_refund_id: refund_data.refund_id.to_string(),
+                            refund_status,
+                        }),
+                        ..item.data
+                    })
+                }
+            }
         }
     }
 }