diff --git a/src/Flurl.Http.Xml/CapturedXmlContent.cs b/src/Flurl.Http.Xml/CapturedXmlContent.cs
index 8fea848..9a485db 100644
--- a/src/Flurl.Http.Xml/CapturedXmlContent.cs
+++ b/src/Flurl.Http.Xml/CapturedXmlContent.cs
@@ -9,10 +9,11 @@ namespace Flurl.Http.Xml
 	/// </summary>
 	public class CapturedXmlContent : CapturedStringContent
 	{
-		/// <summary>
-		/// Initializes a new instance of the <see cref="CapturedXmlContent"/> class.
-		/// </summary>
-		/// <param name="xml">The XML.</param>
-		public CapturedXmlContent(string xml) : base(xml, Encoding.UTF8, "application/xml") { }
+	    /// <summary>
+	    /// Initializes a new instance of the <see cref="CapturedXmlContent"/> class.
+	    /// </summary>
+	    /// <param name="xml">The XML.</param>
+	    /// <param name="mediaType">The media-type.</param>
+	    public CapturedXmlContent(string xml, string mediaType) : base(xml, Encoding.UTF8, mediaType) { }
 	}
 }
\ No newline at end of file
diff --git a/src/Flurl.Http.Xml/FlurlClientExtensions.cs b/src/Flurl.Http.Xml/FlurlClientExtensions.cs
index 1eb1a55..be087c5 100644
--- a/src/Flurl.Http.Xml/FlurlClientExtensions.cs
+++ b/src/Flurl.Http.Xml/FlurlClientExtensions.cs
@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
@@ -12,47 +14,49 @@ namespace Flurl.Http.Xml
 	/// </summary>
 	public static class FlurlClientExtensions
 	{
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="client">The client.</param>
-		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
-		/// <returns>
-		/// A Task whose result is the XML response body deserialized to an object of type T.
-		/// </returns>
-		public static Task<T> GetXmlAsync<T>(this FlurlClient client, CancellationToken cancellationToken)
+	    /// <summary>
+	    /// Sends an asynchronous GET request.
+	    /// </summary>
+	    /// <typeparam name="T"></typeparam>
+	    /// <param name="client">The client.</param>
+	    /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+	    /// <returns>
+	    /// A Task whose result is the XML response body deserialized to an object of type T.
+	    /// </returns>
+	    public static Task<T> GetXmlAsync<T>(this IFlurlClient client, CancellationToken cancellationToken)
 		{
 			return client.SendAsync(HttpMethod.Get, cancellationToken: cancellationToken).ReceiveXml<T>();
 		}
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <returns>A Task whose result is the XML response body deserialized to an object of type T.</returns>
-		public static Task<T> GetXmlAsync<T>(this FlurlClient client)
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <returns>A Task whose result is the XML response body deserialized to an object of type T.</returns>
+        public static Task<T> GetXmlAsync<T>(this IFlurlClient client)
 		{
 			return client.SendAsync(HttpMethod.Get).ReceiveXml<T>();
 		}
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <param name="client">The client.</param>
-		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
-		/// <returns>
-		/// A Task whose result is the XML response body parsed into an XDocument.
-		/// </returns>
-		public static Task<XDocument> GetXDocumentAsync(this FlurlClient client, CancellationToken cancellationToken)
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>
+        /// A Task whose result is the XML response body parsed into an XDocument.
+        /// </returns>
+        public static Task<XDocument> GetXDocumentAsync(this IFlurlClient client, CancellationToken cancellationToken)
 		{
 			return client.SendAsync(HttpMethod.Get, cancellationToken: cancellationToken).ReceiveXDocument();
 		}
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
-		public static Task<XDocument> GetXDocumentAsync(this FlurlClient client)
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
+        public static Task<XDocument> GetXDocumentAsync(this IFlurlClient client)
 		{
 			return client.SendAsync(HttpMethod.Get).ReceiveXDocument();
 		}
@@ -75,7 +79,7 @@ public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient
 		/// Sends an asynchronous GET request.
 		/// </summary>
 		/// <returns>A Task whose result is the XML response body parsed into a collection of XElements.</returns>
-		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient client, string expression)
+		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this IFlurlClient client, string expression)
 		{
 			return client.SendAsync(HttpMethod.Get).ReceiveXElementsFromXPath(expression);
 		}
@@ -90,7 +94,7 @@ public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient
 		/// <returns>
 		/// A Task whose result is the XML response body parsed into a collection of XElements.
 		/// </returns>
-		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient client, string expression, IXmlNamespaceResolver resolver, CancellationToken cancellationToken)
+		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this IFlurlClient client, string expression, IXmlNamespaceResolver resolver, CancellationToken cancellationToken)
 		{
 			return client.SendAsync(HttpMethod.Get, cancellationToken: cancellationToken).ReceiveXElementsFromXPath(expression, resolver);
 		}
@@ -99,23 +103,39 @@ public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient
 		/// Sends an asynchronous GET request.
 		/// </summary>
 		/// <returns>A Task whose result is the XML response body parsed into a collection of XElements.</returns>
-		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this FlurlClient client, string expression, IXmlNamespaceResolver resolver)
+		public static Task<IEnumerable<XElement>> GetXElementsFromXPath(this IFlurlClient client, string expression, IXmlNamespaceResolver resolver)
 		{
 			return client.SendAsync(HttpMethod.Get).ReceiveXElementsFromXPath(expression, resolver);
 		}
 
-		/// <summary>
-		/// Sends an asynchronous POST request.
-		/// </summary>
-		/// <param name="client">The client.</param>
-		/// <param name="data">Contents of the request body.</param>
-		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
-		/// <returns>
-		/// A Task whose result is the received HttpResponseMessage.
-		/// </returns>
-		public static Task<HttpResponseMessage> PostXmlAsync(this FlurlClient client, object data, CancellationToken cancellationToken)
+        private static string GetMediaType(this IFlurlClient client)
+	    {
+	        if (client.HttpClient.DefaultRequestHeaders.Accept.Any())
+	        {
+	            // return media type of first accepted media type containing "xml", else of first accepted media type
+	            var requestHeaders = client.HttpClient.DefaultRequestHeaders;
+                var accept = requestHeaders.Accept.First(x => x.MediaType.IndexOf("xml", StringComparison.OrdinalIgnoreCase) >= 0)
+	                ?? requestHeaders.Accept.First();
+
+	            return accept.MediaType;
+	        }
+
+            // no accepted media type present, return default
+	        return "application/xml";
+        }
+
+        /// <summary>
+        /// Sends an asynchronous POST request.
+        /// </summary>
+        /// <param name="client">The client.</param>
+        /// <param name="data">Contents of the request body.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>
+        /// A Task whose result is the received HttpResponseMessage.
+        /// </returns>
+        public static Task<HttpResponseMessage> PostXmlAsync(this IFlurlClient client, object data, CancellationToken cancellationToken)
 		{
-			var content = new CapturedXmlContent(client.Settings.XmlSerializer().Serialize(data));
+			var content = new CapturedXmlContent(client.Settings.XmlSerializer().Serialize(data), client.GetMediaType());
 			return client.SendAsync(HttpMethod.Post, content: content, cancellationToken: cancellationToken);
 		}
 
@@ -127,9 +147,9 @@ public static Task<HttpResponseMessage> PostXmlAsync(this FlurlClient client, ob
 		/// <returns>
 		/// A Task whose result is the received HttpResponseMessage.
 		/// </returns>
-		public static Task<HttpResponseMessage> PostXmlAsync(this FlurlClient client, object data)
+		public static Task<HttpResponseMessage> PostXmlAsync(this IFlurlClient client, object data)
 		{
-			var content = new CapturedXmlContent(client.Settings.XmlSerializer().Serialize(data));
+			var content = new CapturedXmlContent(client.Settings.XmlSerializer().Serialize(data), client.GetMediaType());
 			return client.SendAsync(HttpMethod.Post, content: content);
 		}
 	}
diff --git a/src/Flurl.Http.Xml/HttpResponseMessageExtensions.cs b/src/Flurl.Http.Xml/HttpResponseMessageExtensions.cs
index c617573..c6bf8d0 100644
--- a/src/Flurl.Http.Xml/HttpResponseMessageExtensions.cs
+++ b/src/Flurl.Http.Xml/HttpResponseMessageExtensions.cs
@@ -1,7 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Linq;
@@ -24,62 +26,91 @@ private static HttpCall GetHttpCall(HttpRequestMessage request)
 	        return null;
         }
 
-		/// <summary>
-		/// Deserializes XML-formatted HTTP response body to object of type T. Intended to chain off an async HTTP.
-		/// </summary>
-		/// <typeparam name="T">A type whose structure matches the expected XML response.</typeparam>
-		/// <returns>A Task whose result is an object containing data in the response body.</returns>
-		/// <example>x = await url.PosAsync(data).ReceiveXml&lt;T&gt;()</example>
-		public static async Task<T> ReceiveXml<T>(this Task<HttpResponseMessage> response)
-		{
-			var resp = await response.ConfigureAwait(false);
-			var call = GetHttpCall(resp.RequestMessage);
-			try
-			{
-				using (var stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false))
-				{
-					return call.Settings.XmlSerializer().Deserialize<T>(stream);
-				}
-			}
-			catch (Exception ex)
-			{
-				var s = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
-				call.Exception = ex;
-				throw new FlurlHttpException(call, s, ex);
-			}
-		}
+	    private static string GetMediaType(HttpRequestMessage request)
+	    {
+	        if (request.Headers.Accept.Any())
+	        {
+	            // return media type of first accepted media type containing "xml", else of first accepted media type
+	            var acceptHeader = request.Headers.Accept.First(x => x.MediaType.IndexOf("xml", StringComparison.OrdinalIgnoreCase) >= 0)
+	                         ?? request.Headers.Accept.First();
 
-		/// <summary>
-		/// Parses XML-formatted HTTP response body into an XDocument. Intended to chain off an async call.
-		/// </summary>
-		/// <returns>A Task whose result is an XDocument containing XML data from the response body.</returns>
-		/// <example>d = await url.PostAsync(data).ReceiveXDocument()</example>
-		public static async Task<XDocument> ReceiveXDocument(this Task<HttpResponseMessage> response)
-		{
-			var resp = await response.ConfigureAwait(false);
-			var call = GetHttpCall(resp.RequestMessage);
-			try
-			{
-				using (var stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false))
-				using (var streamReader = new StreamReader(stream))
-				{
-					return XDocument.Parse(streamReader.ReadToEnd());
-				}
-			}
-			catch (Exception ex)
-			{
-				var s = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
-				call.Exception = ex;
-				throw new FlurlHttpException(call, s, ex);
-			}
-		}
+	            return acceptHeader.MediaType;
+	        }
 
-		/// <summary>
-		/// Parses XML-formatted HTTP response body into a collection of XElements. Intended to chain off an async call.
-		/// </summary>
-		/// <returns>A Task whose result is a collection of XElements from an XDocument containing XML data from the response body.</returns>
-		/// <example>d = await url.PostAsync(data).ReceiveXElementsFromXPath(xpathExpression)</example>
-		public static async Task<IEnumerable<XElement>> ReceiveXElementsFromXPath(this Task<HttpResponseMessage> response, string expression)
+	        // no accepted media type present, return default
+	        return "application/xml";
+	    }
+
+        /// <summary>
+        /// Receives XML-formatted HTTP response body. Intended to chain off an async HTTP.
+        /// </summary>
+        /// <param name="responseMessage">The response.</param>
+        /// <returns>A Task whose result is a response message containing data in the response body.</returns>
+        /// <example>x = await url.PostAsync(data).ReceiveXmlResponseMessage()</example>
+        public static async Task<HttpResponseMessage> ReceiveXmlResponseMessage(this Task<HttpResponseMessage> responseMessage)
+	    {
+	        var response = await responseMessage.ConfigureAwait(false);
+	        response.Content.Headers.ContentType = new MediaTypeHeaderValue(GetMediaType(response.RequestMessage));
+
+            return response;
+	    }
+
+        private static async Task<T> ReceiveFromXmlStream<T>(this Task<HttpResponseMessage> response, Func<HttpCall, Stream, T> streamHandler)
+	    {
+	        var resp = await ReceiveXmlResponseMessage(response);
+	        var call = GetHttpCall(resp.RequestMessage);
+
+            try
+            {
+                using (var stream = await resp.Content.ReadAsStreamAsync().ConfigureAwait(false))
+	            {
+	                return streamHandler(call, stream);
+	            }
+	        }
+	        catch (Exception ex)
+	        {
+	            var s = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
+	            call.Exception = ex;
+	            throw new FlurlHttpException(call, s, ex);
+	        }
+	    }
+
+        /// <summary>
+        /// Deserializes XML-formatted HTTP response body to object of type T. Intended to chain off an async HTTP.
+        /// </summary>
+        /// <typeparam name="T">A type whose structure matches the expected XML response.</typeparam>
+        /// <param name="response">The response.</param>
+        /// <returns>A Task whose result is an object containing data in the response body.</returns>
+        /// <example>x = await url.PostAsync(data).ReceiveXml&lt;T&gt;()</example>
+        public static async Task<T> ReceiveXml<T>(this Task<HttpResponseMessage> response)
+	    {
+	        return await ReceiveFromXmlStream(response, (call, stm) => 
+                call.Settings.XmlSerializer().Deserialize<T>(stm));
+	    }
+
+        /// <summary>
+        /// Parses XML-formatted HTTP response body into an XDocument. Intended to chain off an async call.
+        /// </summary>
+        /// <param name="response">The response.</param>
+        /// <returns>A Task whose result is an XDocument containing XML data from the response body.</returns>
+        /// <example>d = await url.PostAsync(data).ReceiveXDocument()</example>
+        public static async Task<XDocument> ReceiveXDocument(this Task<HttpResponseMessage> response)
+	    {
+	        return await ReceiveFromXmlStream(response, (call, stm) =>
+	        {
+	            using (var streamReader = new StreamReader(stm))
+	            {
+	                return XDocument.Parse(streamReader.ReadToEnd());
+	            }
+            });
+	    }
+
+        /// <summary>
+        /// Parses XML-formatted HTTP response body into a collection of XElements. Intended to chain off an async call.
+        /// </summary>
+        /// <returns>A Task whose result is a collection of XElements from an XDocument containing XML data from the response body.</returns>
+        /// <example>d = await url.PostAsync(data).ReceiveXElementsFromXPath(xpathExpression)</example>
+        public static async Task<IEnumerable<XElement>> ReceiveXElementsFromXPath(this Task<HttpResponseMessage> response, string expression)
 		{
 			var doc = await response.ReceiveXDocument().ConfigureAwait(false);
 			return doc.XPathSelectElements(expression);
diff --git a/src/Flurl.Http.Xml/UrlExtensions.cs b/src/Flurl.Http.Xml/UrlExtensions.cs
index f84b7e5..1d71db7 100644
--- a/src/Flurl.Http.Xml/UrlExtensions.cs
+++ b/src/Flurl.Http.Xml/UrlExtensions.cs
@@ -12,39 +12,41 @@ namespace Flurl.Http.Xml
 	/// </summary>
 	public static class UrlExtensions
 	{
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <typeparam name="T"></typeparam>
-		/// <param name="url">The URL.</param>
-		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
-		/// <returns>
-		/// A Task whose result is the XML response body deserialized to an object of type T.
-		/// </returns>
-		public static Task<T> GetXmlAsync<T>(this Url url, CancellationToken cancellationToken) 
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="url">The URL.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>
+        /// A Task whose result is the XML response body deserialized to an object of type T.
+        /// </returns>
+        public static Task<T> GetXmlAsync<T>(this Url url, CancellationToken cancellationToken) 
 			=> new FlurlClient(url, true).GetXmlAsync<T>(cancellationToken);
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <returns>A Task whose result is the XML response body deserialized to an object of type T.</returns>
-		public static Task<T> GetXmlAsync<T>(this Url url) 
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="url">The URL.</param>
+        /// <returns>A Task whose result is the XML response body deserialized to an object of type T.</returns>
+        public static Task<T> GetXmlAsync<T>(this Url url) 
 			=> new FlurlClient(url, true).GetXmlAsync<T>();
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <param name="url">The URL.</param>
-		/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
-		/// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
-		public static Task<XDocument> GetXDocumentAsync(this Url url, CancellationToken cancellationToken) 
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="url">The URL.</param>
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
+        public static Task<XDocument> GetXDocumentAsync(this Url url, CancellationToken cancellationToken) 
 			=> new FlurlClient(url, true).GetXDocumentAsync(cancellationToken);
 
-		/// <summary>
-		/// Sends an asynchronous GET request.
-		/// </summary>
-		/// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
-		public static Task<XDocument> GetXDocumentAsync(this Url url) => new FlurlClient(url, true).GetXDocumentAsync();
+        /// <summary>
+        /// Sends an asynchronous GET request.
+        /// </summary>
+        /// <param name="url">The URL.</param>
+        /// <returns>A Task whose result is the XML response body parsed into an XDocument.</returns>
+        public static Task<XDocument> GetXDocumentAsync(this Url url) => new FlurlClient(url, true).GetXDocumentAsync();
 
 		/// <summary>
 		/// Sends an asynchronous GET request.
diff --git a/test/Flurl.Http.Xml.Tests/StringExtensionsShould.cs b/test/Flurl.Http.Xml.Tests/StringExtensionsShould.cs
index 820551d..6dc9958 100644
--- a/test/Flurl.Http.Xml.Tests/StringExtensionsShould.cs
+++ b/test/Flurl.Http.Xml.Tests/StringExtensionsShould.cs
@@ -3,7 +3,6 @@
 using System.Threading.Tasks;
 using System.Xml;
 using System.Xml.Linq;
-using Flurl.Http.Configuration;
 using Flurl.Http.Xml.Tests.Factories;
 using Flurl.Http.Xml.Tests.Models;
 using Xunit;
diff --git a/test/Flurl.Http.Xml.Tests/UrlExtensionsShould.cs b/test/Flurl.Http.Xml.Tests/UrlExtensionsShould.cs
index 80a50a2..f14092e 100644
--- a/test/Flurl.Http.Xml.Tests/UrlExtensionsShould.cs
+++ b/test/Flurl.Http.Xml.Tests/UrlExtensionsShould.cs
@@ -166,5 +166,21 @@ public async Task PostXmlToXDocumentWithCancellationTokenAsync()
 
             AssertXDocument(result, 3, "Test");
         }
+
+        [Theory]
+        [InlineData("text/xml", "text/xml")]
+        [InlineData("text/something+xml", "text/something+xml")]
+        [InlineData(null, "application/xml")]
+        public async Task ReceiveCorrectMediaType(string acceptMediaType, string expectedContentType)
+        {
+            FlurlHttp.Configure(c => c.HttpClientFactory = new EchoHttpClientFactory());
+
+            var result = await new Url("https://some.url")
+                .WithHeader("Accept", acceptMediaType)
+                .PostXmlAsync(new TestModel { Number = 3, Text = "Test" })
+                .ReceiveXmlResponseMessage();
+
+            Assert.Equal(expectedContentType, result?.Content?.Headers?.ContentType?.MediaType);
+        }
     }
 }