diff --git a/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs b/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs
index dcf6a329..4a6319aa 100644
--- a/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs
+++ b/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs
@@ -1678,14 +1678,70 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
                 propertyOrFieldType = fieldInfo.FieldType;
             }
 
-            // Call Promote and if that returns false, just try to convert the expression to the destination type using Expression.Convert
-            var promoted = _parsingConfig.ExpressionPromoter.Promote(expressions[i], propertyOrFieldType, true, true) ?? Expression.Convert(expressions[i], propertyOrFieldType);
-            memberBindings[i] = Expression.Bind(memberInfo, promoted);
+            // Call Promote and if that returns null, try to rebuild a nested MemberInitExpression for the target type,
+            // and if that also fails, try to convert the expression to the destination type using Expression.Convert.
+            var promoted = _parsingConfig.ExpressionPromoter.Promote(expressions[i], propertyOrFieldType, true, true);
+            if (promoted == null && expressions[i] is MemberInitExpression memberInitExpression &&
+                TryRebuildMemberInitExpression(memberInitExpression, propertyOrFieldType, out var rebuilt))
+            {
+                promoted = rebuilt;
+            }
+            memberBindings[i] = Expression.Bind(memberInfo, promoted ?? Expression.Convert(expressions[i], propertyOrFieldType));
         }
 
         return Expression.MemberInit(Expression.New(type), memberBindings);
     }
 
+    private static bool TryRebuildMemberInitExpression(MemberInitExpression memberInitExpression, Type targetType, [NotNullWhen(true)] out Expression? expression)
+    {
+        expression = null;
+
+        var defaultConstructor = targetType.GetConstructor(Type.EmptyTypes);
+        if (defaultConstructor == null)
+        {
+            return false;
+        }
+
+        var newBindings = new MemberBinding[memberInitExpression.Bindings.Count];
+        for (var i = 0; i < memberInitExpression.Bindings.Count; i++)
+        {
+            if (memberInitExpression.Bindings[i] is not MemberAssignment assignment)
+            {
+                return false;
+            }
+
+            var memberName = assignment.Member.Name;
+            MemberInfo? targetMember = targetType.GetProperty(memberName) ?? (MemberInfo?)targetType.GetField(memberName);
+            if (targetMember == null)
+            {
+                return false;
+            }
+
+            var targetMemberType = targetMember is PropertyInfo targetPropertyInfo
+                ? targetPropertyInfo.PropertyType
+                : ((FieldInfo)targetMember).FieldType;
+
+            var bindingExpression = assignment.Expression;
+            if (bindingExpression is MemberInitExpression nestedMemberInit && bindingExpression.Type != targetMemberType)
+            {
+                if (!TryRebuildMemberInitExpression(nestedMemberInit, targetMemberType, out var rebuiltNested))
+                {
+                    return false;
+                }
+                bindingExpression = rebuiltNested;
+            }
+            else if (bindingExpression.Type != targetMemberType)
+            {
+                bindingExpression = Expression.Convert(bindingExpression, targetMemberType);
+            }
+
+            newBindings[i] = Expression.Bind(targetMember, bindingExpression);
+        }
+
+        expression = Expression.MemberInit(Expression.New(targetType), newBindings);
+        return true;
+    }
+
     private Expression ParseLambdaInvocation(LambdaExpression lambda)
     {
         int errorPos = _textParser.CurrentToken.Pos;
diff --git a/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs b/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs
index b24a2bd2..4417d1a0 100644
--- a/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs
+++ b/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs
@@ -2303,6 +2303,68 @@ public void DynamicExpressionParser_ParseLambda_LambdaParameter_SameNameAsDynami
         DynamicExpressionParser.ParseLambda<bool>(new ParsingConfig(), false, "new[]{1,2,3}.Any(z => z > 0)");
     }
 
+    // https://github.com/zzzprojects/System.Linq.Dynamic.Core/issues/701
+    [Fact]
+    public void DynamicExpressionParser_ParseLambda_NestedObjectInitialization()
+    {
+        // Arrange
+        var srcType = typeof(CustomerForNestedNewTest);
+
+        // Act
+        var lambda = DynamicExpressionParser.ParseLambda(ParsingConfig.DefaultEFCore21, srcType, srcType, "new (new (3 as Id) as CurrentDepartment)");
+        var @delegate = lambda.Compile();
+        var result = (CustomerForNestedNewTest)@delegate.DynamicInvoke(new CustomerForNestedNewTest())!;
+
+        // Assert
+        result.Should().NotBeNull();
+        result.CurrentDepartment.Should().NotBeNull();
+        result.CurrentDepartment!.Id.Should().Be(3);
+    }
+
+    // https://github.com/zzzprojects/System.Linq.Dynamic.Core/issues/701
+    [Fact]
+    public void DynamicExpressionParser_ParseLambda_NestedObjectInitialization_ThreeLevelsDeep()
+    {
+        // Arrange — exercises the recursive TryRebuildMemberInitExpression path.
+        // The parser propagates _resultType (CustomerForNestedNewTest) into all nested new
+        // expressions. The middle "new (new (3 as Id) as Sub)" therefore builds a
+        // MIE<Customer>{ Sub = MIE<Department>{Id=3} }.  When the outer new binds that to its own
+        // "Sub" property (type DepartmentForNestedNewTest), TryRebuildMemberInitExpression is
+        // called and encounters the inner MIE<Department>{Id=3} binding — a MemberInitExpression
+        // itself — which triggers the recursive call to rebuild it for SubDepartmentForNestedNewTest.
+        var srcType = typeof(CustomerForNestedNewTest);
+
+        // Act
+        var lambda = DynamicExpressionParser.ParseLambda(ParsingConfig.DefaultEFCore21, srcType, srcType,
+            "new (new (new (3 as Id) as Sub) as Sub)");
+        var @delegate = lambda.Compile();
+        var result = (CustomerForNestedNewTest)@delegate.DynamicInvoke(new CustomerForNestedNewTest())!;
+
+        // Assert
+        result.Should().NotBeNull();
+        result.Sub.Should().NotBeNull();
+        result.Sub!.Sub.Should().NotBeNull();
+        result.Sub.Sub!.Id.Should().Be(3);
+    }
+
+    public class CustomerForNestedNewTest
+    {
+        public int Id { get; set; }
+        public DepartmentForNestedNewTest? CurrentDepartment { get; set; }
+        public DepartmentForNestedNewTest? Sub { get; set; }
+    }
+
+    public class DepartmentForNestedNewTest
+    {
+        public int Id { get; set; }
+        public SubDepartmentForNestedNewTest? Sub { get; set; }
+    }
+
+    public class SubDepartmentForNestedNewTest
+    {
+        public int Id { get; set; }
+    }
+
     public class DefaultDynamicLinqCustomTypeProviderForGenericExtensionMethod : DefaultDynamicLinqCustomTypeProvider
     {
         public DefaultDynamicLinqCustomTypeProviderForGenericExtensionMethod() : base(ParsingConfig.Default)