diff --git a/arangodb-net-standard.Test/GraphApi/GraphApiClientTest.cs b/arangodb-net-standard.Test/GraphApi/GraphApiClientTest.cs
index f3bd9703..edb66d3e 100644
--- a/arangodb-net-standard.Test/GraphApi/GraphApiClientTest.cs
+++ b/arangodb-net-standard.Test/GraphApi/GraphApiClientTest.cs
@@ -786,7 +786,7 @@ await _fixture.ArangoDBClient.Graph.PostGraphAsync(new PostGraphBody
                 toClx,
                 new { myKey = "myValue" });
 
-            // Create the edge
+            // Create the edges
 
             var createEdgeResponse = await _client.PostEdgeAsync(
                 graphName,
@@ -802,12 +802,28 @@ await _fixture.ArangoDBClient.Graph.PostGraphAsync(new PostGraphBody
                     ReturnNew = true,
                     WaitForSync = true
                 });
-            // Delete edge
+
+            var createEdgeResponse2 = await _client.PostEdgeAsync(
+                graphName,
+                edgeClx,
+                new
+                {
+                    _from = fromResponse._id,
+                    _to = toResponse._id,
+                    myKey = "myValue"
+                },
+                new PostEdgeQuery
+                {
+                    ReturnNew = true,
+                    WaitForSync = true
+                });
+
+            // Delete edge with document ID
+
             DeleteEdgeResponse<DeleteGraphEdgeMockModel> response =
                 await _client.DeleteEdgeAsync<DeleteGraphEdgeMockModel>(
                     graphName,
-                    edgeClx,
-                    createEdgeResponse.Edge._key,
+                    createEdgeResponse.Edge._id,
                     new DeleteEdgeQuery
                     {
                         ReturnOld = true,
@@ -818,6 +834,23 @@ await _client.DeleteEdgeAsync<DeleteGraphEdgeMockModel>(
             Assert.Equal(createEdgeResponse.New.myKey, response.Old.myKey);
             Assert.True(response.Removed);
             Assert.False(response.Error);
+
+            // Delete edge with collection name and key
+
+            response = await _client.DeleteEdgeAsync<DeleteGraphEdgeMockModel>(
+                   graphName,
+                   edgeClx,
+                   createEdgeResponse2.Edge._key,
+                   new DeleteEdgeQuery
+                   {
+                       ReturnOld = true,
+                       WaitForSync = true
+                   });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.Equal(createEdgeResponse2.New.myKey, response.Old.myKey);
+            Assert.True(response.Removed);
+            Assert.False(response.Error);
         }
 
         [Fact]
@@ -863,7 +896,21 @@ public async Task GetVertexAsync_ShouldSucceed()
                 Name = clxToAdd + "_vtx"
             });
 
-            var response = await _client.GetVertexAsync<GetVertexMockModel>(graphName, clxToAdd, createVtxResponse.Vertex._key);
+            var response = await _client.GetVertexAsync<GetVertexMockModel>(
+                graphName,
+                createVtxResponse.Vertex._id);
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.False(response.Error);
+            Assert.NotNull(response.Vertex);
+            Assert.Equal(clxToAdd + "_vtx", response.Vertex.Name);
+            Assert.Equal(createVtxResponse.Vertex._key, response.Vertex._key);
+            Assert.Equal(createVtxResponse.Vertex._id, response.Vertex._id);
+
+            response = await _client.GetVertexAsync<GetVertexMockModel>(
+                graphName,
+                clxToAdd,
+                createVtxResponse.Vertex._key);
 
             Assert.Equal(HttpStatusCode.OK, response.Code);
             Assert.False(response.Error);
@@ -966,6 +1013,8 @@ public async Task DeleteVertexAsync_ShouldSucceed()
                     Collection = clxToAdd
                 });
 
+            // Create vertex
+
             var vertexProperty = clxToAdd + "_vtx";
 
             var createVtxResponse = await _client.PostVertexAsync(graphName, clxToAdd, new
@@ -975,12 +1024,37 @@ public async Task DeleteVertexAsync_ShouldSucceed()
 
             Assert.Equal(HttpStatusCode.Accepted, createVtxResponse.Code);
 
-            var response = await _client.DeleteVertexAsync<DeleteVertexMockModel>(graphName, clxToAdd, createVtxResponse.Vertex._key, new DeleteVertexQuery
+            var createVtxResponse2 = await _client.PostVertexAsync(graphName, clxToAdd, new
             {
-                ReturnOld = true,
-                WaitForSync = true
+                Name = vertexProperty
             });
 
+            Assert.Equal(HttpStatusCode.Accepted, createVtxResponse2.Code);
+
+            var response = await _client.DeleteVertexAsync<DeleteVertexMockModel>(
+                graphName,
+                createVtxResponse.Vertex._id,
+                new DeleteVertexQuery
+                {
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.False(response.Error);
+            Assert.True(response.Removed);
+            Assert.Equal(vertexProperty, response.Old.Name);
+
+            response = await _client.DeleteVertexAsync<DeleteVertexMockModel>(
+                graphName,
+                clxToAdd,
+                createVtxResponse2.Vertex._key,
+                new DeleteVertexQuery
+                {
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
             Assert.Equal(HttpStatusCode.OK, response.Code);
             Assert.False(response.Error);
             Assert.True(response.Removed);
@@ -1090,15 +1164,46 @@ public async Task PatchVertexAsync_ShouldSucceed()
                 WaitForSync = true
             });
 
-            var response = await _client.PatchVertexAsync<dynamic, PatchVertexMockModel>(graphName, clxToAdd, createVtxResponse.Vertex._key, new
-            {
-                Name = clxToAdd + "_vtx_2"
-            }, new PatchVertexQuery
-            {
-                ReturnNew = true,
-                ReturnOld = true,
-                WaitForSync = true
-            });
+            // Patch with document ID
+
+            var response = await _client.PatchVertexAsync<dynamic, PatchVertexMockModel>(
+                graphName,
+                createVtxResponse.Vertex._id,
+                new
+                {
+                    Name = clxToAdd + "_vtx_2"
+                },
+                new PatchVertexQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.False(response.Error);
+            Assert.NotNull(response.Vertex);
+            Assert.NotEqual(createVtxResponse.Vertex._rev, response.Vertex._rev);
+            Assert.NotEqual(createVtxResponse.Vertex._rev, response.New._rev);
+            Assert.NotEqual(createVtxResponse.New.Name, response.New.Name);
+            Assert.Equal(createVtxResponse.New.Value, response.New.Value);
+
+            // Patch with collection name and document key
+
+            response = await _client.PatchVertexAsync<dynamic, PatchVertexMockModel>(
+                graphName,
+                clxToAdd,
+                createVtxResponse.Vertex._key,
+                new
+                {
+                    Name = clxToAdd + "_vtx_3"
+                },
+                new PatchVertexQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
 
             Assert.Equal(HttpStatusCode.OK, response.Code);
             Assert.False(response.Error);
@@ -1231,23 +1336,56 @@ await _fixture.ArangoDBClient.Graph.PostGraphAsync(new PostGraphBody
                     WaitForSync = true
                 });
 
-            var response = await _client.PutEdgeAsync(graphName, edgeClx, createEdgeResponse.Edge._key, new
-            {
-                _from = fromResponse._id,
-                _to = toResponse._id,
-                myKey = "newValue"
-            }, new PutEdgeQuery
-            {
-                ReturnNew = true,
-                ReturnOld = true,
-                WaitForSync = true
-            });
+            // Put with document ID
+
+            var response = await _client.PutEdgeAsync(
+                graphName,
+                createEdgeResponse.Edge._id,
+                new
+                {
+                    _from = fromResponse._id,
+                    _to = toResponse._id,
+                    myKey = "newValue"
+                },
+                new PutEdgeQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
 
             Assert.Equal(HttpStatusCode.OK, response.Code);
             Assert.Equal(createEdgeResponse.New.myKey, response.Old.myKey);
             Assert.NotEqual(createEdgeResponse.New.myKey, response.New.myKey);
             Assert.False(response.Error);
             Assert.NotEqual(response.Edge._rev, createEdgeResponse.Edge._rev);
+
+            string previousValue = response.New.myKey;
+
+            // Put with collection name and document key
+
+            response = await _client.PutEdgeAsync(
+                graphName,
+                edgeClx,
+                createEdgeResponse.Edge._key,
+                new
+                {
+                    _from = fromResponse._id,
+                    _to = toResponse._id,
+                    myKey = "newValue2"
+                },
+                new PutEdgeQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.Equal(previousValue, response.Old.myKey);
+            Assert.NotEqual(createEdgeResponse.New.myKey, response.New.myKey);
+            Assert.False(response.Error);
+            Assert.NotEqual(response.Edge._rev, createEdgeResponse.Edge._rev);
         }
 
         [Fact]
@@ -1547,10 +1685,11 @@ await _fixture.ArangoDBClient.Graph.PostGraphAsync(new PostGraphBody
                     WaitForSync = true
                 });
 
+            // Patch with document ID
+
             var response = await _client.PatchEdgeAsync<object, PatchEdgeMockModel>(
                 graphName,
-                edgeClx,
-                createEdgeResponse.Edge._key,
+                createEdgeResponse.Edge._id,
                 new
                 {
                     _from = fromResponse._id,
@@ -1570,6 +1709,34 @@ await _fixture.ArangoDBClient.Graph.PostGraphAsync(new PostGraphBody
             Assert.NotEqual(createEdgeResponse.Edge._rev, response.Edge._rev);
             Assert.Equal(createEdgeResponse.New.value, response.New.value);
             Assert.Equal(createEdgeResponse.New.value, response.Old.value);
+
+            string previousValue = response.New.myKey;
+
+            // Patch with collection name and document key
+
+            response = await _client.PatchEdgeAsync<object, PatchEdgeMockModel>(
+                graphName,
+                edgeClx,
+                createEdgeResponse.Edge._key,
+                new
+                {
+                    _from = fromResponse._id,
+                    _to = toResponse._id,
+                    myKey = "newValue2"
+                }, new PatchEdgeQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.Equal(previousValue, response.Old.myKey);
+            Assert.NotEqual(createEdgeResponse.New.myKey, response.New.myKey);
+            Assert.False(response.Error);
+            Assert.NotEqual(createEdgeResponse.Edge._rev, response.Edge._rev);
+            Assert.Equal(createEdgeResponse.New.value, response.New.value);
+            Assert.Equal(createEdgeResponse.New.value, response.Old.value);
         }
 
         [Fact]
@@ -1608,26 +1775,58 @@ public async Task PutVertexAsync_ShouldSuceed()
                     Collection = vertexClx
                 });
 
-            var beforeVertexClxVtx = vertexClx + "_vtx";
-            var afterVertexClxVtx = vertexClx + "_vtx_2";
+            string initialValue = vertexClx + "_vtx";
+            string putValue = vertexClx + "_vtx_2";
 
             var createVertexResponse = await _client.PostVertexAsync(graphName, vertexClx, new
             {
-                Name = beforeVertexClxVtx
-            });
-            var response = await _client.PutVertexAsync(graphName, vertexClx, createVertexResponse.Vertex._key, new PutVertexMockModel
-            {
-                Name = afterVertexClxVtx
-            }, new PutVertexQuery
-            {
-                ReturnNew = true,
-                ReturnOld = true,
-                WaitForSync = true
+                Name = initialValue
             });
 
+            // Put with document ID
+
+            var response = await _client.PutVertexAsync(
+                graphName,
+                createVertexResponse.Vertex._id,
+                new PutVertexMockModel
+                {
+                    Name = putValue
+                },
+                new PutVertexQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
+            Assert.Equal(HttpStatusCode.OK, response.Code);
+            Assert.False(response.Error);
+            Assert.Equal(putValue, response.New.Name);
+            Assert.NotEqual(response.New.Name, response.Old.Name);
+            Assert.NotEqual(createVertexResponse.Vertex._rev, response.Vertex._rev);
+
+            // Put with collection name and document key
+
+            putValue = vertexClx + "_vtx_3";
+
+            response = await _client.PutVertexAsync(
+                graphName,
+                vertexClx,
+                createVertexResponse.Vertex._key,
+                new PutVertexMockModel
+                {
+                    Name = putValue
+                },
+                new PutVertexQuery
+                {
+                    ReturnNew = true,
+                    ReturnOld = true,
+                    WaitForSync = true
+                });
+
             Assert.Equal(HttpStatusCode.OK, response.Code);
             Assert.False(response.Error);
-            Assert.Equal(afterVertexClxVtx, response.New.Name);
+            Assert.Equal(putValue, response.New.Name);
             Assert.NotEqual(response.New.Name, response.Old.Name);
             Assert.NotEqual(createVertexResponse.Vertex._rev, response.Vertex._rev);
         }
diff --git a/arangodb-net-standard/ApiClientBase.cs b/arangodb-net-standard/ApiClientBase.cs
index 746fa42c..04931830 100644
--- a/arangodb-net-standard/ApiClientBase.cs
+++ b/arangodb-net-standard/ApiClientBase.cs
@@ -39,6 +39,12 @@ protected async Task<ApiErrorException> GetApiErrorException(IApiClientResponse
             }
         }
 
+        /// <summary>
+        /// Checks whether the provided document ID is in the correct form
+        /// of "{collection}/{key}".
+        /// </summary>
+        /// <exception cref="ArgumentException">The document ID is invalid</exception>
+        /// <param name="documentId">The document ID to validate.</param>
         protected void ValidateDocumentId(string documentId)
         {
             if (documentId.Split('/').Length != 2)
diff --git a/arangodb-net-standard/GraphApi/GraphApiClient.cs b/arangodb-net-standard/GraphApi/GraphApiClient.cs
index 1f88f5db..03396e33 100644
--- a/arangodb-net-standard/GraphApi/GraphApiClient.cs
+++ b/arangodb-net-standard/GraphApi/GraphApiClient.cs
@@ -1,6 +1,7 @@
 using ArangoDBNetStandard.GraphApi.Models;
 using ArangoDBNetStandard.Serialization;
 using ArangoDBNetStandard.Transport;
+using System;
 using System.Net;
 using System.Threading.Tasks;
 
@@ -448,14 +449,39 @@ public virtual async Task<GetEdgeResponse<T>> GetEdgeAsync<T>(
         /// <param name="edgeKey">The _key attribute of the edge.</param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
+        public virtual Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
             string graphName,
             string collectionName,
             string edgeKey,
             DeleteEdgeQuery query = null)
         {
+            return DeleteEdgeAsync<T>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey),
+                query);
+
+        }
+
+        /// <summary>
+        /// Removes an edge based on its document ID.
+        /// </summary>
+        /// <exception cref="ArgumentException">Provided document ID is invalid.</exception>
+        /// <typeparam name="T">The type of the edge that is returned in
+        /// <see cref="DeleteEdgeResponse{T}.Old"/> if requested.</typeparam>
+        /// <param name="graphName">The name of the graph.</param>
+        /// <param name="documentId">The document ID of the edge to delete.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
+            string graphName,
+            string documentId,
+            DeleteEdgeQuery query = null)
+        {
+            ValidateDocumentId(documentId);
+
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) +
-                "/edge/" + WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey);
+                "/edge/" + documentId;
+
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
@@ -479,14 +505,36 @@ public virtual async Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
         /// <param name="vertexKey"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<GetVertexResponse<T>> GetVertexAsync<T>(
+        public virtual Task<GetVertexResponse<T>> GetVertexAsync<T>(
             string graphName,
             string collectionName,
             string vertexKey,
             GetVertexQuery query = null)
         {
+            return GetVertexAsync<T>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + vertexKey,
+                query);
+        }
+
+        /// <summary>
+        /// Gets a vertex based on its document ID.
+        /// </summary>
+        /// <exception cref="ArgumentException">Provided document ID is invalid.</exception>
+        /// <param name="graphName">The name of the graph to get the vertex from.</param>
+        /// <param name="documentId">The document ID of the vertex to retrieve.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<GetVertexResponse<T>> GetVertexAsync<T>(
+          string graphName,
+          string documentId,
+          GetVertexQuery query = null)
+        {
+            ValidateDocumentId(documentId);
+
             string uri = _graphApiPath + '/' + WebUtility.UrlEncode(graphName) +
-                "/vertex/" + WebUtility.UrlEncode(collectionName) + "/" + vertexKey;
+                "/vertex/" + documentId;
+
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
@@ -511,19 +559,41 @@ public virtual async Task<GetVertexResponse<T>> GetVertexAsync<T>(
         /// <param name="vertexKey"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
+        public virtual Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
             string graphName,
             string collectionName,
             string vertexKey,
             DeleteVertexQuery query = null)
         {
+            return DeleteVertexAsync<T>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(vertexKey),
+                query);
+        }
+
+        /// <summary>
+        /// Removes a vertex based on its document ID.
+        /// </summary>
+        /// <exception cref="ArgumentException">Provided document ID is invalid.</exception>
+        /// <param name="graphName">The name of the graph to delete the vertex from.</param>
+        /// <param name="documentId">The document ID of the vertex to delete.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
+            string graphName,
+            string documentId,
+            DeleteVertexQuery query = null)
+        {
+            ValidateDocumentId(documentId);
+
             string uri = _graphApiPath + '/' + WebUtility.UrlEncode(graphName) +
-                "/vertex/" + WebUtility.UrlEncode(collectionName) + "/" +
-                WebUtility.UrlEncode(vertexKey);
+                "/vertex/" + documentId;
+
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
             }
+
             using (var response = await _transport.DeleteAsync(uri))
             {
                 if (response.IsSuccessStatusCode)
@@ -549,19 +619,49 @@ public virtual async Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
         /// <param name="body"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
+        public virtual Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
             string graphName,
             string collectionName,
             string vertexKey,
             T body,
             PatchVertexQuery query = null)
         {
+            return PatchVertexAsync<T, U>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(vertexKey),
+                body,
+                query);
+        }
+
+        /// <summary>
+        /// Updates the data of the specific vertex based on its document ID.
+        /// </summary>
+        /// <exception cref="ArgumentException">Provided document ID is invalid.</exception>
+        /// <typeparam name="T">Type of the patch object</typeparam>
+        /// <typeparam name="U">Type of the returned document, only applies when
+        /// <see cref="PatchVertexQuery.ReturnNew"/> or <see cref="PatchVertexQuery.ReturnOld"/>
+        /// are used.</typeparam>
+        /// <param name="graphName">The name of the graph in which to update the vertex.</param>
+        /// <param name="documentId">The document ID of the vertex to update.</param>
+        /// <param name="body"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
+            string graphName,
+            string documentId,
+            T body,
+            PatchVertexQuery query = null)
+        {
+            ValidateDocumentId(documentId);
+
             string uri = _graphApiPath + '/' + WebUtility.UrlEncode(graphName) +
-                "/vertex/" + WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(vertexKey);
+                "/vertex/" + documentId;
+
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
             }
+
             var content = GetContent(body, false, false);
             using (var response = await _transport.PatchAsync(uri, content))
             {
@@ -585,22 +685,47 @@ public virtual async Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
         /// <param name="edge"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
+        public virtual Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
             string graphName,
             string collectionName,
             string edgeKey,
             T edge,
             PutEdgeQuery query = null)
         {
-            var content = GetContent(edge, false, false);
+            return PutEdgeAsync<T>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey),
+                edge,
+                query);
+        }
+
+        /// <summary>
+        /// Replaces the data of an edge based on its document ID.
+        /// </summary>
+        /// <exception cref="ArgumentException">Provided document ID is invalid.</exception>
+        /// <typeparam name="T">Type of the document used for the update.</typeparam>
+        /// <param name="graphName">The name of the graph in which to replace the edge.</param>
+        /// <param name="documentId">The document ID of the edge to replace.</param>
+        /// <param name="edge"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
+            string graphName,
+            string documentId,
+            T edge,
+            PutEdgeQuery query = null)
+        {
+            ValidateDocumentId(documentId);
 
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) +
-                "/edge/" + WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey);
+                "/edge/" + documentId;
 
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
             }
+
+            var content = GetContent(edge, false, false);
             using (var response = await _transport.PutAsync(uri, content))
             {
                 if (response.IsSuccessStatusCode)
@@ -655,29 +780,54 @@ public virtual async Task<PutEdgeDefinitionResponse> PutEdgeDefinitionAsync(
         /// <typeparam name="T">Type of the patch object used to perform a partial update of the edge document.</typeparam>
         /// <typeparam name="U">Type of the returned edge document,
         /// when <see cref="PatchEdgeQuery.ReturnOld"/> or <see cref="PatchEdgeQuery.ReturnNew"/> query params are used.</typeparam>
-        /// <param name="graphName"></param>
-        /// <param name="collectionName"></param>
-        /// <param name="edgeKey"></param>
+        /// <param name="graphName">The name of the graph in which to update the edge.</param>
+        /// <param name="collectionName">The name of the edge collection.</param>
+        /// <param name="edgeKey">The document key of the edge to update.</param>
         /// <param name="edge"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
+        public virtual Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
             string graphName,
             string collectionName,
             string edgeKey,
             T edge,
             PatchEdgeQuery query = null)
         {
-            var content = GetContent(edge, true, true);
+            return PatchEdgeAsync<T, U>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey),
+                edge,
+                query);
+        }
+
+        /// <summary>
+        /// Updates the data of the specific edge based on its document ID.
+        /// </summary>
+        /// <typeparam name="T">Type of the patch object used to perform a partial update of the edge document.</typeparam>
+        /// <typeparam name="U">Type of the returned edge document,
+        /// when <see cref="PatchEdgeQuery.ReturnOld"/> or <see cref="PatchEdgeQuery.ReturnNew"/> query params are used.</typeparam>
+        /// <param name="graphName">The name of the graph in which to update the edge.</param>
+        /// <param name="documentId">The document ID of the edge to update.</param>
+        /// <param name="edge"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
+            string graphName,
+            string documentId,
+            T edge,
+            PatchEdgeQuery query = null)
+        {
+            ValidateDocumentId(documentId);
 
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) +
-                "/edge/" + WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(edgeKey);
+                "/edge/" + documentId;
 
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
             }
 
+            var content = GetContent(edge, true, true);
             using (var response = await _transport.PatchAsync(uri, content))
             {
                 if (response.IsSuccessStatusCode)
@@ -700,19 +850,45 @@ public virtual async Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
         /// <param name="vertex"></param>
         /// <param name="query"></param>
         /// <returns></returns>
-        public virtual async Task<PutVertexResponse<T>> PutVertexAsync<T>(
+        public virtual Task<PutVertexResponse<T>> PutVertexAsync<T>(
             string graphName,
             string collectionName,
             string key,
             T vertex,
             PutVertexQuery query = null)
         {
+            return PutVertexAsync<T>(
+                graphName,
+                WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(key),
+                vertex,
+                query);
+        }
+
+        /// <summary>
+        /// Replaces the data of a vertex based on its document ID.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="graphName">The name of the graph in which to replace the vertex.</param>
+        /// <param name="documentId">The document ID of the vertex to replace.</param>
+        /// <param name="vertex"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        public virtual async Task<PutVertexResponse<T>> PutVertexAsync<T>(
+            string graphName,
+            string documentId,
+            T vertex,
+            PutVertexQuery query = null)
+        {
+            ValidateDocumentId(documentId);
+
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) +
-               "/vertex/" + WebUtility.UrlEncode(collectionName) + "/" + WebUtility.UrlEncode(key);
+               "/vertex/" + documentId;
+
             if (query != null)
             {
                 uri += "?" + query.ToQueryString();
             }
+
             var content = GetContent(vertex, true, true);
             using (var response = await _transport.PutAsync(uri, content))
             {
diff --git a/arangodb-net-standard/GraphApi/IGraphApiClient.cs b/arangodb-net-standard/GraphApi/IGraphApiClient.cs
index 16fd268c..ad313bea 100644
--- a/arangodb-net-standard/GraphApi/IGraphApiClient.cs
+++ b/arangodb-net-standard/GraphApi/IGraphApiClient.cs
@@ -209,6 +209,21 @@ Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
           string edgeKey,
           DeleteEdgeQuery query = null);
 
+        /// <summary>
+        /// Removes an edge based on its document ID.
+        /// </summary>
+        /// <typeparam name="T">The type of the edge that is returned in
+        /// <see cref="DeleteEdgeResponse{T}.Old"/> if requested.</typeparam>
+        /// <param name="graphName">The name of the graph.</param>
+        /// <param name="documentId">The document ID of the edge to delete.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
+          string graphName,
+          string documentId,
+          DeleteEdgeQuery query = null);
+
+        /// <summary>
         /// Gets a vertex from the given collection.
         /// GET/_api/gharial/{graph}/vertex/{collection}/{vertex}
         /// </summary>
@@ -223,6 +238,18 @@ Task<GetVertexResponse<T>> GetVertexAsync<T>(
           string vertexKey,
           GetVertexQuery query = null);
 
+        /// <summary>
+        /// Gets a vertex based on its document ID.
+        /// </summary>
+        /// <param name="graphName">The name of the graph to get the vertex from.</param>
+        /// <param name="documentId">The document ID of the vertex to retrieve.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<GetVertexResponse<T>> GetVertexAsync<T>(
+          string graphName,
+          string documentId,
+          GetVertexQuery query = null);
+
         /// <summary>
         /// Removes a vertex from the collection.
         /// DELETE/_api/gharial/{graph}/vertex/{collection}/{vertex}
@@ -238,6 +265,18 @@ Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
           string vertexKey,
           DeleteVertexQuery query = null);
 
+        /// <summary>
+        /// Removes a vertex based on its document ID.
+        /// </summary>
+        /// <param name="graphName">The name of the graph to delete the vertex from.</param>
+        /// <param name="documentId">The document ID of the vertex to delete.</param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
+          string graphName,
+          string documentId,
+          DeleteVertexQuery query = null);
+
         /// <summary>
         /// Updates the data of the specific vertex in the collection.
         /// PATCH/_api/gharial/{graph}/vertex/{collection}/{vertex}
@@ -259,6 +298,24 @@ Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
           T body,
           PatchVertexQuery query = null);
 
+        /// <summary>
+        /// Updates the data of the specific vertex based on its document ID.
+        /// </summary>
+        /// <typeparam name="T">Type of the patch object</typeparam>
+        /// <typeparam name="U">Type of the returned document, only applies when
+        /// <see cref="PatchVertexQuery.ReturnNew"/> or <see cref="PatchVertexQuery.ReturnOld"/>
+        /// are used.</typeparam>
+        /// <param name="graphName">The name of the graph in which to update the vertex.</param>
+        /// <param name="documentId">The document ID of the vertex to update.</param>
+        /// <param name="body"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
+          string graphName,
+          string documentId,
+          T body,
+          PatchVertexQuery query = null);
+
         /// <summary>
         /// Replaces the data of an edge in the collection.
         /// PUT /_api/gharial/{graph}/edge/{collection}/{edge}
@@ -277,6 +334,21 @@ Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
           T edge,
           PutEdgeQuery query = null);
 
+        /// <summary>
+        /// Replaces the data of an edge based on its document ID.
+        /// </summary>
+        /// <typeparam name="T">Type of the document used for the update.</typeparam>
+        /// <param name="graphName">The name of the graph in which to replace the edge.</param>
+        /// <param name="documentId">The document ID of the edge to replace.</param>
+        /// <param name="edge"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
+          string graphName,
+          string documentId,
+          T edge,
+          PutEdgeQuery query = null);
+
         /// <summary>
         /// Change one specific edge definition.
         /// This will modify all occurrences of this definition in all graphs known to your database.
@@ -300,9 +372,9 @@ Task<PutEdgeDefinitionResponse> PutEdgeDefinitionAsync(
         /// <typeparam name="T">Type of the patch object used to perform a partial update of the edge document.</typeparam>
         /// <typeparam name="U">Type of the returned edge document,
         /// when <see cref="PatchEdgeQuery.ReturnOld"/> or <see cref="PatchEdgeQuery.ReturnNew"/> query params are used.</typeparam>
-        /// <param name="graphName"></param>
-        /// <param name="collectionName"></param>
-        /// <param name="edgeKey"></param>
+        /// <param name="graphName">The name of the graph in which to update the edge.</param>
+        /// <param name="collectionName">The name of the edge collection.</param>
+        /// <param name="edgeKey">The document key of the edge to update.</param>
         /// <param name="edge"></param>
         /// <param name="query"></param>
         /// <returns></returns>
@@ -313,6 +385,23 @@ Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
           T edge,
           PatchEdgeQuery query = null);
 
+        /// <summary>
+        /// Updates the data of the specific edge based on its document ID.
+        /// </summary>
+        /// <typeparam name="T">Type of the patch object used to perform a partial update of the edge document.</typeparam>
+        /// <typeparam name="U">Type of the returned edge document,
+        /// when <see cref="PatchEdgeQuery.ReturnOld"/> or <see cref="PatchEdgeQuery.ReturnNew"/> query params are used.</typeparam>
+        /// <param name="graphName">The name of the graph in which to update the edge.</param>
+        /// <param name="documentId">The document ID of the edge to update.</param>
+        /// <param name="edge"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
+          string graphName,
+          string documentId,
+          T edge,
+          PatchEdgeQuery query = null);
+
         /// <summary>
         /// Replaces the data of a vertex in the collection.
         /// PUT/_api/gharial/{graph}/vertex/{collection}/{vertex}
@@ -330,5 +419,20 @@ Task<PutVertexResponse<T>> PutVertexAsync<T>(
           string key,
           T vertex,
           PutVertexQuery query = null);
+
+        /// <summary>
+        /// Replaces the data of a vertex based on its document ID.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="graphName">The name of the graph in which to replace the vertex.</param>
+        /// <param name="documentId">The document ID of the vertex to replace.</param>
+        /// <param name="vertex"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        Task<PutVertexResponse<T>> PutVertexAsync<T>(
+          string graphName,
+          string documentId,
+          T vertex,
+          PutVertexQuery query = null);
     }
 }