diff --git a/InertiaCore/Inertia.cs b/InertiaCore/Inertia.cs
index d13b932..1334629 100644
--- a/InertiaCore/Inertia.cs
+++ b/InertiaCore/Inertia.cs
@@ -31,6 +31,8 @@ public static class Inertia
 
     public static void Share(IDictionary<string, object?> data) => _factory.Share(data);
 
+    public static void FlushShared() => _factory.FlushShared();
+
     public static AlwaysProp Always(string value) => _factory.Always(value);
 
     public static AlwaysProp Always(Func<string> callback) => _factory.Always(callback);
diff --git a/InertiaCore/ResponseFactory.cs b/InertiaCore/ResponseFactory.cs
index ad57af9..b58678e 100644
--- a/InertiaCore/ResponseFactory.cs
+++ b/InertiaCore/ResponseFactory.cs
@@ -22,6 +22,7 @@ internal interface IResponseFactory
     public LocationResult Location(string url);
     public void Share(string key, object? value);
     public void Share(IDictionary<string, object?> data);
+    public void FlushShared();
     public AlwaysProp Always(object? value);
     public AlwaysProp Always(Func<object?> callback);
     public AlwaysProp Always(Func<Task<object?>> callback);
@@ -131,6 +132,17 @@ public void Share(IDictionary<string, object?> data)
         context.Features.Set(sharedData);
     }
 
+    public void FlushShared()
+    {
+        var context = _contextAccessor.HttpContext!;
+
+        var sharedData = context.Features.Get<InertiaSharedProps>();
+        if (sharedData != null)
+        {
+            sharedData.Clear();
+        }
+    }
+
     public LazyProp Lazy(Func<object?> callback) => new(callback);
     public LazyProp Lazy(Func<Task<object?>> callback) => new(callback);
     public AlwaysProp Always(object? value) => new(value);
diff --git a/InertiaCore/Utils/InertiaSharedProps.cs b/InertiaCore/Utils/InertiaSharedProps.cs
index 68b9bbd..e091ccb 100644
--- a/InertiaCore/Utils/InertiaSharedProps.cs
+++ b/InertiaCore/Utils/InertiaSharedProps.cs
@@ -26,4 +26,9 @@ public void Set(string key, object? value)
         Data ??= new Dictionary<string, object?>();
         Data[key.ToCamelCase()] = value;
     }
+
+    public void Clear()
+    {
+        Data = null;
+    }
 }
diff --git a/InertiaCoreTests/UnitTestSharedData.cs b/InertiaCoreTests/UnitTestSharedData.cs
index fc64336..1034cd3 100644
--- a/InertiaCoreTests/UnitTestSharedData.cs
+++ b/InertiaCoreTests/UnitTestSharedData.cs
@@ -31,4 +31,53 @@ public async Task TestSharedProps()
             { "errors", new Dictionary<string, string>(0) }
         }));
     }
+
+    [Test]
+    [Description("Test if FlushShared clears all shared data properly.")]
+    public async Task TestFlushShared()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Test = "Test"
+        });
+
+        var sharedProps = new InertiaSharedProps();
+        sharedProps.Set("TestShared", "Shared");
+        sharedProps.Set("AnotherShared", "AnotherValue");
+
+        var context = PrepareContext(null, sharedProps);
+
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "test", "Test" },
+            { "testShared", "Shared" },
+            { "anotherShared", "AnotherValue" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+
+        sharedProps.Clear();
+
+        var responseAfterFlush = _factory.Render("Test/Page", new
+        {
+            Test = "Test"
+        });
+
+        var contextAfterFlush = PrepareContext(null, sharedProps);
+
+        responseAfterFlush.SetContext(contextAfterFlush);
+        await responseAfterFlush.ProcessResponse();
+
+        var pageAfterFlush = responseAfterFlush.GetJson().Value as Page;
+
+        Assert.That(pageAfterFlush?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "test", "Test" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
 }