diff --git a/src/Nest.Tests.Unit/Search/Sort/SortTests.cs b/src/Nest.Tests.Unit/Search/Sort/SortTests.cs
index ff2dc540a3c..96d4390b602 100644
--- a/src/Nest.Tests.Unit/Search/Sort/SortTests.cs
+++ b/src/Nest.Tests.Unit/Search/Sort/SortTests.cs
@@ -1,192 +1,253 @@
 using NUnit.Framework;
 using Nest.Tests.MockData.Domain;
 
-namespace Nest.Tests.Unit.Search.Sort
-{
+namespace Nest.Tests.Unit.Search.Sort {
     [TestFixture]
-    public class SortTests
-    {
+    public class SortTests {
         [Test]
-        public void TestSort()
-        {
+        public void TestSort() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
-        .Sort(sort => sort
-          .OnField(e => e.Country)
-          .MissingLast()
-          .Descending()
-      );
+                .Sort(sort => sort
+                    .OnField(e => e.Country)
+                    .MissingLast()
+                    .Descending()
+                );
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            country: {
-              missing: ""_last"",
-              order: ""desc""
-            }
-          }
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    country: {
+                      missing: ""_last"",
+                      order: ""desc""
+                    }
+                  }
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
 
         [Test]
-        public void TestSortOnSortField()
-        {
+        public void TestSortOnSortField() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
-        .Sort(sort => sort
-          .OnField(e => e.Name)
-          .MissingLast()
-          .Descending()
-      );
+                .Sort(sort => sort
+                    .OnField(e => e.Name)
+                    .MissingLast()
+                    .Descending()
+                );
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            ""name.sort"": {
-              missing: ""_last"",
-              order: ""desc""
-            }
-          }
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    ""name.sort"": {
+                      missing: ""_last"",
+                      order: ""desc""
+                    }
+                  }
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
 
         [Test]
-        public void TestSortAscending()
-        {
+        public void TestSortAscending() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
                 .SortAscending(f => f.Country);
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            country : ""asc""
-            }          
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    country : ""asc""
+                    }          
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
 
         [Test]
-        public void TestSortDescending()
-        {
+        public void TestSortDescending() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
                 .SortDescending(f => f.Country);
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            country : ""desc""
-            }          
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    country : ""desc""
+                    }          
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
 
         [Test]
-        public void TestSortAscendingOnSortField()
-        {
+        public void TestSortAscendingOnSortField() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
                 .SortAscending(f => f.Name);
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            ""name.sort"" : ""asc""
-            }          
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    ""name.sort"" : ""asc""
+                    }          
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
 
         [Test]
-        public void TestSortDescendingOnSortField()
-        {
+        public void TestSortDescendingOnSortField() {
             var s = new SearchDescriptor<ElasticSearchProject>()
                 .From(0)
                 .Size(10)
                 .SortDescending(f => f.Name);
             var json = TestElasticClient.Serialize(s);
-            var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            ""name.sort"" : ""desc""
-            }          
-        }";
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    ""name.sort"" : ""desc""
+                    }          
+                }";
+            Assert.True(json.JsonEquals(expected), json);
+        }
+
+        [Test]
+        public void TestSortGeo() {
+            var s = new SearchDescriptor<ElasticSearchProject>()
+                .From(0)
+                .Size(10)
+                .SortGeoDistance(sort => sort
+                    .OnField(e => e.Origin)
+                    .MissingLast()
+                    .Descending()
+                    .PinTo(40, -70)
+                    .Unit(GeoUnit.km)
+                );
+            var json = TestElasticClient.Serialize(s);
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    _geo_distance: {
+                      missing: ""_last"",
+                      order: ""desc"",
+                      ""origin"": ""40, -70"",
+                      unit: ""km""
+                    }
+                  }
+                }";
+            Assert.True(json.JsonEquals(expected), json);
+        }
+
+        [Test]
+        public void TestSortScript() {
+            var s = new SearchDescriptor<ElasticSearchProject>()
+                .From(0)
+                .Size(10)
+                .SortScript(sort => sort
+                    .MissingLast()
+                    .Descending()
+                    .Script("doc['field_name'].value * factor")
+                    .Params(p => p
+                        .Add("factor", 1.1)
+                    )
+                    .Type("number")
+                );
+            var json = TestElasticClient.Serialize(s);
+            var expected = @"
+                {
+                  from: 0,
+                  size: 10,
+                  sort: {
+                    _script: {
+                      missing: ""_last"",
+                      order: ""desc"",
+                      type: ""number"",
+                      script: ""doc['field_name'].value * factor"",
+                      params: {
+                        factor: 1.1
+                      }
+                    }
+                  }
+                }";
+            Assert.True(json.JsonEquals(expected), json);
+        }
+
+        [Test]
+        public void TestNestedFilter() {
+            var s = new SearchDescriptor<ElasticSearchProject>()
+                .Sort(sort => sort
+                    .OnField(e => e.Id)
+                    .NestedFilter(f => f.Term("name", "value"))
+                );
+            var json = TestElasticClient.Serialize(s);
+            var expected = @"
+                {
+                  ""sort"": {
+                    ""id"": {
+                      ""nested_filter"": {
+                        ""term"": {
+                          ""name"": ""value""
+                        }
+                      }
+                    }
+                  }
+                }";
+            Assert.True(json.JsonEquals(expected), json);
+        }
+
+        [Test]
+        public void TestNestedPath() {
+            var s = new SearchDescriptor<ElasticSearchProject>()
+                .Sort(sort => sort
+                    .OnField(e => e.Id)
+                    .NestedPath("name")
+                );
+            var json = TestElasticClient.Serialize(s);
+            var expected = @"
+                {
+                  ""sort"": {
+                    ""id"": {
+                      ""nested_path"": ""name""
+                    }
+                  }
+                }";
+            Assert.True(json.JsonEquals(expected), json);
+        }
+
+        [Test]
+        public void TestNestedPathObject() {
+            var s = new SearchDescriptor<ElasticSearchProject>()
+                .Sort(sort => sort
+                    .OnField(e => e.Id)
+                    .NestedPath(f => f.Name)
+                );
+            var json = TestElasticClient.Serialize(s);
+            var expected = @"
+                {
+                  ""sort"": {
+                    ""id"": {
+                      ""nested_path"": ""name""
+                    }
+                  }
+                }";
             Assert.True(json.JsonEquals(expected), json);
         }
-    [Test]
-    public void TestSortGeo()
-    {
-      var s = new SearchDescriptor<ElasticSearchProject>()
-        .From(0)
-        .Size(10)
-        .SortGeoDistance(sort => sort
-          .OnField(e => e.Origin)
-          .MissingLast()
-          .Descending()
-          .PinTo(40, -70)
-          .Unit(GeoUnit.km)
-      );
-      var json = TestElasticClient.Serialize(s);
-      var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            _geo_distance: {
-              missing: ""_last"",
-              order: ""desc"",
-              ""origin"": ""40, -70"",
-              unit: ""km""
-            }
-          }
-        }";
-      Assert.True(json.JsonEquals(expected), json);
-    }
-    [Test]
-    public void TestSortScript()
-    {
-      var s = new SearchDescriptor<ElasticSearchProject>()
-        .From(0)
-        .Size(10)
-        .SortScript(sort => sort
-          .MissingLast()
-          .Descending()
-          .Script("doc['field_name'].value * factor")
-          .Params(p=>p
-            .Add("factor", 1.1)
-          )
-          .Type("number")
-      );
-      var json = TestElasticClient.Serialize(s);
-      var expected = @"  {
-          from: 0,
-          size: 10,
-          sort: {
-            _script: {
-              missing: ""_last"",
-              order: ""desc"",
-              type: ""number"",
-              script: ""doc['field_name'].value * factor"",
-              params: {
-                factor: 1.1
-              }
-            }
-          }
-        }";
-      Assert.True(json.JsonEquals(expected), json);
-    }
     }
-}
+}
\ No newline at end of file
diff --git a/src/Nest/DSL/SortDescriptor.cs b/src/Nest/DSL/SortDescriptor.cs
index 4bdab963280..a61b383aa74 100644
--- a/src/Nest/DSL/SortDescriptor.cs
+++ b/src/Nest/DSL/SortDescriptor.cs
@@ -18,6 +18,12 @@ public class SortDescriptor<T> where T : class
     [JsonProperty("order")]
     internal string _Order { get; set; }
 
+    [JsonProperty("nested_filter")]
+    internal BaseFilter _NestedFilter { get; set; }
+
+    [JsonProperty("nested_path")]
+    internal string _NestedPath { get; set; }
+
     public virtual SortDescriptor<T> OnField(string field)
     {
       this._Field = field;
@@ -64,6 +70,23 @@ public virtual SortDescriptor<T> Descending()
       this._Order = "desc";
       return this;
     }
+    public virtual SortDescriptor<T> NestedFilter(Func<FilterDescriptor<T>, BaseFilter> filterSelector) {
+        filterSelector.ThrowIfNull("filterSelector");
+
+        var filter = new FilterDescriptor<T>();
+        _NestedFilter = filterSelector(filter);
+        return this;
+    }
+    public virtual SortDescriptor<T> NestedPath(string path) {
+        _NestedPath = path;
+        return this;
+    }
+    public SortDescriptor<T> NestedPath(Expression<Func<T, object>> objectPath) {
+        var resolver = new PropertyNameResolver();
+        _NestedPath = resolver.Resolve(objectPath);
+        return this;
+    }
+
     /// <summary>
     /// Pass true to sort ascending false to sort descending
     /// </summary>