API error handling in Flask - Mini Project: Build & Apply

API Error Handling in Flask

📖 Scenario: You are building a simple Flask API that returns user data. Sometimes, the user ID requested might not exist. You want to handle this error gracefully and return a clear message with the right HTTP status code.

🎯 Goal: Create a Flask API with a route /user/<int:user_id> that returns user data if found. If the user ID does not exist, return a JSON error message with status code 404 using Flask's error handling.

📋 What You'll Learn

Create a dictionary called users with these exact entries: 1: {'name': 'Alice', 'age': 30}, 2: {'name': 'Bob', 'age': 25}, 3: {'name': 'Charlie', 'age': 35}

Create a Flask app instance called app

Add a route /user/<int:user_id> that returns user data as JSON if found

If the user ID is not found, raise a NotFound exception

Add an error handler for NotFound that returns a JSON response with {'error': 'User not found'} and status code 404

💡 Why This Matters

🌍 Real World

APIs often need to handle errors gracefully to give clear feedback to users or client apps. This project shows how to do that in Flask.

💼 Career

Knowing how to handle API errors properly is essential for backend developers and anyone building web services.

1

Create the user data dictionary

Create a dictionary called users with these exact entries: 1: {'name': 'Alice', 'age': 30}, 2: {'name': 'Bob', 'age': 25}, 3: {'name': 'Charlie', 'age': 35}

Flask

# Create the users dictionary with exact entries
# Your code here

Hint

Use a dictionary with integer keys and dictionary values for user info.

2

Create the Flask app instance

Import Flask from flask and create a Flask app instance called app

Flask

users = {
    1: {'name': 'Alice', 'age': 30},
    2: {'name': 'Bob', 'age': 25},
    3: {'name': 'Charlie', 'age': 35}
}

# Import Flask and create app instance
# Your code here

Hint

Use app = Flask(__name__) to create the app instance.

3

Add the user route with error raising

Import jsonify and abort from flask. Add a route /user/<int:user_id> to app that returns the user data as JSON if found in users. If not found, use abort(404) to raise a 404 error.

Flask

from flask import Flask

users = {
    1: {'name': 'Alice', 'age': 30},
    2: {'name': 'Bob', 'age': 25},
    3: {'name': 'Charlie', 'age': 35}
}

app = Flask(__name__)

# Import jsonify and abort
# Add route /user/ that returns user data or aborts 404
# Your code here

Hint

Use @app.route decorator and abort(404) to handle missing users.

4

Add error handler for 404 Not Found

Import NotFound from werkzeug.exceptions. Add an error handler for NotFound to app that returns a JSON response {'error': 'User not found'} with status code 404.

Flask

from flask import Flask, jsonify, abort

users = {
    1: {'name': 'Alice', 'age': 30},
    2: {'name': 'Bob', 'age': 25},
    3: {'name': 'Charlie', 'age': 35}
}

app = Flask(__name__)

@app.route('/user/')
def get_user(user_id):
    if user_id in users:
        return jsonify(users[user_id])
    else:
        abort(404)

# Import NotFound and add error handler for it
# Your code here

Hint

Use @app.errorhandler(NotFound) decorator and return JSON with status 404.

Practice

1. What is the main purpose of using @app.errorhandler in a Flask API?

easy

A. To start the Flask application

B. To define new API routes

C. To catch specific errors and return custom responses

D. To connect to a database

Solution

1. Step 1: Understand the role of @app.errorhandler

   This decorator is used to catch errors that happen during API requests.

2. Step 2: Recognize its use for custom responses

   It allows you to send back clear messages and proper HTTP status codes when errors occur.

3. Final Answer:

   To catch specific errors and return custom responses -> Option C

4. Quick Check:

   @app.errorhandler catches errors [OK]

Hint: Remember: errorhandler catches errors to customize responses [OK]

Common Mistakes:

• Thinking it defines routes
• Confusing it with app.run()
• Assuming it manages database connections

2. Which of the following is the correct syntax to handle a 404 error in Flask?

easy

A. @app.errorhandler(404)
def not_found(error):
return 'Not Found', 404

B. @app.route(404)
def not_found():
return 'Not Found'

C. @app.errorhandler('404')
def not_found(error):
return 'Not Found', 404

D. @app.errorhandler(404)
def not_found():
return 'Not Found'

Solution

1. Step 1: Identify correct decorator usage

   The @app.errorhandler decorator takes an integer status code like 404 without quotes.

2. Step 2: Check function signature and return

   The handler function should accept an error argument and return a response with the status code.

3. Final Answer:

   @app.errorhandler(404)\ndef not_found(error):\n return 'Not Found', 404 -> Option A

4. Quick Check:

   Correct decorator and function signature = @app.errorhandler(404) def not_found(error): return 'Not Found', 404 [OK]

Hint: Use integer status codes without quotes in errorhandler [OK]

Common Mistakes:

• Using @app.route instead of @app.errorhandler
• Passing status code as string '404'
• Omitting the error parameter in handler function

3. Given this Flask error handler code:

from flask import abort, jsonify
@app.errorhandler(400)
def bad_request(error):
    return jsonify({'error': 'Bad Request'}), 400

@app.route('/test')
def test():
    abort(400)

What will be the JSON response and status code when accessing /test?

medium

A. {"error": "Bad Request"} with status code 400

B. Plain text 'Bad Request' with status code 200

C. Default Flask 400 error page with status code 400

D. Empty response with status code 400

Solution

1. Step 1: Understand abort triggers error handler

   The abort(400) call triggers the 400 error handler defined by @app.errorhandler(400).

2. Step 2: Check handler return value

   The handler returns a JSON dictionary with the error message and status code 400.

3. Final Answer:

   {"error": "Bad Request"} with status code 400 -> Option A

4. Quick Check:

   abort triggers handler response JSON + 400 [OK]

Hint: abort(code) triggers matching errorhandler response [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Assuming default Flask error page shows
• Missing status code in response

4. What is wrong with this Flask error handler code?

@app.errorhandler(500)
def internal_error():
    return {'error': 'Server Error'}, 500

medium

A. The decorator should be @app.route, not @app.errorhandler

B. The status code 500 should be a string '500'

C. The return value must be a string, not a dictionary

D. The handler function must accept an error parameter

Solution

1. Step 1: Check function signature for error handlers

   Error handler functions must accept one parameter for the error object.

2. Step 2: Identify missing parameter

   The function internal_error has no parameters, so Flask will raise a TypeError.

3. Final Answer:

   The handler function must accept an error parameter -> Option D

4. Quick Check:

   Error handler functions need error argument [OK]

Hint: Error handlers always need an error parameter [OK]

Common Mistakes:

• Omitting the error parameter
• Using string status codes
• Confusing errorhandler with route decorator

5. You want to create a Flask API error handler that returns a JSON response with a custom message and the correct HTTP status code for any KeyError raised in your routes. Which of the following is the best way to implement this?

hard

A. @app.errorhandler(400)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

B. @app.errorhandler(KeyError)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

C. @app.route('/error')
def handle_key_error():
return {'error': 'Missing key in request'}, 400

D. @app.errorhandler(Exception)
def handle_key_error(error):
return {'error': 'Missing key in request'}, 400

Solution

1. Step 1: Use exception class in errorhandler

   To catch a specific Python error like KeyError, use it directly in @app.errorhandler(KeyError).

2. Step 2: Return JSON with appropriate status code

   Return a JSON message and HTTP 400 (bad request) status code to indicate client error.

3. Final Answer:

   @app.errorhandler(KeyError)\ndef handle_key_error(error):\n return {'error': 'Missing key in request'}, 400 -> Option B

4. Quick Check:

   Use exception class in errorhandler for specific errors [OK]

Hint: Use exception class in errorhandler to catch specific errors [OK]

Common Mistakes:

• Using status code instead of exception class
• Defining error handler as a route
• Catching all exceptions instead of specific one