API error handling in Flask - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of API error handling in Flask?

API error handling in Flask helps manage unexpected problems by sending clear, helpful error messages to users instead of crashing or showing confusing errors.

beginner

How do you create a custom error response in Flask?

You create a custom error response by defining an error handler function with @app.errorhandler(error_code) decorator and returning a JSON response with a message and status code.

beginner

What does the @app.errorhandler decorator do?

The @app.errorhandler decorator tells Flask to run a specific function when a certain error happens, like 404 Not Found or 500 Internal Server Error.

beginner

Why should API error responses use JSON format?

API error responses use JSON so that client apps can easily read and understand the error details and handle them properly, keeping communication clear and consistent.

beginner

What HTTP status code is commonly used for 'Resource Not Found' errors?

The HTTP status code 404 is used to indicate that the requested resource was not found on the server.

Which Flask decorator is used to handle specific HTTP errors?

A @app.errorhandler

B @app.route

C @app.before_request

D @app.after_request

The @app.errorhandler decorator is used to define functions that handle specific HTTP errors.

What should an API return when a requested item is not found?

A HTTP 200 with empty body

B HTTP 500 with server error

C HTTP 301 redirect

D HTTP 404 with JSON error message

APIs should return HTTP 404 status with a JSON error message to clearly indicate the resource was not found.

Why is it important to handle errors in an API?

A To crash the server quickly

B To provide clear feedback to users and clients

C To hide all errors silently

D To slow down the response time

Handling errors properly helps users and client apps understand what went wrong and how to fix it.

Which content type is best for API error responses?

A image/png

B text/html

C application/json

D text/plain

application/json is best because it allows clients to parse error details easily.

What does a 500 HTTP status code indicate?

A Server internal error

B Resource not found

C Client error

D Successful request

500 means the server encountered an unexpected condition that prevented it from fulfilling the request.

Explain how to create a custom error handler in Flask and why it is useful.

Think about how Flask knows what to do when an error happens.

Describe the importance of returning proper HTTP status codes and JSON error messages in API error handling.

Consider how apps talk to each other over the internet.

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