Your Slim app’s routes and middleware are given a PSR 7 request object that represents the current HTTP request received by your web server. The request object implements the PSR 7 ServerRequestInterface with which you can inspect and manipulate the HTTP request method, headers, and body.
The PSR 7 request object is injected into your Slim application routes as the first argument to the route callback like this:
The PSR 7 request object is injected into your Slim application middleware as the first argument of the middleware callable like this:
Every HTTP request has a method that is typically one of:
You can inspect the HTTP request’s method with the Request object method
Because this is a common task, Slim’s
built-in PSR 7 implementation also provides these proprietary methods that return
It is possible to fake or override the HTTP request method. This is
useful if, for example, you need to mimic a
PUT request using a traditional
web browser that only supports
There are two ways to override the HTTP request method. You can include a
_METHOD parameter in a
POST request’s body. The HTTP request must use the
application/x-www-form-urlencoded content type.
You can also override the HTTP request method with a custom
X-Http-Method-Override HTTP request header. This works with any HTTP request
You can fetch the original (non-overridden) HTTP method with the PSR 7 Request
object’s method named
Every HTTP request has a URI that identifies the requested application resource. The HTTP request URI has several parts:
You can fetch the PSR 7 Request object’s URI object with its
The PSR 7 Request object’s URI is itself an object that provides the following methods to inspect the HTTP request’s URL parts:
getQuery()(returns the full query string, e.g.
You can get the query parameters as an associative array on the Request object using
You can also get a single query parameter value, with optional default value if the parameter is missing, using
getQueryParam($key, $default = null).
getBasePath()method. This will be an empty string if the Slim application is installed in the document root's top-most directory.
Every HTTP request has headers. These are metadata that describe the HTTP request but are not visible in the request’s body. Slim’s PSR 7 Request object provides several methods to inspect its headers.
You can fetch all HTTP request headers as an associative array with the PSR 7
getHeaders() method. The resultant associative array’s keys
are the header names and its values are themselves a numeric array of string
values for their respective header name.
You can get a single header’s value(s) with the PSR 7 Request object’s
getHeader($name) method. This returns an array of values for the given header name. Remember, a single
HTTP header may have more than one value!
You may also fetch a comma-separated string with all values for a given header
with the PSR 7 Request object’s
getHeaderLine($name) method. Unlike the
getHeader($name) method, this method returns a comma-separated string.
You can test for the presence of a header with the PSR 7 Request object’s
Every HTTP request has a body. If you are building a Slim application that
consumes JSON or XML data, you can use the PSR 7 Request object’s
getParsedBody() method to parse the HTTP request body into a native PHP format.
Slim can parse JSON, XML, and URL-encoded data out of the box.
For URL-encoded requests, you can also get a single parameter value, with optional default value if the parameter is missing, using
getParsedBodyParam($key, $default = null).
Technically speaking, Slim’s PSR 7 Request object represents the HTTP request
body as an instance of
\Psr\Http\Message\StreamInterface. You can get
the HTTP request body
StreamInterface instance with the PSR 7 Request object’s
getBody() method. The
getBody() method is preferable if the incoming HTTP
request size is unknown or too large for available memory.
\Psr\Http\Message\StreamInterface instance provides the following
methods to read and iterate its underlying PHP
getMetadata($key = null)
getParsedBody on the Request object multiple times, the body is
only parsed once, even if the Request body is modified in the meantime.
To ensure the body is reparsed, the Request object’s method
reparseBody can be
The file uploads in
$_FILES are available from the Request object’s
getUploadedFiles() method. This returns an array keyed by the name of the
Each object in the
$files array is a instance of
\Psr\Http\Message\UploadedFileInterface and supports the following methods:
See the cookbook on how to upload files using a POST form.
Slim’s PSR 7 Request implementation provides these additional proprietary methods to help you further inspect the HTTP request.
You can detect XHR requests with the Request object’s
isXhr() method. This
method detects the presence of the
X-Requested-With HTTP request header and
ensures its value is
You can fetch the HTTP request content type with the Request object’s
getContentType() method. This returns the
Content-Type header’s full value as provided by the HTTP client.
You may not want the complete
Content-Type header. What if, instead, you only want the media type? You can fetch the HTTP request media type with the Request object’s
You can fetch the appended media type parameters as an associative array with the Request object’s
One of the most common media type parameters is the HTTP request character set. The Request object provides a dedicated method to retrieve this media type parameter.
You can fetch the HTTP request content length with the Request object’s
To fetch single request parameter value, use methods:
getServerParam(), counterparts of PSR-7’s plural form get*Params() methods.
For example, to get a single Server Parameter:
Sometimes in middleware you require the parameter of your route.
In this example we are checking first that the user is logged in and second that the user has permissions to view the particular video they are attempting to view.
Slim looks as the request’s media type and if it recognises it, will parse it into structured data available via
$request->getParsedBody(). This is usually an array, but is an object for XML media types.
The following media types are recognised and parsed:
If you want Slim to parse content from a different media type then you need to either parse the raw body yourself or register a new media parser. Media parsers are simply callables that accept an
$input string and return a parsed object or array.
Register a new media parser in an application or route middleware. Note that you must register the parser before you try to access the parsed body for the first time.
For example, to automatically parse JSON that is sent with a
With PSR-7 it is possible to inject objects/values into the request object for further processing. In your applications middleware often need to pass along information to your route closure and the way to do is it is to add it to the request object via an attribute.
Example, Setting a value on your request object.
Example, how to retrieve the value.
The request object also has bulk functions as well.