v2.2 LTS
Masonite Essentials

Learn more by reading the Validation documentation.

The Request class is initialized when the server first starts and is modified on every request. This means that the Request class acts as a singleton and is not reinitialized on every request. This presents both pros and cons during developing Masonite. It's great to not have to worry about a new object being instantiated every time but the con is that some attributes need to be reset at the end of the request.
The Request class is loaded into the IOC container first so any Service Provider will have access to it. The IOC container allows all parts of the framework to be resolved by the IOC container and auto inject any dependencies they need.
Read more about the IOC container in the Service Container documentation.

The Request class is bound into the IOC container once when the server is first started. This takes the WSGI environment variables generated by your WSGI server as a parameter. Because of this, we reload the WSGI values on every request but the actual Request object does not change. In other words, the memory address of the Request object is always the same but the class attributes will change of every request. This is done already for you by the Masonite framework itself. This Request class is bound and initialized inside the AppProvider Service Provider. We grab this request object by simply passing in Request into the parameters of anything resolved by the Service Container such as middleware, drivers and controller methods like so:
def show(self, request: Request):
request #== <masonite.request.Request>
Masonite is smart enough to know that we need the Request class and it will inject it into our method for us.

Masonite ships with a HelpersProvider Service Provider which adds several helper functions. One of these helper functions is the request() function. This function will return the request object. Because of this, these two pieces of code are identical:
def show(self, request: Request):
def show(self):
Notice we didn't import anything at the top of our file and also didn't retrieve any objects from the IOC container. Masonite helper functions act just like any other built in Python function.
Read more about helper functions in the Helper Functions documentation.

The Request has several helper methods attached to it in order to interact with various aspects of the request.
In order to get the current request input variables such as the form data during a POST request or the query string during a GET request looks like:
def show(self, request: Request):
There is no difference between any HTTP methods (GET, POST, PUT, etc) when it comes to getting input data. They are all retrieved through this .input() method so there is no need to make a distinction if the request is GET or POST

We can get all the request input variables such as input data from a form request or GET data from a query string. Note that it does not matter what HTTP method you are using, the input method will know what input data to get dependent on the current HTTP method (GET, POST, PUT, etc)
This will return all the available request input variables for that request as a dictionary.
# GET: /dashboard?user=Joe&status=1
def show(self, request: Request):
return request.all() # {'user': 'Joe', 'status': '1'}
This method will get all of the request input variables to include any internal framework variables completely handled internally such as __token and __method. You can exclude them by passing in False into the method or specifying it explicitly:
# GET: /dashboard?user=Joe&status=1&__token=837674634
def show(self, request: Request):
return request.all(internal_variables=False) # {'user': 'Joe', 'status': '1'}
To get a specific input:
# GET: /dashboard?firstname=Joe
def show(self, request: Request):
return request.input('firstname') # Joe

Input data will be cleaned of HTML tags and other security measures. This may cause unwanted return values if you are expecting something like a JSON string. If you want to opt to not clean the input you can specify that as a keyword argument:
request.input('firstname', clean=False) # Joe
To check if some request input data exists:
# GET: /dashboard?firstname=Joe
def show(self, request: Request):
return request.has('firstname') # True

If your input is a dictionary you have two choices how you want to access the dictionary. You can either access it normally:
request.input('payload')['user']['address'] # 123 Smith Rd
Or you can use dot notation to fetch the value for simplicity:
request.input('payload.user.address') # 123 Smith Rd
You can also use a * wildcard to get all values from a dictionary list. Take this code example:
"user": {
"id": 1,
"addresses": [
{"id": 1, 'street': "A Street"},
{"id": 2, 'street': "B Street"}
request.input('user.addresses.*.id') # [1,2]

You can only get a certain set of parameters if you have a need to do so. This can be used like:
# GET: /dashboard?firstname=Joe&lastname=Mancuso&active=1
def show(self, request: Request):
return request.only('firstname', 'active') # {'firstname': 'Joe', 'active': '1'}

We can specify a set of parameters to exclude from the inputs returned. For example:
# GET: /dashboard?firstname=Joe&lastname=Mancuso&active=1
def show(self, request: Request):
return request.without('lastname') # {'firstname': 'Joe', 'active': '1'}
Notice it returned everything besides lastname.

To get the request parameter retrieved from the url. This is used to get variables inside: /dashboard/@firstname for example.
# Route: /dashboard/@firstname
# GET: /dashboard/Joe
def show(self, request: Request):
return request.param('firstname') # Joe

Sometimes you may want to handle incoming JSON requests. This could be form external API's like Github.
Masonite will detect that an incoming request is a JSON request and put the cast the JSON to a dictionary and load it into the payload request input. For example if you have an incoming request of:
"name": "Joe",
"email": "[email protected]"
Then we can fetch this input in a controller using the normal input() method like so:
def show(self, request: Request):
request.input('name') # Joe

You may also set a cookie in the browser. The below code will set a cookie named key to the value of value.
By default, all cookies are encrypted with your secret key which is generated in your .env file when you installed Masonite. This is a security measure to ensure malicious Javascript code cannot fetch cookies if they are somehow retrieved. All cookies are set with the HTTP_ONLY flag meaning that Javascript cannot read them although you can turn this off using a parameter.

def show(self, request: Request):
return request.cookie('key', 'value')

If you choose to not encrypt your values and create cookies with the plain text value then you can pass a third value of True or False. You can also be more explicit if you like:
def show(self, request: Request):
return request.cookie('key', 'value', encrypt=False)

All cookies are set as session cookies. This means that when the user closes out the browser completely, all cookies will be deleted.
def show(self, request: Request):
return request.cookie('key', 'value', expires="5 minutes")
This will set a cookie thats expires 5 minutes from the current time.

Again, as a security measure, all cookies automatically are set with the HttpOnly flag which makes it unavailable to any Javascript code. You can turn this off:
def show(self, request: Request):
return request.cookie('key', 'value', http_only=False)
This will now allow Javascript to read the cookie.

You can get all the cookies set from the browser
def show(self, request: Request):
return request.get_cookies()
You can get a specific cookie set from the browser
def show(self, request: Request):
return request.get_cookie('key')
Again, all cookies are encrypted by default so if you set a cookie with encryption then this method will decrypt the cookie. If you set a cookie in plain text then you should pass the False as the second parameter here to tell Masonite not to decrypt your plain text cookie value.:
def show(self, request: Request):
return request.get_cookie('key', decrypt=False)
This will return the plain text version of the cookie.
If Masonite attempts to decrypt a cookie but cannot then Masonite will assume that the secret key that encrypted it was changed or the cookie has been tampered with and will delete the cookie completely.
If your secret key has been compromised then you may change the key at anytime and all cookies set on your server will be removed.

You may also delete a cookie. This will remove it from the browser.
def show(self, request: Request):
return request.delete_cookie('key')

You can also get the current user from the request. This requires the LoadUserMiddleware middleware which is in Masonite by default. This will return an instance of the current user.
def show(self, request: Request):
return request.user()

You can also get a route URL via the route name. Let's say we have a route like this:
We can get the URL from the route name like so:
def show(self):
request().route('dashboard') # /dashboard

if we have route parameters like this:
then we can pass in a dictionary:
def show(self, request: Request):
request.route('dashboard.user', {'user': 1}) # /dashboard/1
You may also pass a list if that makes more sense to you:
def show(self, request: Request):
request.route('dashboard.user', [1]) # /dashboard/1
This will inject that value for each parameter in order. For example if we have this route:
then we can use:
def show(self, request: Request):
request.route('dashboard.user', [1, 2, 'some-slug'])
# /dashboard/1/2/some-slug

We can also check if a route contains a specific pattern:
# GET /dashboard/user/1
def show(self, request: Request):
request.contains('/dashboard/*/1') #== True
You can also use this in a template and pass in a show parameter to return a string instead. This is useful if you want to show active status classes depending on the current route:
<a href=".." class="{{ request().contains('/dashboard/*/edit', show='active')">
<a href=".." class="{{ request().contains('/dashboard/*/create', show='active')">

We can get the current url with:
def show(self, request: Request):
return request.path #== /dashboard/user

You can specify a url to redirect to
def show(self, request: Request):
return request.redirect('/home')
If the url contains http than the route will redirect to the external website
def show(self, request: Request):
return request.redirect('http://google.com')
You can redirect to a named route
def show(self, request: Request):
return request.redirect_to('dashboard')
You can also use the name parameter on the redirect method:
def show(self, request: Request):
return request.redirect(name="dashboard")
You can also redirect to a specific controller. This will find the URL that is attached to the controller method
def show(self, request: Request):
return request.redirect(controller="[email protected]")
Sometimes your routes may require parameters passed to it such as redirecting to a route that has a url like: /url/@firstname:string/@lastname:string.
Redirecting to a named route with URL parameters:
def show(self, request: Request):
return request.redirect_to('dashboard', {'firstname': 'Joseph', 'lastname': 'Mancuso'})
Redirecting to a url in your application with URL parameters:
def show(self, request: Request):
return request.redirect('dashboard/@id', {'id': '1'})

There will be plenty of times you will need to redirect back to where the user came just came from. In order for this work we will need to specify where we need to go back to. We can use the back method for this.

Masonite will check for a __back input and redirect to that route. We can specify one using the back() view helper function:
<form action="{{ route('dashboard.create') }}" method="POST">
{{ csrf_field }}
{{ back() }}
By default the back helper will return the current path so you can easily go back to the previous page after the form is submitted.
You can also specify a path to go back to:
<form action="{{ route('dashboard.create') }}" method="POST">
{{ csrf_field }}
{{ back('/another/path') }}

After submitting the form you can redirect back to wherever the back template method was pointing to using the back() method:
def show(self, request: Request):
return request.back()
This will also flash the current inputs to the session. You can then get the inputs using the {{ old('key') }} template helper:
<input type="text" name="email" value="{{ old ('email') }}">

You can redirect back with validation error message or redirect back with input value:
def show(self, request: Request):
errors = request.validate(
required(['email', 'password'])
if errors:
return request.back().with_errors(errors)

When redirecting back there are times where you will also want to flash the inputs to the session. With this you can simply use the back() method but if you want a bit more control you can use the with_input() method.
def show(self, request: Request):
errors = request.validate(
required(['email', 'password'])
if errors:
return request.redirect('/dashboard/errors').with_input()
You can then get the inputs using the {{ old('key') }} template helper:
<input type="text" name="email" value="{{ old ('email') }}">

We can also specify a default route just in case a form submitted does not specify one using a form helper:
def show(self, request: Request):
return request.back(default='/hit/route')
This will check for the __back input and if it doesn't exist it will use this default route. This is the same as a redirect if you don't use the back() helper.

You can load a specific secret key into the request by using:
This will load a secret key into the request which will be used for encryptions purposes throughout your Masonite project.
Note that by default, the secret key is pulled from your configuration file so you do NOT need to supply a secret key, but the option is there if you need to change it for testing and development purposes.

You can also get and set any headers that the request has.
You can get all WSGI information by printing:
def show(self, request: Request):
This will print the environment setup by the WSGI server. Use this for development purposes.
You can also get a specific header:
def show(self, request: Request):
This will return whatever the HTTP_AUTHORIZATION header if one exists. If that does not exist then the AUTHORIZATION header will be returned. If that does not exist then None will be returned.
We can also set headers:
def show(self, request: Request):
request.header('AUTHORIZATION', 'Bearer some-secret-key')
Masonite will automatically prepend a HTTP_ to the header being set for standards purposes so this will set the HTTP_AUTHORIZATION header. If you do not want the HTTP prefix then pass a third parameter:
request.header('AUTHORIZATION', 'Bearer some-secret-key')
This will set the AUTHORIZATION header instead of the HTTP_AUTHORIZATION header.
You can also set headers with a dictionary:
'AUTHORIZATION': 'Bearer some-secret-key',
'Content-Type': 'application/json'

Masonite will set a status code of 404 Not Found at the beginning of every request. If the status code is not changed throughout the code, either through the developer or third party packages, as it passes through each Service Provider then the status code will continue to be 404 Not Found when the output is generated. You do not have to explicitly specify this as the framework itself handles status codes. If a route matches and your controller method is about to be hit then Masonite will set 200 OK and hit your route. This allows Masonite to specify a good status code but also allows you to change it again inside your controller method.
You could change this status code in either any of your controllers or even a third party package via a Service Provider.
For example, the Masonite Entry package sets certain status codes upon certain actions on an API endpoint. These can be 429 Too Many Requests or 201 Created. These status codes need to be set before the StartProvider is ran so if you have a third party package that sets status codes or headers, then they will need to be placed above this Service Provider in a project.
If you are not specifying status codes in a package and simple specifying them in a controller then you can do so freely without any caveats. You can set status codes like so:
request.status('429 Too Many Requests')
You can also use an integer which will find the correct status code for you:
This snippet is exactly the same as the string based snippet above.
This will set the correct status code before the output is sent to the browser. You can look up a list of HTTP status codes from an online resource and specify any you need to. There are no limitations to which ones you can use.

You can get the request method simply:
# PUT: /dashboard
def show(self, request: Request):
return request.get_request_method() # 'PUT'

Typically, forms only have support for GET and POST. You may want to change what HTTP method is used when submitting a form such as PATCH.
This will look like:
<form action="/dashboard" method="POST">
<input type="hidden" name="request_method" value="PATCH">
or you can optionally use a helper method:
<form action="/dashboard" method="POST">
{{ request_method('PATCH') }}
When the form is submitted, it will process as a PUT request instead of a POST request.
This will allow this form to hit a route like this:
from masonite.routes import Patch
Patch().route('/dashboard', '[email protected]')

There is a convenient helper method you can use the validate the request. You can import the Validator class and use validation like so:
from masonite.request import Request
from masonite.validation import Validator
def show(self, request: Request, validate: Validator):
errors = request.validate(
if errors:
return request.back().with_errors(errors)
Export as PDF
Copy link
On this page
Getting Started
Helper Function
Method Options
Input Data
Input Cleaning
Getting Dictionary Input
URL Parameters
JSON Payloads
Not Encrypting
Route Parsing
Current URL
Redirecting Back
Form Back Redirection
Redirecting Back
Redirecting Back With Errors
Redirecting Back With Inputs
Default Back URL
Encryption Key
Status Codes
Get Request Method Type
Changing Request Methods in Forms