Request validation in Flask

Introduction

Request validation helps check if the data sent to your Flask app is correct and safe before using it.

When a user submits a form and you want to make sure all required fields are filled.

When your app receives JSON data and you want to confirm it has the right keys and types.

When you want to prevent bad or harmful data from causing errors or security issues.

When you want to give clear error messages if the input is wrong.

When you want to keep your app stable by only accepting expected data.

Syntax

Flask

from flask import request

# Access data
value = request.form.get('field_name')

# Simple manual validation example
if not value:
    return 'Missing field_name', 400

Flask's request object holds all incoming data.

You can check data manually or use libraries like marshmallow or pydantic for easier validation.

Examples

Checks if the 'name' field is sent in a form. If missing, returns an error.

Flask

from flask import request

@app.route('/submit', methods=['POST'])
def submit():
    name = request.form.get('name')
    if not name:
        return 'Name is required', 400
    return f'Hello, {name}!'

Validates JSON input to ensure it contains an 'age' key.

Flask

from flask import request, jsonify

@app.route('/json', methods=['POST'])
def json_route():
    data = request.get_json()
    if not data or 'age' not in data:
        return jsonify({'error': 'Age is required'}), 400
    return jsonify({'age': data['age']})

Uses marshmallow to validate JSON data with required fields and email format.

Flask

from flask import request
from marshmallow import Schema, fields, ValidationError

class UserSchema(Schema):
    username = fields.Str(required=True)
    email = fields.Email(required=True)

@app.route('/user', methods=['POST'])
def user():
    json_data = request.get_json()
    try:
        data = UserSchema().load(json_data)
    except ValidationError as err:
        return err.messages, 400
    return f"User {data['username']} with email {data['email']} created"

Sample Program

This Flask app has a /login route that expects JSON with 'username' and 'password'. It uses marshmallow to check the data. If data is missing or wrong, it sends back errors. If all is good, it welcomes the user.

Flask

from flask import Flask, request, jsonify
from marshmallow import Schema, fields, ValidationError

app = Flask(__name__)

class LoginSchema(Schema):
    username = fields.Str(required=True)
    password = fields.Str(required=True)

@app.route('/login', methods=['POST'])
def login():
    json_data = request.get_json()
    if not json_data:
        return jsonify({'error': 'No input data provided'}), 400
    try:
        data = LoginSchema().load(json_data)
    except ValidationError as err:
        return jsonify(err.messages), 400
    return jsonify({'message': f"Welcome, {data['username']}!"})

if __name__ == '__main__':
    app.run(debug=True)

Important Notes

Always check if request.get_json() returns data before validating.

Using validation libraries helps avoid repetitive manual checks and gives clear error messages.

Return HTTP status code 400 for bad input to inform clients properly.

Summary

Request validation checks incoming data to keep your app safe and working well.

You can validate form data or JSON using simple checks or libraries like marshmallow.

Good validation improves user experience by giving clear errors and prevents bugs.

Practice

1. What is the main purpose of request validation in a Flask application?

easy

A. To store user data permanently

B. To check incoming data for correctness and safety

C. To style the HTML forms automatically

D. To speed up the server response time

Solution

1. Step 1: Understand what request validation means

   Request validation means checking the data sent by users to make sure it is correct and safe to use.

2. Step 2: Identify the main goal of validation

   The main goal is to prevent bad or harmful data from causing errors or security problems.

3. Final Answer:

   To check incoming data for correctness and safety -> Option B

4. Quick Check:

   Request validation = check data safety [OK]

Hint: Validation means checking data is safe and correct [OK]

Common Mistakes:

• Thinking validation speeds up the server
• Confusing validation with styling
• Assuming validation stores data

2. Which of the following is the correct way to access JSON data from a Flask request object?

easy

A. request.get_json()

B. request.json_data

C. request.json()

D. request.data.json

Solution

1. Step 1: Recall Flask's method to get JSON data

   Flask provides the method get_json() to parse JSON from the request body.

2. Step 2: Check each option for correctness

   request.json() uses parentheses but json is a property, not a method. request.json_data and D are not valid Flask attributes.

3. Final Answer:

   request.get_json() -> Option A

4. Quick Check:

   Use get_json() to read JSON data [OK]

Hint: Use request.get_json() to read JSON in Flask [OK]

Common Mistakes:

• Calling request.json as a function
• Using non-existent attributes like json_data
• Trying to access JSON via request.data.json

3. Given this Flask route code, what will be the output if the JSON request body is {"age": 17}?

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/check', methods=['POST'])
def check_age():
    data = request.get_json()
    if data and data.get('age', 0) >= 18:
        return jsonify({'status': 'allowed'})
    else:
        return jsonify({'status': 'denied'})

medium

A. {"status": "allowed"}

B. Empty response

C. 500 Internal Server Error

D. {"status": "denied"}

Solution

1. Step 1: Analyze the JSON input and condition

   The input JSON has "age": 17. The code checks if age is 18 or more.

2. Step 2: Determine which branch runs

   Since 17 is less than 18, the else branch runs, returning {'status': 'denied'}.

3. Final Answer:

   {"status": "denied"} -> Option D

4. Quick Check:

   Age 17 < 18 = denied [OK]

Hint: Check if age >= 18 to allow, else deny [OK]

Common Mistakes:

• Assuming 17 is allowed
• Expecting server error for valid JSON
• Thinking response is empty

4. What is wrong with this Flask code snippet for validating a required 'username' field in JSON?

data = request.get_json()
if 'username' in data:
    return 'Username received'
else:
    return 'Missing username', 400

medium

A. It does not check if data is None before accessing

B. It uses wrong HTTP status code for error

C. It should use request.json instead of get_json()

D. It should return JSON response, not plain text

Solution

1. Step 1: Understand get_json() behavior

   request.get_json() can return None if no JSON is sent or invalid JSON.

2. Step 2: Identify the error in code

   The code accesses 'username' in data without checking if data is None, causing a crash if data is None.

3. Final Answer:

   It does not check if data is None before accessing -> Option A

4. Quick Check:

   Check data is not None before key access [OK]

Hint: Always check if get_json() returned data before use [OK]

Common Mistakes:

• Ignoring None check on JSON data
• Confusing status codes
• Thinking request.json is better than get_json()
• Assuming plain text is always wrong

5. You want to validate a JSON request in Flask to ensure it has a 'name' string and an 'age' integer above 0. Which approach best combines validation and clear error messages?

hard

A. Manually check keys and types, return custom error messages on failure

B. Use request.get_json() and assume data is always correct

C. Use a library like marshmallow to define a schema and validate automatically

D. Skip validation and handle errors later in the code

Solution

1. Step 1: Consider manual validation drawbacks

   Manual checks can be error-prone and verbose, making code hard to maintain.

2. Step 2: Understand benefits of marshmallow

   Marshmallow lets you define clear schemas and automatically validates input, returning helpful error messages.

3. Step 3: Evaluate other options

   Assuming data is correct or skipping validation risks bugs and security issues.

4. Final Answer:

   Use a library like marshmallow to define a schema and validate automatically -> Option C

5. Quick Check:

   Use marshmallow for clear, automatic validation [OK]

Hint: Use marshmallow for easy, clear validation [OK]

Common Mistakes:

• Assuming data is always valid
• Writing complex manual checks
• Ignoring validation completely