diff --git a/.gitattributes b/.gitattributes
index 50ca329f..2e46fbac 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,2 @@
+* text=auto
 *.sh eol=lf
diff --git a/src/HttpClientInterception/DelegateHelpers.cs b/src/HttpClientInterception/DelegateHelpers.cs
index 008e422a..308ba99f 100644
--- a/src/HttpClientInterception/DelegateHelpers.cs
+++ b/src/HttpClientInterception/DelegateHelpers.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace JustEat.HttpClientInterception
@@ -25,14 +26,14 @@ internal static class DelegateHelpers
         /// <returns>
         /// The converted delegate if <paramref name="onIntercepted"/> has a value; otherwise <see langword="null"/>.
         /// </returns>
-        internal static Func<HttpRequestMessage, Task<bool>>? ConvertToBooleanTask(Action<HttpRequestMessage>? onIntercepted)
+        internal static Func<HttpRequestMessage, CancellationToken, Task<bool>>? ConvertToBooleanTask(Action<HttpRequestMessage>? onIntercepted)
         {
             if (onIntercepted == null)
             {
                 return null;
             }
 
-            return (message) =>
+            return (message, _) =>
             {
                 onIntercepted(message);
                 return TrueTask;
@@ -47,14 +48,14 @@ internal static class DelegateHelpers
         /// <returns>
         /// The converted delegate if <paramref name="onIntercepted"/> has a value; otherwise <see langword="null"/>.
         /// </returns>
-        internal static Func<HttpRequestMessage, Task<bool>>? ConvertToBooleanTask(Predicate<HttpRequestMessage>? onIntercepted)
+        internal static Func<HttpRequestMessage, CancellationToken, Task<bool>>? ConvertToBooleanTask(Predicate<HttpRequestMessage>? onIntercepted)
         {
             if (onIntercepted == null)
             {
                 return null;
             }
 
-            return (message) => Task.FromResult(onIntercepted(message));
+            return (message, _) => Task.FromResult(onIntercepted(message));
         }
 
         /// <summary>
@@ -65,18 +66,54 @@ internal static class DelegateHelpers
         /// <returns>
         /// The converted delegate if <paramref name="onIntercepted"/> has a value; otherwise <see langword="null"/>.
         /// </returns>
-        internal static Func<HttpRequestMessage, Task<bool>>? ConvertToBooleanTask(Func<HttpRequestMessage, Task>? onIntercepted)
+        internal static Func<HttpRequestMessage, CancellationToken, Task<bool>>? ConvertToBooleanTask(Func<HttpRequestMessage, Task>? onIntercepted)
         {
             if (onIntercepted == null)
             {
                 return null;
             }
 
-            return async (message) =>
+            return ConvertToBooleanTask((message, _) => onIntercepted(message));
+        }
+
+        /// <summary>
+        /// Converts a function delegate for an intercepted message to return a
+        /// <see cref="Task{TResult}"/> which returns <see langword="true"/>.
+        /// </summary>
+        /// <param name="onIntercepted">An optional delegate to convert.</param>
+        /// <returns>
+        /// The converted delegate if <paramref name="onIntercepted"/> has a value; otherwise <see langword="null"/>.
+        /// </returns>
+        internal static Func<HttpRequestMessage, CancellationToken, Task<bool>>? ConvertToBooleanTask(Func<HttpRequestMessage, CancellationToken, Task>? onIntercepted)
+        {
+            if (onIntercepted == null)
+            {
+                return null;
+            }
+
+            return async (message, token) =>
             {
-                await onIntercepted(message).ConfigureAwait(false);
+                await onIntercepted(message, token).ConfigureAwait(false);
                 return true;
             };
         }
+
+        /// <summary>
+        /// Converts a function delegate for an intercepted message to return a
+        /// <see cref="Task{TResult}"/> which returns <see langword="true"/>.
+        /// </summary>
+        /// <param name="onIntercepted">An optional delegate to convert.</param>
+        /// <returns>
+        /// The converted delegate if <paramref name="onIntercepted"/> has a value; otherwise <see langword="null"/>.
+        /// </returns>
+        internal static Func<HttpRequestMessage, CancellationToken, Task<bool>>? ConvertToBooleanTask(Func<HttpRequestMessage, Task<bool>>? onIntercepted)
+        {
+            if (onIntercepted == null)
+            {
+                return null;
+            }
+
+            return async (message, _) => await onIntercepted(message).ConfigureAwait(false);
+        }
     }
 }
diff --git a/src/HttpClientInterception/HttpClientInterceptorOptions.cs b/src/HttpClientInterception/HttpClientInterceptorOptions.cs
index a5ef2fbe..b131c0b1 100644
--- a/src/HttpClientInterception/HttpClientInterceptorOptions.cs
+++ b/src/HttpClientInterception/HttpClientInterceptorOptions.cs
@@ -330,6 +330,7 @@ public HttpClientInterceptorOptions Register(HttpRequestInterceptionBuilder buil
         /// Gets the HTTP response, if any, set up for the specified HTTP request as an asynchronous operation.
         /// </summary>
         /// <param name="request">The HTTP request to try and get the intercepted response for.</param>
+        /// <param name="cancellationToken">The optional token to monitor for cancellation requests.</param>
         /// <returns>
         /// A <see cref="Task{TResult}"/> that returns the HTTP response to use, if any,
         /// for <paramref name="request"/>; otherwise <see langword="null"/>.
@@ -337,7 +338,7 @@ public HttpClientInterceptorOptions Register(HttpRequestInterceptionBuilder buil
         /// <exception cref="ArgumentNullException">
         /// <paramref name="request"/> is <see langword="null"/>.
         /// </exception>
-        public virtual async Task<HttpResponseMessage?> GetResponseAsync(HttpRequestMessage request)
+        public virtual async Task<HttpResponseMessage?> GetResponseAsync(HttpRequestMessage request, CancellationToken cancellationToken = default)
         {
             if (request == null)
             {
@@ -354,7 +355,7 @@ public HttpClientInterceptorOptions Register(HttpRequestInterceptionBuilder buil
             var response = matchResult.Item2;
 
             // If Item1 is true, then Item2 is non-null
-            if (response!.OnIntercepted != null && !await response.OnIntercepted(request).ConfigureAwait(false))
+            if (response!.OnIntercepted != null && !await response.OnIntercepted(request, cancellationToken).ConfigureAwait(false))
             {
                 return null;
             }
diff --git a/src/HttpClientInterception/HttpInterceptionResponse.cs b/src/HttpClientInterception/HttpInterceptionResponse.cs
index 420b1a06..9a9d5a52 100644
--- a/src/HttpClientInterception/HttpInterceptionResponse.cs
+++ b/src/HttpClientInterception/HttpInterceptionResponse.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Net;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace JustEat.HttpClientInterception
@@ -48,7 +49,7 @@ internal sealed class HttpInterceptionResponse
 
         internal IEnumerable<KeyValuePair<string, IEnumerable<string>>>? ResponseHeaders { get; set; }
 
-        internal Func<HttpRequestMessage, Task<bool>>? OnIntercepted { get; set; }
+        internal Func<HttpRequestMessage, CancellationToken, Task<bool>>? OnIntercepted { get; set; }
 
         internal Version? Version { get; set; }
     }
diff --git a/src/HttpClientInterception/HttpRequestInterceptionBuilder.cs b/src/HttpClientInterception/HttpRequestInterceptionBuilder.cs
index afaf6738..20b1d72b 100644
--- a/src/HttpClientInterception/HttpRequestInterceptionBuilder.cs
+++ b/src/HttpClientInterception/HttpRequestInterceptionBuilder.cs
@@ -6,6 +6,7 @@
 using System.IO;
 using System.Net;
 using System.Net.Http;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace JustEat.HttpClientInterception
@@ -35,7 +36,7 @@ public class HttpRequestInterceptionBuilder
 
         private HttpMethod _method = HttpMethod.Get;
 
-        private Func<HttpRequestMessage, Task<bool>>? _onIntercepted;
+        private Func<HttpRequestMessage, CancellationToken, Task<bool>>? _onIntercepted;
 
         private Func<HttpRequestMessage, Task<bool>>? _requestMatcher;
 
@@ -79,7 +80,7 @@ public HttpRequestInterceptionBuilder()
         /// </remarks>
         public HttpRequestInterceptionBuilder For(Predicate<HttpRequestMessage> predicate)
         {
-            _requestMatcher = predicate == null ? null : DelegateHelpers.ConvertToBooleanTask(predicate);
+            _requestMatcher = predicate == null ? null : new Func<HttpRequestMessage, Task<bool>>((message) => Task.FromResult(predicate(message)));
             return this;
         }
 
@@ -690,6 +691,39 @@ public HttpRequestInterceptionBuilder WithInterceptionCallback(Func<HttpRequestM
         /// The current <see cref="HttpRequestInterceptionBuilder"/>.
         /// </returns>
         public HttpRequestInterceptionBuilder WithInterceptionCallback(Func<HttpRequestMessage, Task<bool>> onIntercepted)
+        {
+            _onIntercepted = DelegateHelpers.ConvertToBooleanTask(onIntercepted);
+            return this;
+        }
+
+        /// <summary>
+        /// Sets an asynchronous callback to use to use when a request is intercepted that returns
+        /// <see langword="true"/> if the request should be intercepted or <see langword="false"/>
+        /// if the request should not be intercepted.
+        /// </summary>
+        /// <param name="onIntercepted">A delegate to a method to await when a request is intercepted.</param>
+        /// <returns>
+        /// The current <see cref="HttpRequestInterceptionBuilder"/>.
+        /// </returns>
+        public HttpRequestInterceptionBuilder WithInterceptionCallback(Func<HttpRequestMessage, CancellationToken, Task> onIntercepted)
+        {
+            _onIntercepted = DelegateHelpers.ConvertToBooleanTask(onIntercepted);
+            return this;
+        }
+
+        /// <summary>
+        /// Sets an asynchronous callback to use to use when a request is intercepted that returns
+        /// <see langword="true"/> if the request should be intercepted or <see langword="false"/>
+        /// if the request should not be intercepted.
+        /// </summary>
+        /// <param name="onIntercepted">
+        /// A delegate to a method to await when a request is intercepted which returns a <see langword="bool"/>
+        /// indicating whether the request should be intercepted or not.
+        /// </param>
+        /// <returns>
+        /// The current <see cref="HttpRequestInterceptionBuilder"/>.
+        /// </returns>
+        public HttpRequestInterceptionBuilder WithInterceptionCallback(Func<HttpRequestMessage, CancellationToken, Task<bool>> onIntercepted)
         {
             _onIntercepted = onIntercepted;
             return this;
diff --git a/src/HttpClientInterception/InterceptingHttpMessageHandler.cs b/src/HttpClientInterception/InterceptingHttpMessageHandler.cs
index da2718d3..c5ecb2d7 100644
--- a/src/HttpClientInterception/InterceptingHttpMessageHandler.cs
+++ b/src/HttpClientInterception/InterceptingHttpMessageHandler.cs
@@ -54,7 +54,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
                 await _options.OnSend(request).ConfigureAwait(false);
             }
 
-            var response = await _options.GetResponseAsync(request).ConfigureAwait(false);
+            var response = await _options.GetResponseAsync(request, cancellationToken).ConfigureAwait(false);
 
             if (response == null && _options.OnMissingRegistration != null)
             {
diff --git a/src/HttpClientInterception/PublicAPI.Shipped.txt b/src/HttpClientInterception/PublicAPI.Shipped.txt
index 04227da3..232093da 100644
--- a/src/HttpClientInterception/PublicAPI.Shipped.txt
+++ b/src/HttpClientInterception/PublicAPI.Shipped.txt
@@ -48,6 +48,8 @@ JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithContentStream(
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Action<System.Net.Http.HttpRequestMessage> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Func<System.Net.Http.HttpRequestMessage, System.Threading.Tasks.Task<bool>> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Func<System.Net.Http.HttpRequestMessage, System.Threading.Tasks.Task> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
+JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Func<System.Net.Http.HttpRequestMessage, System.Threading.CancellationToken, System.Threading.Tasks.Task<bool>> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
+JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Func<System.Net.Http.HttpRequestMessage, System.Threading.CancellationToken, System.Threading.Tasks.Task> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithInterceptionCallback(System.Predicate<System.Net.Http.HttpRequestMessage> onIntercepted) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithMediaType(string mediaType) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 JustEat.HttpClientInterception.HttpRequestInterceptionBuilder.WithReason(string reasonPhrase) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
@@ -88,4 +90,4 @@ static JustEat.HttpClientInterception.HttpRequestInterceptionBuilderExtensions.W
 static JustEat.HttpClientInterception.HttpRequestInterceptionBuilderExtensions.WithFormContent(this JustEat.HttpClientInterception.HttpRequestInterceptionBuilder builder, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<string, string>> parameters) -> JustEat.HttpClientInterception.HttpRequestInterceptionBuilder
 virtual JustEat.HttpClientInterception.HttpClientInterceptorOptions.CreateHttpClient(System.Net.Http.HttpMessageHandler innerHandler = null) -> System.Net.Http.HttpClient
 virtual JustEat.HttpClientInterception.HttpClientInterceptorOptions.CreateHttpMessageHandler() -> System.Net.Http.DelegatingHandler
-virtual JustEat.HttpClientInterception.HttpClientInterceptorOptions.GetResponseAsync(System.Net.Http.HttpRequestMessage request) -> System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage>
+virtual JustEat.HttpClientInterception.HttpClientInterceptorOptions.GetResponseAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage>
diff --git a/tests/HttpClientInterception.Tests/Examples.cs b/tests/HttpClientInterception.Tests/Examples.cs
index 6f295efe..79191559 100644
--- a/tests/HttpClientInterception.Tests/Examples.cs
+++ b/tests/HttpClientInterception.Tests/Examples.cs
@@ -7,6 +7,7 @@
 using System.Net;
 using System.Net.Http;
 using System.Text.Json;
+using System.Threading;
 using System.Threading.Tasks;
 using JustEat.HttpClientInterception.GitHub;
 using Newtonsoft.Json.Linq;
@@ -627,5 +628,44 @@ public static async Task Intercept_Http_Get_For_Json_Object_Using_System_Text_Js
             content.RootElement.GetProperty("Id").GetInt32().ShouldBe(1);
             content.RootElement.GetProperty("Link").GetString().ShouldBe("https://www.just-eat.co.uk/privacy-policy");
         }
+
+        [Fact]
+        public static async Task Inject_Latency_For_Http_Get_With_Cancellation()
+        {
+            // Arrange
+            var latency = TimeSpan.FromMilliseconds(50);
+
+            var builder = new HttpRequestInterceptionBuilder()
+                .ForHost("www.google.co.uk")
+                .WithInterceptionCallback(async (_, token) =>
+                {
+                    try
+                    {
+                        await Task.Delay(latency, token);
+                    }
+                    catch (TaskCanceledException)
+                    {
+                        // Ignored
+                    }
+                    finally
+                    {
+                        // Assert
+                        token.IsCancellationRequested.ShouldBeTrue();
+                    }
+                });
+
+            var options = new HttpClientInterceptorOptions()
+                .Register(builder);
+
+            using var cts = new CancellationTokenSource(TimeSpan.Zero);
+
+            using var client = options.CreateHttpClient();
+
+            // Act
+            await client.GetAsync("http://www.google.co.uk", cts.Token);
+
+            // Assert
+            cts.IsCancellationRequested.ShouldBeTrue();
+        }
     }
 }
diff --git a/tests/HttpClientInterception.Tests/HttpClientInterceptorOptionsTests.cs b/tests/HttpClientInterception.Tests/HttpClientInterceptorOptionsTests.cs
index a74339ac..b16b866e 100644
--- a/tests/HttpClientInterception.Tests/HttpClientInterceptorOptionsTests.cs
+++ b/tests/HttpClientInterception.Tests/HttpClientInterceptorOptionsTests.cs
@@ -8,6 +8,7 @@
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Threading;
 using System.Threading.Tasks;
 using Shouldly;
 using Xunit;
@@ -762,9 +763,9 @@ internal HeaderMatchingOptions(Predicate<HttpRequestHeaders> matchHeaders)
                 _matchHeaders = matchHeaders;
             }
 
-            public override async Task<HttpResponseMessage> GetResponseAsync(HttpRequestMessage request)
+            public override async Task<HttpResponseMessage> GetResponseAsync(HttpRequestMessage request, CancellationToken cancellationToken = default)
             {
-                HttpResponseMessage response = await base.GetResponseAsync(request);
+                HttpResponseMessage response = await base.GetResponseAsync(request, cancellationToken);
 
                 if (response != null && _matchHeaders(request.Headers))
                 {
diff --git a/tests/HttpClientInterception.Tests/HttpRequestInterceptionBuilderTests.cs b/tests/HttpClientInterception.Tests/HttpRequestInterceptionBuilderTests.cs
index b63fa682..739026a8 100644
--- a/tests/HttpClientInterception.Tests/HttpRequestInterceptionBuilderTests.cs
+++ b/tests/HttpClientInterception.Tests/HttpRequestInterceptionBuilderTests.cs
@@ -1016,6 +1016,35 @@ Task<bool> OnInterceptedAsync(HttpRequestMessage request)
             wasDelegateInvoked.ShouldBeTrue();
         }
 
+        [Fact]
+        public static async Task Register_For_Callback_Invokes_Delegate_With_CancellationToken_And_Intercepts_If_Returns_True()
+        {
+            // Arrange
+            var requestUri = new Uri("https://api.just-eat.com/");
+            var content = new { foo = "bar" };
+
+            bool wasDelegateInvoked = false;
+
+            Task<bool> OnInterceptedAsync(HttpRequestMessage request, CancellationToken token)
+            {
+                wasDelegateInvoked = true;
+                return Task.FromResult(true);
+            }
+
+            var builder = new HttpRequestInterceptionBuilder()
+                .ForPost()
+                .ForUri(requestUri)
+                .WithInterceptionCallback(OnInterceptedAsync);
+
+            var options = new HttpClientInterceptorOptions().Register(builder);
+
+            // Act
+            await HttpAssert.PostAsync(options, requestUri.ToString(), content);
+
+            // Assert
+            wasDelegateInvoked.ShouldBeTrue();
+        }
+
         [Fact]
         public static async Task Register_For_Callback_Invokes_Delegate_And_Does_Not_Intercept_If_Returns_False()
         {
@@ -1049,6 +1078,39 @@ Task<bool> OnInterceptedAsync(HttpRequestMessage request)
             wasDelegateInvoked.ShouldBeTrue();
         }
 
+        [Fact]
+        public static async Task Register_For_Callback_Invokes_Delegate_With_CancellationToken_And_Does_Not_Intercept_If_Returns_False()
+        {
+            // Arrange
+            var requestUri = new Uri("https://api.just-eat.com/");
+            var content = new { foo = "bar" };
+
+            bool wasDelegateInvoked = false;
+
+            Task<bool> OnInterceptedAsync(HttpRequestMessage request, CancellationToken token)
+            {
+                wasDelegateInvoked = true;
+                return Task.FromResult(false);
+            }
+
+            var builder = new HttpRequestInterceptionBuilder()
+                .ForPost()
+                .ForUri(requestUri)
+                .WithInterceptionCallback(OnInterceptedAsync);
+
+            var options = new HttpClientInterceptorOptions()
+                .ThrowsOnMissingRegistration()
+                .Register(builder);
+
+            // Act
+            var exception = await Assert.ThrowsAsync<HttpRequestNotInterceptedException>(
+                () => HttpAssert.PostAsync(options, requestUri.ToString(), content));
+
+            // Assert
+            exception.Message.ShouldStartWith("No HTTP response is configured for ");
+            wasDelegateInvoked.ShouldBeTrue();
+        }
+
         [Fact]
         public static async Task Register_For_Callback_Clears_Delegate_For_Action_If_Set_To_Null()
         {
@@ -1097,6 +1159,54 @@ public static async Task Register_For_Callback_Clears_Delegate_For_Predicate_If_
             wasDelegateInvoked.ShouldBeFalse();
         }
 
+        [Fact]
+        public static async Task Register_For_Callback_Clears_Delegate_For_Predicate_With_Cancellation_If_Set_To_Null()
+        {
+            // Arrange
+            var requestUri = new Uri("https://api.just-eat.com/");
+            var content = new { foo = "bar" };
+
+            bool wasDelegateInvoked = false;
+
+            var builder = new HttpRequestInterceptionBuilder()
+                .ForPost()
+                .ForUri(requestUri)
+                .WithInterceptionCallback((request) => wasDelegateInvoked = true)
+                .WithInterceptionCallback(null as Func<HttpRequestMessage, CancellationToken, Task>);
+
+            var options = new HttpClientInterceptorOptions().Register(builder);
+
+            // Act
+            await HttpAssert.PostAsync(options, requestUri.ToString(), content);
+
+            // Assert
+            wasDelegateInvoked.ShouldBeFalse();
+        }
+
+        [Fact]
+        public static async Task Register_For_Callback_Clears_Delegate_For_Async_Predicate_If_Set_To_Null()
+        {
+            // Arrange
+            var requestUri = new Uri("https://api.just-eat.com/");
+            var content = new { foo = "bar" };
+
+            bool wasDelegateInvoked = false;
+
+            var builder = new HttpRequestInterceptionBuilder()
+                .ForPost()
+                .ForUri(requestUri)
+                .WithInterceptionCallback((request) => wasDelegateInvoked = true)
+                .WithInterceptionCallback(null as Func<HttpRequestMessage, Task<bool>>);
+
+            var options = new HttpClientInterceptorOptions().Register(builder);
+
+            // Act
+            await HttpAssert.PostAsync(options, requestUri.ToString(), content);
+
+            // Assert
+            wasDelegateInvoked.ShouldBeFalse();
+        }
+
         [Fact]
         public static async Task Builder_For_Any_Host_Registers_Interception()
         {