This class wraps all functionality related to extracting information from a http request. Much of the functionality is inspired by the Request class in Express.js, so the documentation for this will complement this document. As reqres is build on top of the Rook specifications the Request object is initialized from a Rook-compliant object. This will often be the request object provided by the httpuv framework. While it shouldn't be needed, the original Rook object is always accessible and can be modified, though any modifications will not propagate to derived values in the Request object (e.g. changing the HTTP_HOST element of the Rook object will not change the host field of the Request object). Because of this, direct manipulation of the Rook object is generally discouraged.

as.Request(x, ...)




An object coercible to a Request.


Parameters passed on to Request$new()


A Request object (for as.Request()) or a logical indicating whether the object is a Request (for is.Request())


A new 'Request'-object is initialized using the new() method on the generator:


req <- Request$new(rook, trust = FALSE)


rookThe rook request that the new object should wrap
trustIs this request trusted blindly. If TRUE X-Forwarded-* headers will be returned when querying host, ip, and protocol


The following fields are accessible in a Request object:


A logical indicating whether the request is trusted. Mutable


A string indicating the request method (in lower case, e.g. 'get', 'put', etc.). Immutable


An object holding the body of the request. This is an empty string by default and needs to be populated using the set_body() method (this is often done using a body parser that accesses the Rook$input stream). Immutable


Access a named list of all cookies in the request. These have been URI decoded. Immutable


Access a named list of all headers in the request. In order to follow R variable naming standards - have been substituted with _. Use the get_header() method to lookup based on the correct header name. Immutable


Return the domain of the server given by the "Host" header if trust == FALSE. If trust == true returns the X-Forwarded-Host instead.


Returns the remote address of the request if trust == FALSE. if trust == TRUE it will instead return the first value of the X-Forwarded-For header. Immutable


If trust == TRUE it will return the full list of ips in the X-Forwarded-For header. If trust == FALSE it will return an empty vector. Immutable


Returns the protocol (e.g. 'http') used for the request. If trust == TRUE it will use the value of the X-Forwarded-Proto header. Immutable


The mount point of the application receiving this request. Can be empty if the application is mounted on the server root. Immutable


The part of the url following the root. Defines the local target of the request (independent of where it is mounted). Immutable


The full URL of the request. Immutable


The query string of the request (anything following "?" in the URL) parsed into a named list. The query has been url decoded and "+" has been substituted with space. Multiple queries are expected to be separated by either "&" or "|". Immutable


The unparsed query string of the request, including "?". If no query string exists it will be "" rather than "?"


A logical indicating whether the X-Requested-With header equals XMLHttpRequest thus indicating that the request was performed using a JavaScript library such as jQuery. Immutable


A logical indicating whether the request was performed using a secure connection, i.e. protocol == 'https'. Immutable


The original object used to create the Request object. As reqres currently only works with rook this will always return the original rook object. Immutable, though the content of the rook object itself might be manipulated as it is an environment.


If a Response object has been created for this request it is accessible through this field. Immutable


The following methods are available in a Request object:


Sets the content of the request body. This method should mainly be used in concert with a body parser that reads the rook$input stream


Sets the cookies of the request. The cookies are automatically parsed and populated, so this method is mainly available to facilitate cookie signing and encryption


Get the header of the specified name.


Given a vector of response content types it returns the preferred one based on the Accept header.


Given a vector of possible character encodings it returns the preferred one based on the Accept-Charset header.


Given a vector of possible content encodings (usually compression algorithms) it selects the preferred one based on the Accept-Encoding header. If there is no match it will return "identity" signaling no compression.


Given a vector of possible content languages it selects the best one based on the Accept-Language header.


Queries whether the body of the request is in a given format by looking at the Content-Type header. Used for selecting the best parsing method.


Creates a new Response object from the request

parse(..., autofail = TRUE)

Based on provided parsers it selects the appropriate one by looking at the Content-Type header and assigns the result to the request body. A parser is a function accepting a raw vector, and a named list of additional directives, and returns an R object of any kind (if the parser knows the input to be plain text, simply wrap it in rawToChar()). If the body is compressed, it will be decompressed based on the Content-Encoding header prior to passing it on to the parser. See parsers for a list of pre-supplied parsers. Parsers are either supplied in a named list or as named arguments to the parse method. The names should correspond to mime types or known file extensions. If autofail = TRUE the response will be set with the correct error code if parsing fails. parse() returns TRUE if parsing was successful and FALSE if not

parse_raw(autofail = TRUE)

This is a simpler version of the parse() method. It will attempt to decompress the body and set the body field to the resulting raw vector. It is then up to the server to decide how to handle the payload. It returns TRUE if successful and FALSE otherwise.


Prints a HTTP representation of the request to the output stream.

See also

Response for handling http responses


fake_rook <- fiery::fake_request( '', content = 'This is an elaborate ruse', headers = list( Accept = 'application/json; text/*', Content_Type = 'text/plain' ) ) req <- Request$new(fake_rook) # Get full URL req$url
#> [1] ""
# Get list of query parameters req$query
#> $id #> [1] 34632 #> #> $question #> [1] "who is hadley" #>
# Test if content is text req$is('txt')
#> [1] TRUE
# Perform content negotiation for the response req$accepts(c('html', 'json', 'txt'))
#> [1] "json"
# Cleaning up connections rm(fake_rook, req) gc()
#> used (Mb) gc trigger (Mb) max used (Mb) #> Ncells 774328 41.4 1224421 65.4 1224421 65.4 #> Vcells 1490413 11.4 8388608 64.0 2471676 18.9