diff --git a/crates/api_models/src/payments.rs b/crates/api_models/src/payments.rs
index ef0ae3a15ce6..717a908b1f0d 100644
--- a/crates/api_models/src/payments.rs
+++ b/crates/api_models/src/payments.rs
@@ -322,9 +322,7 @@ impl PaymentsRequest {
     pub fn get_total_capturable_amount(&self) -> Option<i64> {
         let surcharge_amount = self
             .surcharge_details
-            .map(|surcharge_details| {
-                surcharge_details.surcharge_amount + surcharge_details.tax_amount.unwrap_or(0)
-            })
+            .map(|surcharge_details| surcharge_details.get_total_surcharge_amount())
             .unwrap_or(0);
         self.amount
             .map(|amount| i64::from(amount) + surcharge_amount)
diff --git a/crates/data_models/src/payments/payment_attempt.rs b/crates/data_models/src/payments/payment_attempt.rs
index f7b849f1d4e1..61e48cb64e9a 100644
--- a/crates/data_models/src/payments/payment_attempt.rs
+++ b/crates/data_models/src/payments/payment_attempt.rs
@@ -156,6 +156,16 @@ pub struct PaymentAttempt {
     pub unified_message: Option<String>,
 }
 
+impl PaymentAttempt {
+    pub fn get_total_amount(&self) -> i64 {
+        self.amount + self.surcharge_amount.unwrap_or(0) + self.tax_amount.unwrap_or(0)
+    }
+    pub fn get_total_surcharge_amount(&self) -> Option<i64> {
+        self.surcharge_amount
+            .map(|surcharge_amount| surcharge_amount + self.tax_amount.unwrap_or(0))
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct PaymentListFilters {
     pub connector: Vec<String>,
diff --git a/crates/router/src/connector/paypal.rs b/crates/router/src/connector/paypal.rs
index 334a58040261..7a9799d415dd 100644
--- a/crates/router/src/connector/paypal.rs
+++ b/crates/router/src/connector/paypal.rs
@@ -265,10 +265,6 @@ impl ConnectorValidation for Paypal {
             ),
         }
     }
-
-    fn validate_if_surcharge_implemented(&self) -> CustomResult<(), errors::ConnectorError> {
-        Ok(())
-    }
 }
 
 impl
@@ -423,10 +419,7 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         let connector_router_data = paypal::PaypalRouterData::try_from((
             &self.get_currency_unit(),
             req.request.currency,
-            req.request
-                .surcharge_details
-                .as_ref()
-                .map_or(req.request.amount, |surcharge| surcharge.final_amount),
+            req.request.amount,
             req,
         ))?;
         let connector_req = paypal::PaypalPaymentsRequest::try_from(&connector_router_data)?;
diff --git a/crates/router/src/connector/trustpay.rs b/crates/router/src/connector/trustpay.rs
index c618357ffb5d..ef8099159644 100644
--- a/crates/router/src/connector/trustpay.rs
+++ b/crates/router/src/connector/trustpay.rs
@@ -154,11 +154,7 @@ impl ConnectorCommon for Trustpay {
     }
 }
 
-impl ConnectorValidation for Trustpay {
-    fn validate_if_surcharge_implemented(&self) -> CustomResult<(), errors::ConnectorError> {
-        Ok(())
-    }
-}
+impl ConnectorValidation for Trustpay {}
 
 impl api::Payment for Trustpay {}
 
@@ -432,12 +428,7 @@ impl
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
         let currency = req.request.get_currency()?;
-        let amount = req
-            .request
-            .surcharge_details
-            .as_ref()
-            .map(|surcharge_details| surcharge_details.final_amount)
-            .unwrap_or(req.request.get_amount()?);
+        let amount = req.request.get_amount()?;
         let connector_router_data = trustpay::TrustpayRouterData::try_from((
             &self.get_currency_unit(),
             currency,
@@ -544,12 +535,7 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         req: &types::PaymentsAuthorizeRouterData,
         _connectors: &settings::Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let amount = req
-            .request
-            .surcharge_details
-            .as_ref()
-            .map(|surcharge_details| surcharge_details.final_amount)
-            .unwrap_or(req.request.amount);
+        let amount = req.request.amount;
         let connector_router_data = trustpay::TrustpayRouterData::try_from((
             &self.get_currency_unit(),
             req.request.currency,
diff --git a/crates/router/src/connector/utils.rs b/crates/router/src/connector/utils.rs
index 9283ff41f73a..d06caf3ae202 100644
--- a/crates/router/src/connector/utils.rs
+++ b/crates/router/src/connector/utils.rs
@@ -28,8 +28,8 @@ use crate::{
     },
     pii::PeekInterface,
     types::{
-        self, api, storage::payment_attempt::PaymentAttemptExt, transformers::ForeignTryFrom,
-        ApplePayPredecryptData, BrowserInformation, PaymentsCancelData, ResponseId,
+        self, api, transformers::ForeignTryFrom, ApplePayPredecryptData, BrowserInformation,
+        PaymentsCancelData, ResponseId,
     },
     utils::{OptionExt, ValueExt},
 };
@@ -367,6 +367,10 @@ pub trait PaymentsAuthorizeRequestData {
     fn get_connector_mandate_id(&self) -> Result<String, Error>;
     fn get_complete_authorize_url(&self) -> Result<String, Error>;
     fn get_ip_address_as_optional(&self) -> Option<Secret<String, IpAddress>>;
+    fn get_original_amount(&self) -> i64;
+    fn get_surcharge_amount(&self) -> Option<i64>;
+    fn get_tax_on_surcharge_amount(&self) -> Option<i64>;
+    fn get_total_surcharge_amount(&self) -> Option<i64>;
 }
 
 pub trait PaymentMethodTokenizationRequestData {
@@ -473,6 +477,27 @@ impl PaymentsAuthorizeRequestData for types::PaymentsAuthorizeData {
                 .map(|ip| Secret::new(ip.to_string()))
         })
     }
+    fn get_original_amount(&self) -> i64 {
+        self.surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.original_amount)
+            .unwrap_or(self.amount)
+    }
+    fn get_surcharge_amount(&self) -> Option<i64> {
+        self.surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.surcharge_amount)
+    }
+    fn get_tax_on_surcharge_amount(&self) -> Option<i64> {
+        self.surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.tax_on_surcharge_amount)
+    }
+    fn get_total_surcharge_amount(&self) -> Option<i64> {
+        self.surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.get_total_surcharge_amount())
+    }
 }
 
 pub trait ConnectorCustomerData {
diff --git a/crates/router/src/core/payment_methods/surcharge_decision_configs.rs b/crates/router/src/core/payment_methods/surcharge_decision_configs.rs
index e130795e945a..db1064b36a7a 100644
--- a/crates/router/src/core/payment_methods/surcharge_decision_configs.rs
+++ b/crates/router/src/core/payment_methods/surcharge_decision_configs.rs
@@ -310,6 +310,7 @@ fn get_surcharge_details_from_surcharge_output(
         .transpose()?
         .unwrap_or(0);
     Ok(types::SurchargeDetails {
+        original_amount: payment_attempt.amount,
         surcharge: match surcharge_details.surcharge {
             surcharge_decision_configs::SurchargeOutput::Fixed { amount } => {
                 common_utils_types::Surcharge::Fixed(amount)
diff --git a/crates/router/src/core/payments.rs b/crates/router/src/core/payments.rs
index 3c7ac0fd78d0..3f815f16be4a 100644
--- a/crates/router/src/core/payments.rs
+++ b/crates/router/src/core/payments.rs
@@ -204,10 +204,6 @@ where
         );
 
         if should_continue_transaction {
-            operation
-                .to_domain()?
-                .populate_payment_data(state, &mut payment_data, &merchant_account)
-                .await?;
             payment_data = match connector_details {
                 api::ConnectorCallType::PreDetermined(connector) => {
                     let schedule_time = if should_add_task_to_process_tracker {
@@ -484,6 +480,13 @@ where
         .surcharge_applicable
         .unwrap_or(false)
     {
+        if let Some(surcharge_details) = payment_data.payment_attempt.get_surcharge_details() {
+            // if retry payment, surcharge would have been populated from the previous attempt. Use the same surcharge
+            let surcharge_details =
+                types::SurchargeDetails::from((&surcharge_details, &payment_data.payment_attempt));
+            payment_data.surcharge_details = Some(surcharge_details);
+            return Ok(());
+        }
         let raw_card_key = payment_data
             .payment_method_data
             .as_ref()
@@ -562,6 +565,7 @@ where
             payment_data.payment_attempt.amount + surcharge_amount + tax_on_surcharge_amount;
         Ok(Some(api::SessionSurchargeDetails::PreDetermined(
             types::SurchargeDetails {
+                original_amount: payment_data.payment_attempt.amount,
                 surcharge: Surcharge::Fixed(surcharge_amount),
                 tax_on_surcharge: None,
                 surcharge_amount,
diff --git a/crates/router/src/core/payments/flows/authorize_flow.rs b/crates/router/src/core/payments/flows/authorize_flow.rs
index 4ef23f481a2c..c934c7c2cd67 100644
--- a/crates/router/src/core/payments/flows/authorize_flow.rs
+++ b/crates/router/src/core/payments/flows/authorize_flow.rs
@@ -76,12 +76,6 @@ impl Feature<api::Authorize, types::PaymentsAuthorizeData> for types::PaymentsAu
             .connector
             .validate_capture_method(self.request.capture_method)
             .to_payment_failed_response()?;
-        if self.request.surcharge_details.is_some() {
-            connector
-                .connector
-                .validate_if_surcharge_implemented()
-                .to_payment_failed_response()?;
-        }
 
         if self.should_proceed_with_authorize() {
             self.decide_authentication_type();
diff --git a/crates/router/src/core/payments/operations/payment_approve.rs b/crates/router/src/core/payments/operations/payment_approve.rs
index 7d0ec0718c25..1a6945b09c84 100644
--- a/crates/router/src/core/payments/operations/payment_approve.rs
+++ b/crates/router/src/core/payments/operations/payment_approve.rs
@@ -139,7 +139,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             payment_method_type.or(payment_attempt.payment_method_type);
         payment_attempt.payment_experience = request.payment_experience;
         currency = payment_attempt.currency.get_required_value("currency")?;
-        amount = payment_attempt.amount.into();
+        amount = payment_attempt.get_total_amount().into();
 
         helpers::validate_customer_id_mandatory_cases(
             request.setup_future_usage.is_some(),
diff --git a/crates/router/src/core/payments/operations/payment_cancel.rs b/crates/router/src/core/payments/operations/payment_cancel.rs
index 7e6572ff07dc..9810980cd34a 100644
--- a/crates/router/src/core/payments/operations/payment_cancel.rs
+++ b/crates/router/src/core/payments/operations/payment_cancel.rs
@@ -102,7 +102,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
         .await?;
 
         let currency = payment_attempt.currency.get_required_value("currency")?;
-        let amount = payment_attempt.amount.into();
+        let amount = payment_attempt.get_total_amount().into();
 
         payment_attempt.cancellation_reason = request.cancellation_reason.clone();
 
diff --git a/crates/router/src/core/payments/operations/payment_capture.rs b/crates/router/src/core/payments/operations/payment_capture.rs
index 19998a9a0a71..3986b16ce353 100644
--- a/crates/router/src/core/payments/operations/payment_capture.rs
+++ b/crates/router/src/core/payments/operations/payment_capture.rs
@@ -124,7 +124,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
 
         currency = payment_attempt.currency.get_required_value("currency")?;
 
-        amount = payment_attempt.amount.into();
+        amount = payment_attempt.get_total_amount().into();
 
         let shipping_address = helpers::create_or_find_address_for_payment_by_request(
             db,
diff --git a/crates/router/src/core/payments/operations/payment_complete_authorize.rs b/crates/router/src/core/payments/operations/payment_complete_authorize.rs
index 3e91a09ab54e..abb08d14d927 100644
--- a/crates/router/src/core/payments/operations/payment_complete_authorize.rs
+++ b/crates/router/src/core/payments/operations/payment_complete_authorize.rs
@@ -135,7 +135,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             .payment_experience
             .or(payment_attempt.payment_experience);
         currency = payment_attempt.currency.get_required_value("currency")?;
-        amount = payment_attempt.amount.into();
+        amount = payment_attempt.get_total_amount().into();
 
         helpers::validate_customer_id_mandatory_cases(
             request.setup_future_usage.is_some(),
diff --git a/crates/router/src/core/payments/operations/payment_confirm.rs b/crates/router/src/core/payments/operations/payment_confirm.rs
index 8481cd5c8360..b15b8cb1a8ef 100644
--- a/crates/router/src/core/payments/operations/payment_confirm.rs
+++ b/crates/router/src/core/payments/operations/payment_confirm.rs
@@ -377,7 +377,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
         payment_attempt.capture_method = request.capture_method.or(payment_attempt.capture_method);
 
         currency = payment_attempt.currency.get_required_value("currency")?;
-        amount = payment_attempt.amount.into();
+        amount = payment_attempt.get_total_amount().into();
 
         helpers::validate_customer_id_mandatory_cases(
             request.setup_future_usage.is_some(),
@@ -732,7 +732,7 @@ impl<F: Clone, Ctx: PaymentMethodRetrieve>
                 m_db.update_payment_attempt_with_attempt_id(
                     m_payment_data_payment_attempt,
                     storage::PaymentAttemptUpdate::ConfirmUpdate {
-                        amount: payment_data.amount.into(),
+                        amount: payment_data.payment_attempt.amount,
                         currency: payment_data.currency,
                         status: attempt_status,
                         payment_method,
@@ -780,7 +780,7 @@ impl<F: Clone, Ctx: PaymentMethodRetrieve>
                 m_db.update_payment_intent(
                     m_payment_data_payment_intent,
                     storage::PaymentIntentUpdate::Update {
-                        amount: payment_data.amount.into(),
+                        amount: payment_data.payment_intent.amount,
                         currency: payment_data.currency,
                         setup_future_usage,
                         status: intent_status,
diff --git a/crates/router/src/core/payments/operations/payment_create.rs b/crates/router/src/core/payments/operations/payment_create.rs
index 87a6b6927513..cec6b50b1c18 100644
--- a/crates/router/src/core/payments/operations/payment_create.rs
+++ b/crates/router/src/core/payments/operations/payment_create.rs
@@ -297,7 +297,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             .map(|(payment_method_data, additional_payment_data)| {
                 payment_method_data.apply_additional_payment_data(additional_payment_data)
             });
-
+        let amount = payment_attempt.get_total_amount().into();
         let payment_data = PaymentData {
             flow: PhantomData,
             payment_intent,
@@ -645,6 +645,12 @@ impl PaymentCreate {
         } else {
             utils::get_payment_attempt_id(payment_id, 1)
         };
+        let surcharge_amount = request
+            .surcharge_details
+            .map(|surcharge_details| surcharge_details.surcharge_amount);
+        let tax_amount = request
+            .surcharge_details
+            .and_then(|surcharge_details| surcharge_details.tax_amount);
 
         Ok((
             storage::PaymentAttemptNew {
@@ -670,6 +676,8 @@ impl PaymentCreate {
                 payment_token: request.payment_token.clone(),
                 mandate_id: request.mandate_id.clone(),
                 business_sub_label: request.business_sub_label.clone(),
+                surcharge_amount,
+                tax_amount,
                 mandate_details: request
                     .mandate_data
                     .as_ref()
diff --git a/crates/router/src/core/payments/operations/payment_reject.rs b/crates/router/src/core/payments/operations/payment_reject.rs
index 5cb3c95dc257..37c7dfd1bae6 100644
--- a/crates/router/src/core/payments/operations/payment_reject.rs
+++ b/crates/router/src/core/payments/operations/payment_reject.rs
@@ -100,7 +100,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
         .await?;
 
         let currency = payment_attempt.currency.get_required_value("currency")?;
-        let amount = payment_attempt.amount.into();
+        let amount = payment_attempt.get_total_amount().into();
 
         let frm_response = db
         .find_fraud_check_by_payment_id(payment_intent.payment_id.clone(), merchant_account.merchant_id.clone())
diff --git a/crates/router/src/core/payments/operations/payment_response.rs b/crates/router/src/core/payments/operations/payment_response.rs
index f92487d74a7b..8b301c525fd7 100644
--- a/crates/router/src/core/payments/operations/payment_response.rs
+++ b/crates/router/src/core/payments/operations/payment_response.rs
@@ -24,10 +24,7 @@ use crate::{
     services::RedirectForm,
     types::{
         self, api,
-        storage::{
-            self, enums,
-            payment_attempt::{AttemptStatusExt, PaymentAttemptExt},
-        },
+        storage::{self, enums, payment_attempt::AttemptStatusExt},
         transformers::{ForeignFrom, ForeignTryFrom},
         CaptureSyncResponse,
     },
diff --git a/crates/router/src/core/payments/operations/payment_session.rs b/crates/router/src/core/payments/operations/payment_session.rs
index 7d9c37339349..6f7dcd6c11a7 100644
--- a/crates/router/src/core/payments/operations/payment_session.rs
+++ b/crates/router/src/core/payments/operations/payment_session.rs
@@ -93,7 +93,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
 
         payment_attempt.payment_method = Some(storage_enums::PaymentMethod::Wallet);
 
-        let amount = payment_intent.amount.into();
+        let amount = payment_attempt.get_total_amount().into();
 
         let shipping_address = helpers::create_or_find_address_for_payment_by_request(
             db,
diff --git a/crates/router/src/core/payments/operations/payment_start.rs b/crates/router/src/core/payments/operations/payment_start.rs
index 67c8579d263a..8896e4e43efe 100644
--- a/crates/router/src/core/payments/operations/payment_start.rs
+++ b/crates/router/src/core/payments/operations/payment_start.rs
@@ -89,7 +89,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
 
         currency = payment_attempt.currency.get_required_value("currency")?;
-        amount = payment_attempt.amount.into();
+        amount = payment_attempt.get_total_amount().into();
 
         let shipping_address = helpers::create_or_find_address_for_payment_by_request(
             db,
diff --git a/crates/router/src/core/payments/operations/payment_status.rs b/crates/router/src/core/payments/operations/payment_status.rs
index 44fbdf107818..c5311ce3d035 100644
--- a/crates/router/src/core/payments/operations/payment_status.rs
+++ b/crates/router/src/core/payments/operations/payment_status.rs
@@ -244,7 +244,7 @@ async fn get_tracker_for_sync<
     let payment_id_str = payment_attempt.payment_id.clone();
 
     currency = payment_attempt.currency.get_required_value("currency")?;
-    amount = payment_attempt.amount.into();
+    amount = payment_attempt.get_total_amount().into();
 
     let shipping_address = helpers::get_address_by_id(
         db,
diff --git a/crates/router/src/core/payments/operations/payment_update.rs b/crates/router/src/core/payments/operations/payment_update.rs
index 3ae0aae6d111..9d8ff08f6e24 100644
--- a/crates/router/src/core/payments/operations/payment_update.rs
+++ b/crates/router/src/core/payments/operations/payment_update.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use api_models::enums::FrmSuggestion;
+use api_models::{enums::FrmSuggestion, payments::RequestSurchargeDetails};
 use async_trait::async_trait;
 use common_utils::ext_traits::{AsyncExt, Encode, ValueExt};
 use error_stack::{report, IntoReport, ResultExt};
@@ -281,11 +281,25 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             })
             .await
             .transpose()?;
-        let next_operation: BoxedOperation<'a, F, api::PaymentsRequest, Ctx> =
+        let (next_operation, amount): (BoxedOperation<'a, F, api::PaymentsRequest, Ctx>, _) =
             if request.confirm.unwrap_or(false) {
-                Box::new(operations::PaymentConfirm)
+                let amount = {
+                    let amount = request
+                        .amount
+                        .map(Into::into)
+                        .unwrap_or(payment_attempt.amount);
+                    payment_attempt.amount = amount;
+                    payment_intent.amount = amount;
+                    let surcharge_amount = request
+                        .surcharge_details
+                        .as_ref()
+                        .map(RequestSurchargeDetails::get_total_surcharge_amount)
+                        .or(payment_attempt.get_total_surcharge_amount());
+                    (amount + surcharge_amount.unwrap_or(0)).into()
+                };
+                (Box::new(operations::PaymentConfirm), amount)
             } else {
-                Box::new(self)
+                (Box::new(self), amount)
             };
 
         payment_intent.status = match request.payment_method_data.as_ref() {
diff --git a/crates/router/src/core/payments/operations/payments_incremental_authorization.rs b/crates/router/src/core/payments/operations/payments_incremental_authorization.rs
index 3a0dfd19a650..f707fe3a1dad 100644
--- a/crates/router/src/core/payments/operations/payments_incremental_authorization.rs
+++ b/crates/router/src/core/payments/operations/payments_incremental_authorization.rs
@@ -92,7 +92,7 @@ impl<F: Send + Clone, Ctx: PaymentMethodRetrieve>
             .to_not_found_response(errors::ApiErrorResponse::PaymentNotFound)?;
 
         let currency = payment_attempt.currency.get_required_value("currency")?;
-        let amount = payment_attempt.amount;
+        let amount = payment_attempt.get_total_amount();
 
         let profile_id = payment_intent
             .profile_id
diff --git a/crates/router/src/core/payments/transformers.rs b/crates/router/src/core/payments/transformers.rs
index 2aaf0b2957f6..f0d8c9fd7552 100644
--- a/crates/router/src/core/payments/transformers.rs
+++ b/crates/router/src/core/payments/transformers.rs
@@ -1038,6 +1038,11 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsAuthoriz
                 None
             }
         });
+        let amount = payment_data
+            .surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.final_amount)
+            .unwrap_or(payment_data.amount.into());
         Ok(Self {
             payment_method_data: payment_method_data.get_required_value("payment_method_data")?,
             setup_future_usage: payment_data.payment_intent.setup_future_usage,
@@ -1048,7 +1053,7 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsAuthoriz
             statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,
             statement_descriptor: payment_data.payment_intent.statement_descriptor_name,
             capture_method: payment_data.payment_attempt.capture_method,
-            amount: payment_data.amount.into(),
+            amount,
             currency: payment_data.currency,
             browser_info,
             email: payment_data.email,
@@ -1301,9 +1306,14 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsSessionD
                     .collect::<Result<Vec<_>, _>>()
             })
             .transpose()?;
+        let amount = payment_data
+            .surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.final_amount)
+            .unwrap_or(payment_data.amount.into());
 
         Ok(Self {
-            amount: payment_data.amount.into(),
+            amount,
             currency: payment_data.currency,
             country: payment_data.address.billing.and_then(|billing_address| {
                 billing_address.address.and_then(|address| address.country)
@@ -1425,6 +1435,11 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::CompleteAuthoriz
                 payload: redirect.json_payload,
             }
         });
+        let amount = payment_data
+            .surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.final_amount)
+            .unwrap_or(payment_data.amount.into());
 
         Ok(Self {
             setup_future_usage: payment_data.payment_intent.setup_future_usage,
@@ -1434,7 +1449,7 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::CompleteAuthoriz
             confirm: payment_data.payment_attempt.confirm,
             statement_descriptor_suffix: payment_data.payment_intent.statement_descriptor_suffix,
             capture_method: payment_data.payment_attempt.capture_method,
-            amount: payment_data.amount.into(),
+            amount,
             currency: payment_data.currency,
             browser_info,
             email: payment_data.email,
@@ -1499,12 +1514,17 @@ impl<F: Clone> TryFrom<PaymentAdditionalData<'_, F>> for types::PaymentsPreProce
             .change_context(errors::ApiErrorResponse::InvalidDataValue {
                 field_name: "browser_info",
             })?;
+        let amount = payment_data
+            .surcharge_details
+            .as_ref()
+            .map(|surcharge_details| surcharge_details.final_amount)
+            .unwrap_or(payment_data.amount.into());
 
         Ok(Self {
             payment_method_data,
             email: payment_data.email,
             currency: Some(payment_data.currency),
-            amount: Some(payment_data.amount.into()),
+            amount: Some(amount),
             payment_method_type: payment_data.payment_attempt.payment_method_type,
             setup_mandate_details: payment_data.setup_mandate,
             capture_method: payment_data.payment_attempt.capture_method,
diff --git a/crates/router/src/core/payments/types.rs b/crates/router/src/core/payments/types.rs
index 001082d2c92e..00160db9855f 100644
--- a/crates/router/src/core/payments/types.rs
+++ b/crates/router/src/core/payments/types.rs
@@ -178,6 +178,8 @@ impl MultipleCaptureData {
 
 #[derive(Clone, Debug, serde::Deserialize, serde::Serialize)]
 pub struct SurchargeDetails {
+    /// original_amount
+    pub original_amount: i64,
     /// surcharge value
     pub surcharge: common_types::Surcharge,
     /// tax on surcharge value
@@ -198,6 +200,7 @@ impl From<(&RequestSurchargeDetails, &PaymentAttempt)> for SurchargeDetails {
         let surcharge_amount = request_surcharge_details.surcharge_amount;
         let tax_on_surcharge_amount = request_surcharge_details.tax_amount.unwrap_or(0);
         Self {
+            original_amount: payment_attempt.amount,
             surcharge: common_types::Surcharge::Fixed(request_surcharge_details.surcharge_amount),
             tax_on_surcharge: None,
             surcharge_amount,
@@ -219,13 +222,15 @@ impl ForeignTryFrom<(&SurchargeDetails, &PaymentAttempt)> for SurchargeDetailsRe
             currency.to_currency_base_unit_asf64(surcharge_details.tax_on_surcharge_amount)?;
         let display_final_amount =
             currency.to_currency_base_unit_asf64(surcharge_details.final_amount)?;
+        let display_total_surcharge_amount = currency.to_currency_base_unit_asf64(
+            surcharge_details.surcharge_amount + surcharge_details.tax_on_surcharge_amount,
+        )?;
         Ok(Self {
             surcharge: surcharge_details.surcharge.clone().into(),
             tax_on_surcharge: surcharge_details.tax_on_surcharge.clone().map(Into::into),
             display_surcharge_amount,
             display_tax_on_surcharge_amount,
-            display_total_surcharge_amount: display_surcharge_amount
-                + display_tax_on_surcharge_amount,
+            display_total_surcharge_amount,
             display_final_amount,
         })
     }
diff --git a/crates/router/src/services/api.rs b/crates/router/src/services/api.rs
index 7680ff29d45c..ea254ee4fabf 100644
--- a/crates/router/src/services/api.rs
+++ b/crates/router/src/services/api.rs
@@ -100,10 +100,6 @@ pub trait ConnectorValidation: ConnectorCommon {
     fn is_webhook_source_verification_mandatory(&self) -> bool {
         false
     }
-
-    fn validate_if_surcharge_implemented(&self) -> CustomResult<(), errors::ConnectorError> {
-        Err(errors::ConnectorError::NotImplemented(format!("Surcharge for {}", self.id())).into())
-    }
 }
 
 #[async_trait::async_trait]
diff --git a/crates/router/src/types.rs b/crates/router/src/types.rs
index ecbea1e793c6..cc14fe36a044 100644
--- a/crates/router/src/types.rs
+++ b/crates/router/src/types.rs
@@ -38,7 +38,7 @@ use crate::{
         payments::{types, PaymentData, RecurringMandatePaymentData},
     },
     services,
-    types::{storage::payment_attempt::PaymentAttemptExt, transformers::ForeignFrom},
+    types::transformers::ForeignFrom,
     utils::OptionExt,
 };
 
@@ -373,6 +373,14 @@ pub struct PayoutsFulfillResponseData {
 #[derive(Debug, Clone)]
 pub struct PaymentsAuthorizeData {
     pub payment_method_data: payments::PaymentMethodData,
+    /// total amount (original_amount + surcharge_amount + tax_on_surcharge_amount)  
+    /// If connector supports separate field for surcharge amount, consider using below functions defined on `PaymentsAuthorizeData` to fetch original amount and surcharge amount separately  
+    /// ```
+    /// get_original_amount()
+    /// get_surcharge_amount()
+    /// get_tax_on_surcharge_amount()
+    /// get_total_surcharge_amount() // returns surcharge_amount + tax_on_surcharge_amount
+    /// ```
     pub amount: i64,
     pub email: Option<Email>,
     pub currency: storage_enums::Currency,