diff --git a/crates/api_models/src/enums.rs b/crates/api_models/src/enums.rs
index 9da929e51c..8e1c71c227 100644
--- a/crates/api_models/src/enums.rs
+++ b/crates/api_models/src/enums.rs
@@ -401,6 +401,7 @@ pub enum PaymentMethodType {
 pub enum WalletIssuer {
     GooglePay,
     ApplePay,
+    Paypal,
 }
 
 #[derive(
diff --git a/crates/router/src/connector/adyen/transformers.rs b/crates/router/src/connector/adyen/transformers.rs
index 84caa7524e..36a4c80410 100644
--- a/crates/router/src/connector/adyen/transformers.rs
+++ b/crates/router/src/connector/adyen/transformers.rs
@@ -340,6 +340,10 @@ impl TryFrom<&types::PaymentsAuthorizeRouterData> for AdyenPaymentRequest {
                     };
                     Ok(AdyenPaymentMethod::ApplePay(apple_pay_data))
                 }
+
+                api_enums::WalletIssuer::Paypal => Err(errors::ConnectorError::NotImplemented(
+                    "Adyen - Paypal".to_string(),
+                )),
             },
 
             storage_enums::PaymentMethodType::Paypal => {
diff --git a/crates/router/src/connector/braintree/transformers.rs b/crates/router/src/connector/braintree/transformers.rs
index c4a5b0bb6e..bda1dc5b6f 100644
--- a/crates/router/src/connector/braintree/transformers.rs
+++ b/crates/router/src/connector/braintree/transformers.rs
@@ -14,7 +14,7 @@ pub struct PaymentOptions {
     submit_for_settlement: bool,
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+#[derive(Debug, Serialize, Eq, PartialEq)]
 pub struct BraintreePaymentsRequest {
     transaction: TransactionBody,
 }
@@ -40,20 +40,40 @@ impl TryFrom<&types::PaymentsSessionRouterData> for BraintreeSessionRequest {
     }
 }
 
-#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+#[derive(Debug, Serialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct TransactionBody {
     amount: String,
     device_data: DeviceData,
     options: PaymentOptions,
-    credit_card: Card,
+    #[serde(flatten)]
+    payment_method_data_type: PaymentMethodType,
     #[serde(rename = "type")]
     kind: String,
 }
 
+#[derive(Debug, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+#[serde(tag = "type")]
+pub enum PaymentMethodType {
+    CreditCard(Card),
+    PaymentMethodNonce(Nonce),
+}
+
+#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+pub struct Nonce {
+    payment_method_nonce: String,
+}
+
 #[derive(Default, Debug, Serialize, Eq, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct Card {
+    credit_card: CardDetails,
+}
+
+#[derive(Default, Debug, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct CardDetails {
     number: String,
     expiration_month: String,
     expiration_year: String,
@@ -63,34 +83,47 @@ pub struct Card {
 impl TryFrom<&types::PaymentsAuthorizeRouterData> for BraintreePaymentsRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(item: &types::PaymentsAuthorizeRouterData) -> Result<Self, Self::Error> {
-        match item.request.payment_method_data {
-            api::PaymentMethod::Card(ref ccard) => {
-                let submit_for_settlement = matches!(
-                    item.request.capture_method,
-                    Some(enums::CaptureMethod::Automatic) | None
-                );
-                let braintree_payment_request = TransactionBody {
-                    amount: item.request.amount.to_string(),
-                    device_data: DeviceData {},
-                    options: PaymentOptions {
-                        submit_for_settlement,
-                    },
-                    credit_card: Card {
-                        number: ccard.card_number.peek().clone(),
-                        expiration_month: ccard.card_exp_month.peek().clone(),
-                        expiration_year: ccard.card_exp_year.peek().clone(),
-                        cvv: ccard.card_cvc.peek().clone(),
-                    },
-                    kind: "sale".to_string(),
-                };
-                Ok(BraintreePaymentsRequest {
-                    transaction: braintree_payment_request,
-                })
+        let submit_for_settlement = matches!(
+            item.request.capture_method,
+            Some(enums::CaptureMethod::Automatic) | None
+        );
+
+        let amount = item.request.amount.to_string();
+        let device_data = DeviceData {};
+        let options = PaymentOptions {
+            submit_for_settlement,
+        };
+        let kind = "sale".to_string();
+
+        let payment_method_data_type = match item.request.payment_method_data {
+            api::PaymentMethod::Card(ref ccard) => Ok(PaymentMethodType::CreditCard(Card {
+                credit_card: CardDetails {
+                    number: ccard.card_number.peek().clone(),
+                    expiration_month: ccard.card_exp_month.peek().clone(),
+                    expiration_year: ccard.card_exp_year.peek().clone(),
+                    cvv: ccard.card_cvc.peek().clone(),
+                },
+            })),
+            api::PaymentMethod::Wallet(ref wallet_data) => {
+                Ok(PaymentMethodType::PaymentMethodNonce(Nonce {
+                    payment_method_nonce: wallet_data.token.to_string(),
+                }))
             }
-            _ => Err(
-                errors::ConnectorError::NotImplemented("Current Payment Method".to_string()).into(),
-            ),
-        }
+            _ => Err(errors::ConnectorError::NotImplemented(format!(
+                "Current Payment Method - {:?}",
+                item.request.payment_method_data
+            ))),
+        }?;
+        let braintree_transaction_body = TransactionBody {
+            amount,
+            device_data,
+            options,
+            payment_method_data_type,
+            kind,
+        };
+        Ok(BraintreePaymentsRequest {
+            transaction: braintree_transaction_body,
+        })
     }
 }
 
@@ -140,7 +173,9 @@ impl Default for BraintreePaymentStatus {
 impl From<BraintreePaymentStatus> for enums::AttemptStatus {
     fn from(item: BraintreePaymentStatus) -> Self {
         match item {
-            BraintreePaymentStatus::Succeeded => enums::AttemptStatus::Charged,
+            BraintreePaymentStatus::Succeeded | BraintreePaymentStatus::SubmittedForSettlement => {
+                enums::AttemptStatus::Charged
+            }
             BraintreePaymentStatus::AuthorizedExpired => enums::AttemptStatus::AuthorizationFailed,
             BraintreePaymentStatus::Failed
             | BraintreePaymentStatus::GatewayRejected