API error handling in Flask - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the HTTP status code returned by this Flask error handler?

Consider this Flask code snippet that handles a 404 error. What HTTP status code will the client receive when this error handler is triggered?

Flask

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

@app.errorhandler(404)
def not_found(error):
    return jsonify({'error': 'Not found'}), 404

A 400

B 500

C 200

D 404

💡 Hint

Look at the second value returned in the tuple from the error handler.

The error handler returns a tuple with a JSON response and the status code 404, so the client receives a 404 status.

📝 Syntax

intermediate

Which option correctly raises a custom error with a JSON response in Flask?

You want to raise a 400 Bad Request error with a JSON message in Flask. Which code snippet correctly does this?

A

from flask import jsonify
return jsonify({'error': 'Bad request'}), 400

B

from flask import abort
abort(400, description={'error': 'Bad request'})

C

from flask import abort
abort(jsonify({'error': 'Bad request'}), 400)

D raise Exception(jsonify({'error': 'Bad request'}), 400)

💡 Hint

Flask's abort function does not accept a JSON object as description.

Option A returns a JSON response with status 400 correctly. Option A misuses abort with a dict description, C misuses abort with jsonify, and D raises a generic Exception which is not handled.

🔧 Debug

advanced

Why does this Flask error handler not return JSON as expected?

This Flask error handler is supposed to return JSON for 500 errors, but the client receives HTML instead. Why?

Flask

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

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

A The handler returns a dict, but Flask needs jsonify() to convert it to JSON response.

B The error handler must return a string, not a dict.

C The status code 500 is not allowed in error handlers.

D Flask automatically converts dict to JSON, so the problem is elsewhere.

💡 Hint

Check how Flask converts return values to responses.

Returning a dict alone does not produce a JSON response. Flask requires jsonify() to create a proper JSON response with correct headers.

❓ state_output

advanced

What is the output when a 403 error occurs with this Flask setup?

Given this Flask app, what JSON response does the client receive when a 403 Forbidden error is triggered?

Flask

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

@app.errorhandler(403)
def forbidden(error):
    response = jsonify({'message': 'Access denied'})
    response.status_code = 403
    return response

A {'error': 'Forbidden'} with HTTP status 403

B {'message': 'Access denied'} with HTTP status 403

C {'message': 'Access denied'} with HTTP status 200

D HTML error page with HTTP status 403

💡 Hint

Look at the JSON content and status code set in the response object.

The handler returns a JSON with key 'message' and sets status code 403 explicitly, so client gets that JSON and status 403.

🧠 Conceptual

expert

Which statement about Flask error handling is true?

Choose the correct statement about how Flask handles errors and error handlers.

A Flask automatically converts any returned dict from error handlers into JSON responses.

B Flask error handlers only work for HTTP errors raised by abort(), not for exceptions.

C Flask error handlers can catch exceptions globally and return custom responses for any HTTP status code.

D Flask requires error handlers to return plain strings, not JSON or response objects.

💡 Hint

Think about how Flask errorhandler decorator works with exceptions and HTTP codes.

Flask error handlers can catch exceptions or HTTP errors globally and return any custom response including JSON with any status code.

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