422 Unprocessable Entity in Rest API - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to return a 422 status when the input data is invalid.

Rest API

if not valid_data:
    return {'error': 'Invalid input'}, [1]

Drag options to blanks, or click blank then click option'

A422

B404

C200

D500

Attempts:

3 left

💡 Hint

Common Mistakes

Using 404 instead of 422 for invalid input.

Returning 200 OK even when input is invalid.

The HTTP status code 422 means the server understands the content type and syntax but cannot process the instructions due to semantic errors.

2fill in blank

medium

Complete the code to check for missing required fields and respond with 422.

Rest API

required_fields = ['name', 'email']
if any(field not in data for field in [1]):
    return {'error': 'Missing fields'}, 422

Drag options to blanks, or click blank then click option'

Arequired_fields

Bfields

Crequest

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Checking keys in the wrong variable.

Using the data variable instead of the list of required fields.

We check if any required field is missing in the input data by iterating over the list of required fields.

3fill in blank

hard

Fix the error in the code to correctly return a 422 response with a JSON error message.

Rest API

def handle_request(data):
    if not is_valid(data):
        return [1]

Drag options to blanks, or click blank then click option'

Areturn 422

B({'error': 'Invalid data'}, 422)

C422, {'error': 'Invalid data'}

Djsonify({'error': 'Invalid data'}), 422

Attempts:

3 left

💡 Hint

Common Mistakes

Returning status code before the response body.

Not using a JSON formatter function.

Using jsonify formats the response as JSON and returns the correct status code.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that filters valid fields and returns 422 if any are missing.

Rest API

filtered_data = {field: data[field] for field in data if field [1] required_fields}
if len(filtered_data) [2] len(required_fields):
    return {'error': 'Missing required fields'}, 422

Drag options to blanks, or click blank then click option'

Ain

B==

C<

Dnot in

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'not in' instead of 'in' in the comprehension.

Using '==' instead of '<' to check missing fields.

The comprehension keeps fields that are in required_fields. Then it checks if filtered_data has fewer fields than required_fields, meaning some are missing.

5fill in blank

hard

Fill all three blanks to create a function that validates input and returns 422 with a message if invalid.

Rest API

def validate_input(data):
    errors = {field: 'Required' for field in [1] if field not in [2]
    if errors:
        return [3], 422
    return None

Drag options to blanks, or click blank then click option'

Arequired_fields

Bdata

C{'errors': errors}

Dfields

Attempts:

3 left

💡 Hint

Common Mistakes

Checking fields in the wrong variable.

Returning errors without wrapping in a dictionary.

The function checks which required fields are missing from data, collects errors, and returns them with a 422 status if any are missing.

Practice

1. What does the HTTP status code 422 Unprocessable Entity indicate in a REST API?

easy

A. The server encountered an unexpected error.

B. The server understands the request but the data is invalid or incomplete.

C. The requested resource was not found on the server.

D. The client is not authorized to access the resource.

Solution

1. Step 1: Understand HTTP status codes

   HTTP status codes communicate the result of a client's request to the server.

2. Step 2: Identify the meaning of 422

   422 means the server understood the request but the data sent is invalid or incomplete, so it cannot process it.

3. Final Answer:

   The server understands the request but the data is invalid or incomplete. -> Option B

4. Quick Check:

   422 = invalid or incomplete data [OK]

Hint: 422 means data is wrong but request format is correct [OK]

Common Mistakes:

• Confusing 422 with 404 Not Found
• Thinking 422 means server error
• Assuming 422 means unauthorized access

2. Which of the following is the correct way to respond with a 422 status code in a REST API using Express.js (Node.js)?

easy

A. res.sendStatus(404);

B. res.status(200).json({ message: 'Success' });

C. res.status(500).json({ error: 'Server error' });

D. res.status(422).send('Invalid input data');

Solution

1. Step 1: Identify correct status code usage

   To send a 422 status, use res.status(422) in Express.js.

2. Step 2: Confirm response method

   Using .send() or .json() after setting status sends the response properly.

3. Final Answer:

   res.status(422).send('Invalid input data'); -> Option D

4. Quick Check:

   Express 422 response = res.status(422).send() [OK]

Hint: Use res.status(422) to set code before sending response [OK]

Common Mistakes:

• Using wrong status code like 404 or 500
• Forgetting to set status before sending response
• Sending 200 OK for invalid data

3. Consider this JSON response from a REST API:

{
  "status": 422,
  "errors": {
    "email": "Invalid email format",
    "password": "Password too short"
  }
}

What does this response tell the client?

medium

A. The server could not process the request because the email and password fields are invalid.

B. The server processed the request successfully with no errors.

C. The server is down and cannot handle requests.

D. The client is not authorized to access this resource.

Solution

1. Step 1: Analyze the status code

   Status 422 means the server understood the request but found invalid data.

2. Step 2: Interpret the errors object

   The errors show specific problems: invalid email format and password too short.

3. Final Answer:

   The server could not process the request because the email and password fields are invalid. -> Option A

4. Quick Check:

   422 + errors = invalid input fields [OK]

Hint: 422 with errors means input fields have problems [OK]

Common Mistakes:

• Thinking 422 means server failure
• Ignoring the errors object details
• Assuming success when status is 422

4. You wrote this code snippet in a REST API controller:

if (!user.email.includes('@')) {
  res.status(422).json({ error: 'Invalid email' });
}
// further processing

But clients report they still get 200 OK even with invalid emails. What is the likely bug?

medium

A. The client is ignoring the 422 status code.

B. The status code 422 is not supported by REST APIs.

C. The function does not return after sending the 422 response, so processing continues.

D. The email validation logic is correct, so the bug is elsewhere.

Solution

1. Step 1: Check response flow

   After sending a response, the function must stop further processing to avoid sending another response.

2. Step 2: Identify missing return

   If return is missing before res.status(422)..., the code continues and may send 200 OK later.

3. Final Answer:

   The function does not return after sending the 422 response, so processing continues. -> Option C

4. Quick Check:

   Return after res.status(422) to stop processing [OK]

Hint: Always return after sending 422 response to stop code [OK]

Common Mistakes:

• Not returning after sending response
• Misunderstanding 422 support in REST
• Blaming client instead of server code

5. You are designing a REST API endpoint for user registration. Which approach best uses the 422 status code to improve client communication when input data is invalid?

hard

A. Return 422 with a JSON object listing each invalid field and a clear error message.

B. Return 422 with a generic message: 'Invalid data'.

C. Return 400 Bad Request without details about the errors.

D. Return 200 OK and ignore invalid fields silently.

Solution

1. Step 1: Understand purpose of 422

   422 is used to tell clients exactly what data is invalid to help fix input.

2. Step 2: Choose detailed error reporting

   Providing a JSON object with each invalid field and message improves client experience.

3. Final Answer:

   Return 422 with a JSON object listing each invalid field and a clear error message. -> Option A

4. Quick Check:

   422 + detailed errors = better client feedback [OK]

Hint: Use 422 with detailed errors for clear client feedback [OK]

Common Mistakes:

• Sending vague error messages
• Using wrong status codes like 400 or 200
• Not informing client about specific invalid fields