diff --git a/chopper/lib/src/base.dart b/chopper/lib/src/base.dart
index 624607b3..4fa556c2 100644
--- a/chopper/lib/src/base.dart
+++ b/chopper/lib/src/base.dart
@@ -293,9 +293,10 @@ class ChopperClient {
     ConvertRequest? requestConverter,
     ConvertResponse? responseConverter,
   }) async {
-    var req = await _interceptRequest(
+    final Request req = await _interceptRequest(
       await _handleRequestConverter(request, requestConverter),
     );
+
     _requestController.add(req);
 
     final streamRes = await httpClient.send(await req.toBaseRequest());
@@ -307,7 +308,11 @@ class ChopperClient {
     dynamic res = Response(response, response.body);
 
     if (authenticator != null) {
-      var updatedRequest = await authenticator!.authenticate(req, res, request);
+      final Request? updatedRequest = await authenticator!.authenticate(
+        request,
+        res,
+        request,
+      );
 
       if (updatedRequest != null) {
         res = await send<BodyType, InnerType>(
diff --git a/chopper/test/authenticator_test.dart b/chopper/test/authenticator_test.dart
new file mode 100644
index 00000000..8f4ebb20
--- /dev/null
+++ b/chopper/test/authenticator_test.dart
@@ -0,0 +1,392 @@
+import 'dart:convert' show jsonEncode;
+
+import 'package:chopper/chopper.dart';
+import 'package:http/http.dart' as http;
+import 'package:http/testing.dart';
+import 'package:test/test.dart';
+
+import 'fake_authenticator.dart';
+
+void main() async {
+  final Uri baseUrl = Uri.parse('http://localhost:8000');
+
+  ChopperClient buildClient([http.Client? httpClient]) => ChopperClient(
+        baseUrl: baseUrl,
+        client: httpClient,
+        interceptors: [
+          (Request req) => applyHeader(req, 'foo', 'bar'),
+        ],
+        converter: JsonConverter(),
+        authenticator: FakeAuthenticator(),
+      );
+
+  late bool authenticated;
+  final Map<String, bool> tested = {
+    'unauthenticated': false,
+    'authenticated': false,
+  };
+
+  setUp(() {
+    authenticated = false;
+    tested['unauthenticated'] = false;
+    tested['authenticated'] = false;
+  });
+
+  group('GET', () {
+    test('authorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/get?key=val'),
+        );
+        expect(request.method, equals('GET'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.get(
+        Uri(
+          path: '/test/get',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+
+      httpClient.close();
+    });
+
+    test('unauthorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/get?key=val'),
+        );
+        expect(request.method, equals('GET'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+
+        if (!authenticated) {
+          tested['unauthenticated'] = true;
+          authenticated = true;
+
+          return http.Response('unauthorized', 401);
+        } else {
+          tested['authenticated'] = true;
+          expect(request.headers['authorization'], equals('some_fake_token'));
+        }
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.get(
+        Uri(
+          path: '/test/get',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+      expect(tested['authenticated'], equals(true));
+      expect(tested['unauthenticated'], equals(true));
+
+      httpClient.close();
+    });
+  });
+
+  group('POST', () {
+    test('authorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/post?key=val'),
+        );
+        expect(request.method, equals('POST'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.post(
+        Uri(
+          path: '/test/post',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+
+      httpClient.close();
+    });
+
+    test('unauthorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/post?key=val'),
+        );
+        expect(request.method, equals('POST'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        if (!authenticated) {
+          tested['unauthenticated'] = true;
+          authenticated = true;
+
+          return http.Response('unauthorized', 401);
+        } else {
+          tested['authenticated'] = true;
+          expect(request.headers['authorization'], equals('some_fake_token'));
+        }
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.post(
+        Uri(
+          path: '/test/post',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+      expect(tested['authenticated'], equals(true));
+      expect(tested['unauthenticated'], equals(true));
+
+      httpClient.close();
+    });
+  });
+
+  group('PUT', () {
+    test('authorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/put?key=val'),
+        );
+        expect(request.method, equals('PUT'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.put(
+        Uri(
+          path: '/test/put',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+
+      httpClient.close();
+    });
+
+    test('unauthorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/put?key=val'),
+        );
+        expect(request.method, equals('PUT'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        if (!authenticated) {
+          tested['unauthenticated'] = true;
+          authenticated = true;
+
+          return http.Response('unauthorized', 401);
+        } else {
+          tested['authenticated'] = true;
+          expect(request.headers['authorization'], equals('some_fake_token'));
+        }
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.put(
+        Uri(
+          path: '/test/put',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+      expect(tested['authenticated'], equals(true));
+      expect(tested['unauthenticated'], equals(true));
+
+      httpClient.close();
+    });
+  });
+
+  group('PATCH', () {
+    test('authorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/patch?key=val'),
+        );
+        expect(request.method, equals('PATCH'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.patch(
+        Uri(
+          path: '/test/patch',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+
+      httpClient.close();
+    });
+
+    test('unauthorized', () async {
+      final httpClient = MockClient((request) async {
+        expect(
+          request.url.toString(),
+          equals('$baseUrl/test/patch?key=val'),
+        );
+        expect(request.method, equals('PATCH'));
+        expect(request.headers['foo'], equals('bar'));
+        expect(request.headers['int'], equals('42'));
+        expect(
+          request.body,
+          jsonEncode(
+            {
+              'name': 'john',
+              'surname': 'doe',
+            },
+          ),
+        );
+
+        if (!authenticated) {
+          tested['unauthenticated'] = true;
+          authenticated = true;
+
+          return http.Response('unauthorized', 401);
+        } else {
+          tested['authenticated'] = true;
+          expect(request.headers['authorization'], equals('some_fake_token'));
+        }
+
+        return http.Response('ok', 200);
+      });
+
+      final chopper = buildClient(httpClient);
+      final response = await chopper.patch(
+        Uri(
+          path: '/test/patch',
+          queryParameters: {'key': 'val'},
+        ),
+        headers: {'int': '42'},
+        body: {
+          'name': 'john',
+          'surname': 'doe',
+        },
+      );
+
+      expect(response.body, equals('ok'));
+      expect(response.statusCode, equals(200));
+      expect(tested['authenticated'], equals(true));
+      expect(tested['unauthenticated'], equals(true));
+
+      httpClient.close();
+    });
+  });
+}
diff --git a/chopper/test/fake_authenticator.dart b/chopper/test/fake_authenticator.dart
new file mode 100644
index 00000000..22de9356
--- /dev/null
+++ b/chopper/test/fake_authenticator.dart
@@ -0,0 +1,23 @@
+import 'dart:async' show FutureOr;
+
+import 'package:chopper/chopper.dart';
+
+class FakeAuthenticator extends Authenticator {
+  @override
+  FutureOr<Request?> authenticate(
+    Request request,
+    Response response, [
+    Request? originalRequest,
+  ]) async {
+    if (response.statusCode == 401) {
+      return request.copyWith(
+        headers: <String, String>{
+          ...request.headers,
+          'authorization': 'some_fake_token',
+        },
+      );
+    }
+
+    return null;
+  }
+}