diff --git a/InertiaCore/Response.cs b/InertiaCore/Response.cs
index 7bdd2cb..2082a03 100644
--- a/InertiaCore/Response.cs
+++ b/InertiaCore/Response.cs
@@ -4,6 +4,7 @@
 using InertiaCore.Models;
 using InertiaCore.Props;
 using InertiaCore.Utils;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 using Microsoft.AspNetCore.Mvc.ViewFeatures;
@@ -60,9 +61,10 @@ protected internal async Task ProcessResponse()
         var props = _props;
 
         props = ResolveSharedProps(props);
+        props = ResolveInertiaPropertyProviders(props);
         props = ResolvePartialProperties(props);
         props = ResolveAlways(props);
-        props = await ResolvePropertyInstances(props);
+        props = await ResolvePropertyInstances(props, _context!.HttpContext.Request);
 
         return props;
     }
@@ -79,6 +81,32 @@ protected internal async Task ProcessResponse()
         return props;
     }
 
+    /// <summary>
+    /// Resolve properties from objects implementing ProvidesInertiaProperties.
+    /// </summary>
+    private Dictionary<string, object?> ResolveInertiaPropertyProviders(Dictionary<string, object?> props)
+    {
+        var context = new RenderContext(_component, _context!.HttpContext.Request);
+
+        foreach (var pair in props.ToList())
+        {
+            if (pair.Value is ProvidesInertiaProperties provider)
+            {
+                // Remove the provider object itself
+                props.Remove(pair.Key);
+
+                // Add the properties it provides
+                var providedProps = provider.ToInertiaProperties(context);
+                foreach (var providedProp in providedProps)
+                {
+                    props[providedProp.Key] = providedProp.Value;
+                }
+            }
+        }
+
+        return props;
+    }
+
     /// <summary>
     /// Resolve the `only` and `except` partial request props.
     /// </summary>
@@ -147,7 +175,7 @@ protected internal async Task ProcessResponse()
     /// <summary>
     /// Resolve all necessary class instances in the given props.
     /// </summary>
-    private static async Task<Dictionary<string, object?>> ResolvePropertyInstances(Dictionary<string, object?> props)
+    private static async Task<Dictionary<string, object?>> ResolvePropertyInstances(Dictionary<string, object?> props, HttpRequest request)
     {
         return (await Task.WhenAll(props.Select(async pair =>
         {
@@ -158,12 +186,13 @@ protected internal async Task ProcessResponse()
                 Func<object?> f => (key, await f.ResolveAsync()),
                 Task t => (key, await t.ResolveResult()),
                 InvokableProp p => (key, await p.Invoke()),
+                ProvidesInertiaProperty pip => (key, pip.ToInertiaProperty(new PropertyContext(key, props, request))),
                 _ => (key, pair.Value)
             };
 
             if (value.Item2 is Dictionary<string, object?> dict)
             {
-                value = (key, await ResolvePropertyInstances(dict));
+                value = (key, await ResolvePropertyInstances(dict, request));
             }
 
             return value;
@@ -218,4 +247,74 @@ public Response WithViewData(IDictionary<string, object> viewData)
         _viewData = viewData;
         return this;
     }
+
+    /// <summary>
+    /// Add additional properties to the page.
+    /// </summary>
+    /// <param name="key">The property key, a dictionary of properties, or a ProvidesInertiaProperties object</param>
+    /// <param name="value">The property value (only used when key is a string)</param>
+    /// <returns>The Response instance for method chaining</returns>
+    public Response With(string key, object? value)
+    {
+        _props[key] = value;
+        return this;
+    }
+
+    /// <summary>
+    /// Add additional properties to the page from a dictionary.
+    /// </summary>
+    /// <param name="properties">Dictionary of properties to add</param>
+    /// <returns>The Response instance for method chaining</returns>
+    public Response With(IDictionary<string, object?> properties)
+    {
+        foreach (var kvp in properties)
+        {
+            _props[kvp.Key] = kvp.Value;
+        }
+        return this;
+    }
+
+    /// <summary>
+    /// Add additional properties to the page from a ProvidesInertiaProperties object.
+    /// </summary>
+    /// <param name="provider">The property provider</param>
+    /// <returns>The Response instance for method chaining</returns>
+    public Response With(ProvidesInertiaProperties provider)
+    {
+        // Generate a unique key for the provider
+        var providerKey = $"__provider_{Guid.NewGuid():N}";
+        _props[providerKey] = provider;
+        return this;
+    }
+
+    /// <summary>
+    /// Add additional properties to the page from an anonymous object.
+    /// </summary>
+    /// <param name="properties">Anonymous object with properties to add</param>
+    /// <returns>The Response instance for method chaining</returns>
+    public Response With(object properties)
+    {
+        if (properties == null) return this;
+
+        if (properties is IDictionary<string, object?> dict)
+        {
+            return With(dict);
+        }
+
+        if (properties is ProvidesInertiaProperties provider)
+        {
+            return With(provider);
+        }
+
+        // Convert anonymous object to dictionary
+        var props = properties.GetType().GetProperties()
+            .ToDictionary(p => p.Name, p => p.GetValue(properties));
+
+        foreach (var kvp in props)
+        {
+            _props[kvp.Key] = kvp.Value;
+        }
+
+        return this;
+    }
 }
diff --git a/InertiaCore/Utils/PropertyContext.cs b/InertiaCore/Utils/PropertyContext.cs
new file mode 100644
index 0000000..6c0acfd
--- /dev/null
+++ b/InertiaCore/Utils/PropertyContext.cs
@@ -0,0 +1,37 @@
+using Microsoft.AspNetCore.Http;
+
+namespace InertiaCore.Utils;
+
+/// <summary>
+/// Provides context information for individual property transformation.
+/// </summary>
+public class PropertyContext
+{
+    /// <summary>
+    /// The key of the property being transformed.
+    /// </summary>
+    public string Key { get; }
+
+    /// <summary>
+    /// All properties in the response.
+    /// </summary>
+    public Dictionary<string, object?> Props { get; }
+
+    /// <summary>
+    /// The current HTTP request.
+    /// </summary>
+    public HttpRequest Request { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the PropertyContext class.
+    /// </summary>
+    /// <param name="key">The property key</param>
+    /// <param name="props">All properties</param>
+    /// <param name="request">The HTTP request</param>
+    public PropertyContext(string key, Dictionary<string, object?> props, HttpRequest request)
+    {
+        Key = key;
+        Props = props;
+        Request = request;
+    }
+}
\ No newline at end of file
diff --git a/InertiaCore/Utils/ProvidesInertiaProperties.cs b/InertiaCore/Utils/ProvidesInertiaProperties.cs
new file mode 100644
index 0000000..2f29b59
--- /dev/null
+++ b/InertiaCore/Utils/ProvidesInertiaProperties.cs
@@ -0,0 +1,16 @@
+using System.Collections;
+
+namespace InertiaCore.Utils;
+
+/// <summary>
+/// Interface for objects that can provide dynamic Inertia properties.
+/// </summary>
+public interface ProvidesInertiaProperties
+{
+    /// <summary>
+    /// Generates Inertia properties based on the current render context.
+    /// </summary>
+    /// <param name="context">The render context containing component name and request information</param>
+    /// <returns>An enumerable of key-value pairs representing the properties</returns>
+    IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context);
+}
\ No newline at end of file
diff --git a/InertiaCore/Utils/ProvidesInertiaProperty.cs b/InertiaCore/Utils/ProvidesInertiaProperty.cs
new file mode 100644
index 0000000..2911625
--- /dev/null
+++ b/InertiaCore/Utils/ProvidesInertiaProperty.cs
@@ -0,0 +1,14 @@
+namespace InertiaCore.Utils;
+
+/// <summary>
+/// Interface for objects that can transform themselves into an Inertia property value.
+/// </summary>
+public interface ProvidesInertiaProperty
+{
+    /// <summary>
+    /// Transforms the object into an Inertia property value based on the given context.
+    /// </summary>
+    /// <param name="context">The property context containing key, props, and request information</param>
+    /// <returns>The transformed property value</returns>
+    object? ToInertiaProperty(PropertyContext context);
+}
\ No newline at end of file
diff --git a/InertiaCore/Utils/RenderContext.cs b/InertiaCore/Utils/RenderContext.cs
new file mode 100644
index 0000000..6a9eeee
--- /dev/null
+++ b/InertiaCore/Utils/RenderContext.cs
@@ -0,0 +1,30 @@
+using Microsoft.AspNetCore.Http;
+
+namespace InertiaCore.Utils;
+
+/// <summary>
+/// Provides context information for Inertia property generation.
+/// </summary>
+public class RenderContext
+{
+    /// <summary>
+    /// The name of the component being rendered.
+    /// </summary>
+    public string Component { get; }
+
+    /// <summary>
+    /// The current HTTP request.
+    /// </summary>
+    public HttpRequest Request { get; }
+
+    /// <summary>
+    /// Initializes a new instance of the RenderContext class.
+    /// </summary>
+    /// <param name="component">The component name</param>
+    /// <param name="request">The HTTP request</param>
+    public RenderContext(string component, HttpRequest request)
+    {
+        Component = component;
+        Request = request;
+    }
+}
\ No newline at end of file
diff --git a/InertiaCoreTests/UnitTestInertiaPropertyProviders.cs b/InertiaCoreTests/UnitTestInertiaPropertyProviders.cs
new file mode 100644
index 0000000..23cfb95
--- /dev/null
+++ b/InertiaCoreTests/UnitTestInertiaPropertyProviders.cs
@@ -0,0 +1,261 @@
+using InertiaCore.Models;
+using InertiaCore.Utils;
+using Microsoft.AspNetCore.Http;
+
+namespace InertiaCoreTests;
+
+public partial class Tests
+{
+    [Test]
+    [Description("Test if ProvidesInertiaProperties interface works correctly.")]
+    public async Task TestInertiaPropertyProvider()
+    {
+        var provider = new TestPropertyProvider();
+
+        var response = _factory.Render("Test/Page", new
+        {
+            Test = "Test",
+            Provider = provider
+        });
+
+        var context = PrepareContext();
+
+        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" },
+            { "user", "John Doe" },
+            { "permissions", new List<string> { "read", "write" } },
+            { "component", "Test/Page" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if multiple ProvidesInertiaProperties objects work together.")]
+    public async Task TestMultipleInertiaPropertyProviders()
+    {
+        var userProvider = new UserPropertyProvider();
+        var settingsProvider = new SettingsPropertyProvider();
+
+        var response = _factory.Render("Dashboard/Index", new
+        {
+            Test = "Test",
+            UserProvider = userProvider,
+            SettingsProvider = settingsProvider
+        });
+
+        var context = PrepareContext();
+
+        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" },
+            { "user", "Alice" },
+            { "role", "admin" },
+            { "theme", "dark" },
+            { "language", "en" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if ProvidesInertiaProperties receives correct RenderContext.")]
+    public async Task TestInertiaPropertyProviderContext()
+    {
+        var provider = new ContextAwarePropertyProvider();
+
+        var response = _factory.Render("User/Profile", new
+        {
+            Provider = provider
+        });
+
+        var headers = new HeaderDictionary
+        {
+            { "X-Custom-Header", "test-value" }
+        };
+
+        var context = PrepareContext(headers);
+
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "component", "User/Profile" },
+            { "hasCustomHeader", true },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if ProvidesInertiaProperty interface works correctly.")]
+    public async Task TestSingleInertiaPropertyProvider()
+    {
+        var provider = new TestInertiaPropertyProvider();
+
+        var response = _factory.Render("Test/Page", new
+        {
+            Test = "Test",
+            PropertyProvider = provider
+        });
+
+        var context = PrepareContext();
+
+        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" },
+            { "propertyProvider", "Transformed: " },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if ProvidesInertiaProperty receives correct PropertyContext.")]
+    public async Task TestSingleInertiaPropertyProviderWithContext()
+    {
+        var provider = new ContextAwareInertiaPropertyProvider();
+
+        var response = _factory.Render("User/Profile", new
+        {
+            InitialProp = "initial",
+            ContextProvider = provider
+        });
+
+        var headers = new HeaderDictionary
+        {
+            { "Authorization", "Bearer token123" }
+        };
+
+        var context = PrepareContext(headers);
+
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initialProp", "initial" },
+            { "contextProvider", "contextProvider::True" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test if multiple ProvidesInertiaProperty objects work correctly.")]
+    public async Task TestMultipleSingleInertiaPropertyProviders()
+    {
+        var provider1 = new SimpleInertiaPropertyProvider("Value1");
+        var provider2 = new SimpleInertiaPropertyProvider("Value2");
+
+        var response = _factory.Render("Dashboard/Index", new
+        {
+            Test = "Test",
+            Provider1 = provider1,
+            Provider2 = provider2
+        });
+
+        var context = PrepareContext();
+
+        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" },
+            { "provider1", "Processed: Value1" },
+            { "provider2", "Processed: Value2" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+}
+
+// Test implementations of ProvidesInertiaProperties
+internal class TestPropertyProvider : ProvidesInertiaProperties
+{
+    public IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context)
+    {
+        yield return new KeyValuePair<string, object?>("user", "John Doe");
+        yield return new KeyValuePair<string, object?>("permissions", new List<string> { "read", "write" });
+        yield return new KeyValuePair<string, object?>("component", context.Component);
+    }
+}
+
+internal class UserPropertyProvider : ProvidesInertiaProperties
+{
+    public IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context)
+    {
+        yield return new KeyValuePair<string, object?>("user", "Alice");
+        yield return new KeyValuePair<string, object?>("role", "admin");
+    }
+}
+
+internal class SettingsPropertyProvider : ProvidesInertiaProperties
+{
+    public IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context)
+    {
+        yield return new KeyValuePair<string, object?>("theme", "dark");
+        yield return new KeyValuePair<string, object?>("language", "en");
+    }
+}
+
+internal class ContextAwarePropertyProvider : ProvidesInertiaProperties
+{
+    public IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context)
+    {
+        yield return new KeyValuePair<string, object?>("component", context.Component);
+        yield return new KeyValuePair<string, object?>("hasCustomHeader",
+            context.Request.Headers.ContainsKey("X-Custom-Header"));
+    }
+}
+
+// Test implementations of ProvidesInertiaProperty
+internal class TestInertiaPropertyProvider : ProvidesInertiaProperty
+{
+    public object? ToInertiaProperty(PropertyContext context)
+    {
+        return $"Transformed: {context.Request.Path}";
+    }
+}
+
+internal class ContextAwareInertiaPropertyProvider : ProvidesInertiaProperty
+{
+    public object? ToInertiaProperty(PropertyContext context)
+    {
+        var hasAuth = context.Request.Headers.ContainsKey("Authorization");
+        return $"{context.Key}:{context.Request.Path}:{hasAuth}";
+    }
+}
+
+internal class SimpleInertiaPropertyProvider : ProvidesInertiaProperty
+{
+    private readonly string _value;
+
+    public SimpleInertiaPropertyProvider(string value)
+    {
+        _value = value;
+    }
+
+    public object? ToInertiaProperty(PropertyContext context)
+    {
+        return $"Processed: {_value}";
+    }
+}
\ No newline at end of file
diff --git a/InertiaCoreTests/UnitTestResponseWith.cs b/InertiaCoreTests/UnitTestResponseWith.cs
new file mode 100644
index 0000000..04440a3
--- /dev/null
+++ b/InertiaCoreTests/UnitTestResponseWith.cs
@@ -0,0 +1,221 @@
+using InertiaCore.Models;
+using InertiaCore.Utils;
+
+namespace InertiaCoreTests;
+
+public partial class Tests
+{
+    [Test]
+    [Description("Test With method adding a single property.")]
+    public async Task TestResponseWithSingleProperty()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        response.With("Additional", "Property");
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "additional", "Property" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test With method adding multiple properties from dictionary.")]
+    public async Task TestResponseWithDictionary()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        var additionalProps = new Dictionary<string, object?>
+        {
+            { "Property1", "Value1" },
+            { "Property2", 42 },
+            { "Property3", true }
+        };
+
+        response.With(additionalProps);
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "property1", "Value1" },
+            { "property2", 42 },
+            { "property3", true },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test With method adding properties from anonymous object.")]
+    public async Task TestResponseWithAnonymousObject()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        response.With(new
+        {
+            Property1 = "Value1",
+            Property2 = 42,
+            Property3 = true
+        });
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "property1", "Value1" },
+            { "property2", 42 },
+            { "property3", true },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test With method adding ProvidesInertiaProperties object.")]
+    public async Task TestResponseWithPropertyProvider()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        var provider = new TestPropertyProviderForWith();
+        response.With(provider);
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "providedUser", "Jane Doe" },
+            { "providedRole", "admin" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test fluent chaining of With method.")]
+    public async Task TestResponseWithFluentChaining()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        response
+            .With("Property1", "Value1")
+            .With(new { Property2 = 42 })
+            .With(new Dictionary<string, object?> { { "Property3", true } });
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "property1", "Value1" },
+            { "property2", 42 },
+            { "property3", true },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test With method overwriting existing property.")]
+    public async Task TestResponseWithOverwriteProperty()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value",
+            ToOverwrite = "OldValue"
+        });
+
+        response.With("ToOverwrite", "NewValue");
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "toOverwrite", "NewValue" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+
+    [Test]
+    [Description("Test With method combined with WithViewData.")]
+    public async Task TestResponseWithAndViewData()
+    {
+        var response = _factory.Render("Test/Page", new
+        {
+            Initial = "Value"
+        });
+
+        response
+            .With("AdditionalProp", "AdditionalValue")
+            .WithViewData(new Dictionary<string, object>
+            {
+                { "ViewDataKey", "ViewDataValue" }
+            });
+
+        var context = PrepareContext();
+        response.SetContext(context);
+        await response.ProcessResponse();
+
+        var page = response.GetJson().Value as Page;
+
+        Assert.That(page?.Props, Is.EqualTo(new Dictionary<string, object?>
+        {
+            { "initial", "Value" },
+            { "additionalProp", "AdditionalValue" },
+            { "errors", new Dictionary<string, string>(0) }
+        }));
+    }
+}
+
+// Test property provider for With method tests
+internal class TestPropertyProviderForWith : ProvidesInertiaProperties
+{
+    public IEnumerable<KeyValuePair<string, object?>> ToInertiaProperties(RenderContext context)
+    {
+        yield return new KeyValuePair<string, object?>("providedUser", "Jane Doe");
+        yield return new KeyValuePair<string, object?>("providedRole", "admin");
+    }
+}
\ No newline at end of file