diff --git a/Sources/AsyncHTTPClient/HTTPHandler.swift b/Sources/AsyncHTTPClient/HTTPHandler.swift
index d152e6660..41867ac3a 100644
--- a/Sources/AsyncHTTPClient/HTTPHandler.swift
+++ b/Sources/AsyncHTTPClient/HTTPHandler.swift
@@ -107,8 +107,8 @@ extension HTTPClient {
             /// UNIX Domain Socket HTTP request.
             case unixSocket(_ scheme: UnixScheme)
 
-            private static var hostSchemes = ["http", "https"]
-            private static var unixSchemes = ["unix", "http+unix", "https+unix"]
+            private static var hostRestrictedSchemes: Set = ["http", "https"]
+            private static var allSupportedSchemes: Set = ["http", "https", "unix", "http+unix", "https+unix"]
 
             init(forScheme scheme: String) throws {
                 switch scheme {
@@ -158,12 +158,14 @@ extension HTTPClient {
                 }
             }
 
-            func supports(scheme: String) -> Bool {
+            func supportsRedirects(to scheme: String?) -> Bool {
+                guard let scheme = scheme?.lowercased() else { return false }
+
                 switch self {
                 case .host:
-                    return Kind.hostSchemes.contains(scheme)
+                    return Kind.hostRestrictedSchemes.contains(scheme)
                 case .unixSocket:
-                    return Kind.unixSchemes.contains(scheme)
+                    return Kind.allSupportedSchemes.contains(scheme)
                 }
             }
         }
@@ -1051,7 +1053,7 @@ internal struct RedirectHandler<ResponseType> {
             return nil
         }
 
-        guard self.request.kind.supports(scheme: self.request.scheme) else {
+        guard self.request.kind.supportsRedirects(to: url.scheme) else {
             return nil
         }
 
diff --git a/Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift b/Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift
index e5df9cfc5..6beba8938 100644
--- a/Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift
+++ b/Tests/AsyncHTTPClientTests/HTTPClientTestUtils.swift
@@ -495,6 +495,12 @@ internal final class HttpBinHandler: ChannelInboundHandler {
                 headers.add(name: "Location", value: "/redirect/infinite1")
                 self.resps.append(HTTPResponseBuilder(status: .found, headers: headers))
                 return
+            case "/redirect/target":
+                var headers = self.responseHeaders
+                let targetURL = req.headers["X-Target-Redirect-URL"].first ?? ""
+                headers.add(name: "Location", value: targetURL)
+                self.resps.append(HTTPResponseBuilder(status: .found, headers: headers))
+                return
             case "/percent%20encoded":
                 if req.method != .GET {
                     self.resps.append(HTTPResponseBuilder(status: .methodNotAllowed))
diff --git a/Tests/AsyncHTTPClientTests/HTTPClientTests.swift b/Tests/AsyncHTTPClientTests/HTTPClientTests.swift
index 5a31937b2..2de420716 100644
--- a/Tests/AsyncHTTPClientTests/HTTPClientTests.swift
+++ b/Tests/AsyncHTTPClientTests/HTTPClientTests.swift
@@ -347,6 +347,95 @@ class HTTPClientTests: XCTestCase {
 
         response = try localClient.get(url: self.defaultHTTPBinURLPrefix + "redirect/https?port=\(httpsBin.port)").wait()
         XCTAssertEqual(response.status, .ok)
+
+        XCTAssertNoThrow(try TemporaryFileHelpers.withTemporaryUnixDomainSocketPathName { httpSocketPath in
+            XCTAssertNoThrow(try TemporaryFileHelpers.withTemporaryUnixDomainSocketPathName { httpsSocketPath in
+                let socketHTTPBin = HTTPBin(bindTarget: .unixDomainSocket(httpSocketPath))
+                let socketHTTPSBin = HTTPBin(ssl: true, bindTarget: .unixDomainSocket(httpsSocketPath))
+                defer {
+                    XCTAssertNoThrow(try socketHTTPBin.shutdown())
+                    XCTAssertNoThrow(try socketHTTPSBin.shutdown())
+                }
+
+                // From HTTP or HTTPS to HTTP+UNIX should fail to redirect
+                var targetURL = "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                var request = try Request(url: self.defaultHTTPBinURLPrefix + "redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                var response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .found)
+                XCTAssertEqual(response.headers.first(name: "Location"), targetURL)
+
+                request = try Request(url: "https://localhost:\(httpsBin.port)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .found)
+                XCTAssertEqual(response.headers.first(name: "Location"), targetURL)
+
+                // From HTTP or HTTPS to HTTPS+UNIX should also fail to redirect
+                targetURL = "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                request = try Request(url: self.defaultHTTPBinURLPrefix + "redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .found)
+                XCTAssertEqual(response.headers.first(name: "Location"), targetURL)
+
+                request = try Request(url: "https://localhost:\(httpsBin.port)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .found)
+                XCTAssertEqual(response.headers.first(name: "Location"), targetURL)
+
+                // ... while HTTP+UNIX to HTTP, HTTPS, or HTTP(S)+UNIX should succeed
+                targetURL = self.defaultHTTPBinURLPrefix + "ok"
+                request = try Request(url: "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "https://localhost:\(httpsBin.port)/ok"
+                request = try Request(url: "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                request = try Request(url: "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                request = try Request(url: "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                // ... and HTTPS+UNIX to HTTP, HTTPS, or HTTP(S)+UNIX should succeed
+                targetURL = self.defaultHTTPBinURLPrefix + "ok"
+                request = try Request(url: "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "https://localhost:\(httpsBin.port)/ok"
+                request = try Request(url: "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "http+unix://\(httpSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                request = try Request(url: "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+
+                targetURL = "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/ok"
+                request = try Request(url: "https+unix://\(httpsSocketPath.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!)/redirect/target", method: .GET, headers: ["X-Target-Redirect-URL": targetURL], body: nil)
+
+                response = try localClient.execute(request: request).wait()
+                XCTAssertEqual(response.status, .ok)
+            })
+        })
     }
 
     func testHttpHostRedirect() {