diff --git a/arangodb-net-standard/AdminApi/AdminApiClient.cs b/arangodb-net-standard/AdminApi/AdminApiClient.cs
index 5e710714..02e2e895 100644
--- a/arangodb-net-standard/AdminApi/AdminApiClient.cs
+++ b/arangodb-net-standard/AdminApi/AdminApiClient.cs
@@ -70,9 +70,9 @@ public virtual async Task<GetLogsResponse> GetLogsAsync(GetLogsQuery query = nul
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetLogsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetLogsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -96,7 +96,7 @@ public virtual async Task<bool> PostReloadRoutingInfoAsync(CancellationToken tok
                 {
                     return true;
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -119,9 +119,9 @@ public virtual async Task<GetServerIdResponse> GetServerIdAsync(CancellationToke
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetServerIdResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetServerIdResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -143,9 +143,9 @@ public virtual async Task<GetServerRoleResponse> GetServerRoleAsync(Cancellation
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetServerRoleResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetServerRoleResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -167,9 +167,9 @@ public virtual async Task<GetServerEngineTypeResponse> GetServerEngineTypeAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetServerEngineTypeResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetServerEngineTypeResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -196,9 +196,9 @@ public virtual async Task<GetServerVersionResponse> GetServerVersionAsync(GetSer
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetServerVersionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetServerVersionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -220,9 +220,9 @@ public virtual async Task<GetLicenseResponse> GetLicenseAsync(CancellationToken
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetLicenseResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetLicenseResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -245,15 +245,15 @@ public virtual async Task<PutLicenseResponse> PutLicenseAsync(string licenseKey,
             {
                 uri += '?' + query.ToQueryString();
             }
-            var content = GetContent(licenseKey, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(licenseKey, new ApiClientSerializationOptions(true, true));
             using (var response = await _client.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutLicenseResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutLicenseResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/AnalyzerApi/AnalyzerApiClient.cs b/arangodb-net-standard/AnalyzerApi/AnalyzerApiClient.cs
index 5ea10d02..ecb2558a 100644
--- a/arangodb-net-standard/AnalyzerApi/AnalyzerApiClient.cs
+++ b/arangodb-net-standard/AnalyzerApi/AnalyzerApiClient.cs
@@ -62,9 +62,9 @@ public virtual async Task<GetAllAnalyzersResponse> GetAllAnalyzersAsync(Cancella
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAllAnalyzersResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAllAnalyzersResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -82,15 +82,15 @@ public virtual async Task<Analyzer> PostAnalyzerAsync(Analyzer body, Cancellatio
                 throw new ArgumentException("body is required", nameof(body));
             }
             var uri = _analyzerApiPath;
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PostAsync(uri, content, null, token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<Analyzer>(stream);
+                    return await DeserializeJsonFromStreamAsync<Analyzer>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -113,9 +113,9 @@ public virtual async Task<GetAnalyzerResponse> GetAnalyzerAsync(string analyzerN
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAnalyzerResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAnalyzerResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -138,9 +138,9 @@ public virtual async Task<DeleteAnalyzerResponse> DeleteAnalyzerAsync(string ana
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteAnalyzerResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteAnalyzerResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/ApiClientBase.cs b/arangodb-net-standard/ApiClientBase.cs
index 7e912379..dba79340 100644
--- a/arangodb-net-standard/ApiClientBase.cs
+++ b/arangodb-net-standard/ApiClientBase.cs
@@ -25,12 +25,12 @@ public ApiClientBase(IApiClientSerialization serialization)
         /// </summary>
         /// <param name="response">The error response from ArangoDB.</param>
         /// <returns></returns>
-        protected async Task<ApiErrorException> GetApiErrorException(IApiClientResponse response)
+        protected async Task<ApiErrorException> GetApiErrorExceptionAsync(IApiClientResponse response)
         {
             var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
             try
             {
-                var error = _serialization.DeserializeFromStream<ApiErrorResponse>(stream);
+                var error = await _serialization.DeserializeFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 return new ApiErrorException(error);
             }
             catch (Exception e)
@@ -54,11 +54,11 @@ protected void ValidateDocumentId(string documentId)
             }
         }
 
-        protected T DeserializeJsonFromStream<T>(Stream stream)
+        protected async Task<T> DeserializeJsonFromStreamAsync<T>(Stream stream)
         {
             try
             {
-                return _serialization.DeserializeFromStream<T>(stream);
+                return await  _serialization.DeserializeFromStreamAsync<T>(stream).ConfigureAwait(false);
             }
             catch (Exception e)
             {
@@ -66,11 +66,11 @@ protected T DeserializeJsonFromStream<T>(Stream stream)
             }
         }
 
-        protected byte[] GetContent<T>(T item, ApiClientSerializationOptions serializationOptions)
+        protected async Task<byte[]> GetContentAsync<T>(T item, ApiClientSerializationOptions serializationOptions)
         {
             try
             {
-                return _serialization.Serialize(item, serializationOptions);
+                return await _serialization.SerializeAsync(item, serializationOptions).ConfigureAwait(false);
             }
             catch (Exception e)
             {
@@ -78,11 +78,11 @@ protected byte[] GetContent<T>(T item, ApiClientSerializationOptions serializati
             }
         }
 
-        protected string GetContentString<T>(T item, ApiClientSerializationOptions serializationOptions)
+        protected async Task<string> GetContentStringAsync<T>(T item, ApiClientSerializationOptions serializationOptions)
         {
             try
             {
-                return _serialization.SerializeToString(item, serializationOptions);
+                return await _serialization.SerializeToStringAsync(item, serializationOptions).ConfigureAwait(false);
             }
             catch (Exception e)
             {
diff --git a/arangodb-net-standard/AqlFunctionApi/AqlFunctionApiClient.cs b/arangodb-net-standard/AqlFunctionApi/AqlFunctionApiClient.cs
index 0ec57180..66d8626e 100644
--- a/arangodb-net-standard/AqlFunctionApi/AqlFunctionApiClient.cs
+++ b/arangodb-net-standard/AqlFunctionApi/AqlFunctionApiClient.cs
@@ -59,16 +59,16 @@ public virtual async Task<PostAqlFunctionResponse> PostAqlFunctionAsync(
             PostAqlFunctionBody body,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
 
             using (var response = await _transport.PostAsync(_apiPath, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostAqlFunctionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostAqlFunctionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -97,9 +97,9 @@ public virtual async Task<DeleteAqlFunctionResponse> DeleteAqlFunctionAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteAqlFunctionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteAqlFunctionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -125,9 +125,9 @@ public virtual async Task<GetAqlFunctionsResponse> GetAqlFunctionsAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAqlFunctionsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAqlFunctionsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -149,15 +149,15 @@ public virtual async Task<PostExplainAqlQueryResponse> PostExplainAqlQueryAsync(
 
             string uri = "_api/explain";
 
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostExplainAqlQueryResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostExplainAqlQueryResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -179,15 +179,15 @@ public virtual async Task<PostParseAqlQueryResponse> PostParseAqlQueryAsync(
 
             string uri = "_api/query";
 
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostParseAqlQueryResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostParseAqlQueryResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -232,9 +232,9 @@ public virtual async Task<ResponseBase> DeleteKillRunningAqlQueryAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ResponseBase>(stream);
+                    return await DeserializeJsonFromStreamAsync<ResponseBase>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -267,9 +267,9 @@ public virtual async Task<ResponseBase> DeleteClearSlowAqlQueriesAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ResponseBase>(stream);
+                    return await DeserializeJsonFromStreamAsync<ResponseBase>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -310,9 +310,9 @@ public virtual async Task<List<SlowAqlQuery>> GetSlowAqlQueriesAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<List<SlowAqlQuery>>(stream);
+                    return await DeserializeJsonFromStreamAsync<List<SlowAqlQuery>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -334,9 +334,9 @@ public virtual async Task<ResponseBase> DeleteClearAqlQueryCacheAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ResponseBase>(stream);
+                    return await DeserializeJsonFromStreamAsync<ResponseBase>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -359,9 +359,9 @@ public virtual async Task<List<CachedAqlQueryResult>> GetCachedAqlQueryResultsAs
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<List<CachedAqlQueryResult>>(stream);
+                    return await DeserializeJsonFromStreamAsync<List<CachedAqlQueryResult>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -382,9 +382,9 @@ public virtual async Task<QueryCacheGlobalProperties> GetQueryCacheGlobalPropert
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<QueryCacheGlobalProperties>(stream);
+                    return await DeserializeJsonFromStreamAsync<QueryCacheGlobalProperties>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -411,15 +411,15 @@ public virtual async Task<QueryCacheGlobalProperties> PutAdjustQueryCacheGlobalP
 
             string uri = "_api/query-cache/properties";
 
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<QueryCacheGlobalProperties>(stream);
+                    return await DeserializeJsonFromStreamAsync<QueryCacheGlobalProperties>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -438,9 +438,9 @@ public virtual async Task<QueryTrackingConfiguration> GetQueryTrackingConfigurat
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<QueryTrackingConfiguration>(stream);
+                    return await DeserializeJsonFromStreamAsync<QueryTrackingConfiguration>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -466,15 +466,15 @@ public virtual async Task<QueryTrackingConfiguration> PutChangeQueryTrackingConf
 
             string uri = "_api/query/properties";
 
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<QueryTrackingConfiguration>(stream);
+                    return await DeserializeJsonFromStreamAsync<QueryTrackingConfiguration>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -503,9 +503,9 @@ public virtual async Task<List<RunningAqlQuery>> GetCurrentlyRunningAqlQueriesAs
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<List<RunningAqlQuery>>(stream);
+                    return await DeserializeJsonFromStreamAsync<List<RunningAqlQuery>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -528,9 +528,9 @@ public virtual async Task<List<GetQueryRule>> GetQueryRulesAsync(CancellationTok
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<List<GetQueryRule>>(stream);
+                    return await DeserializeJsonFromStreamAsync<List<GetQueryRule>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/AuthApi/AuthApiClient.cs b/arangodb-net-standard/AuthApi/AuthApiClient.cs
index 7c0678f4..c263c32b 100644
--- a/arangodb-net-standard/AuthApi/AuthApiClient.cs
+++ b/arangodb-net-standard/AuthApi/AuthApiClient.cs
@@ -69,15 +69,15 @@ public virtual async Task<JwtTokenResponse> GetJwtTokenAsync(
             JwtTokenRequestBody body,
             CancellationToken token = default)
         {
-            byte[] content = GetContent(body, new ApiClientSerializationOptions(true, false));
+            byte[] content = await GetContentAsync(body, new ApiClientSerializationOptions(true, false)).ConfigureAwait(false);
             using (var response = await _client.PostAsync("/_open/auth", content,null,token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<JwtTokenResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<JwtTokenResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/BulkOperationsApi/BulkOperationsApiClient.cs b/arangodb-net-standard/BulkOperationsApi/BulkOperationsApiClient.cs
index 16053271..b4d9223a 100644
--- a/arangodb-net-standard/BulkOperationsApi/BulkOperationsApiClient.cs
+++ b/arangodb-net-standard/BulkOperationsApi/BulkOperationsApiClient.cs
@@ -88,7 +88,7 @@ public virtual async Task<ImportDocumentsResponse> PostImportDocumentArraysAsync
             var options = new ApiClientSerializationOptions(true, true);
             foreach (var valueArr in body.ValueArrays)
             {
-                sb.AppendLine(GetContentString(valueArr, options));
+                sb.AppendLine(await GetContentStringAsync(valueArr, options).ConfigureAwait(false));
             }
             return await PostImportDocumentArraysAsync(query, sb.ToString(),token)
                 .ConfigureAwait(false);
@@ -130,9 +130,9 @@ public virtual async Task<ImportDocumentsResponse> PostImportDocumentArraysAsync
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<ImportDocumentsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<ImportDocumentsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -177,13 +177,13 @@ public virtual async Task<ImportDocumentsResponse> PostImportDocumentObjectsAsyn
                 //body should be a list of documents seperated by newline char
                 foreach (var doc in body.Documents)
                 {
-                    sb.AppendLine(GetContentString(doc, options));
+                    sb.AppendLine(await GetContentStringAsync(doc, options).ConfigureAwait(false));
                 }
             }
             else
             {
                 //body should be one array of JSON objects
-                sb.Append(GetContentString(body.Documents, options));
+                sb.Append(await GetContentStringAsync(body.Documents, options).ConfigureAwait(false));
             }
             return await PostImportDocumentObjectsAsync(query, sb.ToString(),token)
                 .ConfigureAwait(false);
@@ -232,9 +232,9 @@ public virtual async Task<ImportDocumentsResponse> PostImportDocumentObjectsAsyn
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<ImportDocumentsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<ImportDocumentsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/CollectionApi/CollectionApiClient.cs b/arangodb-net-standard/CollectionApi/CollectionApiClient.cs
index 08c7d062..e4b4a6cf 100644
--- a/arangodb-net-standard/CollectionApi/CollectionApiClient.cs
+++ b/arangodb-net-standard/CollectionApi/CollectionApiClient.cs
@@ -65,15 +65,15 @@ public virtual async Task<PostCollectionResponse> PostCollectionAsync(
             {
                 uriString += "?" + options.ToQueryString();
             }
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PostAsync(uriString, content, null, token).ConfigureAwait(false))
             {
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<PostCollectionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostCollectionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -94,9 +94,9 @@ public virtual async Task<DeleteCollectionResponse> DeleteCollectionAsync(string
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteCollectionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteCollectionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -121,9 +121,9 @@ public virtual async Task<TruncateCollectionResponse> TruncateCollectionAsync(st
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<TruncateCollectionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<TruncateCollectionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -147,9 +147,9 @@ public virtual async Task<GetCollectionCountResponse> GetCollectionCountAsync(st
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionCountResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionCountResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             };
         }
 
@@ -173,9 +173,9 @@ public virtual async Task<GetCollectionsResponse> GetCollectionsAsync(GetCollect
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -197,10 +197,10 @@ public async Task<GetCollectionResponse> GetCollectionAsync(string collectionNam
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    var collection = DeserializeJsonFromStream<GetCollectionResponse>(stream);
+                    var collection = await DeserializeJsonFromStreamAsync<GetCollectionResponse>(stream).ConfigureAwait(false);
                     return collection;
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -222,9 +222,9 @@ public virtual async Task<GetCollectionPropertiesResponse> GetCollectionProperti
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionPropertiesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionPropertiesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -239,20 +239,20 @@ public virtual async Task<GetCollectionPropertiesResponse> GetCollectionProperti
         public virtual async Task<RenameCollectionResponse> RenameCollectionAsync(string collectionName, RenameCollectionBody body,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, false));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, false)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(
                 _collectionApiPath + "/" + WebUtility.UrlEncode(collectionName) + "/rename", 
                 content,
                 null,
                 token).ConfigureAwait(false))
-            {
+           {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    var collection = DeserializeJsonFromStream<RenameCollectionResponse>(stream);
+                    var collection =await DeserializeJsonFromStreamAsync<RenameCollectionResponse>(stream).ConfigureAwait(false);
                     return collection;
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -274,9 +274,9 @@ public virtual async Task<GetCollectionRevisionResponse> GetCollectionRevisionAs
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionRevisionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionRevisionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -293,7 +293,7 @@ public virtual async Task<PutCollectionPropertyResponse> PutCollectionPropertyAs
             PutCollectionPropertyBody body,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(
                 _collectionApiPath + "/" + collectionName + "/properties", 
                 content,
@@ -303,9 +303,9 @@ public virtual async Task<PutCollectionPropertyResponse> PutCollectionPropertyAs
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutCollectionPropertyResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutCollectionPropertyResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -327,10 +327,10 @@ public virtual async Task<GetCollectionFiguresResponse> GetCollectionFiguresAsyn
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionFiguresResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionFiguresResponse>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             };
         }
 
@@ -361,9 +361,9 @@ public virtual async Task<GetChecksumResponse> GetChecksumAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetChecksumResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetChecksumResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -391,9 +391,9 @@ public virtual async Task<PutLoadIndexesIntoMemoryResponse> PutLoadIndexesIntoMe
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutLoadIndexesIntoMemoryResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutLoadIndexesIntoMemoryResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -417,9 +417,9 @@ public virtual async Task<PutRecalculateCountResponse> PutRecalculateCountAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutRecalculateCountResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutRecalculateCountResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -449,15 +449,15 @@ public virtual async Task<PutDocumentShardResponse> PutDocumentShardAsync(
                 throw new ArgumentException($"{nameof(body)} is required", nameof(body));
             }
             string uriString = _collectionApiPath + "/" + WebUtility.UrlEncode(collectionName) + "/responsibleShard";
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uriString, content, null, token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutDocumentShardResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutDocumentShardResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -482,9 +482,9 @@ public virtual async Task<GetCollectionShardsResponse> GetCollectionShardsAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionShardsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionShardsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -512,9 +512,9 @@ public virtual async Task<GetCollectionShardsDetailedResponse> GetCollectionShar
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCollectionShardsDetailedResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCollectionShardsDetailedResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -540,9 +540,9 @@ public virtual async Task<PutCompactCollectionDataResponse> PutCompactCollection
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutCompactCollectionDataResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutCompactCollectionDataResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/CursorApi/CursorApiClient.cs b/arangodb-net-standard/CursorApi/CursorApiClient.cs
index 16176f6a..60191545 100644
--- a/arangodb-net-standard/CursorApi/CursorApiClient.cs
+++ b/arangodb-net-standard/CursorApi/CursorApiClient.cs
@@ -122,7 +122,7 @@ public virtual async Task<CursorResponse<T>> PostCursorAsync<T>(
             CursorHeaderProperties headerProperties = null,
             CancellationToken token = default)
         {
-            var content = GetContent(postCursorBody, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(postCursorBody, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headerProperties);
             using (var response = await _client.PostAsync(_cursorApiPath,
                 content,
@@ -132,10 +132,9 @@ public virtual async Task<CursorResponse<T>> PostCursorAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<CursorResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<CursorResponse<T>>(stream).ConfigureAwait(false);
                 }
-
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -157,10 +156,10 @@ public virtual async Task<DeleteCursorResponse> DeleteCursorAsync(string cursorI
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteCursorResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteCursorResponse>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -181,10 +180,10 @@ public virtual async Task<PutCursorResponse<T>> PutCursorAsync<T>(string cursorI
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutCursorResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutCursorResponse<T>>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -205,9 +204,9 @@ public virtual async Task<CursorResponse<T>> PostAdvanceCursorAsync<T>(string cu
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<CursorResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<CursorResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/DatabaseApi/DatabaseApiClient.cs b/arangodb-net-standard/DatabaseApi/DatabaseApiClient.cs
index 776238e4..c749c665 100644
--- a/arangodb-net-standard/DatabaseApi/DatabaseApiClient.cs
+++ b/arangodb-net-standard/DatabaseApi/DatabaseApiClient.cs
@@ -55,15 +55,15 @@ public DatabaseApiClient(IApiClientTransport client, IApiClientSerialization ser
         /// <returns></returns>
         public virtual async Task<PostDatabaseResponse> PostDatabaseAsync(PostDatabaseBody request, CancellationToken token = default)
         {
-            var content = GetContent(request, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(request, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PostAsync(_databaseApiPath, content, null, token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostDatabaseResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostDatabaseResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -82,9 +82,9 @@ public virtual async Task<DeleteDatabaseResponse> DeleteDatabaseAsync(string dat
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteDatabaseResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteDatabaseResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -105,9 +105,9 @@ public virtual async Task<GetDatabasesResponse> GetDatabasesAsync(CancellationTo
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetDatabasesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetDatabasesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -123,9 +123,9 @@ public virtual async Task<GetDatabasesResponse> GetUserDatabasesAsync(Cancellati
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetDatabasesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetDatabasesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -141,9 +141,9 @@ public virtual async Task<GetCurrentDatabaseInfoResponse> GetCurrentDatabaseInfo
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetCurrentDatabaseInfoResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetCurrentDatabaseInfoResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/DocumentApi/DocumentApiClient.cs b/arangodb-net-standard/DocumentApi/DocumentApiClient.cs
index f5953c5e..54b4de9f 100644
--- a/arangodb-net-standard/DocumentApi/DocumentApiClient.cs
+++ b/arangodb-net-standard/DocumentApi/DocumentApiClient.cs
@@ -118,17 +118,17 @@ public virtual async Task<PostDocumentResponse<U>> PostDocumentAsync<T, U>(
                 uriString += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(document, serializationOptions);
+            var content = await GetContentAsync(document, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PostAsync(uriString, content, headerCollection, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostDocumentResponse<U>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostDocumentResponse<U>>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -158,7 +158,7 @@ public virtual async Task<PostDocumentsResponse<T>> PostDocumentsAsync<T>(
                 uriString += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(documents, serializationOptions);
+            var content = await GetContentAsync(documents, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PostAsync(uriString, content, headerCollection, token: token).ConfigureAwait(false))
             {
@@ -171,11 +171,11 @@ public virtual async Task<PostDocumentsResponse<T>> PostDocumentsAsync<T>(
                     else
                     {
                         var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                        return DeserializeJsonFromStream<PostDocumentsResponse<T>>(stream);
+                        return await DeserializeJsonFromStreamAsync<PostDocumentsResponse<T>>(stream).ConfigureAwait(false);
                     }
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -205,7 +205,7 @@ public virtual async Task<PutDocumentsResponse<T>> PutDocumentsAsync<T>(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(documents, serializationOptions);
+            var content = await GetContentAsync(documents, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PutAsync(uri, content, headerCollection, token: token).ConfigureAwait(false))
             {
@@ -218,11 +218,11 @@ public virtual async Task<PutDocumentsResponse<T>> PutDocumentsAsync<T>(
                     else
                     {
                         var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                        return DeserializeJsonFromStream<PutDocumentsResponse<T>>(stream);
+                        return await DeserializeJsonFromStreamAsync<PutDocumentsResponse<T>>(stream).ConfigureAwait(false);
                     }
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -255,17 +255,17 @@ public virtual async Task<PutDocumentResponse<T>> PutDocumentAsync<T>(
                 uri += "?" + opts.ToQueryString();
             }
 
-            var content = GetContent(doc, serializationOptions);
+            var content = await GetContentAsync(doc, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PutAsync(uri, content, headerCollection, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutDocumentResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutDocumentResponse<T>>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -344,11 +344,11 @@ public virtual async Task<T> GetDocumentAsync<T>(
             if (response.IsSuccessStatusCode)
             {
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                var document = DeserializeJsonFromStream<T>(stream);
+                var document = await DeserializeJsonFromStreamAsync<T>(stream).ConfigureAwait(false);
                 return document;
             }
 
-            throw await GetApiErrorException(response).ConfigureAwait(false);
+            throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -372,18 +372,18 @@ public virtual async Task<List<T>> GetDocumentsAsync<T>(
             CancellationToken token = default)
         {
             string uri = $"{_docApiPath}/{WebUtility.UrlEncode(collectionName)}?onlyget=true";
-            var content = GetContent(selectors, new ApiClientSerializationOptions(false, true));
+            var content = await GetContentAsync(selectors, new ApiClientSerializationOptions(false, true)).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PutAsync(uri, content, headerCollection, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    var documents = DeserializeJsonFromStream<List<T>>(stream);
+                    var documents = await DeserializeJsonFromStreamAsync<List<T>>(stream).ConfigureAwait(false);
                     return documents;
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -486,11 +486,11 @@ public virtual async Task<DeleteDocumentResponse<T>> DeleteDocumentAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    var responseModel = DeserializeJsonFromStream<DeleteDocumentResponse<T>>(stream);
+                    var responseModel = await DeserializeJsonFromStreamAsync<DeleteDocumentResponse<T>>(stream).ConfigureAwait(false);
                     return responseModel;
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -544,7 +544,7 @@ public virtual async Task<DeleteDocumentsResponse<T>> DeleteDocumentsAsync<T>(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(selectors, new ApiClientSerializationOptions(false, false));
+            var content = await GetContentAsync(selectors, new ApiClientSerializationOptions(false, false)).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.DeleteAsync(uri, content, headerCollection, token: token).ConfigureAwait(false))
             {
@@ -557,11 +557,11 @@ public virtual async Task<DeleteDocumentsResponse<T>> DeleteDocumentsAsync<T>(
                     else
                     {
                         var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                        return DeserializeJsonFromStream<DeleteDocumentsResponse<T>>(stream);
+                        return await DeserializeJsonFromStreamAsync<DeleteDocumentsResponse<T>>(stream).ConfigureAwait(false); 
                     }
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -605,7 +605,7 @@ public virtual async Task<PatchDocumentsResponse<U>> PatchDocumentsAsync<T, U>(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(patches, serializationOptions);
+            var content = await GetContentAsync(patches, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PatchAsync(uri, content, headerCollection, token: token).ConfigureAwait(false))
             {
@@ -618,11 +618,11 @@ public virtual async Task<PatchDocumentsResponse<U>> PatchDocumentsAsync<T, U>(
                     else
                     {
                         var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                        return DeserializeJsonFromStream<PatchDocumentsResponse<U>>(stream);
+                        return await DeserializeJsonFromStreamAsync<PatchDocumentsResponse<U>>(stream).ConfigureAwait(false);
                     }
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -735,17 +735,17 @@ public virtual async Task<PatchDocumentResponse<U>> PatchDocumentAsync<T, U>(
                 uriString += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(body, serializationOptions);
+            var content = await GetContentAsync(body, serializationOptions).ConfigureAwait(false);
             var headerCollection = GetHeaderCollection(headers);
             using (var response = await _client.PatchAsync(uriString, content, headerCollection, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PatchDocumentResponse<U>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PatchDocumentResponse<U>>(stream).ConfigureAwait(false);
                 }
 
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
diff --git a/arangodb-net-standard/GraphApi/GraphApiClient.cs b/arangodb-net-standard/GraphApi/GraphApiClient.cs
index 3b6b81c3..cc5d9e96 100644
--- a/arangodb-net-standard/GraphApi/GraphApiClient.cs
+++ b/arangodb-net-standard/GraphApi/GraphApiClient.cs
@@ -70,16 +70,16 @@ public virtual async Task<PostGraphResponse> PostGraphAsync(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(postGraphBody, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(postGraphBody, new ApiClientSerializationOptions(true, true));
 
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostGraphResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostGraphResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -100,9 +100,9 @@ public virtual async Task<GetGraphsResponse> GetGraphsAsync( CancellationToken t
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetGraphsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetGraphsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -130,9 +130,9 @@ public virtual async Task<DeleteGraphResponse> DeleteGraphAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteGraphResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteGraphResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -151,9 +151,9 @@ public virtual async Task<GetGraphResponse> GetGraphAsync(string graphName, Canc
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetGraphResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetGraphResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -171,9 +171,9 @@ public virtual async Task<GetVertexCollectionsResponse> GetVertexCollectionsAsyn
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetVertexCollectionsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetVertexCollectionsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -191,9 +191,9 @@ public virtual async Task<GetEdgeCollectionsResponse> GetEdgeCollectionsAsync(st
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetEdgeCollectionsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetEdgeCollectionsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -215,7 +215,7 @@ public virtual async Task<PostEdgeDefinitionResponse> PostEdgeDefinitionAsync(
             string graphName,
             PostEdgeDefinitionBody body, CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true));
 
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) + "/edge";
 
@@ -224,9 +224,9 @@ public virtual async Task<PostEdgeDefinitionResponse> PostEdgeDefinitionAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostEdgeDefinitionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostEdgeDefinitionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -245,16 +245,16 @@ public virtual async Task<PostVertexCollectionResponse> PostVertexCollectionAsyn
         {
             string uri = _graphApiPath + '/' + WebUtility.UrlEncode(graphName) + "/vertex";
 
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true));
 
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostVertexCollectionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostVertexCollectionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -287,15 +287,15 @@ public virtual async Task<PostVertexResponse<T>> PostVertexAsync<T>(
             {
                 uri += "?" + query.ToQueryString();
             }
-            var content = GetContent(vertex, serializationOptions);
+            var content = await GetContentAsync(vertex, serializationOptions).ConfigureAwait(false);
             using (var response = await _transport.PostAsync(uri, content,headers?.ToWebHeaderCollection(), token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostVertexResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostVertexResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -326,9 +326,9 @@ public virtual async Task<DeleteEdgeDefinitionResponse> DeleteEdgeDefinitionAsyn
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteEdgeDefinitionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteEdgeDefinitionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -360,9 +360,9 @@ public virtual async Task<DeleteVertexCollectionResponse> DeleteVertexCollection
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteVertexCollectionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteVertexCollectionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -394,7 +394,7 @@ public virtual async Task<PostEdgeResponse<T>> PostEdgeAsync<T>(
             GraphHeaderProperties headers = null, 
             CancellationToken token = default)
         {
-            var content = GetContent(edge, serializationOptions);
+            var content = await GetContentAsync(edge, serializationOptions);
 
             string uri = _graphApiPath + "/" + WebUtility.UrlEncode(graphName) +
                 "/edge/" + WebUtility.UrlEncode(collectionName);
@@ -409,9 +409,9 @@ public virtual async Task<PostEdgeResponse<T>> PostEdgeAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostEdgeResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostEdgeResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -472,9 +472,9 @@ public virtual async Task<GetEdgeResponse<T>> GetEdgeAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetEdgeResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetEdgeResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -540,9 +540,9 @@ public virtual async Task<DeleteEdgeResponse<T>> DeleteEdgeAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteEdgeResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteEdgeResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -603,9 +603,9 @@ public virtual async Task<GetVertexResponse<T>> GetVertexAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetVertexResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetVertexResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -668,9 +668,9 @@ public virtual async Task<DeleteVertexResponse<T>> DeleteVertexAsync<T>(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteVertexResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteVertexResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -748,15 +748,15 @@ public virtual async Task<PatchVertexResponse<U>> PatchVertexAsync<T, U>(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(body, serializationOptions);
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(false, false)).ConfigureAwait(false);
             using (var response = await _transport.PatchAsync(uri, content,headers?.ToWebHeaderCollection(), token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PatchVertexResponse<U>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PatchVertexResponse<U>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -828,16 +828,15 @@ public virtual async Task<PutEdgeResponse<T>> PutEdgeAsync<T>(
                 uri += "?" + query.ToQueryString();
             }
 
-            var content = GetContent(edge, serializationOptions);
-
+            var content = await GetContentAsync(edge, new ApiClientSerializationOptions(false, false)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, headers?.ToWebHeaderCollection(), token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutEdgeResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutEdgeResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -866,15 +865,15 @@ public virtual async Task<PutEdgeDefinitionResponse> PutEdgeDefinitionAsync(
             {
                 uriString += "?" + query.ToQueryString();
             }
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uriString, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutEdgeDefinitionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutEdgeDefinitionResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -948,16 +947,15 @@ public virtual async Task<PatchEdgeResponse<U>> PatchEdgeAsync<T, U>(
             {
                 uri += "?" + query.ToQueryString();
             }
-
-            var content = GetContent(edge, serializationOptions);
+            var content = await GetContentAsync(edge, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PatchAsync(uri, content, headers?.ToWebHeaderCollection(), token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PatchEdgeResponse<U>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PatchEdgeResponse<U>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -1027,16 +1025,15 @@ public virtual async Task<PutVertexResponse<T>> PutVertexAsync<T>(
             {
                 uri += "?" + query.ToQueryString();
             }
-            var content = GetContent(vertex, serializationOptions);
+            var content = await GetContentAsync(vertex, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, headers?.ToWebHeaderCollection(),token:token).ConfigureAwait(false))
-
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutVertexResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutVertexResponse<T>>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
diff --git a/arangodb-net-standard/IndexApi/IndexApiClient.cs b/arangodb-net-standard/IndexApi/IndexApiClient.cs
index 884ff953..32ce5a54 100644
--- a/arangodb-net-standard/IndexApi/IndexApiClient.cs
+++ b/arangodb-net-standard/IndexApi/IndexApiClient.cs
@@ -63,9 +63,9 @@ public virtual async Task<GetIndexResponse> GetIndexAsync(string indexId,
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetIndexResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetIndexResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -84,9 +84,9 @@ public virtual async Task<DeleteIndexResponse> DeleteIndexAsync(string indexId,
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteIndexResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteIndexResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -119,9 +119,9 @@ public virtual async Task<GetAllCollectionIndexesResponse> GetAllCollectionIndex
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAllCollectionIndexesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAllCollectionIndexesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -158,15 +158,15 @@ public virtual async Task<IndexResponseBase> PostIndexAsync(PostIndexQuery query
             }
 
             uri += '?' + query.ToQueryString();
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PostAsync(uri, content,token:token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<IndexResponseBase>(stream);
+                    return await DeserializeJsonFromStreamAsync<IndexResponseBase>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
diff --git a/arangodb-net-standard/PregelApi/PregelApiClient.cs b/arangodb-net-standard/PregelApi/PregelApiClient.cs
index 565dd92b..b049f539 100644
--- a/arangodb-net-standard/PregelApi/PregelApiClient.cs
+++ b/arangodb-net-standard/PregelApi/PregelApiClient.cs
@@ -68,15 +68,15 @@ public PregelApiClient(IApiClientTransport transport, IApiClientSerialization se
         public virtual async Task<string> PostStartJobAsync(PostStartJobBody body, CancellationToken token = default)
         {
             string uri = _apiPath;
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true));
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<string>(stream);
+                    return await DeserializeJsonFromStreamAsync<string>(stream);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -99,9 +99,9 @@ public virtual async Task<PregelJobStatus> GetJobStatusAsync(string jobId, Cance
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PregelJobStatus>(stream);
+                    return await DeserializeJsonFromStreamAsync<PregelJobStatus>(stream);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -122,9 +122,9 @@ public virtual async Task<List<PregelJobStatus>> GetAllRunningJobsAsync(Cancella
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<List<PregelJobStatus>>(stream);
+                    return await DeserializeJsonFromStreamAsync<List<PregelJobStatus>>(stream);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -150,9 +150,9 @@ public virtual async Task<string> DeleteJobAsync(string jobId, CancellationToken
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<string>(stream);
+                    return await DeserializeJsonFromStreamAsync<string>(stream);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/Serialization/ApiClientSerialization.cs b/arangodb-net-standard/Serialization/ApiClientSerialization.cs
index a8245d16..3964f469 100644
--- a/arangodb-net-standard/Serialization/ApiClientSerialization.cs
+++ b/arangodb-net-standard/Serialization/ApiClientSerialization.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace ArangoDBNetStandard.Serialization
 {
@@ -28,6 +29,15 @@ public abstract class ApiClientSerialization : IApiClientSerialization
         /// <returns></returns>
         public abstract T DeserializeFromStream<T>(Stream stream);
 
+        /// <summary>
+        /// Asynchronously deserializes the data structure contained by the specified stream
+        /// into an instance of the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+        /// <param name="stream">The stream containing the JSON structure to deserialize.</param>
+        /// <returns></returns>
+        public abstract Task<T> DeserializeFromStreamAsync<T>(Stream stream);
+
         /// <summary>
         /// Serializes the specified object to a sequence of bytes,
         /// following the provided rules for camel case property name and null value handling.
@@ -39,6 +49,17 @@ public abstract class ApiClientSerialization : IApiClientSerialization
         /// <returns></returns>
         public abstract byte[] Serialize<T>(T item, ApiClientSerializationOptions serializationOptions);
 
+        /// <summary>
+        /// Asynchronously serializes the specified object to a sequence of bytes,
+        /// following the provided rules for camel case property name and null value handling.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to serialize.</typeparam>
+        /// <param name="item">The object to serialize.</param>
+        /// <param name="serializationOptions">The serialization options. When the value is null the
+        /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
+        /// <returns></returns>
+        public abstract Task<byte[]> SerializeAsync<T>(T item, ApiClientSerializationOptions serializationOptions);
+
         /// <summary>
         /// Serializes the specified object to a JSON string,
         /// following the provided rules for camel case property name and null value handling.
@@ -49,5 +70,16 @@ public abstract class ApiClientSerialization : IApiClientSerialization
         /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
         /// <returns></returns>
         public abstract string SerializeToString<T>(T item, ApiClientSerializationOptions serializationOptions);
+
+        /// <summary>
+        /// Asynchronously serializes the specified object to a JSON string,
+        /// following the provided rules for camel case property name and null value handling.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to serialize.</typeparam>
+        /// <param name="item">The object to serialize.</param>
+        /// <param name="serializationOptions">The serialization options. When the value is null the
+        /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
+        /// <returns></returns>
+        public abstract Task<string> SerializeToStringAsync<T>(T item, ApiClientSerializationOptions serializationOptions);
     }
 }
diff --git a/arangodb-net-standard/Serialization/IApiClientSerialization.cs b/arangodb-net-standard/Serialization/IApiClientSerialization.cs
index f2731190..1c0bfe14 100644
--- a/arangodb-net-standard/Serialization/IApiClientSerialization.cs
+++ b/arangodb-net-standard/Serialization/IApiClientSerialization.cs
@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 
 namespace ArangoDBNetStandard.Serialization
 {
@@ -8,16 +9,16 @@ namespace ArangoDBNetStandard.Serialization
     public interface IApiClientSerialization
     {
         /// <summary>
-        /// Deserializes the data structure contained by the specified stream
+        /// Asynchronously deserializes the data structure contained by the specified stream
         /// into an instance of the specified type.
         /// </summary>
         /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
         /// <param name="stream">The stream containing the JSON structure to deserialize.</param>
         /// <returns></returns>
-        T DeserializeFromStream<T>(Stream stream);
+        Task<T> DeserializeFromStreamAsync<T>(Stream stream);
 
         /// <summary>
-        /// Serializes the specified object to a sequence of bytes,
+        /// Asynchronously serializes the specified object to a sequence of bytes,
         /// following the provided rules for camel case property name and null value handling.
         /// </summary>
         /// <typeparam name="T">The type of the object to serialize.</typeparam>
@@ -25,10 +26,10 @@ public interface IApiClientSerialization
         /// <param name="serializationOptions">The serialization options. When the value is null the
         /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
         /// <returns></returns>
-        byte[] Serialize<T>(T item, ApiClientSerializationOptions serializationOptions);
+        Task<byte[]> SerializeAsync<T>(T item, ApiClientSerializationOptions serializationOptions);
 
         /// <summary>
-        /// Serializes the specified object to a JSON string,
+        /// Asynchronously serializes the specified object to a JSON string,
         /// following the provided rules for camel case property name and null value handling.
         /// </summary>
         /// <typeparam name="T">The type of the object to serialize.</typeparam>
@@ -36,6 +37,6 @@ public interface IApiClientSerialization
         /// <param name="serializationOptions">The serialization options. When the value is null the
         /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
         /// <returns></returns>
-        string SerializeToString<T>(T item, ApiClientSerializationOptions serializationOptions);
+        Task<string> SerializeToStringAsync<T>(T item, ApiClientSerializationOptions serializationOptions);
     }
-}
+}
\ No newline at end of file
diff --git a/arangodb-net-standard/Serialization/JsonNetApiClientSerialization.cs b/arangodb-net-standard/Serialization/JsonNetApiClientSerialization.cs
index 89635b59..c03543f0 100644
--- a/arangodb-net-standard/Serialization/JsonNetApiClientSerialization.cs
+++ b/arangodb-net-standard/Serialization/JsonNetApiClientSerialization.cs
@@ -2,7 +2,9 @@
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
 using System.IO;
+using System.Runtime.InteropServices.ComTypes;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace ArangoDBNetStandard.Serialization
 {
@@ -36,6 +38,19 @@ public override T DeserializeFromStream<T>(Stream stream)
             }
         }
 
+        /// <summary>
+        /// Asynchronously deserializes the data structure contained by the specified stream
+        /// into an instance of the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to deserialize to.</typeparam>
+        /// <param name="stream">The stream containing the JSON structure to deserialize.</param>
+        /// <returns></returns>
+        public override async Task<T> DeserializeFromStreamAsync<T>(Stream stream)
+        {
+            T result = DeserializeFromStream<T>(stream);
+            return await Task.FromResult(result);
+        }
+
         /// <summary>
         /// 
         /// </summary>
@@ -51,6 +66,20 @@ public override byte[] Serialize<T>(T item, ApiClientSerializationOptions serial
             return Encoding.UTF8.GetBytes(json);
         }
 
+        /// <summary>
+        /// Asynchronously serializes the specified object to a sequence of bytes,
+        /// following the provided rules for camel case property name and null value handling.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to serialize.</typeparam>
+        /// <param name="item">The object to serialize.</param>
+        /// <param name="serializationOptions">The serialization options. When the value is null the
+        /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
+        /// <returns></returns>
+        public override async Task<byte[]> SerializeAsync<T>(T item, ApiClientSerializationOptions serializationOptions)
+        {
+            var result = Serialize<T>(item,serializationOptions);
+            return await Task.FromResult(result);
+        }
 
         /// <summary>
         /// Serializes an object to JSON string
@@ -90,5 +119,20 @@ public override string SerializeToString<T>(T item, ApiClientSerializationOption
 
             return json;
         }
+
+        /// <summary>
+        /// Asynchronously serializes the specified object to a JSON string,
+        /// following the provided rules for camel case property name and null value handling.
+        /// </summary>
+        /// <typeparam name="T">The type of the object to serialize.</typeparam>
+        /// <param name="item">The object to serialize.</param>
+        /// <param name="serializationOptions">The serialization options. When the value is null the
+        /// the serialization options should be provided by the serializer, otherwise the given options should be used.</param>
+        /// <returns></returns>
+        public override async Task<string> SerializeToStringAsync<T>(T item, ApiClientSerializationOptions serializationOptions)
+        {
+            var result = SerializeToString(item, serializationOptions);
+            return await Task.FromResult(result);
+        }
     }
 }
diff --git a/arangodb-net-standard/TransactionApi/TransactionApiClient.cs b/arangodb-net-standard/TransactionApi/TransactionApiClient.cs
index 66cc0827..8f8af105 100644
--- a/arangodb-net-standard/TransactionApi/TransactionApiClient.cs
+++ b/arangodb-net-standard/TransactionApi/TransactionApiClient.cs
@@ -65,16 +65,16 @@ public virtual async Task<PostTransactionResponse<T>> PostTransactionAsync<T>(
             PostTransactionBody body,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PostAsync(_transactionApiPath, content, token: token).ConfigureAwait(false))
             {
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<PostTransactionResponse<T>>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostTransactionResponse<T>>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error = await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
@@ -101,10 +101,10 @@ public virtual async Task<StreamTransactionResponse> AbortTransaction(string tra
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<StreamTransactionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<StreamTransactionResponse>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error = await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
@@ -130,7 +130,7 @@ public virtual async Task<StreamTransactionResponse> BeginTransaction(
             ApiHeaderProperties headerProperties = null,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true));
             string beginTransactionPath = string.Format(_streamTransactionApiPath, "begin");
             using (var response = await _client.PostAsync(
                 beginTransactionPath,
@@ -141,10 +141,10 @@ public virtual async Task<StreamTransactionResponse> BeginTransaction(
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<StreamTransactionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<StreamTransactionResponse>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error = await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
@@ -171,10 +171,10 @@ public virtual async Task<StreamTransactionResponse> CommitTransaction(string tr
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<StreamTransactionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<StreamTransactionResponse>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error = await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
@@ -195,10 +195,10 @@ public virtual async Task<StreamTransactions> GetAllRunningTransactions(
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<StreamTransactions>(stream);
+                    return await DeserializeJsonFromStreamAsync<StreamTransactions>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error = await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
@@ -222,10 +222,10 @@ public virtual async Task<StreamTransactionResponse> GetTransactionStatus(string
                 var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
                 if (response.IsSuccessStatusCode)
                 {
-                    return DeserializeJsonFromStream<StreamTransactionResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<StreamTransactionResponse>(stream).ConfigureAwait(false);
                 }
 
-                var error = DeserializeJsonFromStream<ApiErrorResponse>(stream);
+                var error =await DeserializeJsonFromStreamAsync<ApiErrorResponse>(stream).ConfigureAwait(false);
                 throw new ApiErrorException(error);
             }
         }
diff --git a/arangodb-net-standard/UserApi/UserApiClient.cs b/arangodb-net-standard/UserApi/UserApiClient.cs
index 6c4b376e..35a955e8 100644
--- a/arangodb-net-standard/UserApi/UserApiClient.cs
+++ b/arangodb-net-standard/UserApi/UserApiClient.cs
@@ -58,15 +58,15 @@ public UserApiClient(IApiClientTransport client, IApiClientSerialization seriali
         public virtual async Task<PostUserResponse> PostUserAsync(PostUserBody body,
             CancellationToken token = default)
         {
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PostAsync(_userApiPath, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PostUserResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PostUserResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -83,15 +83,15 @@ public virtual async Task<PutUserResponse> PutUserAsync(string username, PutUser
             CancellationToken token = default)
         {
             string uri = _userApiPath + '/' + username;
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutUserResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutUserResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -108,15 +108,15 @@ public virtual async Task<PatchUserResponse> PatchUserAsync(string username, Pat
             CancellationToken token = default)
         {
             string uri = _userApiPath + '/' + username;
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PatchAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PatchUserResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PatchUserResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -137,9 +137,9 @@ public virtual async Task<GetUserResponse> GetUserAsync(string username,
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetUserResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetUserResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -159,9 +159,9 @@ public virtual async Task<DeleteUserResponse> DeleteUserAsync(string username,
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteUserResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteUserResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -181,9 +181,9 @@ public virtual async Task<GetUsersResponse> GetUsersAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetUsersResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetUsersResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -204,15 +204,15 @@ public virtual async Task<PutAccessLevelResponse> PutDatabaseAccessLevelAsync(
         {
             string uri = _userApiPath + "/" + WebUtility.UrlEncode(username)
                 + "/database/" + WebUtility.UrlEncode(dbName);
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -235,9 +235,9 @@ public virtual async Task<GetAccessLevelResponse> GetDatabaseAccessLevelAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -263,9 +263,9 @@ public virtual async Task<DeleteAccessLevelResponse> DeleteDatabaseAccessLevelAs
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -292,9 +292,9 @@ public virtual async Task<GetAccessibleDatabasesResponse> GetAccessibleDatabases
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAccessibleDatabasesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAccessibleDatabasesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -318,15 +318,15 @@ public virtual async Task<PutAccessLevelResponse> PutCollectionAccessLevelAsync(
             string uri = _userApiPath + "/" + WebUtility.UrlEncode(username)
                 + "/database/" + WebUtility.UrlEncode(dbName) + "/" +
                 WebUtility.UrlEncode(collectionName);
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _client.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -352,9 +352,9 @@ public virtual async Task<GetAccessLevelResponse> GetCollectionAccessLevelAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -383,9 +383,9 @@ public virtual async Task<DeleteAccessLevelResponse> DeleteCollectionAccessLevel
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteAccessLevelResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteAccessLevelResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }
diff --git a/arangodb-net-standard/ViewApi/ViewsApiClient.cs b/arangodb-net-standard/ViewApi/ViewsApiClient.cs
index 97d66670..dde01428 100644
--- a/arangodb-net-standard/ViewApi/ViewsApiClient.cs
+++ b/arangodb-net-standard/ViewApi/ViewsApiClient.cs
@@ -62,9 +62,9 @@ public virtual async Task<GetAllViewsResponse> GetAllViewsAsync(
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetAllViewsResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetAllViewsResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -83,19 +83,19 @@ public virtual async Task<GetAllViewsResponse> GetAllViewsAsync(
         public virtual async Task<ViewResponse> PostCreateViewAsync(ViewDetails body, bool ignoreNullValuesOnSerialization=true, CancellationToken token = default)
         {
             string uri = _apiPath;
-            var content = GetContent(body, 
-                new ApiClientSerializationOptions(
-                    useCamelCasePropertyNames: true,
-                    ignoreNullValues: ignoreNullValuesOnSerialization,
-                    applySerializationOptionsToDictionaryValues: true));
+
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(useCamelCasePropertyNames: true,
+                                                                                        ignoreNullValues: ignoreNullValuesOnSerialization,
+                                                                                        applySerializationOptionsToDictionaryValues: true)).ConfigureAwait(false);
+
             using (var response = await _transport.PostAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<ViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -115,9 +115,9 @@ public virtual async Task<DeleteViewResponse> DeleteViewAsync(string viewNameOrI
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<DeleteViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<DeleteViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -137,9 +137,9 @@ public virtual async Task<GetViewResponse> GetViewAsync(string viewNameOrId,
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -159,9 +159,9 @@ public virtual async Task<GetViewPropertiesResponse> GetViewPropertiesAsync(stri
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<GetViewPropertiesResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<GetViewPropertiesResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -182,19 +182,18 @@ public virtual async Task<ViewResponse> PatchViewPropertiesAsync(string viewName
             bool ignoreNullValuesOnSerialization = true, CancellationToken token = default)
         {
             string uri = $"{_apiPath}/{viewNameOrId}/properties";
-            var content = GetContent(body,
-                new ApiClientSerializationOptions(
-                    useCamelCasePropertyNames: true,
-                    ignoreNullValues: ignoreNullValuesOnSerialization,
-                    applySerializationOptionsToDictionaryValues: true));
+
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(useCamelCasePropertyNames: true,
+                                                                                        ignoreNullValues: ignoreNullValuesOnSerialization,
+                                                                                        applySerializationOptionsToDictionaryValues: true)).ConfigureAwait(false);
             using (var response = await _transport.PatchAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<ViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -215,19 +214,18 @@ public virtual async Task<ViewResponse> PutViewPropertiesAsync(string viewName,
             bool ignoreNullValuesOnSerialization = true, CancellationToken token = default)
         {
             string uri = $"{_apiPath}/{viewName}/properties";
-            var content = GetContent(body,
-                new ApiClientSerializationOptions(
-                    useCamelCasePropertyNames: true,
-                    ignoreNullValues: ignoreNullValuesOnSerialization,
-                    applySerializationOptionsToDictionaryValues: true));
+
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(useCamelCasePropertyNames: true,
+                                                                                        ignoreNullValues: ignoreNullValuesOnSerialization,
+                                                                                        applySerializationOptionsToDictionaryValues: true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<ViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<ViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
 
@@ -243,15 +241,15 @@ public virtual async Task<PutRenameViewResponse> PutRenameViewAsync(string viewN
             CancellationToken token = default)
         {
             string uri = $"{_apiPath}/{viewName}/rename";
-            var content = GetContent(body, new ApiClientSerializationOptions(true, true));
+            var content = await GetContentAsync(body, new ApiClientSerializationOptions(true, true)).ConfigureAwait(false);
             using (var response = await _transport.PutAsync(uri, content, token: token).ConfigureAwait(false))
             {
                 if (response.IsSuccessStatusCode)
                 {
                     var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                    return DeserializeJsonFromStream<PutRenameViewResponse>(stream);
+                    return await DeserializeJsonFromStreamAsync<PutRenameViewResponse>(stream).ConfigureAwait(false);
                 }
-                throw await GetApiErrorException(response).ConfigureAwait(false);
+                throw await GetApiErrorExceptionAsync(response).ConfigureAwait(false);
             }
         }
     }