diff --git a/CHANGELOG.md b/CHANGELOG.md
index 775f3248c9..94358ae8c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 
 ### Features
 
+- User Feedback can now be captured without errors/exceptions. Note that these APIs replace the older UserFeedback APIs, which have now been marked as obsolete (and will be removed in a future major version bump) ([#3981](https://github.com/getsentry/sentry-dotnet/pull/3981))
 - Users can now register their own MAUI controls for breadcrumb creation ([#3997](https://github.com/getsentry/sentry-dotnet/pull/3997))
 - Serilog scope properties are now sent with Sentry events ([#3976](https://github.com/getsentry/sentry-dotnet/pull/3976))
 - The sample seed used for sampling decisions is now propagated, for use in downstream custom trace samplers ([#3951](https://github.com/getsentry/sentry-dotnet/pull/3951))
diff --git a/samples/Sentry.Samples.AspNetCore.Mvc/Controllers/HomeController.cs b/samples/Sentry.Samples.AspNetCore.Mvc/Controllers/HomeController.cs
index de18940dd7..ef3a27275b 100644
--- a/samples/Sentry.Samples.AspNetCore.Mvc/Controllers/HomeController.cs
+++ b/samples/Sentry.Samples.AspNetCore.Mvc/Controllers/HomeController.cs
@@ -1,6 +1,7 @@
 using System.Data;
 using System.Diagnostics;
 using Microsoft.AspNetCore.Mvc;
+using Samples.AspNetCore.Mvc.Models;
 using Sentry.Ben.BlockingDetector;
 using Sentry.Samples.AspNetCore.Mvc.Models;
 
@@ -176,4 +177,33 @@ public IActionResult Error()
     {
         return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
     }
+
+    [HttpGet("[controller]/feedback")]
+    public IActionResult Feedback()
+    {
+        return View();
+    }
+
+    [HttpPost]
+    public async Task<IActionResult> SubmitFeedback(FeedbackModel feedback)
+    {
+        if (!ModelState.IsValid)
+        {
+            return View("Feedback", feedback);
+        }
+
+        var sentryFeedback = new SentryFeedback(feedback.Message!, feedback.ContactEmail, feedback.Name);
+        var hint = new SentryHint();
+
+        if (feedback.Screenshot is { Length: > 0 })
+        {
+            await using var memoryStream = new MemoryStream();
+            await feedback.Screenshot.CopyToAsync(memoryStream);
+            hint.AddAttachment(memoryStream.ToArray(), feedback.Screenshot.FileName, AttachmentType.Default, "image/png");
+        }
+
+        SentrySdk.CaptureFeedback(sentryFeedback, null, hint);
+        ViewBag.Message = "Feedback submitted successfully!";
+        return View("Index");
+    }
 }
diff --git a/samples/Sentry.Samples.AspNetCore.Mvc/Models/FeedbackModel.cs b/samples/Sentry.Samples.AspNetCore.Mvc/Models/FeedbackModel.cs
new file mode 100644
index 0000000000..00dfba0ca3
--- /dev/null
+++ b/samples/Sentry.Samples.AspNetCore.Mvc/Models/FeedbackModel.cs
@@ -0,0 +1,16 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Samples.AspNetCore.Mvc.Models;
+
+public class FeedbackModel
+{
+    [Required]
+    public string? Message { get; set; }
+
+    [EmailAddress]
+    public string? ContactEmail { get; set; }
+
+    public string? Name { get; set; }
+
+    public IFormFile? Screenshot { get; set; }
+}
diff --git a/samples/Sentry.Samples.AspNetCore.Mvc/Sentry.Samples.AspNetCore.Mvc.csproj b/samples/Sentry.Samples.AspNetCore.Mvc/Sentry.Samples.AspNetCore.Mvc.csproj
index b2b958bf3c..d3bbf0aa34 100644
--- a/samples/Sentry.Samples.AspNetCore.Mvc/Sentry.Samples.AspNetCore.Mvc.csproj
+++ b/samples/Sentry.Samples.AspNetCore.Mvc/Sentry.Samples.AspNetCore.Mvc.csproj
@@ -18,4 +18,8 @@
     <ProjectReference Include="..\..\src\Sentry.AspNetCore\Sentry.AspNetCore.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <AdditionalFiles Include="Views\Home\Feedback.cshtml" />
+  </ItemGroup>
+
 </Project>
diff --git a/samples/Sentry.Samples.AspNetCore.Mvc/Views/Home/Feedback.cshtml b/samples/Sentry.Samples.AspNetCore.Mvc/Views/Home/Feedback.cshtml
new file mode 100644
index 0000000000..1534eda1c8
--- /dev/null
+++ b/samples/Sentry.Samples.AspNetCore.Mvc/Views/Home/Feedback.cshtml
@@ -0,0 +1,36 @@
+@model Samples.AspNetCore.Mvc.Models.FeedbackModel
+
+@{
+    ViewData["Title"] = "Submit Feedback";
+}
+
+<h2>Submit Feedback</h2>
+
+@if (ViewBag.Message != null)
+{
+    <div class="alert alert-success">@ViewBag.Message</div>
+}
+
+<form asp-action="SubmitFeedback" method="post" enctype="multipart/form-data">
+    <div class="form-group">
+        <label asp-for="Message"></label>
+        <textarea asp-for="Message" class="form-control"></textarea>
+        <span asp-validation-for="Message" class="text-danger"></span>
+    </div>
+    <div class="form-group">
+        <label asp-for="ContactEmail"></label>
+        <input asp-for="ContactEmail" class="form-control" />
+        <span asp-validation-for="ContactEmail" class="text-danger"></span>
+    </div>
+    <div class="form-group">
+        <label asp-for="Name"></label>
+        <input asp-for="Name" class="form-control" />
+        <span asp-validation-for="Name" class="text-danger"></span>
+    </div>
+    <div class="form-group">
+        <label asp-for="Screenshot">Attach Screenshot</label>
+        <input asp-for="Screenshot" type="file" class="form-control" />
+        <span asp-validation-for="Screenshot" class="text-danger"></span>
+    </div>
+    <button type="submit" class="btn btn-primary">Submit</button>
+</form>
diff --git a/samples/Sentry.Samples.AspNetCore.Mvc/Views/Shared/_Layout.cshtml b/samples/Sentry.Samples.AspNetCore.Mvc/Views/Shared/_Layout.cshtml
index a10ed1f464..6de93829f5 100644
--- a/samples/Sentry.Samples.AspNetCore.Mvc/Views/Shared/_Layout.cshtml
+++ b/samples/Sentry.Samples.AspNetCore.Mvc/Views/Shared/_Layout.cshtml
@@ -31,6 +31,9 @@
                         <li class="nav-item">
                             <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Action">Action Throws</a>
                         </li>
+                        <li class="nav-item">
+                            <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Feedback">Submit Feedback</a>
+                        </li>
                     </ul>
                 </div>
             </div>
diff --git a/samples/Sentry.Samples.Console.Customized/Program.cs b/samples/Sentry.Samples.Console.Customized/Program.cs
index f85ae49da6..dac1d9062a 100644
--- a/samples/Sentry.Samples.Console.Customized/Program.cs
+++ b/samples/Sentry.Samples.Console.Customized/Program.cs
@@ -142,12 +142,18 @@ await SentrySdk.ConfigureScopeAsync(async scope =>
 
             var eventId = SentrySdk.CaptureMessage("Some warning!", SentryLevel.Warning);
 
-            // Send an user feedback linked to the warning.
+            // Send feedback linked to the warning.
             var timestamp = DateTime.Now.Ticks;
             var user = $"user{timestamp}";
             var email = $"user{timestamp}@user{timestamp}.com";
-
-            SentrySdk.CaptureUserFeedback(new UserFeedback(eventId, user, email, "this is a sample user feedback"));
+            SentrySdk.CaptureFeedback(new SentryFeedback(
+                message: "this is a sample user feedback",
+                contactEmail: email,
+                name: user,
+                replayId: null,
+                url: null,
+                associatedEventId: eventId
+            ));
 
             var error = new Exception("Attempting to send this multiple times");
 
diff --git a/samples/Sentry.Samples.Maui/MainPage.xaml b/samples/Sentry.Samples.Maui/MainPage.xaml
index d1519f610c..672b9d2347 100644
--- a/samples/Sentry.Samples.Maui/MainPage.xaml
+++ b/samples/Sentry.Samples.Maui/MainPage.xaml
@@ -70,6 +70,13 @@
                 Clicked="OnNativeCrashClicked"
                 HorizontalOptions="Center" />
 
+            <Button
+                x:Name="FeedbackBtn"
+                Text="Submit Feedback"
+                SemanticProperties.Hint="Provides a form that can be used to capture open feedback from the user."
+                Clicked="OnFeedbackClicked"
+                HorizontalOptions="Center" />
+
         </VerticalStackLayout>
     </ScrollView>
 
diff --git a/samples/Sentry.Samples.Maui/MainPage.xaml.cs b/samples/Sentry.Samples.Maui/MainPage.xaml.cs
index 9bbeed01d9..70215b3578 100644
--- a/samples/Sentry.Samples.Maui/MainPage.xaml.cs
+++ b/samples/Sentry.Samples.Maui/MainPage.xaml.cs
@@ -95,4 +95,9 @@ protected override Task<HttpResponseMessage> SendAsync(
             CancellationToken cancellationToken)
             => throw new Exception();
     }
+
+    private async void OnFeedbackClicked(object sender, EventArgs e)
+    {
+        await Navigation.PushModalAsync(new SubmitFeedback());
+    }
 }
diff --git a/samples/Sentry.Samples.Maui/SubmitFeedback.xaml b/samples/Sentry.Samples.Maui/SubmitFeedback.xaml
new file mode 100644
index 0000000000..f51c08ace5
--- /dev/null
+++ b/samples/Sentry.Samples.Maui/SubmitFeedback.xaml
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Sentry.Samples.Maui.SubmitFeedback">
+    <ContentPage.Content>
+        <StackLayout Padding="20">
+            <Label Text="Message" />
+            <Editor x:Name="MessageEditor" Placeholder="Enter your feedback message" />
+
+            <Label Text="Contact Email" Margin="0,20,0,0" />
+            <Entry x:Name="ContactEmailEntry" Placeholder="Enter your contact email" />
+
+            <Label Text="Name" Margin="0,20,0,0" />
+            <Entry x:Name="NameEntry" Placeholder="Enter your name" />
+
+            <Button Text="Attach Screenshot" Clicked="OnAttachScreenshotClicked" Margin="0,20,0,0" />
+
+            <StackLayout Orientation="Horizontal" HorizontalOptions="EndAndExpand" Margin="0,20,0,0" Spacing="10">
+                <Button Text="Cancel" Clicked="OnCancelClicked" BackgroundColor="Red" TextColor="White" />
+                <Button Text="Submit" Clicked="OnSubmitClicked" BackgroundColor="Green" TextColor="White" />
+            </StackLayout>
+        </StackLayout>
+    </ContentPage.Content>
+</ContentPage>
diff --git a/samples/Sentry.Samples.Maui/SubmitFeedback.xaml.cs b/samples/Sentry.Samples.Maui/SubmitFeedback.xaml.cs
new file mode 100644
index 0000000000..84b5453d36
--- /dev/null
+++ b/samples/Sentry.Samples.Maui/SubmitFeedback.xaml.cs
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Sentry.Samples.Maui;
+
+public partial class SubmitFeedback : ContentPage
+{
+    [GeneratedRegex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$")]
+    private static partial Regex EmailPattern();
+
+    private string _screenshotPath;
+
+    private bool IsValidEmail(string email) => string.IsNullOrWhiteSpace(email) || EmailPattern().IsMatch(email);
+
+    public SubmitFeedback()
+    {
+        InitializeComponent();
+    }
+
+    private async void OnSubmitClicked(object sender, EventArgs e)
+    {
+        var message = MessageEditor.Text;
+        var contactEmail = ContactEmailEntry.Text;
+        var name = NameEntry.Text;
+
+        if (string.IsNullOrWhiteSpace(message))
+        {
+            await DisplayAlert("Validation Error", "Message is required.", "OK");
+            return;
+        }
+
+        if (!IsValidEmail(contactEmail))
+        {
+            await DisplayAlert("Validation Error", "Please enter a valid email address.", "OK");
+            return;
+        }
+
+        SentryHint hint = null;
+        if (!string.IsNullOrEmpty(_screenshotPath))
+        {
+            hint = new SentryHint();
+            hint.AddAttachment(_screenshotPath, AttachmentType.Default, "image/png");
+        }
+
+        // Handle the feedback submission logic here
+        var feedback = new SentryFeedback(message, contactEmail, name);
+        SentrySdk.CaptureFeedback(feedback, hint: hint);
+
+        await DisplayAlert("Feedback Submitted", "Thank you for your feedback!", "OK");
+        await Navigation.PopModalAsync();
+    }
+
+    private async void OnCancelClicked(object sender, EventArgs e)
+    {
+        await Navigation.PopModalAsync();
+    }
+
+    private async void OnAttachScreenshotClicked(object sender, EventArgs e)
+    {
+        try
+        {
+            var result = await FilePicker.PickAsync(new PickOptions
+            {
+                FileTypes = FilePickerFileType.Images,
+                PickerTitle = "Select a screenshot"
+            });
+
+            if (result != null)
+            {
+                _screenshotPath = result.FullPath;
+                await DisplayAlert("Screenshot Attached", "Screenshot has been attached successfully.", "OK");
+            }
+        }
+        catch (Exception ex)
+        {
+            await DisplayAlert("Error", $"An error occurred while selecting the screenshot: {ex.Message}", "OK");
+        }
+    }
+}
diff --git a/src/Sentry/Extensibility/DisabledHub.cs b/src/Sentry/Extensibility/DisabledHub.cs
index 3ed44e3a09..6c18af6e45 100644
--- a/src/Sentry/Extensibility/DisabledHub.cs
+++ b/src/Sentry/Extensibility/DisabledHub.cs
@@ -147,6 +147,13 @@ public bool CaptureEnvelope(Envelope envelope)
     /// </summary>
     public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null, SentryHint? hint = null) => SentryId.Empty;
 
+    /// <summary>
+    /// No-Op.
+    /// </summary>
+    public void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null)
+    {
+    }
+
     /// <summary>
     /// No-Op.
     /// </summary>
@@ -205,6 +212,7 @@ public void Dispose()
     /// <summary>
     /// No-Op.
     /// </summary>
+    [Obsolete("Use CaptureFeedback instead.")]
     public void CaptureUserFeedback(UserFeedback userFeedback)
     {
     }
diff --git a/src/Sentry/Extensibility/HubAdapter.cs b/src/Sentry/Extensibility/HubAdapter.cs
index 5a4f01b62e..61d715d341 100644
--- a/src/Sentry/Extensibility/HubAdapter.cs
+++ b/src/Sentry/Extensibility/HubAdapter.cs
@@ -222,6 +222,14 @@ public SentryId CaptureEvent(SentryEvent evt, Scope? scope)
     public SentryId CaptureEvent(SentryEvent evt, Scope? scope, SentryHint? hint = null)
         => SentrySdk.CaptureEvent(evt, scope, hint);
 
+    /// <summary>
+    /// Forwards the call to <see cref="SentrySdk"/>.
+    /// </summary>
+    [DebuggerStepThrough]
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null)
+        => SentrySdk.CaptureFeedback(feedback, scope, hint);
+
     /// <summary>
     /// Forwards the call to <see cref="SentrySdk"/>.
     /// </summary>
@@ -292,6 +300,7 @@ public Task FlushAsync(TimeSpan timeout)
     /// </summary>
     [DebuggerStepThrough]
     [EditorBrowsable(EditorBrowsableState.Never)]
+    [Obsolete("Use CaptureFeedback instead.")]
     public void CaptureUserFeedback(UserFeedback sentryUserFeedback)
         => SentrySdk.CaptureUserFeedback(sentryUserFeedback);
 }
diff --git a/src/Sentry/ISentryClient.cs b/src/Sentry/ISentryClient.cs
index e3e12fe191..3841539cc2 100644
--- a/src/Sentry/ISentryClient.cs
+++ b/src/Sentry/ISentryClient.cs
@@ -28,10 +28,19 @@ public interface ISentryClient
     /// <returns>The Id of the event.</returns>
     SentryId CaptureEvent(SentryEvent evt, Scope? scope = null, SentryHint? hint = null);
 
+    /// <summary>
+    /// Captures feedback from the user.
+    /// </summary>
+    /// <param name="feedback">The feedback to send to Sentry.</param>
+    /// <param name="scope">An optional scope to be applied to the event.</param>
+    /// <param name="hint">An optional hint providing high level context for the source of the event</param>
+    void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null);
+
     /// <summary>
     /// Captures a user feedback.
     /// </summary>
     /// <param name="userFeedback">The user feedback to send to Sentry.</param>
+    [Obsolete("Use CaptureFeedback instead.")]
     void CaptureUserFeedback(UserFeedback userFeedback);
 
     /// <summary>
diff --git a/src/Sentry/Internal/Extensions/CollectionsExtensions.cs b/src/Sentry/Internal/Extensions/CollectionsExtensions.cs
index 19277a632a..8d7b6f7bdf 100644
--- a/src/Sentry/Internal/Extensions/CollectionsExtensions.cs
+++ b/src/Sentry/Internal/Extensions/CollectionsExtensions.cs
@@ -17,6 +17,24 @@ public static TValue GetOrCreate<TValue>(
         throw new($"Expected a type of {typeof(TValue)} to exist for the key '{key}'. Instead found a {value.GetType()}. The likely cause of this is that the value for '{key}' has been incorrectly set to an instance of a different type.");
     }
 
+    public static TValue? TryGetValue<TValue>(
+        this ConcurrentDictionary<string, object> dictionary,
+        string key)
+        where TValue : class
+    {
+        if (!dictionary.TryGetValue(key, out var value))
+        {
+            return null;
+        }
+
+        if (value is TValue casted)
+        {
+            return casted;
+        }
+
+        throw new($"Expected a type of {typeof(TValue)} to exist for the key '{key}'. Instead found a {value.GetType()}. The likely cause of this is that the value for '{key}' has been incorrectly set to an instance of a different type.");
+    }
+
     public static void TryCopyTo<TKey, TValue>(this IDictionary<TKey, TValue> from, IDictionary<TKey, TValue> to)
         where TKey : notnull
     {
diff --git a/src/Sentry/Internal/Hub.cs b/src/Sentry/Internal/Hub.cs
index a564ab1791..cd00686250 100644
--- a/src/Sentry/Internal/Hub.cs
+++ b/src/Sentry/Internal/Hub.cs
@@ -506,6 +506,17 @@ private SentryId CaptureEvent(SentryEvent evt, SentryHint? hint, Scope scope)
         }
     }
 
+    public void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null)
+    {
+        if (!IsEnabled)
+        {
+            return;
+        }
+
+        scope ??= CurrentScope;
+        CurrentClient.CaptureFeedback(feedback, scope, hint);
+    }
+
 #if MEMORY_DUMP_SUPPORTED
     internal void CaptureHeapDump(string dumpFile)
     {
@@ -534,6 +545,7 @@ internal void CaptureHeapDump(string dumpFile)
     }
 #endif
 
+    [Obsolete("Use CaptureFeedback instead.")]
     public void CaptureUserFeedback(UserFeedback userFeedback)
     {
         if (!IsEnabled)
diff --git a/src/Sentry/Protocol/Envelopes/Envelope.cs b/src/Sentry/Protocol/Envelopes/Envelope.cs
index 29ad6a8e07..b62dc82c98 100644
--- a/src/Sentry/Protocol/Envelopes/Envelope.cs
+++ b/src/Sentry/Protocol/Envelopes/Envelope.cs
@@ -248,31 +248,78 @@ public static Envelope FromEvent(
                     continue;
                 }
 
-                try
-                {
-                    // We pull the stream out here so we can length check
-                    // to avoid adding an invalid attachment
-                    var stream = attachment.Content.GetStream();
-                    if (stream.TryGetLength() != 0)
-                    {
-                        items.Add(EnvelopeItem.FromAttachment(attachment, stream));
-                    }
-                    else
-                    {
-                        // We would normally dispose the stream when we dispose the envelope item
-                        // But in this case, we need to explicitly dispose here or we will be leaving
-                        // the stream open indefinitely.
-                        stream.Dispose();
-
-                        logger?.LogWarning("Did not add '{0}' to envelope because the stream was empty.",
-                            attachment.FileName);
-                    }
-                }
-                catch (Exception exception)
-                {
-                    logger?.LogError(exception, "Failed to add attachment: {0}.", attachment.FileName);
-                }
+                AddEnvelopeItemFromAttachment(items, attachment, logger);
+            }
+        }
+
+        if (sessionUpdate is not null)
+        {
+            items.Add(EnvelopeItem.FromSession(sessionUpdate));
+        }
+
+        return new Envelope(eventId, header, items);
+    }
+
+    private static void AddEnvelopeItemFromAttachment(List<EnvelopeItem> items, SentryAttachment attachment,
+        IDiagnosticLogger? logger)
+    {
+        try
+        {
+            // We pull the stream out here so we can length check
+            // to avoid adding an invalid attachment
+            var stream = attachment.Content.GetStream();
+            if (stream.TryGetLength() != 0)
+            {
+                items.Add(EnvelopeItem.FromAttachment(attachment, stream));
             }
+            else
+            {
+                // We would normally dispose the stream when we dispose the envelope item
+                // But in this case, we need to explicitly dispose here or we will be leaving
+                // the stream open indefinitely.
+                stream.Dispose();
+
+                logger?.LogWarning("Did not add '{0}' to envelope because the stream was empty.",
+                    attachment.FileName);
+            }
+        }
+        catch (Exception exception)
+        {
+            logger?.LogError(exception, "Failed to add attachment: {0}.", attachment.FileName);
+        }
+    }
+
+    /// <summary>
+    /// Creates an envelope that contains a single feedback event.
+    /// </summary>
+    public static Envelope FromFeedback(
+        SentryEvent @event,
+        IDiagnosticLogger? logger = null,
+        IReadOnlyCollection<SentryAttachment>? attachments = null,
+        SessionUpdate? sessionUpdate = null)
+    {
+        if (@event.Contexts.Feedback == null)
+        {
+            throw new ArgumentException("Unable to create envelope - the event does not contain any feedback.");
+        }
+
+        var eventId = @event.EventId;
+        var header = CreateHeader(eventId, @event.DynamicSamplingContext);
+
+        var items = new List<EnvelopeItem>
+        {
+            EnvelopeItem.FromFeedback(@event)
+        };
+
+        if (attachments is { Count: > 0 })
+        {
+            if (attachments.Count > 1)
+            {
+                logger?.LogWarning("Feedback can only contain one attachment. Discarding {0} additional attachments.",
+                    attachments.Count - 1);
+            }
+
+            AddEnvelopeItemFromAttachment(items, attachments.First(), logger);
         }
 
         if (sessionUpdate is not null)
@@ -286,6 +333,7 @@ public static Envelope FromEvent(
     /// <summary>
     /// Creates an envelope that contains a single user feedback.
     /// </summary>
+    [Obsolete("Use FromFeedback instead.")]
     public static Envelope FromUserFeedback(UserFeedback sentryUserFeedback)
     {
         var eventId = sentryUserFeedback.EventId;
diff --git a/src/Sentry/Protocol/Envelopes/EnvelopeItem.cs b/src/Sentry/Protocol/Envelopes/EnvelopeItem.cs
index 9954de43d6..7c721db581 100644
--- a/src/Sentry/Protocol/Envelopes/EnvelopeItem.cs
+++ b/src/Sentry/Protocol/Envelopes/EnvelopeItem.cs
@@ -13,6 +13,7 @@ public sealed class EnvelopeItem : ISerializable, IDisposable
     private const string TypeKey = "type";
 
     internal const string TypeValueEvent = "event";
+    internal const string TypeValueFeedback = "feedback";
     internal const string TypeValueUserReport = "user_report";
     internal const string TypeValueTransaction = "transaction";
     internal const string TypeValueSpan = "span";
@@ -216,9 +217,23 @@ public static EnvelopeItem FromEvent(SentryEvent @event)
         return new EnvelopeItem(header, new JsonSerializable(@event));
     }
 
+    /// <summary>
+    /// Creates an <see cref="EnvelopeItem"/> from a feedback <paramref name="event"/>.
+    /// </summary>
+    public static EnvelopeItem FromFeedback(SentryEvent @event)
+    {
+        var header = new Dictionary<string, object?>(1, StringComparer.Ordinal)
+        {
+            [TypeKey] = TypeValueFeedback
+        };
+
+        return new EnvelopeItem(header, new JsonSerializable(@event));
+    }
+
     /// <summary>
     /// Creates an <see cref="EnvelopeItem"/> from <paramref name="sentryUserFeedback"/>.
     /// </summary>
+    [Obsolete("Use FromFeedback instead.")]
     public static EnvelopeItem FromUserFeedback(UserFeedback sentryUserFeedback)
     {
         var header = new Dictionary<string, object?>(1, StringComparer.Ordinal)
@@ -392,9 +407,11 @@ private static async Task<ISerializable> DeserializePayloadAsync(
         // User report
         if (string.Equals(payloadType, TypeValueUserReport, StringComparison.OrdinalIgnoreCase))
         {
+#pragma warning disable CS0618 // Type or member is obsolete
             var bufferLength = (int)(payloadLength ?? stream.Length);
             var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
             var userFeedback = Json.Parse(buffer, UserFeedback.FromJson);
+#pragma warning restore CS0618 // Type or member is obsolete
 
             return new JsonSerializable(userFeedback);
         }
diff --git a/src/Sentry/SentryClient.cs b/src/Sentry/SentryClient.cs
index 7d5b071dc5..7aef9aa8b5 100644
--- a/src/Sentry/SentryClient.cs
+++ b/src/Sentry/SentryClient.cs
@@ -82,6 +82,42 @@ public SentryId CaptureEvent(SentryEvent? @event, Scope? scope = null, SentryHin
     }
 
     /// <inheritdoc />
+    public void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null)
+    {
+        if (string.IsNullOrEmpty(feedback.Message))
+        {
+            _options.LogWarning("Feedback dropped due to empty message.");
+            return;
+        }
+
+        scope ??= new Scope(_options);
+        hint ??= new SentryHint();
+        hint.AddAttachmentsFromScope(scope);
+
+        _options.LogInfo("Capturing feedback: '{0}'.", feedback.Message);
+
+        var evt = new SentryEvent { Level = SentryLevel.Info };
+        evt.Contexts.Feedback = feedback;
+        // type: 'feedback',
+
+        // Evaluate and copy before invoking the callback
+        scope.Evaluate();
+        scope.Apply(evt);
+
+        if (scope.Level != null && scope.Level != SentryLevel.Info)
+        {
+            // Level on scope takes precedence over the one on event
+            _options.LogInfo("Overriding level set on feedback event '{0}' with level set on scope '{1}'.", evt.Level, scope.Level);
+            evt.Level = scope.Level;
+        }
+
+        var attachments = hint.Attachments.ToList();
+        var envelope = Envelope.FromFeedback(evt, _options.DiagnosticLogger, attachments, scope.SessionUpdate);
+        CaptureEnvelope(envelope);
+    }
+
+    /// <inheritdoc />
+    [Obsolete("Use CaptureFeedback instead.")]
     public void CaptureUserFeedback(UserFeedback userFeedback)
     {
         if (userFeedback.EventId.Equals(SentryId.Empty))
diff --git a/src/Sentry/SentryClientExtensions.cs b/src/Sentry/SentryClientExtensions.cs
index 686a732229..2af8b85f8c 100644
--- a/src/Sentry/SentryClientExtensions.cs
+++ b/src/Sentry/SentryClientExtensions.cs
@@ -40,6 +40,15 @@ public static SentryId CaptureMessage(this ISentryClient client, string message,
         return SentryId.Empty;
     }
 
+    /// <summary>
+    /// Captures feedback from the user.
+    /// </summary>
+    public static void CaptureFeedback(this ISentryClient client, string message, string? contactEmail = null,
+        string? name = null, string? replayId = null, string? url = null, SentryId? associatedEventId = null,
+        Scope? scope = null, SentryHint? hint = null)
+        => client.CaptureFeedback(new SentryFeedback(message, contactEmail, name, replayId, url, associatedEventId),
+            scope, hint);
+
     /// <summary>
     /// Captures a user feedback.
     /// </summary>
@@ -48,6 +57,7 @@ public static SentryId CaptureMessage(this ISentryClient client, string message,
     /// <param name="email">The user email.</param>
     /// <param name="comments">The user comments.</param>
     /// <param name="name">The optional username.</param>
+    [Obsolete("Use CaptureFeedback instead.")]
     public static void CaptureUserFeedback(this ISentryClient client, SentryId eventId, string email, string comments,
         string? name = null)
     {
diff --git a/src/Sentry/SentryContexts.cs b/src/Sentry/SentryContexts.cs
index a9a2ed3efb..b0abb14227 100644
--- a/src/Sentry/SentryContexts.cs
+++ b/src/Sentry/SentryContexts.cs
@@ -30,6 +30,23 @@ public sealed class SentryContexts : IDictionary<string, object>, ISentryJsonSer
     /// </summary>
     public Device Device => _innerDictionary.GetOrCreate<Device>(Device.Type);
 
+    /// <summary>
+    /// Holds user feedback.
+    /// </summary>
+    public SentryFeedback? Feedback
+    {
+        get => _innerDictionary.TryGetValue<SentryFeedback>(SentryFeedback.Type);
+        set
+        {
+            if (value is null)
+            {
+                _innerDictionary.TryRemove(SentryFeedback.Type, out _);
+                return;
+            }
+            _innerDictionary[SentryFeedback.Type] = value;
+        }
+    }
+
     /// <summary>
     /// Defines the operating system.
     /// </summary>
@@ -147,6 +164,10 @@ public static SentryContexts FromJson(JsonElement json)
             {
                 result[name] = Device.FromJson(value);
             }
+            else if (string.Equals(type, SentryFeedback.Type, StringComparison.OrdinalIgnoreCase))
+            {
+                result[name] = SentryFeedback.FromJson(value);
+            }
             else if (string.Equals(type, OperatingSystem.Type, StringComparison.OrdinalIgnoreCase))
             {
                 result[name] = OperatingSystem.FromJson(value);
diff --git a/src/Sentry/SentryFeedback.cs b/src/Sentry/SentryFeedback.cs
new file mode 100644
index 0000000000..19dee45099
--- /dev/null
+++ b/src/Sentry/SentryFeedback.cs
@@ -0,0 +1,101 @@
+using Sentry.Extensibility;
+using Sentry.Internal;
+using Sentry.Internal.Extensions;
+
+namespace Sentry;
+
+/// <summary>
+/// Sentry User Feedback.
+/// </summary>
+public sealed class SentryFeedback : ISentryJsonSerializable, ICloneable<SentryFeedback>
+{
+    /// <summary>
+    /// Tells Sentry which type of context this is.
+    /// </summary>
+    internal const string Type = "feedback";
+
+    /// <summary>
+    /// Message containing the user's feedback.
+    /// </summary>
+    public string Message { get; set; } = string.Empty;
+
+    /// <summary>
+    /// The user's contact email address.
+    /// </summary>
+    public string? ContactEmail { get; set; }
+
+    /// <summary>
+    /// The name of the user.
+    /// </summary>
+    public string? Name { get; set; }
+
+    /// <summary>
+    /// Optional ID of the Replay session associated with the feedback.
+    /// </summary>
+    public string? ReplayId { get; set; }
+
+    /// <summary>
+    /// Url that the feedback relates to
+    /// </summary>
+    public string? Url { get; set; }
+
+    /// <summary>
+    /// Optional ID of the event that the user feedback is associated with.
+    /// </summary>
+    public SentryId? AssociatedEventId { get; set; }
+
+    /// <summary>
+    /// Creates an instance of <see cref="SentryFeedback"/>.
+    /// </summary>
+    public SentryFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, SentryId? associatedEventId = null)
+    {
+        Message = message;
+        ContactEmail = contactEmail;
+        Name = name;
+        ReplayId = replayId;
+        Url = url;
+        AssociatedEventId = associatedEventId;
+    }
+
+    /// <inheritdoc />
+    public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
+    {
+        if (string.IsNullOrEmpty(Message))
+        {
+            logger?.LogWarning("Feedback message is empty - serializing as null");
+            writer.WriteNullValue();
+            return;
+        }
+
+        writer.WriteStartObject();
+
+        writer.WriteString("message", Message);
+        writer.WriteStringIfNotWhiteSpace("contact_email", ContactEmail);
+        writer.WriteStringIfNotWhiteSpace("name", Name);
+        writer.WriteStringIfNotWhiteSpace("replay_id", ReplayId);
+        writer.WriteStringIfNotWhiteSpace("url", Url);
+        writer.WriteSerializableIfNotNull("associated_event_id", AssociatedEventId, logger);
+
+        writer.WriteEndObject();
+    }
+
+    /// <summary>
+    /// Parses from JSON.
+    /// </summary>
+    public static SentryFeedback FromJson(JsonElement json)
+    {
+        var message = json.GetPropertyOrNull("message")?.GetString() ?? "<empty>";
+        var contactEmail = json.GetPropertyOrNull("contact_email")?.GetString();
+        var name = json.GetPropertyOrNull("name")?.GetString();
+        var replayId = json.GetPropertyOrNull("replay_id")?.GetString();
+        var url = json.GetPropertyOrNull("url")?.GetString();
+        var eventId = json.GetPropertyOrNull("associated_event_id")?.Pipe(SentryId.FromJson);
+
+        return new SentryFeedback(message, contactEmail, name, replayId, url, eventId);
+    }
+
+    internal SentryFeedback Clone() => ((ICloneable<SentryFeedback>)this).Clone();
+
+    SentryFeedback ICloneable<SentryFeedback>.Clone()
+        => new(Message, ContactEmail, Name, ReplayId, Url, AssociatedEventId);
+}
diff --git a/src/Sentry/SentrySdk.cs b/src/Sentry/SentrySdk.cs
index 505bf7bb1b..401a0fa6f0 100644
--- a/src/Sentry/SentrySdk.cs
+++ b/src/Sentry/SentrySdk.cs
@@ -481,11 +481,29 @@ public static SentryId CaptureMessage(string message, SentryLevel level = Sentry
     public static SentryId CaptureMessage(string message, Action<Scope> configureScope, SentryLevel level = SentryLevel.Info)
         => CurrentHub.CaptureMessage(message, configureScope, level);
 
+    /// <summary>
+    /// Captures feedback from the user.
+    /// </summary>
+    [DebuggerStepThrough]
+    public static void CaptureFeedback(SentryFeedback feedback, Scope? scope = null, SentryHint? hint = null)
+        => CurrentHub.CaptureFeedback(feedback, scope, hint);
+
+    /// <summary>
+    /// Captures feedback from the user.
+    /// </summary>
+    [DebuggerStepThrough]
+    public static void CaptureFeedback(string message, string? contactEmail = null, string? name = null,
+        string? replayId = null, string? url = null, SentryId? associatedEventId = null, Scope? scope = null,
+        SentryHint? hint = null)
+        => CurrentHub.CaptureFeedback(new SentryFeedback(message, contactEmail, name, replayId, url, associatedEventId),
+            scope, hint);
+
     /// <summary>
     /// Captures a user feedback.
     /// </summary>
     /// <param name="userFeedback">The user feedback to send to Sentry.</param>
     [DebuggerStepThrough]
+    [Obsolete("Use CaptureFeedback instead.")]
     public static void CaptureUserFeedback(UserFeedback userFeedback)
         => CurrentHub.CaptureUserFeedback(userFeedback);
 
@@ -497,6 +515,7 @@ public static void CaptureUserFeedback(UserFeedback userFeedback)
     /// <param name="comments">The user comments.</param>
     /// <param name="name">The optional username.</param>
     [DebuggerStepThrough]
+    [Obsolete("Use CaptureFeedback instead.")]
     public static void CaptureUserFeedback(SentryId eventId, string email, string comments, string? name = null)
         => CurrentHub.CaptureUserFeedback(new UserFeedback(eventId, name, email, comments));
 
diff --git a/src/Sentry/UserFeedback.cs b/src/Sentry/UserFeedback.cs
index 3de5773d69..0094a6ade4 100644
--- a/src/Sentry/UserFeedback.cs
+++ b/src/Sentry/UserFeedback.cs
@@ -6,6 +6,7 @@ namespace Sentry;
 /// <summary>
 /// Sentry User Feedback.
 /// </summary>
+[Obsolete("Use SentryFeedback instead.")]
 public sealed class UserFeedback : ISentryJsonSerializable
 {
     /// <summary>
diff --git a/test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt b/test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt
index 2a4a0e61a3..67795954b7 100644
--- a/test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt
+++ b/test/Sentry.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt
@@ -237,9 +237,11 @@ namespace Sentry
         Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null);
         bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
+        void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
         void CaptureSession(Sentry.SessionUpdate sessionUpdate);
         void CaptureTransaction(Sentry.SentryTransaction transaction);
         void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint);
+        [System.Obsolete("Use CaptureFeedback instead.")]
         void CaptureUserFeedback(Sentry.UserFeedback userFeedback);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
@@ -461,9 +463,11 @@ namespace Sentry
         public Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null) { }
         public bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent? @event, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void Dispose() { }
         public System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout) { }
@@ -471,7 +475,9 @@ namespace Sentry
     public static class SentryClientExtensions
     {
         public static Sentry.SentryId CaptureException(this Sentry.ISentryClient client, System.Exception ex) { }
+        public static void CaptureFeedback(this Sentry.ISentryClient client, string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(this Sentry.ISentryClient client, string message, Sentry.SentryLevel level = 1) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(this Sentry.ISentryClient client, Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         public static void Flush(this Sentry.ISentryClient client) { }
         public static void Flush(this Sentry.ISentryClient client, System.TimeSpan timeout) { }
@@ -491,6 +497,7 @@ namespace Sentry
         public Sentry.Protocol.Browser Browser { get; }
         public int Count { get; }
         public Sentry.Protocol.Device Device { get; }
+        public Sentry.SentryFeedback? Feedback { get; set; }
         public Sentry.Protocol.Gpu Gpu { get; }
         public bool IsReadOnly { get; }
         public object this[string key] { get; set; }
@@ -549,6 +556,18 @@ namespace Sentry
         public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
         public static Sentry.SentryEvent FromJson(System.Text.Json.JsonElement json) { }
     }
+    public sealed class SentryFeedback : Sentry.ISentryJsonSerializable
+    {
+        public SentryFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default) { }
+        public Sentry.SentryId? AssociatedEventId { get; set; }
+        public string? ContactEmail { get; set; }
+        public string Message { get; set; }
+        public string? Name { get; set; }
+        public string? ReplayId { get; set; }
+        public string? Url { get; set; }
+        public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
+        public static Sentry.SentryFeedback FromJson(System.Text.Json.JsonElement json) { }
+    }
     public class SentryGraphQLHttpMessageHandler : Sentry.SentryMessageHandler
     {
         public SentryGraphQLHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler = null, Sentry.IHub? hub = null) { }
@@ -803,12 +822,16 @@ namespace Sentry
         public static Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public static Sentry.SentryId CaptureException(System.Exception exception) { }
         public static Sentry.SentryId CaptureException(System.Exception exception, System.Action<Sentry.Scope> configureScope) { }
+        public static void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public static void CaptureFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(string message, Sentry.SentryLevel level = 1) { }
         public static Sentry.SentryId CaptureMessage(string message, System.Action<Sentry.Scope> configureScope, Sentry.SentryLevel level = 1) { }
         public static void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         [System.Obsolete("WARNING: This method deliberately causes a crash, and should not be used in a rea" +
             "l application.")]
@@ -1220,6 +1243,7 @@ namespace Sentry
         public Sentry.ISpan StartChild(string operation) { }
         public void UnsetTag(string key) { }
     }
+    [System.Obsolete("Use SentryFeedback instead.")]
     public sealed class UserFeedback : Sentry.ISentryJsonSerializable
     {
         public UserFeedback(Sentry.SentryId eventId, string? name, string? email, string? comments) { }
@@ -1308,9 +1332,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1352,9 +1378,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureException(System.Exception exception) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1796,8 +1824,10 @@ namespace Sentry.Protocol.Envelopes
         public static System.Threading.Tasks.Task<Sentry.Protocol.Envelopes.Envelope> DeserializeAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default) { }
         public static Sentry.Protocol.Envelopes.Envelope FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.Envelope FromEvent(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
+        public static Sentry.Protocol.Envelopes.Envelope FromFeedback(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
         public static Sentry.Protocol.Envelopes.Envelope FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.Envelope FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.Envelope FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public sealed class EnvelopeItem : Sentry.Protocol.Envelopes.ISerializable, System.IDisposable
@@ -1815,8 +1845,10 @@ namespace Sentry.Protocol.Envelopes
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromAttachment(Sentry.SentryAttachment attachment) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromEvent(Sentry.SentryEvent @event) { }
+        public static Sentry.Protocol.Envelopes.EnvelopeItem FromFeedback(Sentry.SentryEvent @event) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public interface ISerializable
diff --git a/test/Sentry.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt b/test/Sentry.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt
index 2a4a0e61a3..67795954b7 100644
--- a/test/Sentry.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt
+++ b/test/Sentry.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt
@@ -237,9 +237,11 @@ namespace Sentry
         Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null);
         bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
+        void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
         void CaptureSession(Sentry.SessionUpdate sessionUpdate);
         void CaptureTransaction(Sentry.SentryTransaction transaction);
         void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint);
+        [System.Obsolete("Use CaptureFeedback instead.")]
         void CaptureUserFeedback(Sentry.UserFeedback userFeedback);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
@@ -461,9 +463,11 @@ namespace Sentry
         public Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null) { }
         public bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent? @event, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void Dispose() { }
         public System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout) { }
@@ -471,7 +475,9 @@ namespace Sentry
     public static class SentryClientExtensions
     {
         public static Sentry.SentryId CaptureException(this Sentry.ISentryClient client, System.Exception ex) { }
+        public static void CaptureFeedback(this Sentry.ISentryClient client, string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(this Sentry.ISentryClient client, string message, Sentry.SentryLevel level = 1) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(this Sentry.ISentryClient client, Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         public static void Flush(this Sentry.ISentryClient client) { }
         public static void Flush(this Sentry.ISentryClient client, System.TimeSpan timeout) { }
@@ -491,6 +497,7 @@ namespace Sentry
         public Sentry.Protocol.Browser Browser { get; }
         public int Count { get; }
         public Sentry.Protocol.Device Device { get; }
+        public Sentry.SentryFeedback? Feedback { get; set; }
         public Sentry.Protocol.Gpu Gpu { get; }
         public bool IsReadOnly { get; }
         public object this[string key] { get; set; }
@@ -549,6 +556,18 @@ namespace Sentry
         public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
         public static Sentry.SentryEvent FromJson(System.Text.Json.JsonElement json) { }
     }
+    public sealed class SentryFeedback : Sentry.ISentryJsonSerializable
+    {
+        public SentryFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default) { }
+        public Sentry.SentryId? AssociatedEventId { get; set; }
+        public string? ContactEmail { get; set; }
+        public string Message { get; set; }
+        public string? Name { get; set; }
+        public string? ReplayId { get; set; }
+        public string? Url { get; set; }
+        public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
+        public static Sentry.SentryFeedback FromJson(System.Text.Json.JsonElement json) { }
+    }
     public class SentryGraphQLHttpMessageHandler : Sentry.SentryMessageHandler
     {
         public SentryGraphQLHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler = null, Sentry.IHub? hub = null) { }
@@ -803,12 +822,16 @@ namespace Sentry
         public static Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public static Sentry.SentryId CaptureException(System.Exception exception) { }
         public static Sentry.SentryId CaptureException(System.Exception exception, System.Action<Sentry.Scope> configureScope) { }
+        public static void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public static void CaptureFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(string message, Sentry.SentryLevel level = 1) { }
         public static Sentry.SentryId CaptureMessage(string message, System.Action<Sentry.Scope> configureScope, Sentry.SentryLevel level = 1) { }
         public static void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         [System.Obsolete("WARNING: This method deliberately causes a crash, and should not be used in a rea" +
             "l application.")]
@@ -1220,6 +1243,7 @@ namespace Sentry
         public Sentry.ISpan StartChild(string operation) { }
         public void UnsetTag(string key) { }
     }
+    [System.Obsolete("Use SentryFeedback instead.")]
     public sealed class UserFeedback : Sentry.ISentryJsonSerializable
     {
         public UserFeedback(Sentry.SentryId eventId, string? name, string? email, string? comments) { }
@@ -1308,9 +1332,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1352,9 +1378,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureException(System.Exception exception) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1796,8 +1824,10 @@ namespace Sentry.Protocol.Envelopes
         public static System.Threading.Tasks.Task<Sentry.Protocol.Envelopes.Envelope> DeserializeAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default) { }
         public static Sentry.Protocol.Envelopes.Envelope FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.Envelope FromEvent(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
+        public static Sentry.Protocol.Envelopes.Envelope FromFeedback(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
         public static Sentry.Protocol.Envelopes.Envelope FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.Envelope FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.Envelope FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public sealed class EnvelopeItem : Sentry.Protocol.Envelopes.ISerializable, System.IDisposable
@@ -1815,8 +1845,10 @@ namespace Sentry.Protocol.Envelopes
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromAttachment(Sentry.SentryAttachment attachment) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromEvent(Sentry.SentryEvent @event) { }
+        public static Sentry.Protocol.Envelopes.EnvelopeItem FromFeedback(Sentry.SentryEvent @event) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public interface ISerializable
diff --git a/test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt b/test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt
index 2730a34f6d..0c06282d34 100644
--- a/test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt
+++ b/test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt
@@ -225,9 +225,11 @@ namespace Sentry
         Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null);
         bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
+        void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null);
         void CaptureSession(Sentry.SessionUpdate sessionUpdate);
         void CaptureTransaction(Sentry.SentryTransaction transaction);
         void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint);
+        [System.Obsolete("Use CaptureFeedback instead.")]
         void CaptureUserFeedback(Sentry.UserFeedback userFeedback);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
@@ -449,9 +451,11 @@ namespace Sentry
         public Sentry.SentryId CaptureCheckIn(string monitorSlug, Sentry.CheckInStatus status, Sentry.SentryId? sentryId = default, System.TimeSpan? duration = default, Sentry.Scope? scope = null, System.Action<Sentry.SentryMonitorOptions>? configureMonitorOptions = null) { }
         public bool CaptureEnvelope(Sentry.Protocol.Envelopes.Envelope envelope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent? @event, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void Dispose() { }
         public System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout) { }
@@ -459,7 +463,9 @@ namespace Sentry
     public static class SentryClientExtensions
     {
         public static Sentry.SentryId CaptureException(this Sentry.ISentryClient client, System.Exception ex) { }
+        public static void CaptureFeedback(this Sentry.ISentryClient client, string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(this Sentry.ISentryClient client, string message, Sentry.SentryLevel level = 1) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(this Sentry.ISentryClient client, Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         public static void Flush(this Sentry.ISentryClient client) { }
         public static void Flush(this Sentry.ISentryClient client, System.TimeSpan timeout) { }
@@ -479,6 +485,7 @@ namespace Sentry
         public Sentry.Protocol.Browser Browser { get; }
         public int Count { get; }
         public Sentry.Protocol.Device Device { get; }
+        public Sentry.SentryFeedback? Feedback { get; set; }
         public Sentry.Protocol.Gpu Gpu { get; }
         public bool IsReadOnly { get; }
         public object this[string key] { get; set; }
@@ -537,6 +544,18 @@ namespace Sentry
         public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
         public static Sentry.SentryEvent FromJson(System.Text.Json.JsonElement json) { }
     }
+    public sealed class SentryFeedback : Sentry.ISentryJsonSerializable
+    {
+        public SentryFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default) { }
+        public Sentry.SentryId? AssociatedEventId { get; set; }
+        public string? ContactEmail { get; set; }
+        public string Message { get; set; }
+        public string? Name { get; set; }
+        public string? ReplayId { get; set; }
+        public string? Url { get; set; }
+        public void WriteTo(System.Text.Json.Utf8JsonWriter writer, Sentry.Extensibility.IDiagnosticLogger? logger) { }
+        public static Sentry.SentryFeedback FromJson(System.Text.Json.JsonElement json) { }
+    }
     public class SentryGraphQLHttpMessageHandler : Sentry.SentryMessageHandler
     {
         public SentryGraphQLHttpMessageHandler(System.Net.Http.HttpMessageHandler? innerHandler = null, Sentry.IHub? hub = null) { }
@@ -784,12 +803,16 @@ namespace Sentry
         public static Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public static Sentry.SentryId CaptureException(System.Exception exception) { }
         public static Sentry.SentryId CaptureException(System.Exception exception, System.Action<Sentry.Scope> configureScope) { }
+        public static void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
+        public static void CaptureFeedback(string message, string? contactEmail = null, string? name = null, string? replayId = null, string? url = null, Sentry.SentryId? associatedEventId = default, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public static Sentry.SentryId CaptureMessage(string message, Sentry.SentryLevel level = 1) { }
         public static Sentry.SentryId CaptureMessage(string message, System.Action<Sentry.Scope> configureScope, Sentry.SentryLevel level = 1) { }
         public static void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public static void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public static void CaptureUserFeedback(Sentry.SentryId eventId, string email, string comments, string? name = null) { }
         [System.Obsolete("WARNING: This method deliberately causes a crash, and should not be used in a rea" +
             "l application.")]
@@ -1201,6 +1224,7 @@ namespace Sentry
         public Sentry.ISpan StartChild(string operation) { }
         public void UnsetTag(string key) { }
     }
+    [System.Obsolete("Use SentryFeedback instead.")]
     public sealed class UserFeedback : Sentry.ISentryJsonSerializable
     {
         public UserFeedback(Sentry.SentryId eventId, string? name, string? email, string? comments) { }
@@ -1289,9 +1313,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback userFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1333,9 +1359,11 @@ namespace Sentry.Extensibility
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.Scope? scope, Sentry.SentryHint? hint = null) { }
         public Sentry.SentryId CaptureEvent(Sentry.SentryEvent evt, Sentry.SentryHint? hint, System.Action<Sentry.Scope> configureScope) { }
         public Sentry.SentryId CaptureException(System.Exception exception) { }
+        public void CaptureFeedback(Sentry.SentryFeedback feedback, Sentry.Scope? scope = null, Sentry.SentryHint? hint = null) { }
         public void CaptureSession(Sentry.SessionUpdate sessionUpdate) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction) { }
         public void CaptureTransaction(Sentry.SentryTransaction transaction, Sentry.Scope? scope, Sentry.SentryHint? hint) { }
+        [System.Obsolete("Use CaptureFeedback instead.")]
         public void CaptureUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
         public void ConfigureScope(System.Action<Sentry.Scope> configureScope) { }
         public System.Threading.Tasks.Task ConfigureScopeAsync(System.Func<Sentry.Scope, System.Threading.Tasks.Task> configureScope) { }
@@ -1778,8 +1806,10 @@ namespace Sentry.Protocol.Envelopes
         public static System.Threading.Tasks.Task<Sentry.Protocol.Envelopes.Envelope> DeserializeAsync(System.IO.Stream stream, System.Threading.CancellationToken cancellationToken = default) { }
         public static Sentry.Protocol.Envelopes.Envelope FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.Envelope FromEvent(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
+        public static Sentry.Protocol.Envelopes.Envelope FromFeedback(Sentry.SentryEvent @event, Sentry.Extensibility.IDiagnosticLogger? logger = null, System.Collections.Generic.IReadOnlyCollection<Sentry.SentryAttachment>? attachments = null, Sentry.SessionUpdate? sessionUpdate = null) { }
         public static Sentry.Protocol.Envelopes.Envelope FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.Envelope FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.Envelope FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public sealed class EnvelopeItem : Sentry.Protocol.Envelopes.ISerializable, System.IDisposable
@@ -1797,8 +1827,10 @@ namespace Sentry.Protocol.Envelopes
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromAttachment(Sentry.SentryAttachment attachment) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromCheckIn(Sentry.SentryCheckIn checkIn) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromEvent(Sentry.SentryEvent @event) { }
+        public static Sentry.Protocol.Envelopes.EnvelopeItem FromFeedback(Sentry.SentryEvent @event) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromSession(Sentry.SessionUpdate sessionUpdate) { }
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromTransaction(Sentry.SentryTransaction transaction) { }
+        [System.Obsolete("Use FromFeedback instead.")]
         public static Sentry.Protocol.Envelopes.EnvelopeItem FromUserFeedback(Sentry.UserFeedback sentryUserFeedback) { }
     }
     public interface ISerializable
diff --git a/test/Sentry.Tests/HubTests.cs b/test/Sentry.Tests/HubTests.cs
index b00cc89e7f..d22326b119 100644
--- a/test/Sentry.Tests/HubTests.cs
+++ b/test/Sentry.Tests/HubTests.cs
@@ -1575,11 +1575,33 @@ public void CaptureEvent_HubEnabled(bool enabled)
         _fixture.Client.Received(enabled ? 1 : 0).CaptureEvent(Arg.Any<SentryEvent>(), Arg.Any<Scope>(), Arg.Any<SentryHint>());
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void CaptureFeedback_HubEnabled(bool enabled)
+    {
+        // Arrange
+        var hub = _fixture.GetSut();
+        if (!enabled)
+        {
+            hub.Dispose();
+        }
+
+        var feedback = new SentryFeedback("Test feedback");
+
+        // Act
+        hub.CaptureFeedback(feedback);
+
+        // Assert
+        _fixture.Client.Received(enabled ? 1 : 0).CaptureFeedback(Arg.Any<SentryFeedback>(), Arg.Any<Scope>(), Arg.Any<SentryHint>());
+    }
+
     [Theory]
     [InlineData(true)]
     [InlineData(false)]
     public void CaptureUserFeedback_HubEnabled(bool enabled)
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         // Arrange
         var hub = _fixture.GetSut();
         if (!enabled)
@@ -1594,6 +1616,7 @@ public void CaptureUserFeedback_HubEnabled(bool enabled)
 
         // Assert
         _fixture.Client.Received(enabled ? 1 : 0).CaptureUserFeedback(Arg.Any<UserFeedback>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Theory]
diff --git a/test/Sentry.Tests/Internals/CollectionExtensionsTests.verify.cs b/test/Sentry.Tests/Internals/CollectionExtensionsTests.verify.cs
index 1a8f5528e6..35d2dcc202 100644
--- a/test/Sentry.Tests/Internals/CollectionExtensionsTests.verify.cs
+++ b/test/Sentry.Tests/Internals/CollectionExtensionsTests.verify.cs
@@ -13,4 +13,50 @@ public Task GetOrCreate_invalid_type()
     private class Value
     {
     }
+
+    [Fact]
+    public void TryGetValue_KeyDoesNotExist_ReturnsNull()
+    {
+        // Arrange
+        var dictionary = new ConcurrentDictionary<string, object>();
+
+        // Act
+        var result = dictionary.TryGetValue<string>("nonexistentKey");
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void TryGetValue_KeyExistsAndTypeMatches_ReturnsValue()
+    {
+        // Arrange
+        var dictionary = new ConcurrentDictionary<string, object>
+        {
+            ["existingKey"] = "testValue"
+        };
+
+        // Act
+        var result = dictionary.TryGetValue<string>("existingKey");
+
+        // Assert
+        result.Should().Be("testValue");
+    }
+
+    [Fact]
+    public void TryGetValue_KeyExistsButTypeDoesNotMatch_Throws()
+    {
+        // Arrange
+        var dictionary = new ConcurrentDictionary<string, object>
+        {
+            ["existingKey"] = 123
+        };
+
+        // Act
+        Action act = () => dictionary.TryGetValue<string>("existingKey");
+
+        // Assert
+        act.Should().Throw<Exception>()
+            .WithMessage("Expected a type of System.String to exist for the key 'existingKey'. Instead found a System.Int32. The likely cause of this is that the value for 'existingKey' has been incorrectly set to an instance of a different type.");
+    }
 }
diff --git a/test/Sentry.Tests/Protocol/Envelopes/EnvelopeTests.cs b/test/Sentry.Tests/Protocol/Envelopes/EnvelopeTests.cs
index 93f28b7379..d1715c54ff 100644
--- a/test/Sentry.Tests/Protocol/Envelopes/EnvelopeTests.cs
+++ b/test/Sentry.Tests/Protocol/Envelopes/EnvelopeTests.cs
@@ -798,6 +798,7 @@ public async Task Roundtrip_WithEvent_WithSession_Success()
     [Fact]
     public async Task Roundtrip_WithUserFeedback_Success()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         // Arrange
         var feedback = new UserFeedback(
             SentryId.Create(),
@@ -817,6 +818,95 @@ public async Task Roundtrip_WithUserFeedback_Success()
 
         // Assert
         envelopeRoundtrip.Should().BeEquivalentTo(envelope);
+#pragma warning restore CS0618 // Type or member is obsolete
+    }
+
+    [Fact]
+    public async Task Roundtrip_WithFeedback_Success()
+    {
+        // Arrange
+        var feedback = new SentryFeedback(
+            "Everything is great!",
+            "foo@bar.com",
+            "Someone Nice",
+            "fake-replay-id",
+            "https://www.example.com",
+            SentryId.Create()
+        );
+        var evt = new SentryEvent
+        {
+            Level = SentryLevel.Info,
+            Contexts =
+            {
+                Feedback = feedback
+            }
+        };
+
+        using var envelope = Envelope.FromFeedback(evt);
+
+        using var stream = new MemoryStream();
+
+        // Act
+        await envelope.SerializeAsync(stream, _testOutputLogger);
+        stream.Seek(0, SeekOrigin.Begin);
+
+        using var envelopeRoundtrip = await Envelope.DeserializeAsync(stream);
+
+        // Assert
+        envelopeRoundtrip.Should().BeEquivalentTo(envelope);
+    }
+
+    [Fact]
+    public void FromFeedback_NoFeedbackContext_Throws()
+    {
+        // Arrange
+        var evt = new SentryEvent { Level = SentryLevel.Info };
+
+        // Act
+        Action act = () => Envelope.FromFeedback(evt);
+
+        // Assert
+        act.Should().Throw<ArgumentException>()
+            .WithMessage("Unable to create envelope - the event does not contain any feedback.");
+    }
+
+    [Fact]
+    public void FromFeedback_MultipleAttachments_LogsWarning()
+    {
+        // Arrange
+        var feedback = new SentryFeedback(
+            "Everything is great!",
+            "foo@bar.com",
+            "Someone Nice",
+            "fake-replay-id",
+            "https://www.example.com",
+            SentryId.Create()
+        );
+        var evt = new SentryEvent
+        {
+            Level = SentryLevel.Info,
+            Contexts =
+            {
+                Feedback = feedback
+            }
+        };
+        var logger = Substitute.For<IDiagnosticLogger>();
+        logger.IsEnabled(Arg.Any<SentryLevel>()).Returns(true);
+
+        List<SentryAttachment> attachments = [
+            AttachmentHelper.FakeAttachment("file1.txt"), AttachmentHelper.FakeAttachment("file2.txt")
+        ];
+
+        // Act
+        using var envelope = Envelope.FromFeedback(evt, logger, attachments);
+
+        // Assert
+        logger.Received(1).Log(
+            SentryLevel.Warning,
+            Arg.Is<string>(m => m.Contains("Feedback can only contain one attachment")),
+            null,
+            Arg.Any<object[]>());
+        envelope.Items.Should().ContainSingle(item => item.TryGetType() == EnvelopeItem.TypeValueAttachment);
     }
 
     [Fact]
diff --git a/test/Sentry.Tests/Protocol/UserFeedbackTests.cs b/test/Sentry.Tests/Protocol/UserFeedbackTests.cs
index 2e12f56b0a..5358773067 100644
--- a/test/Sentry.Tests/Protocol/UserFeedbackTests.cs
+++ b/test/Sentry.Tests/Protocol/UserFeedbackTests.cs
@@ -12,6 +12,7 @@ public UserFeedbackTests(ITestOutputHelper output)
     [Fact]
     public void Serialization_SentryUserFeedbacks_Success()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         // Arrange
         var eventId = new SentryId(Guid.Parse("acbe351c61494e7b807fd7e82a435ffc"));
         var userFeedback = new UserFeedback(eventId, "myName", "myEmail@service.com", "my comment");
@@ -30,5 +31,6 @@ public void Serialization_SentryUserFeedbacks_Success()
             }
             """,
             actual);
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 }
diff --git a/test/Sentry.Tests/SentryClientExtensionsTests.cs b/test/Sentry.Tests/SentryClientExtensionsTests.cs
index 9210c7c62f..cb73d048ba 100644
--- a/test/Sentry.Tests/SentryClientExtensionsTests.cs
+++ b/test/Sentry.Tests/SentryClientExtensionsTests.cs
@@ -81,18 +81,22 @@ public void CaptureMessage_NullMessage_DoesNotCapturesEventWithMessage()
     [Fact]
     public void CaptureUserFeedback_EnabledClient_CapturesUserFeedback()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         _ = _sut.IsEnabled.Returns(true);
         _sut.CaptureUserFeedback(Guid.Parse("1ec19311a7c048818de80b18dcc43eaa"), "email@email.com", "comments");
         _sut.Received(1).CaptureUserFeedback(Arg.Any<UserFeedback>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Fact]
     public void CaptureUserFeedback_DisabledClient_DoesNotCaptureUserFeedback()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         _ = _sut.IsEnabled.Returns(false);
         _sut.CaptureUserFeedback(Guid.Parse("1ec19311a7c048818de80b18dcc43eea"), "email@email.com", "comments");
 
         _sut.DidNotReceive().CaptureUserFeedback(Arg.Any<UserFeedback>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Fact]
diff --git a/test/Sentry.Tests/SentryClientTests.cs b/test/Sentry.Tests/SentryClientTests.cs
index dccaf26882..6b85c74de9 100644
--- a/test/Sentry.Tests/SentryClientTests.cs
+++ b/test/Sentry.Tests/SentryClientTests.cs
@@ -799,6 +799,7 @@ public void CaptureEvent_DisposedClient_DoesNotThrow()
     [Fact]
     public void CaptureUserFeedback_EventIdEmpty_IgnoreUserFeedback()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         //Arrange
         var sut = _fixture.GetSut();
 
@@ -808,11 +809,13 @@ public void CaptureUserFeedback_EventIdEmpty_IgnoreUserFeedback()
 
         //Assert
         _ = sut.Worker.DidNotReceive().EnqueueEnvelope(Arg.Any<Envelope>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Fact]
     public void CaptureUserFeedback_ValidUserFeedback_FeedbackRegistered()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         //Arrange
         var sut = _fixture.GetSut();
 
@@ -822,11 +825,13 @@ public void CaptureUserFeedback_ValidUserFeedback_FeedbackRegistered()
 
         //Assert
         _ = sut.Worker.Received(1).EnqueueEnvelope(Arg.Any<Envelope>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Fact]
     public void CaptureUserFeedback_EventIdEmpty_FeedbackIgnored()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         //Arrange
         var sut = _fixture.GetSut();
 
@@ -835,7 +840,9 @@ public void CaptureUserFeedback_EventIdEmpty_FeedbackIgnored()
 
         //Assert
         _ = sut.Worker.DidNotReceive().EnqueueEnvelope(Arg.Any<Envelope>());
+#pragma warning restore CS0618 // Type or member is obsolete
     }
+
     [Fact]
     public void Dispose_should_only_flush()
     {
@@ -849,12 +856,101 @@ public void Dispose_should_only_flush()
         client.CaptureEvent(new SentryEvent { Message = "Test" });
     }
 
+    [Fact]
+    public void CaptureFeedback_DisposedClient_DoesNotThrow()
+    {
+        // Arrange
+        var feedback = new SentryFeedback("Everything is great!");
+
+        var sut = _fixture.GetSut();
+        sut.Dispose();
+
+        // Act / Assert
+        sut.CaptureFeedback(feedback);
+    }
+
+    [Fact]
+    public void CaptureFeedback_NoMessage_FeedbackIgnored()
+    {
+        //Arrange
+        var sut = _fixture.GetSut();
+        var feedback = new SentryFeedback(string.Empty);
+
+        //Act
+        sut.CaptureFeedback(feedback);
+
+        //Assert
+        _ = sut.Worker.DidNotReceive().EnqueueEnvelope(Arg.Any<Envelope>());
+    }
+
+    [Fact]
+    public void CaptureFeedback_ValidUserFeedback_FeedbackRegistered()
+    {
+        //Arrange
+        var sut = _fixture.GetSut();
+        var feedback = new SentryFeedback("Everything is great!");
+
+        //Act
+        sut.CaptureFeedback(feedback);
+
+        //Assert
+        _ = sut.Worker.Received(1).EnqueueEnvelope(Arg.Any<Envelope>());
+    }
+
+    [Fact]
+    public void CaptureFeedback_WithScope_ScopeCopiedToEvent()
+    {
+        //Arrange
+        const string expectedBreadcrumb = "test";
+        var scope = new Scope(_fixture.SentryOptions);
+        scope.AddBreadcrumb(expectedBreadcrumb);
+        scope.Level = SentryLevel.Warning;
+        var feedback = new SentryFeedback("Everything is great!");
+        var sut = _fixture.GetSut();
+
+        Envelope envelope = null;
+        sut.Worker.When(w => w.EnqueueEnvelope(Arg.Any<Envelope>()))
+            .Do(callback => envelope = callback.Arg<Envelope>());
+
+        //Act
+        sut.CaptureFeedback(feedback, scope);
+
+        //Assert
+        _ = sut.Worker.Received(1).EnqueueEnvelope(Arg.Any<Envelope>());
+        envelope.Should().NotBeNull();
+        envelope.Items.Should().Contain(item => item.TryGetType() == EnvelopeItem.TypeValueFeedback);
+        var item = envelope.Items.First(x => x.TryGetType() == EnvelopeItem.TypeValueFeedback);
+        var @event = (SentryEvent)((JsonSerializable)item.Payload).Source;
+        @event.Level.Should().Be(scope.Level);
+        Assert.Equal(scope.Breadcrumbs, @event.Breadcrumbs);
+    }
+
+    [Fact]
+    public void CaptureFeedback_WithHint_HasHintAttachment()
+    {
+        //Arrange
+        var sut = _fixture.GetSut();
+        var feedback = new SentryFeedback("Everything is great!");
+        var hint = new SentryHint();
+        hint.Attachments.Add(AttachmentHelper.FakeAttachment("foo.txt"));
+
+        //Act
+        sut.CaptureFeedback(feedback, null, hint);
+
+        //Assert
+        _ = sut.Worker.Received(1).EnqueueEnvelope(Arg.Any<Envelope>());
+        sut.Worker.Received(1).EnqueueEnvelope(Arg.Is<Envelope>(envelope =>
+            envelope.Items.Count(item => item.TryGetType() == "attachment") == 1));
+    }
+
     [Fact]
     public void CaptureUserFeedback_DisposedClient_DoesNotThrow()
     {
+#pragma warning disable CS0618 // Type or member is obsolete
         var sut = _fixture.GetSut();
         sut.Dispose();
         sut.CaptureUserFeedback(new UserFeedback(SentryId.Empty, "name", "email", "comment"));
+#pragma warning restore CS0618 // Type or member is obsolete
     }
 
     [Fact]