     }
     
     /**
+     Will do a simple Request
+     
+     - Parameter method: HTTP Method
+     - Parameter endpoint: endpoint of the API it should be sent to
+     - Parameter arguments: arguments encoded into the endpoint string
+     - Parameter headers: HTTP Headers that should be added to the request
+     - Parameter auth: Authentication Manager for the request
+     - Parameter body: Data that should be sent in the HTTP Body
+     - Parameter acceptableStatusCodes: HTTP Status Codes that mean a succesfull request was done
+     - Parameter completionQueue: Queue in which the promise should be run
+     - Parameter maxCacheTime: Time the response should be cached
+     
+     - Returns: Promise of Data
+     */
+    public func doDataRequest(with method: HTTPMethod = .get,
+                       to endpoint: Endpoint,
+                       arguments: [String:CustomStringConvertible] = .empty,
+                       headers: [String:CustomStringConvertible] = .empty,
+                       queries: [String:CustomStringConvertible] = .empty,
+                       auth: Auth = NoAuth.standard,
+                       body: Data? = nil,
+                       acceptableStatusCodes: [Int] = [200],
+                       completionQueue: DispatchQueue = .main,
+                       maxCacheTime: CacheTime = .no) -> Data.Result {
+        
+        let url = self.url(for: endpoint, arguments: arguments, queries: queries)
+        let cacheKey = url.relativePath.replacingOccurrences(of: "/", with: "_")
+        
+        if let cached = cache.get(with: cacheKey, maxTime: maxCacheTime) {
+            return .successful(with: cached)
+        }
+        
+        let request = self.request(with: method, to: url, headers: headers, body: body)
+        
+        return auth.apply(to: request).next { request in
+            return self.perform(request: request,
+                                method: method,
+                                at: endpoint,
+                                cacheKey: cacheKey,
+                                acceptableStatusCodes: acceptableStatusCodes,
+                                maxCacheTime: maxCacheTime)
+        }
+    }
+    
+    /**
      Will do a simple Request of a Data Representable Object
      
      - Parameter method: HTTP Method

public extension API {
    
    /**
     Will do a simple Request
     
     - Parameter method: HTTP Method
     - Parameter endpoint: endpoint of the API it should be sent to
     - Parameter arguments: arguments encoded into the endpoint string
     - Parameter headers: HTTP Headers that should be added to the request
     - Parameter auth: Authentication Manager for the request
     - Parameter body: Data that should be sent in the HTTP Body
     - Parameter acceptableStatusCodes: HTTP Status Codes that mean a succesfull request was done
     - Parameter completionQueue: Queue in which the promise should be run
     - Parameter maxCacheTime: Time the response should be cached
     
     - Returns: Promise of Data
     */
    public func doDataRequest(with method: HTTPMethod = .get,
                       to endpoint: Endpoint,
                       arguments: [String:CustomStringConvertible] = .empty,
                       headers: [String:CustomStringConvertible] = .empty,
                       queries: [String:CustomStringConvertible] = .empty,
                       auth: Auth = NoAuth.standard,
                       body: Data? = nil,
                       acceptableStatusCodes: [Int] = [200],
                       completionQueue: DispatchQueue = .main,
                       maxCacheTime: CacheTime = .no) -> Data.Result {
        
        let requestString = arguments ==> endpoint.rawValue ** { string, argument in
            return string.replacingOccurrences(of: "{\(argument.key)}", with: argument.value.description)
        }
        
        let url = (baseQueries + queries >>= { $0.description }) ==> base.appendingPathComponent(requestString) ** { url, query in
            return url.appendingQuery(key: query.key, value: query.value)
        }
        
        let cacheKey = url.relativePath.replacingOccurrences(of: "/", with: "_")
        
        if let cached = cache.get(with: cacheKey, maxTime: maxCacheTime) {
            return .successful(with: cached)
        }
        
        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue

            request.addValue($1, forHTTPHeaderField: $0)
        }
        
        return request
    }
    
    /**
     Will perform a URLRequest
     
     - Parameter request: Request that should be performed
     - Parameter method: HTTP Method
     - Parameter endpoint: Requested endpoint
     - Parameter cacheKey: Key for the Cache
     - Parameter acceptableStatusCodes: Status codes that are considered a success
     - Parameter maxCacheTime: Time the response should be cached
     
     - Returns: Promise of Data
     */
    public func perform(request: URLRequest,
                        method: HTTPMethod,
                        at endpoint: Endpoint,
                        cacheKey: String,
                        acceptableStatusCodes: [Int] = [200],
                        maxCacheTime: CacheTime = .no) -> Data.Result {
        
        return .new { promise in
            var request = request
            self.willPerform(request: &request)
            let session = self.session(for: method, at: endpoint)
