diff --git a/.openapi-generator/FILES b/.openapi-generator/FILES
index ccad4c1..a1cc86b 100644
--- a/.openapi-generator/FILES
+++ b/.openapi-generator/FILES
@@ -7,9 +7,6 @@ Sources/APIHelper.swift
 Sources/APIs.swift
 Sources/APIs/AdvancedAuthenticationAPI.swift
 Sources/APIs/VideosAPI.swift
-Sources/AlamofireImplementations.swift
-Sources/Auth/ApiVideoAuthenticator.swift
-Sources/Auth/ApiVideoCredential.swift
 Sources/CodableHelper.swift
 Sources/Configuration.swift
 Sources/Extensions.swift
@@ -31,6 +28,7 @@ Sources/Models/VideoSourceLiveStream.swift
 Sources/Models/VideoSourceLiveStreamLink.swift
 Sources/OpenISO8601DateFormatter.swift
 Sources/SynchronizedDictionary.swift
+Sources/URLSessionImplementations.swift
 Sources/Upload/FileChunkInputStream.swift
 Sources/Upload/ProgressiveUploadSessionProtocol.swift
 Sources/Upload/RequestTaskQueue.swift
diff --git a/ApiVideoUploader.podspec b/ApiVideoUploader.podspec
index aab0b94..3bded24 100644
--- a/ApiVideoUploader.podspec
+++ b/ApiVideoUploader.podspec
@@ -1,8 +1,8 @@
 Pod::Spec.new do |s|
   s.name = 'ApiVideoUploader'
-  s.ios.deployment_target = '10.0'
-  s.osx.deployment_target = '10.12'
-  s.tvos.deployment_target = '10.0'
+  s.ios.deployment_target = '9.0'
+  s.osx.deployment_target = '10.11'
+  s.tvos.deployment_target = '9.0'
   # Add back when CocoaPods/CocoaPods#11558 is released
   #s.watchos.deployment_target = '3.0'
   s.version = '1.2.2'
@@ -13,5 +13,4 @@ Pod::Spec.new do |s|
   s.summary = 'The official Swift api.video uploader for iOS, macOS and tvOS'
   s.source_files = 'Sources/**/*.swift'
   s.dependency 'AnyCodable-FlightSchool', '~> 0.6.1'
-  s.dependency 'Alamofire', '~> 5.4.3'
 end
diff --git a/Cartfile b/Cartfile
index 4fdc3a6..3f7e630 100644
--- a/Cartfile
+++ b/Cartfile
@@ -1,2 +1 @@
 github "Flight-School/AnyCodable" ~> 0.6.1
-github "Alamofire/Alamofire" ~> 5.4.3
diff --git a/Package.swift b/Package.swift
index ed08137..714471d 100644
--- a/Package.swift
+++ b/Package.swift
@@ -5,9 +5,9 @@ import PackageDescription
 let package = Package(
     name: "ApiVideoUploader",
     platforms: [
-        .iOS(.v10),
-        .macOS(.v10_12),
-        .tvOS(.v10),
+        .iOS(.v9),
+        .macOS(.v10_11),
+        .tvOS(.v9),
         .watchOS(.v3),
     ],
     products: [
@@ -20,14 +20,13 @@ let package = Package(
     dependencies: [
         // Dependencies declare other packages that this package depends on.
         .package(url: "https://github.com/Flight-School/AnyCodable", from: "0.6.1"),
-        .package(url: "https://github.com/Alamofire/Alamofire", from: "5.4.3"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages which this package depends on.
         .target(
             name: "ApiVideoUploader",
-            dependencies: ["AnyCodable", "Alamofire", ],
+            dependencies: ["AnyCodable", ],
             path: "Sources"
         ),
         // Targets for tests
diff --git a/Sources/APIs.swift b/Sources/APIs.swift
index 5ba2602..38e1a2b 100644
--- a/Sources/APIs.swift
+++ b/Sources/APIs.swift
@@ -6,16 +6,33 @@
 
 import Foundation
 public class ApiVideoUploader {
-    public static var apiKey: String? = nil
+    private static var apiKey: String? = nil
     public static var basePath = "https://ws.api.video"
-    internal static var customHeaders:[String: String] = ["AV-Origin-Client": "swift-uploader:1.2.2"]
+    internal static var defaultHeaders:[String: String] = ["AV-Origin-Client": "swift-uploader:1.2.2"]
+    internal static var credential: URLCredential?
     private static var chunkSize: Int = 50 * 1024 * 1024
-    internal static var requestBuilderFactory: RequestBuilderFactory = AlamofireRequestBuilderFactory()
-    internal static var credential = ApiVideoCredential()
+    internal static var requestBuilderFactory: RequestBuilderFactory = URLSessionRequestBuilderFactory()
     public static var apiResponseQueue: DispatchQueue = .main
+    
+    public static var backgroundIdentifier: String = "video.api.upload.background"
     public static var timeout: TimeInterval = 60
+    internal static var customHeaders:[String: String] {
+        var headers = defaultHeaders
+        if let apiKey = apiKey {
+            headers["Authorization"] = apiKey
+        }
+        return headers
+    }
+
+    public static func setApiKey(_ apiKey: String?) {
+        if let apiKey = apiKey {
+            self.apiKey = "Basic " + "\(apiKey):".toBase64()
+        } else {
+            self.apiKey = nil
+        }
+    }
 
-    public static func setChunkSize(chunkSize: Int) throws {
+    public static func setChunkSize(_ chunkSize: Int) throws {
         if (chunkSize > 128 * 1024 * 1024) {
             throw ParameterError.outOfRange
         } else if (chunkSize < 5 * 1024 * 1024) {
@@ -40,25 +57,25 @@ public class ApiVideoUploader {
         }
     }
 
-    static func isValidVersion(version: String) -> Bool {
+    static func isValidVersion(_ version: String) -> Bool {
         let pattern = #"^\d{1,3}(\.\d{1,3}(\.\d{1,3})?)?$"#
         return isValid(pattern: pattern, field: version)
     }
 
-    static func isValidName(name: String) -> Bool {
+    static func isValidName(_ name: String) -> Bool {
         let pattern = #"^[\w\-]{1,50}$"#
         return isValid(pattern: pattern, field: name)
     }
 
     static func setName(key: String, name: String, version: String) throws {
-        if(!isValidName(name: name)) {
+        if(!isValidName(name)) {
             throw ParameterError.invalidName
         }
  
-        if(!isValidVersion(version: version)) {
+        if(!isValidVersion(version)) {
             throw ParameterError.invalidVersion
         }
-        ApiVideoUploader.customHeaders[key] = name + ":" + version
+        ApiVideoUploader.defaultHeaders[key] = name + ":" + version
     }
 
     public static func setSdkName(name: String, version: String) throws {
@@ -68,10 +85,10 @@ public class ApiVideoUploader {
     public static func setApplicationName(name: String, version: String) throws {
         try setName(key: "AV-Origin-App", name: name, version: version)
     }
-
 }
 
 open class RequestBuilder<T> {
+    var credential: URLCredential?
     var headers: [String: String]
     public var parameters: [String: Any]?
     public let method: String
@@ -79,6 +96,8 @@ open class RequestBuilder<T> {
     public let requestTask: RequestTask = RequestTask()
 
     /// Optional block to obtain a reference to the request's progress instance when available.
+    /// With the URLSession http client the request's progress only works on iOS 11.0, macOS 10.13, macCatalyst 13.0, tvOS 11.0, watchOS 4.0.
+    /// If you need to get the request's progress in older OS versions, please use Alamofire http client.
     public var onProgressReady: ((Progress) -> Void)?
 
     required public init(method: String, URLString: String, parameters: [String: Any]?, headers: [String: String] = [:], onProgressReady: ((Progress) -> Void)? = nil) {
@@ -108,9 +127,15 @@ open class RequestBuilder<T> {
         }
         return self
     }
+
+    open func addCredential() -> Self {
+        credential = ApiVideoUploader.credential
+        return self
+    }
 }
 
 public protocol RequestBuilderFactory {
     func getNonDecodableBuilder<T>() -> RequestBuilder<T>.Type
     func getBuilder<T: Decodable>() -> RequestBuilder<T>.Type
+    func getBackgroundBuilder<T: Decodable>() -> RequestBuilder<T>.Type
 }
diff --git a/Sources/APIs/VideosAPI.swift b/Sources/APIs/VideosAPI.swift
index 925add5..4afb8ca 100644
--- a/Sources/APIs/VideosAPI.swift
+++ b/Sources/APIs/VideosAPI.swift
@@ -144,7 +144,7 @@ The latter allows you to split a video source into X chunks and send those chunk
 
         let localVariableHeaderParameters = APIHelper.rejectNilHeaders(localVariableNillableHeaders)
 
-        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBuilder()
+        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBackgroundBuilder()
 
         return localVariableRequestBuilder.init(method: "POST", URLString: (localVariableUrlComponents?.string ?? localVariableURLString), parameters: localVariableParameters, headers: localVariableHeaderParameters, onProgressReady: onProgressReady)
     }
@@ -202,7 +202,7 @@ The latter allows you to split a video source into X chunks and send those chunk
 
         let localVariableHeaderParameters = APIHelper.rejectNilHeaders(localVariableNillableHeaders)
 
-        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBuilder()
+        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBackgroundBuilder()
 
         return localVariableRequestBuilder.init(method: "POST", URLString: (localVariableUrlComponents?.string ?? localVariableURLString), parameters: localVariableParameters, headers: localVariableHeaderParameters, onProgressReady: onProgressReady)
     }
@@ -349,7 +349,7 @@ The latter allows you to split a video source into X chunks and send those chunk
 
         let localVariableHeaderParameters = APIHelper.rejectNilHeaders(localVariableNillableHeaders)
 
-        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBuilder()
+        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBackgroundBuilder()
 
         return localVariableRequestBuilder.init(method: "POST", URLString: (localVariableUrlComponents?.string ?? localVariableURLString), parameters: localVariableParameters, headers: localVariableHeaderParameters, onProgressReady: onProgressReady)
     }
@@ -392,7 +392,7 @@ The latter allows you to split a video source into X chunks and send those chunk
 
         let localVariableHeaderParameters = APIHelper.rejectNilHeaders(localVariableNillableHeaders)
 
-        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBuilder()
+        let localVariableRequestBuilder: RequestBuilder<Video>.Type = ApiVideoUploader.requestBuilderFactory.getBackgroundBuilder()
 
         return localVariableRequestBuilder.init(method: "POST", URLString: (localVariableUrlComponents?.string ?? localVariableURLString), parameters: localVariableParameters, headers: localVariableHeaderParameters, onProgressReady: onProgressReady)
     }
diff --git a/Sources/AlamofireImplementations.swift b/Sources/AlamofireImplementations.swift
deleted file mode 100644
index 1dd6726..0000000
--- a/Sources/AlamofireImplementations.swift
+++ /dev/null
@@ -1,418 +0,0 @@
-// AlamofireImplementations.swift
-//
-// Generated by openapi-generator
-// https://openapi-generator.tech
-//
-
-import Foundation
-import Alamofire
-
-class AlamofireRequestBuilderFactory: RequestBuilderFactory {
-    func getNonDecodableBuilder<T>() -> RequestBuilder<T>.Type {
-        return AlamofireRequestBuilder<T>.self
-    }
-
-    func getBuilder<T: Decodable>() -> RequestBuilder<T>.Type {
-        return AlamofireDecodableRequestBuilder<T>.self
-    }
-}
-
-// Store manager to retain its reference
-private var managerStore = SynchronizedDictionary<String, Alamofire.Session>()
-
-open class AlamofireRequestBuilder<T>: RequestBuilder<T> {
-    required public init(method: String, URLString: String, parameters: [String: Any]?, headers: [String: String] = [:], onProgressReady: ((Progress) -> Void)? = nil) {
-        super.init(method: method, URLString: URLString, parameters: parameters, headers: headers, onProgressReady: onProgressReady)
-    }
-
-    /**
-     May be overridden by a subclass if you want to control the session
-     configuration.
-     */
-    open func createAlamofireSession(interceptor: RequestInterceptor? = nil) -> Alamofire.Session {
-        let configuration = URLSessionConfiguration.default
-        configuration.timeoutIntervalForRequest = ApiVideoUploader.timeout
-        configuration.timeoutIntervalForResource = ApiVideoUploader.timeout
-        configuration.httpAdditionalHeaders = buildHeaders()
-        return Alamofire.Session(configuration: configuration,
-                                 interceptor: interceptor)
-    }
-
-    /**
-     May be overridden by a subclass if you want to custom request constructor.
-     */
-    open func createURLRequest() -> URLRequest? {
-        let xMethod = Alamofire.HTTPMethod(rawValue: method)
-
-        let encoding: ParameterEncoding
-
-        switch xMethod {
-        case .get, .head:
-            encoding = URLEncoding()
-
-        case .options, .post, .put, .patch, .delete, .trace, .connect:
-            encoding = JSONDataEncoding()
-
-        default:
-            fatalError("Unsupported HTTPMethod - \(xMethod.rawValue)")
-        }
-
-        guard let originalRequest = try? URLRequest(url: URLString, method: xMethod, headers: HTTPHeaders(buildHeaders())) else { return nil }
-        return try? encoding.encode(originalRequest, with: parameters)
-    }
-
-    /**
-     May be overridden by a subclass if you want to control the Content-Type
-     that is given to an uploaded form part.
-
-     Return nil to use the default behavior (inferring the Content-Type from
-     the file extension).  Return the desired Content-Type otherwise.
-     */
-    open func contentTypeForFormPart(fileURL: URL) -> String? {
-        return nil
-    }
-
-    /**
-     May be overridden by a subclass if you want to control the request
-     configuration (e.g. to override the cache policy).
-     */
-    open func makeRequest(manager: Session, method: HTTPMethod, encoding: ParameterEncoding, headers: [String: String]) -> DataRequest {
-        return manager.request(URLString, method: method, parameters: parameters, encoding: encoding, headers: HTTPHeaders(headers))
-    }
-
-    private func contentHeaders(withName name: String, fileName: String? = nil, mimeType: String? = nil) -> HTTPHeaders {
-        var disposition = "form-data; name=\"\(name)\""
-        if let fileName = fileName { disposition += "; filename=\"\(fileName)\"" }
-
-        var headers: HTTPHeaders = [.contentDisposition(disposition)]
-        if let mimeType = mimeType { headers.add(.contentType(mimeType)) }
-        
-        return headers
-    }
-
-    @discardableResult
-    override open func execute(_ apiResponseQueue: DispatchQueue = ApiVideoUploader.apiResponseQueue, _ completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) -> RequestTask {
-        let managerId = UUID().uuidString
-        // Create a new manager for each request to customize its request header
-        var manager: Alamofire.Session
-
-        if URLString.hasSuffix("/auth/api-key") {
-            manager = createAlamofireSession()
-        } else if let apiKey = ApiVideoUploader.apiKey {
-            // Create the interceptor
-            let authenticator = ApiVideoAuthenticator(apiKey: apiKey)
-            let interceptor = AuthenticationInterceptor(authenticator: authenticator, credential: ApiVideoUploader.credential)
-
-            manager = createAlamofireSession(interceptor: interceptor)
-        } else {
-            manager = createAlamofireSession()
-        }
-        managerStore[managerId] = manager
-
-        let xMethod = Alamofire.HTTPMethod(rawValue: method)
-
-        let encoding: ParameterEncoding?
-
-        switch xMethod {
-        case .get, .head:
-            encoding = URLEncoding()
-
-        case .options, .post, .put, .patch, .delete, .trace, .connect:
-            let contentType = headers["Content-Type"] ?? "application/json"
-
-            if contentType == "application/json" {
-                encoding = JSONDataEncoding()
-            } else if contentType == "multipart/form-data" {
-                encoding = nil
-
-                let upload = manager.upload(multipartFormData: { mpForm in
-                    for (k, v) in self.parameters! {
-                        switch v {
-                        case let chunkInputStream as FileChunkInputStream:
-                            let fileURL = chunkInputStream.file
-                            let headers = self.contentHeaders(withName: k, fileName: fileURL.lastPathComponent, mimeType: "video/quicktime")
-                            mpForm.append(chunkInputStream, withLength: UInt64(chunkInputStream.capacity), headers: headers)
-                        case let fileURL as URL:
-                            if let mimeType = self.contentTypeForFormPart(fileURL: fileURL) {
-                                mpForm.append(fileURL, withName: k, fileName: fileURL.lastPathComponent, mimeType: mimeType)
-                            } else {
-                                mpForm.append(fileURL, withName: k)
-                            }
-                        case let string as String:
-                            mpForm.append(string.data(using: String.Encoding.utf8)!, withName: k)
-                        case let number as NSNumber:
-                            mpForm.append(number.stringValue.data(using: String.Encoding.utf8)!, withName: k)
-                        default:
-                            fatalError("Unprocessable value \(v) with key \(k)")
-                        }
-                    }
-                }, to: URLString, method: xMethod, headers: nil)
-                .uploadProgress { progress in
-                    if let onProgressReady = self.onProgressReady {
-                        onProgressReady(progress)
-                    }
-                }
-
-                requestTask.set(request: upload)
-
-                self.processRequest(request: upload, managerId, apiResponseQueue, completion)
-            } else if contentType == "application/x-www-form-urlencoded" {
-                encoding = URLEncoding(destination: .httpBody)
-            } else {
-                fatalError("Unsupported Media Type - \(contentType)")
-            }
-
-        default:
-            fatalError("Unsupported HTTPMethod - \(xMethod.rawValue)")
-        }
-
-        if let encoding = encoding {
-            let request = makeRequest(manager: manager, method: xMethod, encoding: encoding, headers: headers)
-            if let onProgressReady = self.onProgressReady {
-                onProgressReady(request.uploadProgress)
-            }
-            processRequest(request: request, managerId, apiResponseQueue, completion)
-            requestTask.set(request: request)
-        }
-
-        return requestTask
-    }
-
-    fileprivate func processRequest(request: DataRequest, _ managerId: String, _ apiResponseQueue: DispatchQueue, _ completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) {
-        let cleanupRequest = {
-            managerStore[managerId] = nil
-        }
-
-        let validatedRequest = request.validate()
-
-        switch T.self {
-        case is Void.Type:
-            validatedRequest.responseData(queue: apiResponseQueue, completionHandler: { voidResponse in
-                cleanupRequest()
-
-                switch voidResponse.result {
-                case .success:
-                    completion(.success(Response(response: voidResponse.response!, body: () as! T)))
-                case let .failure(error):
-                    completion(.failure(ErrorResponse.error(voidResponse.response?.statusCode ?? 500, voidResponse.data, voidResponse.response, error)))
-                }
-
-            })
-        default:
-            fatalError("Unsupported Response Body Type - \(String(describing: T.self))")
-        }
-    }
-
-    open func buildHeaders() -> [String: String] {
-        var httpHeaders = Alamofire.HTTPHeaders.default.dictionary
-        for (key, value) in headers {
-            httpHeaders[key] = value
-        }
-        return httpHeaders
-    }
-
-    fileprivate func getFileName(fromContentDisposition contentDisposition: String?) -> String? {
-
-        guard let contentDisposition = contentDisposition else {
-            return nil
-        }
-
-        let items = contentDisposition.components(separatedBy: ";")
-
-        var filename: String?
-
-        for contentItem in items {
-
-            let filenameKey = "filename="
-            guard let range = contentItem.range(of: filenameKey) else {
-                continue
-            }
-
-            filename = contentItem
-            return filename?
-                .replacingCharacters(in: range, with: "")
-                .replacingOccurrences(of: "\"", with: "")
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-        }
-
-        return filename
-
-    }
-
-    fileprivate func getPath(from url: URL) throws -> String {
-
-        guard var path = URLComponents(url: url, resolvingAgainstBaseURL: true)?.path else {
-            throw DownloadException.requestMissingPath
-        }
-
-        if path.hasPrefix("/") {
-            path.remove(at: path.startIndex)
-        }
-
-        return path
-
-    }
-
-    fileprivate func getURL(from urlRequest: URLRequest) throws -> URL {
-
-        guard let url = urlRequest.url else {
-            throw DownloadException.requestMissingURL
-        }
-
-        return url
-    }
-
-}
-
-open class AlamofireDecodableRequestBuilder<T: Decodable>: AlamofireRequestBuilder<T> {
-
-    override fileprivate func processRequest(request: DataRequest, _ managerId: String, _ apiResponseQueue: DispatchQueue, _ completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) {
-        let cleanupRequest = {
-            managerStore[managerId] = nil
-        }
-
-        let validatedRequest = request.validate()
-
-        switch T.self {
-        case is String.Type:
-            validatedRequest.responseString(queue: apiResponseQueue, completionHandler: { stringResponse in
-                cleanupRequest()
-
-                switch stringResponse.result {
-                case let .success(value):
-                    completion(.success(Response(response: stringResponse.response!, body: value as! T)))
-                case let .failure(error):
-                    completion(.failure(ErrorResponse.error(stringResponse.response?.statusCode ?? 500, stringResponse.data, stringResponse.response, error)))
-                }
-
-            })
-        case is URL.Type:
-            validatedRequest.responseData(queue: apiResponseQueue, completionHandler: { dataResponse in
-                cleanupRequest()
-
-                do {
-
-                    guard case .success = dataResponse.result else {
-                        throw DownloadException.responseFailed
-                    }
-
-                    guard let data = dataResponse.data else {
-                        throw DownloadException.responseDataMissing
-                    }
-
-                    guard let request = request.request else {
-                        throw DownloadException.requestMissing
-                    }
-
-                    let fileManager = FileManager.default
-                    let urlRequest = try request.asURLRequest()
-                    let cachesDirectory = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
-                    let requestURL = try self.getURL(from: urlRequest)
-
-                    var requestPath = try self.getPath(from: requestURL)
-
-                    if let headerFileName = self.getFileName(fromContentDisposition: dataResponse.response?.allHeaderFields["Content-Disposition"] as? String) {
-                        requestPath = requestPath.appending("/\(headerFileName)")
-                    } else {
-                        requestPath = requestPath.appending("/tmp.ApiVideoUploader.\(UUID().uuidString)")
-                    }
-
-                    let filePath = cachesDirectory.appendingPathComponent(requestPath)
-                    let directoryPath = filePath.deletingLastPathComponent().path
-
-                    try fileManager.createDirectory(atPath: directoryPath, withIntermediateDirectories: true, attributes: nil)
-                    try data.write(to: filePath, options: .atomic)
-
-                    completion(.success(Response(response: dataResponse.response!, body: filePath as! T)))
-
-                } catch let requestParserError as DownloadException {
-                    completion(.failure(ErrorResponse.error(400, dataResponse.data, dataResponse.response, requestParserError)))
-                } catch {
-                    completion(.failure(ErrorResponse.error(400, dataResponse.data, dataResponse.response, error)))
-                }
-                return
-            })
-        case is Void.Type:
-            validatedRequest.responseData(queue: apiResponseQueue, completionHandler: { voidResponse in
-                cleanupRequest()
-
-                switch voidResponse.result {
-                case .success:
-                    completion(.success(Response(response: voidResponse.response!, body: () as! T)))
-                case let .failure(error):
-                    completion(.failure(ErrorResponse.error(voidResponse.response?.statusCode ?? 500, voidResponse.data, voidResponse.response, error)))
-                }
-
-            })
-        case is Data.Type:
-            validatedRequest.responseData(queue: apiResponseQueue, completionHandler: { dataResponse in
-                cleanupRequest()
-
-                switch dataResponse.result {
-                case .success:
-                    completion(.success(Response(response: dataResponse.response!, body: dataResponse.data as! T)))
-                case let .failure(error):
-                    completion(.failure(ErrorResponse.error(dataResponse.response?.statusCode ?? 500, dataResponse.data, dataResponse.response, error)))
-                }
-
-            })
-        default:
-            validatedRequest.responseData(queue: apiResponseQueue, completionHandler: { dataResponse in
-                cleanupRequest()
-
-                if case let .failure(error) = dataResponse.result {
-                    var statusCode = dataResponse.response?.statusCode
-                    // Return status code of underlyingError for interception error mainly
-                    if let underlyingErrorResponse = error.underlyingError as? ErrorResponse {
-                        if case let ErrorResponse.error(code, _, _, _) =  underlyingErrorResponse {
-                            statusCode = code
-                        }
-                    }
-                    completion(.failure(ErrorResponse.error(statusCode ?? 500, dataResponse.data, dataResponse.response, error)))
-                    return
-                }
-
-                guard let data = dataResponse.data, !data.isEmpty else {
-                    completion(.failure(ErrorResponse.error(-1, nil, dataResponse.response, DecodableRequestBuilderError.emptyDataResponse)))
-                    return
-                }
-
-                guard let httpResponse = dataResponse.response else {
-                    completion(.failure(ErrorResponse.error(-2, nil, dataResponse.response, DecodableRequestBuilderError.nilHTTPResponse)))
-                    return
-                }
-
-                let decodeResult = CodableHelper.decode(T.self, from: data)
-
-                switch decodeResult {
-                case let .success(decodableObj):
-                    completion(.success(Response(response: httpResponse, body: decodableObj)))
-                case let .failure(error):
-                    completion(.failure(ErrorResponse.error(httpResponse.statusCode, data, httpResponse, error)))
-                }
-
-            })
-        }
-    }
-
-}
-
-extension JSONDataEncoding: ParameterEncoding {
-
-    // MARK: Encoding
-
-    /// Creates a URL request by encoding parameters and applying them onto an existing request.
-    ///
-    /// - parameter urlRequest: The request to have parameters applied.
-    /// - parameter parameters: The parameters to apply. This should have a single key/value
-    ///                         pair with "jsonData" as the key and a Data object as the value.
-    ///
-    /// - throws: An `Error` if the encoding process encounters an error.
-    ///
-    /// - returns: The encoded request.
-    public func encode(_ urlRequest: URLRequestConvertible, with parameters: Parameters?) throws -> URLRequest {
-        let urlRequest = try urlRequest.asURLRequest()
-
-        return encode(urlRequest, with: parameters)
-    }
-}
diff --git a/Sources/Auth/ApiVideoAuthenticator.swift b/Sources/Auth/ApiVideoAuthenticator.swift
deleted file mode 100644
index ed19387..0000000
--- a/Sources/Auth/ApiVideoAuthenticator.swift
+++ /dev/null
@@ -1,52 +0,0 @@
-//  ApiVideoAuthenticator.swift
-//
-
-import Foundation
-import Alamofire
-
-class ApiVideoAuthenticator: Authenticator {
-    private let apiKey: String
-    
-    public init(apiKey: String) {
-        self.apiKey = apiKey
-    }
-    
-    func apply(_ credential: ApiVideoCredential, to urlRequest: inout URLRequest) {
-        urlRequest.headers.add(.authorization(bearerToken: credential.accessToken))
-    }
-
-    func refresh(_ credential: ApiVideoCredential,
-                 for session: Session,
-                 completion: @escaping (Result<ApiVideoCredential, Error>) -> Void) {
-        AdvancedAuthenticationAPI.authenticate(authenticatePayload: AuthenticatePayload(apiKey: apiKey)) { accessToken, error in
-            if let error = error {
-                completion(.failure(error))
-            }
-            if let accessToken = accessToken {
-                ApiVideoUploader.credential = ApiVideoCredential(accessToken: accessToken)
-                completion(.success(ApiVideoUploader.credential))
-            }
-        }
-    }
-
-    func didRequest(_ urlRequest: URLRequest,
-                    with response: HTTPURLResponse,
-                    failDueToAuthenticationError error: Error) -> Bool {
-        // If authentication server CANNOT invalidate credentials, return `false`
-        if response.statusCode != 401 {
-            return false
-        }
-
-        // If authentication server CAN invalidate credentials, then inspect the response matching against what the
-        // authentication server returns as an authentication failure.
-        // We request a new access token if we received a 401 anyway.
-        return true
-    }
-
-    func isRequest(_ urlRequest: URLRequest, authenticatedWith credential: ApiVideoCredential) -> Bool {
-        // If authentication server CAN invalidate credentials, then compare the "Authorization" header value in the
-        // `URLRequest` against the Bearer token generated with the access token of the `Credential`.
-        let bearerToken = HTTPHeader.authorization(bearerToken: credential.accessToken).value
-        return urlRequest.headers["Authorization"] == bearerToken
-    }
-}
diff --git a/Sources/Auth/ApiVideoCredential.swift b/Sources/Auth/ApiVideoCredential.swift
deleted file mode 100644
index 04add43..0000000
--- a/Sources/Auth/ApiVideoCredential.swift
+++ /dev/null
@@ -1,31 +0,0 @@
-//  ApiVideoCredential.swift
-//
-
-import Foundation
-import Alamofire
-
-struct ApiVideoCredential: AuthenticationCredential {
-    let accessToken: String
-    let refreshToken: String
-    let tokenType: String
-    
-    let expiration: Date
-
-    // Require refresh if within 5 minutes of expiration
-    var requiresRefresh: Bool { Date(timeIntervalSinceNow: 60 * 5) > expiration }
-    
-    
-    public init(accessToken: AccessToken) {
-        self.accessToken = accessToken.accessToken!
-        self.refreshToken = accessToken.refreshToken!
-        self.tokenType = accessToken.tokenType!
-        self.expiration = Date(timeIntervalSinceNow: Double(accessToken.expiresIn!))
-    }
-    
-    public init() {
-        self.accessToken = ""
-        self.refreshToken = ""
-        self.tokenType = ""
-        self.expiration = Date()
-    }
-}
diff --git a/Sources/Extensions.swift b/Sources/Extensions.swift
index 59a8a8a..ce97f7d 100644
--- a/Sources/Extensions.swift
+++ b/Sources/Extensions.swift
@@ -115,6 +115,12 @@ extension String: CodingKey {
 
 }
 
+extension String {
+    func toBase64() -> String {
+         return Data(self.utf8).base64EncodedString()
+    }
+}
+
 extension KeyedEncodingContainerProtocol {
 
     public mutating func encodeArray<T>(_ values: [T], forKey key: Self.Key) throws where T: Encodable {
diff --git a/Sources/Models.swift b/Sources/Models.swift
index d336adb..8436e60 100644
--- a/Sources/Models.swift
+++ b/Sources/Models.swift
@@ -5,7 +5,6 @@
 //
 
 import Foundation
-import Alamofire
 
 protocol JSONEncodable {
     func encodeToJSON() -> Any
@@ -65,30 +64,31 @@ open class Response<T> {
 
 public class RequestTask {
     private var lock = NSRecursiveLock()
-    private var request: Request?
+    private var task: URLSessionTask?
 
-    internal func set(request: Request) {
+    internal func set(task: URLSessionTask) {
         lock.lock()
         defer { lock.unlock() }
-        self.request = request
+        self.task = task
     }
 
     public func cancel() {
         lock.lock()
         defer { lock.unlock() }
-        request?.cancel()
-        request = nil
+        task?.cancel()
+        task = nil
     }
 
-    public var state: Request.State {
-        request?.state ?? .initialized
-    }
-
-    public var uploadProgress: Progress? {
-        request?.uploadProgress
+    public var isFinished: Bool {
+        guard let state = task?.state else {
+            return false
+        }
+        
+        return state == URLSessionTask.State.completed
     }
 
-    public var downloadProgress: Progress? {
-        request?.downloadProgress
+    @available(iOS 11.0, macOS 10.13, macCatalyst 13.0, tvOS 11.0, watchOS 4.0, *)
+    public var progress: Progress? {
+        return task?.progress
     }
 }
\ No newline at end of file
diff --git a/Sources/URLSessionImplementations.swift b/Sources/URLSessionImplementations.swift
new file mode 100644
index 0000000..3ff59ae
--- /dev/null
+++ b/Sources/URLSessionImplementations.swift
@@ -0,0 +1,763 @@
+// URLSessionImplementations.swift
+//
+// Generated by openapi-generator
+// https://openapi-generator.tech
+//
+
+import Foundation
+#if !os(macOS)
+import MobileCoreServices
+#endif
+
+public protocol URLSessionProtocol {
+    func dataTask(with request: URLRequest, completionHandler: @escaping @Sendable (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask
+}
+
+extension URLSession: URLSessionProtocol {}
+
+class URLSessionRequestBuilderFactory: RequestBuilderFactory {
+    func getNonDecodableBuilder<T>() -> RequestBuilder<T>.Type {
+        return URLSessionRequestBuilder<T>.self
+    }
+
+    func getBuilder<T: Decodable>() -> RequestBuilder<T>.Type {
+        return URLSessionDecodableRequestBuilder<T>.self
+    }
+
+    func getBackgroundBuilder<T: Decodable>() -> RequestBuilder<T>.Type {
+        return URLSessionDecodableBackgroundUploadRequestBuilder<T>.self
+    }
+}
+
+public typealias ApiVideoUploaderChallengeHandler = ((URLSession, URLSessionTask, URLAuthenticationChallenge) -> (URLSession.AuthChallengeDisposition, URLCredential?))
+
+// Store the URLSession's delegate to retain its reference
+private let sessionDelegate = SessionDelegate()
+
+// Store the URLSession to retain its reference
+private let defaultURLSession = URLSession(configuration: .default, delegate: sessionDelegate, delegateQueue: nil)
+
+// Store current taskDidReceiveChallenge for every URLSessionTask
+private var challengeHandlerStore = SynchronizedDictionary<Int, ApiVideoUploaderChallengeHandler>()
+
+// Store current URLCredential for every URLSessionTask
+private var credentialStore = SynchronizedDictionary<Int, URLCredential>()
+
+open class URLSessionRequestBuilder<T>: RequestBuilder<T> {
+
+    /**
+     May be assigned if you want to control the authentication challenges.
+     */
+    public var taskDidReceiveChallenge: ApiVideoUploaderChallengeHandler?
+
+    /**
+     To observe upload or download progress
+     */
+    public var progressObservation: NSKeyValueObservation?
+
+    /**
+     May be assigned if you want to do any of those things:
+     - control the task completion
+     - intercept and handle errors like authorization
+     - retry the request.
+     */
+    @available(*, deprecated, message: "Please override execute() method to intercept and handle errors like authorization or retry the request. Check the Wiki for more info. https://github.com/OpenAPITools/openapi-generator/wiki/FAQ#how-do-i-implement-bearer-token-authentication-with-urlsession-on-the-swift-api-client")
+    public var taskCompletionShouldRetry: ((Data?, URLResponse?, Error?, @escaping (Bool) -> Void) -> Void)?
+
+    required public init(method: String, URLString: String, parameters: [String: Any]?, headers: [String: String] = [:], onProgressReady: ((Progress) -> Void)? = nil) {
+        super.init(method: method, URLString: URLString, parameters: parameters, headers: headers, onProgressReady: onProgressReady)
+    }
+
+    /**
+     May be overridden by a subclass if you want to control the URLSession
+     configuration.
+     */
+    open func createURLSession() -> URLSessionProtocol {
+        return defaultURLSession
+    }
+
+    /**
+     May be overridden by a subclass if you want to control the Content-Type
+     that is given to an uploaded form part.
+
+     Return nil to use the default behavior (inferring the Content-Type from
+     the file extension).  Return the desired Content-Type otherwise.
+     */
+    open func contentTypeForFormPart(fileURL: URL) -> String? {
+        return nil
+    }
+
+    /**
+     May be overridden by a subclass if you want to control the URLRequest
+     configuration (e.g. to override the cache policy).
+     */
+    open func createURLRequest(urlSession: URLSessionProtocol, method: HTTPMethod, encoding: ParameterEncoding, headers: [String: String]) throws -> URLRequest {
+
+        guard let url = URL(string: URLString) else {
+            throw DownloadException.requestMissingURL
+        }
+
+        var originalRequest = URLRequest(url: url)
+        originalRequest.timeoutInterval = ApiVideoUploader.timeout
+        originalRequest.httpMethod = method.rawValue
+
+        headers.forEach { key, value in
+            originalRequest.setValue(value, forHTTPHeaderField: key)
+        }
+
+        buildHeaders().forEach { key, value in
+            originalRequest.setValue(value, forHTTPHeaderField: key)
+        }
+
+        let modifiedRequest = try encoding.encode(originalRequest, with: parameters)
+
+        return modifiedRequest
+    }
+
+    @discardableResult
+    override open func execute(_ apiResponseQueue: DispatchQueue = ApiVideoUploader.apiResponseQueue, _ completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) -> RequestTask {
+        let urlSession = createURLSession()
+
+        guard let xMethod = HTTPMethod(rawValue: method) else {
+            fatalError("Unsupported Http method - \(method)")
+        }
+
+        let encoding: ParameterEncoding
+
+        switch xMethod {
+        case .get, .head:
+            encoding = URLEncoding()
+
+        case .options, .post, .put, .patch, .delete, .trace, .connect:
+            let contentType = headers["Content-Type"] ?? "application/json"
+
+            if contentType == "application/json" {
+                encoding = JSONDataEncoding()
+            } else if contentType == "multipart/form-data" {
+                encoding = FormDataEncoding(contentTypeForFormPart: contentTypeForFormPart(fileURL:))
+            } else if contentType == "application/x-www-form-urlencoded" {
+                encoding = FormURLEncoding()
+            } else {
+                fatalError("Unsupported Media Type - \(contentType)")
+            }
+        }
+
+        do {
+            let request = try createURLRequest(urlSession: urlSession, method: xMethod, encoding: encoding, headers: headers)
+
+            var taskIdentifier: Int?
+             let cleanupRequest = {
+                 if let taskIdentifier = taskIdentifier {
+                     challengeHandlerStore[taskIdentifier] = nil
+                     credentialStore[taskIdentifier] = nil
+                 }
+             }
+
+            let dataTask = urlSession.dataTask(with: request) { data, response, error in
+
+                if let taskCompletionShouldRetry = self.taskCompletionShouldRetry {
+
+                    taskCompletionShouldRetry(data, response, error) { shouldRetry in
+
+                        if shouldRetry {
+                            cleanupRequest()
+                            self.execute(apiResponseQueue, completion)
+                        } else {
+                            apiResponseQueue.async {
+                                self.processRequestResponse(urlRequest: request, data: data, response: response, error: error, completion: completion)
+                                cleanupRequest()
+                            }
+                        }
+                    }
+                } else {
+                    apiResponseQueue.async {
+                        self.processRequestResponse(urlRequest: request, data: data, response: response, error: error, completion: completion)
+                        cleanupRequest()
+                    }
+                }
+            }
+
+            if #available(iOS 11.0, macOS 10.13, macCatalyst 13.0, tvOS 11.0, watchOS 4.0, *) {
+                if let onProgressReady = onProgressReady {
+                    progressObservation = dataTask.progress.observe(\.fractionCompleted) { progress, _ in
+                        onProgressReady(progress)
+                    }
+                }
+            }
+
+            taskIdentifier = dataTask.taskIdentifier
+            challengeHandlerStore[dataTask.taskIdentifier] = taskDidReceiveChallenge
+            credentialStore[dataTask.taskIdentifier] = credential
+
+            dataTask.resume()
+
+            requestTask.set(task: dataTask)
+        } catch {
+            apiResponseQueue.async {
+                completion(.failure(ErrorResponse.error(415, nil, nil, error)))
+            }
+        }
+
+        return requestTask
+    }
+
+    fileprivate func processRequestResponse(urlRequest: URLRequest, data: Data?, response: URLResponse?, error: Error?, completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) {
+
+        if let error = error {
+            completion(.failure(ErrorResponse.error(-1, data, response, error)))
+            return
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            completion(.failure(ErrorResponse.error(-2, data, response, DecodableRequestBuilderError.nilHTTPResponse)))
+            return
+        }
+
+        guard httpResponse.isStatusCodeSuccessful else {
+            completion(.failure(ErrorResponse.error(httpResponse.statusCode, data, response, DecodableRequestBuilderError.unsuccessfulHTTPStatusCode)))
+            return
+        }
+
+        switch T.self {
+        case is Void.Type:
+
+            completion(.success(Response(response: httpResponse, body: () as! T)))
+
+        default:
+            fatalError("Unsupported Response Body Type - \(String(describing: T.self))")
+        }
+
+    }
+
+    open func buildHeaders() -> [String: String] {
+        var httpHeaders: [String: String] = [:]
+        for (key, value) in headers {
+            httpHeaders[key] = value
+        }
+        for (key, value) in ApiVideoUploader.customHeaders {
+            httpHeaders[key] = value
+        }
+        return httpHeaders
+    }
+
+    fileprivate func getFileName(fromContentDisposition contentDisposition: String?) -> String? {
+
+        guard let contentDisposition = contentDisposition else {
+            return nil
+        }
+
+        let items = contentDisposition.components(separatedBy: ";")
+
+        var filename: String?
+
+        for contentItem in items {
+
+            let filenameKey = "filename="
+            guard let range = contentItem.range(of: filenameKey) else {
+                continue
+            }
+
+            filename = contentItem
+            return filename?
+                .replacingCharacters(in: range, with: "")
+                .replacingOccurrences(of: "\"", with: "")
+                .trimmingCharacters(in: .whitespacesAndNewlines)
+        }
+
+        return filename
+
+    }
+
+    fileprivate func getPath(from url: URL) throws -> String {
+
+        guard var path = URLComponents(url: url, resolvingAgainstBaseURL: true)?.path else {
+            throw DownloadException.requestMissingPath
+        }
+
+        if path.hasPrefix("/") {
+            path.remove(at: path.startIndex)
+        }
+
+        return path
+
+    }
+
+    fileprivate func getURL(from urlRequest: URLRequest) throws -> URL {
+
+        guard let url = urlRequest.url else {
+            throw DownloadException.requestMissingURL
+        }
+
+        return url
+    }
+
+}
+
+open class URLSessionDecodableRequestBuilder<T: Decodable>: URLSessionRequestBuilder<T> {
+    override fileprivate func processRequestResponse(urlRequest: URLRequest, data: Data?, response: URLResponse?, error: Error?, completion: @escaping (_ result: Swift.Result<Response<T>, ErrorResponse>) -> Void) {
+
+        if let error = error {
+            completion(.failure(ErrorResponse.error(-1, data, response, error)))
+            return
+        }
+
+        guard let httpResponse = response as? HTTPURLResponse else {
+            completion(.failure(ErrorResponse.error(-2, data, response, DecodableRequestBuilderError.nilHTTPResponse)))
+            return
+        }
+
+        guard httpResponse.isStatusCodeSuccessful else {
+            completion(.failure(ErrorResponse.error(httpResponse.statusCode, data, response, DecodableRequestBuilderError.unsuccessfulHTTPStatusCode)))
+            return
+        }
+
+        switch T.self {
+        case is String.Type:
+
+            let body = data.flatMap { String(data: $0, encoding: .utf8) } ?? ""
+
+            completion(.success(Response<T>(response: httpResponse, body: body as! T)))
+
+        case is URL.Type:
+            do {
+
+                guard error == nil else {
+                    throw DownloadException.responseFailed
+                }
+
+                guard let data = data else {
+                    throw DownloadException.responseDataMissing
+                }
+
+                let fileManager = FileManager.default
+                let cachesDirectory = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+                let requestURL = try getURL(from: urlRequest)
+
+                var requestPath = try getPath(from: requestURL)
+
+                if let headerFileName = getFileName(fromContentDisposition: httpResponse.allHeaderFields["Content-Disposition"] as? String) {
+                    requestPath = requestPath.appending("/\(headerFileName)")
+                } else {
+                    requestPath = requestPath.appending("/tmp.ApiVideoUploader.\(UUID().uuidString)")
+                }
+
+                let filePath = cachesDirectory.appendingPathComponent(requestPath)
+                let directoryPath = filePath.deletingLastPathComponent().path
+
+                try fileManager.createDirectory(atPath: directoryPath, withIntermediateDirectories: true, attributes: nil)
+                try data.write(to: filePath, options: .atomic)
+
+                completion(.success(Response(response: httpResponse, body: filePath as! T)))
+
+            } catch let requestParserError as DownloadException {
+                completion(.failure(ErrorResponse.error(400, data, response, requestParserError)))
+            } catch {
+                completion(.failure(ErrorResponse.error(400, data, response, error)))
+            }
+
+        case is Void.Type:
+
+            completion(.success(Response(response: httpResponse, body: () as! T)))
+
+        case is Data.Type:
+
+            completion(.success(Response(response: httpResponse, body: data as! T)))
+
+        default:
+
+            guard let data = data, !data.isEmpty else {
+                completion(.failure(ErrorResponse.error(httpResponse.statusCode, nil, response, DecodableRequestBuilderError.emptyDataResponse)))
+                return
+            }
+
+            let decodeResult = CodableHelper.decode(T.self, from: data)
+
+            switch decodeResult {
+            case let .success(decodableObj):
+                completion(.success(Response(response: httpResponse, body: decodableObj)))
+            case let .failure(error):
+                completion(.failure(ErrorResponse.error(httpResponse.statusCode, data, response, error)))
+            }
+        }
+    }
+}
+
+private class BackgroundUploadTaskURLSession<T>: NSObject, URLSessionProtocol, URLSessionDelegate, URLSessionDataDelegate {
+    private let file: URL
+    private lazy var urlSession: URLSession = {
+        URLSession(configuration: .background(withIdentifier: ApiVideoClient.backgroundIdentifier), delegate: self, delegateQueue: nil)
+    }()
+    private var completion: ((Data?, URLResponse?, Error?) -> Void)? = nil
+    
+    init(_ file: URL) {
+        self.file = file
+    }
+    
+    func dataTask(with request: URLRequest, completionHandler: @escaping @Sendable (Data?, URLResponse?, Error?) -> Void) -> URLSessionDataTask {
+        completion = completionHandler
+        return urlSession.uploadTask(with: request, fromFile: file)
+    }
+
+    func urlSession(_ session: URLSession, task: URLSessionTask, didBecomeInvalidWithError error: Error?) {
+        guard let error = error else {
+            return
+        }
+        completion?(nil, task.response, error)
+    }
+    
+    func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+        completion?(data, dataTask.response, nil)
+    }
+    
+    func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        sessionDelegate.urlSession(session, task: task, didReceive: challenge, completionHandler: completionHandler)
+    }
+}
+
+open class URLSessionDecodableBackgroundUploadRequestBuilder<T: Decodable>: URLSessionDecodableRequestBuilder<T> {
+    private var completion: ((Result<Response<T>, ErrorResponse>) -> Void)? = nil
+    
+    override open func createURLSession() -> URLSessionProtocol {
+        guard let parameters = parameters else { fatalError("No parameters found") }
+        
+        // Find file URL
+        var file: URL? = nil
+        for (_, value) in parameters {
+            if let fileURL = value as? URL {
+                file = fileURL
+                break
+            }
+        }
+        guard let fileURL = file else {
+            fatalError("No file URL found")
+        }
+        return BackgroundUploadTaskURLSession<T>(fileURL)
+    }
+}
+
+private class SessionDelegate: NSObject, URLSessionTaskDelegate {
+    func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+
+        var disposition: URLSession.AuthChallengeDisposition = .performDefaultHandling
+
+        var credential: URLCredential?
+
+        if let taskDidReceiveChallenge = challengeHandlerStore[task.taskIdentifier] {
+            (disposition, credential) = taskDidReceiveChallenge(session, task, challenge)
+        } else {
+            if challenge.previousFailureCount > 0 {
+                disposition = .rejectProtectionSpace
+            } else {
+                credential = credentialStore[task.taskIdentifier] ?? session.configuration.urlCredentialStorage?.defaultCredential(for: challenge.protectionSpace)
+
+                if credential != nil {
+                    disposition = .useCredential
+                }
+            }
+        }
+
+        completionHandler(disposition, credential)
+    }
+}
+
+public enum HTTPMethod: String {
+    case options = "OPTIONS"
+    case get = "GET"
+    case head = "HEAD"
+    case post = "POST"
+    case put = "PUT"
+    case patch = "PATCH"
+    case delete = "DELETE"
+    case trace = "TRACE"
+    case connect = "CONNECT"
+}
+
+public protocol ParameterEncoding {
+    func encode(_ urlRequest: URLRequest, with parameters: [String: Any]?) throws -> URLRequest
+}
+
+private class URLEncoding: ParameterEncoding {
+    func encode(_ urlRequest: URLRequest, with parameters: [String: Any]?) throws -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        guard let parameters = parameters else { return urlRequest }
+
+        guard let url = urlRequest.url else {
+            throw DownloadException.requestMissingURL
+        }
+
+        if var urlComponents = URLComponents(url: url, resolvingAgainstBaseURL: false), !parameters.isEmpty {
+            urlComponents.queryItems = APIHelper.mapValuesToQueryItems(parameters)
+            urlRequest.url = urlComponents.url
+        }
+
+        return urlRequest
+    }
+}
+
+private class FormDataEncoding: ParameterEncoding {
+
+    let contentTypeForFormPart: (_ fileURL: URL) -> String?
+
+    init(contentTypeForFormPart: @escaping (_ fileURL: URL) -> String?) {
+        self.contentTypeForFormPart = contentTypeForFormPart
+    }
+
+    func encode(_ urlRequest: URLRequest, with parameters: [String: Any]?) throws -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        guard let parameters = parameters, !parameters.isEmpty else {
+            return urlRequest
+        }
+
+        let boundary = "Boundary-\(UUID().uuidString)"
+
+        urlRequest.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+
+        for (key, value) in parameters {
+            switch value {
+            case let fileChunkInputStream as FileChunkInputStream:
+
+                urlRequest = configureInputStreamRequest(
+                    urlRequest: urlRequest,
+                    boundary: boundary,
+                    name: key,
+                    fileName: fileChunkInputStream.file.lastPathComponent,
+                    inputStream: fileChunkInputStream,
+                    length: UInt64(fileChunkInputStream.capacity)
+                )
+
+            case let fileURL as URL:
+
+                urlRequest = try configureFileUploadRequest(
+                    urlRequest: urlRequest,
+                    boundary: boundary,
+                    name: key,
+                    fileURL: fileURL
+                )
+
+            case let string as String:
+
+                if let data = string.data(using: .utf8) {
+                    urlRequest = configureDataUploadRequest(
+                        urlRequest: urlRequest,
+                        boundary: boundary,
+                        name: key,
+                        data: data
+                    )
+                }
+
+            case let number as NSNumber:
+
+                if let data = number.stringValue.data(using: .utf8) {
+                    urlRequest = configureDataUploadRequest(
+                        urlRequest: urlRequest,
+                        boundary: boundary,
+                        name: key,
+                        data: data
+                    )
+                }
+
+           case let data as Data:
+
+                urlRequest = configureDataUploadRequest(
+                    urlRequest: urlRequest,
+                    boundary: boundary,
+                    name: key,
+                    data: data
+                )
+
+            default:
+                fatalError("Unprocessable value \(value) with key \(key)")
+            }
+        }
+
+        var body = urlRequest.httpBody.orEmpty
+
+        body.append("\r\n--\(boundary)--\r\n")
+
+        urlRequest.httpBody = body
+
+        return urlRequest
+    }
+
+    private func configureInputStreamRequest(urlRequest: URLRequest, boundary: String, name: String, fileName: String, inputStream: InputStream, length: UInt64) -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        var body = urlRequest.httpBody.orEmpty
+
+        let data = encodeInputStream(for: inputStream, withLength: length)
+
+        let mimetype = "video/quicktime"
+
+        // If we already added something then we need an additional newline.
+        if body.count > 0 {
+            body.append("\r\n")
+        }
+
+        // Value boundary.
+        body.append("--\(boundary)\r\n")
+
+        // Value headers.
+        body.append("Content-Disposition: form-data; name=\"\(name)\"; filename=\"\(fileName)\"\r\n")
+        body.append("Content-Type: \(mimetype)\r\n")
+
+        // Separate headers and body.
+        body.append("\r\n")
+
+        // The value data.
+        body.append(data)
+
+        urlRequest.httpBody = body
+
+        return urlRequest
+    }
+
+    private func configureFileUploadRequest(urlRequest: URLRequest, boundary: String, name: String, fileURL: URL) throws -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        var body = urlRequest.httpBody.orEmpty
+
+        let fileData = try Data(contentsOf: fileURL)
+
+        let mimetype = contentTypeForFormPart(fileURL) ?? mimeType(for: fileURL)
+
+        let fileName = fileURL.lastPathComponent
+
+        // If we already added something then we need an additional newline.
+        if body.count > 0 {
+            body.append("\r\n")
+        }
+
+        // Value boundary.
+        body.append("--\(boundary)\r\n")
+
+        // Value headers.
+        body.append("Content-Disposition: form-data; name=\"\(name)\"; filename=\"\(fileName)\"\r\n")
+        body.append("Content-Type: \(mimetype)\r\n")
+
+        // Separate headers and body.
+        body.append("\r\n")
+
+        // The value data.
+        body.append(fileData)
+
+        urlRequest.httpBody = body
+
+        return urlRequest
+    }
+
+    private func configureDataUploadRequest(urlRequest: URLRequest, boundary: String, name: String, data: Data) -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        var body = urlRequest.httpBody.orEmpty
+
+        // If we already added something then we need an additional newline.
+        if body.count > 0 {
+            body.append("\r\n")
+        }
+
+        // Value boundary.
+        body.append("--\(boundary)\r\n")
+
+        // Value headers.
+        body.append("Content-Disposition: form-data; name=\"\(name)\"\r\n")
+
+        // Separate headers and body.
+        body.append("\r\n")
+
+        // The value data.
+        body.append(data)
+
+        urlRequest.httpBody = body
+
+        return urlRequest
+
+    }
+
+    func mimeType(for url: URL) -> String {
+        let pathExtension = url.pathExtension
+
+        if let uti = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, pathExtension as NSString, nil)?.takeRetainedValue() {
+            if let mimetype = UTTypeCopyPreferredTagWithClass(uti, kUTTagClassMIMEType)?.takeRetainedValue() {
+                return mimetype as String
+            }
+        }
+        return "application/octet-stream"
+    }
+
+    private func encodeInputStream(for inputStream: InputStream, withLength length: UInt64) -> Data {
+        inputStream.open()
+        defer { inputStream.close() }
+
+        let streamBufferSize = 1024
+        var encoded = Data()
+
+        while inputStream.hasBytesAvailable {
+            var buffer = [UInt8](repeating: 0, count: streamBufferSize)
+            let bytesRead = inputStream.read(&buffer, maxLength: streamBufferSize)
+
+            if let error = inputStream.streamError {
+                fatalError("Reading input stream failed with error \(error)")
+            }
+
+            if bytesRead > 0 {
+                encoded.append(buffer, count: bytesRead)
+            } else {
+                break
+            }
+        }
+
+        guard UInt64(encoded.count) == length else {
+            fatalError("Unexpected input stream length. Expected: \(length) Got: \(UInt64(encoded.count))")
+        }
+
+        return encoded
+    }
+
+}
+
+private class FormURLEncoding: ParameterEncoding {
+    func encode(_ urlRequest: URLRequest, with parameters: [String: Any]?) throws -> URLRequest {
+
+        var urlRequest = urlRequest
+
+        var requestBodyComponents = URLComponents()
+        requestBodyComponents.queryItems = APIHelper.mapValuesToQueryItems(parameters ?? [:])
+
+        if urlRequest.value(forHTTPHeaderField: "Content-Type") == nil {
+            urlRequest.setValue("application/x-www-form-urlencoded", forHTTPHeaderField: "Content-Type")
+        }
+
+        urlRequest.httpBody = requestBodyComponents.query?.data(using: .utf8)
+
+        return urlRequest
+    }
+}
+
+private extension Data {
+    /// Append string to Data
+    ///
+    /// Rather than littering my code with calls to `dataUsingEncoding` to convert strings to Data, and then add that data to the Data, this wraps it in a nice convenient little extension to Data. This converts using UTF-8.
+    ///
+    /// - parameter string:       The string to be added to the `Data`.
+
+    mutating func append(_ string: String) {
+        if let data = string.data(using: .utf8) {
+            append(data)
+        }
+    }
+}
+
+private extension Optional where Wrapped == Data {
+    var orEmpty: Data {
+        self ?? Data()
+    }
+}
+
+extension JSONDataEncoding: ParameterEncoding {}
diff --git a/Sources/Upload/FileChunkInputStream.swift b/Sources/Upload/FileChunkInputStream.swift
index b1098bc..846be7e 100644
--- a/Sources/Upload/FileChunkInputStream.swift
+++ b/Sources/Upload/FileChunkInputStream.swift
@@ -1,6 +1,3 @@
-//  FileChunkInputStream.swift
-//
-
 import Foundation
 
 public class FileChunkInputStream: InputStream {
diff --git a/Sources/Upload/ProgressiveUploadSessionProtocol.swift b/Sources/Upload/ProgressiveUploadSessionProtocol.swift
index c60261c..88a093a 100644
--- a/Sources/Upload/ProgressiveUploadSessionProtocol.swift
+++ b/Sources/Upload/ProgressiveUploadSessionProtocol.swift
@@ -1,6 +1,3 @@
-//  ProgressiveUploadSessionProtocol.swift
-//
-
 import Foundation
 
 public protocol ProgressiveUploadSessionProtocol {
diff --git a/Sources/Upload/RequestTaskQueue.swift b/Sources/Upload/RequestTaskQueue.swift
index 40b3481..ed5e578 100644
--- a/Sources/Upload/RequestTaskQueue.swift
+++ b/Sources/Upload/RequestTaskQueue.swift
@@ -1,12 +1,10 @@
 import Foundation
-import Alamofire
 
 public class RequestTaskQueue<T>: RequestTask {
     private let operationQueue: OperationQueue
     private var requestBuilders: [RequestBuilder<T>] = []
 
-    private let _downloadProgress = Progress(totalUnitCount: 0)
-    private let _uploadProgress = Progress(totalUnitCount: 0)
+    private let _progress = Progress(totalUnitCount: 0)
 
     internal init(queueLabel: String) {
         operationQueue = OperationQueue()
@@ -15,34 +13,20 @@ public class RequestTaskQueue<T>: RequestTask {
         super.init()
     }
 
-    override public var uploadProgress: Progress {
+    @available(iOS 11.0, macOS 10.13, macCatalyst 13.0, tvOS 11.0, watchOS 4.0, *)
+    override public var progress: Progress {
         var completedUnitCount: Int64 = 0
         var totalUnitCount: Int64 = 0
         requestBuilders.forEach {
-            if let progress = $0.requestTask.uploadProgress {
+            if let progress = $0.requestTask.progress {
                 completedUnitCount += progress.completedUnitCount
                 totalUnitCount += progress.totalUnitCount
             }
         }
 
-        _uploadProgress.totalUnitCount = totalUnitCount
-        _uploadProgress.completedUnitCount = completedUnitCount
-        return _uploadProgress
-    }
-
-    override public var downloadProgress: Progress {
-        var completedUnitCount: Int64 = 0
-        var totalUnitCount: Int64 = 0
-        requestBuilders.forEach {
-            if let progress = $0.requestTask.downloadProgress {
-                completedUnitCount += progress.completedUnitCount
-                totalUnitCount += progress.totalUnitCount
-            }
-        }
-
-        _downloadProgress.totalUnitCount = totalUnitCount
-        _downloadProgress.completedUnitCount = completedUnitCount
-        return _downloadProgress
+        _progress.totalUnitCount = totalUnitCount
+        _progress.completedUnitCount = completedUnitCount
+        return _progress
     }
 
     internal func willExecuteRequestBuilder(requestBuilder: RequestBuilder<T>) -> Void {
@@ -62,6 +46,10 @@ public class RequestTaskQueue<T>: RequestTask {
         }
         operationQueue.cancelAllOperations()
     }
+
+    override public var isFinished: Bool {
+        requestBuilders.allSatisfy { $0.requestTask.isFinished }
+    }
 }
 
 final class RequestOperation<T>: Operation {
diff --git a/Sources/Upload/UploadChunkRequestTaskQueue.swift b/Sources/Upload/UploadChunkRequestTaskQueue.swift
index 5b4e6b6..4ce6aa8 100644
--- a/Sources/Upload/UploadChunkRequestTaskQueue.swift
+++ b/Sources/Upload/UploadChunkRequestTaskQueue.swift
@@ -1,6 +1,4 @@
 import Foundation
-import Alamofire
-
 
 public class UploadChunkRequestTaskQueue: RequestTaskQueue<Video> {
     private let requestBuilders: [RequestBuilder<Video>]
@@ -10,7 +8,7 @@ public class UploadChunkRequestTaskQueue: RequestTaskQueue<Video> {
     private let completion: (_ data: Video?, _ error: Error?) -> Void
 
     private var videoId: String?
-    private let _uploadProgress: Progress
+    private let _progress: Progress
 
     private var hasSentError = false
 
@@ -20,7 +18,7 @@ public class UploadChunkRequestTaskQueue: RequestTaskQueue<Video> {
                   onProgressReady: ((Progress) -> Void)? = nil,
                   apiResponseQueue: DispatchQueue = ApiVideoUploader.apiResponseQueue,
                   completion: @escaping (_ data: Video?, _ error: Error?) -> Void) {
-        _uploadProgress = Progress(totalUnitCount: fileSize)
+        _progress = Progress(totalUnitCount: fileSize)
         self.requestBuilders = requestBuilders
         self.onProgressReady = onProgressReady
         self.apiResponseQueue = apiResponseQueue
@@ -76,14 +74,15 @@ public class UploadChunkRequestTaskQueue: RequestTaskQueue<Video> {
         requestBuilder.onProgressReady = progressReadyHook
     }
 
-    override public var uploadProgress: Progress {
-        _uploadProgress.completedUnitCount = min(super.uploadProgress.completedUnitCount, _uploadProgress.totalUnitCount)
-        return _uploadProgress
+    @available(iOS 11.0, macOS 10.13, macCatalyst 13.0, tvOS 11.0, watchOS 4.0, *)
+    override public var progress: Progress {
+        _progress.completedUnitCount = min(super.progress.completedUnitCount, _progress.totalUnitCount)
+        return _progress
     }
 
     private func progressReadyHook(progress: Progress) -> Void {
         if let onProgressReady = onProgressReady {
-            onProgressReady(uploadProgress)
+            onProgressReady(progress)
         }
     }
 
@@ -98,9 +97,7 @@ public class UploadChunkRequestTaskQueue: RequestTaskQueue<Video> {
             if (videoId == nil) {
                 videoId = data?.videoId
             }
-            if (requestBuilders.allSatisfy {
-                $0.requestTask.state == .finished
-            }) {
+            if (isFinished) {
                 completion(data, nil)
             }
         }
diff --git a/project.yml b/project.yml
index 7000872..5d01e46 100644
--- a/project.yml
+++ b/project.yml
@@ -13,4 +13,3 @@ targets:
     scheme: {}
     dependencies:
     - carthage: AnyCodable
-    - carthage: Alamofire