Error codes for machine consumption in Rest API - Step-by-Step Execution

Concept Flow - Error codes for machine consumption

Client sends request

↓

Server processes request

↓

Check for errors?

No→Send success response

Yes↓

Generate error code

↓

Send error response with code

↓

Client reads error code

↓

Client handles error accordingly

The client sends a request, the server checks for errors, sends back an error code if needed, and the client uses that code to decide what to do.

Execution Sample

Rest API

GET /api/data
Response: 404 Not Found
{
  "error_code": "NOT_FOUND",
  "message": "Data not found"
}

A client requests data, server responds with a 404 error code and a machine-readable error code in JSON.

Execution Table

Step	Action	Server Status	Response Code	Response Body
1	Client sends GET /api/data	Processing request	N/A	N/A
2	Server checks data existence	Data not found	N/A	N/A
3	Server generates error code	Error generated	404	{"error_code": "NOT_FOUND", "message": "Data not found"}
4	Server sends error response	Response sent	404	{"error_code": "NOT_FOUND", "message": "Data not found"}
5	Client receives response	Response received	404	{"error_code": "NOT_FOUND", "message": "Data not found"}
6	Client reads error_code	Error handled	404	Client decides next steps

💡 Execution stops after client receives and processes the error response.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
request	None	GET /api/data	GET /api/data	GET /api/data	Processed
server_status	Idle	Checking data	Error generated	Response sent	Idle
response_code	None	None	404	404	404
response_body	None	None	{"error_code": "NOT_FOUND", "message": "Data not found"}	{"error_code": "NOT_FOUND", "message": "Data not found"}	{"error_code": "NOT_FOUND", "message": "Data not found"}
client_action	Waiting	Waiting	Waiting	Received error	Handled error

Key Moments - 2 Insights

Why does the server send both a numeric HTTP status code and a machine-readable error code?

The HTTP status code (like 404) tells the client the general error type, while the machine-readable error code (like "NOT_FOUND") gives a precise, consistent identifier for the error so the client can handle it programmatically. See execution_table rows 3 and 4.

What happens if the client ignores the error_code in the response body?

If the client ignores the error_code, it may not handle the error correctly or specifically. The client might only see the HTTP status but miss detailed info for proper action. See execution_table row 6 where client reads error_code to decide next steps.

Visual Quiz - 3 Questions

Look at the execution_table, what is the response_code at Step 3?

A 404

B 500

C 200

D 400

💡 Hint

Check the 'Response Code' column at Step 3 in the execution_table.

At which step does the client receive the error response?

A Step 4

B Step 5

C Step 2

D Step 6

💡 Hint

Look for when the client status changes to 'Response received' in the execution_table.

If the server sent a 200 status but included an error_code in the body, what would change in the execution_table?

A Response Code would be 404 and error_code would be missing

B Response Code and error_code would both be 200

C Response Code would be 200 but error_code still present in Response Body

D No change, response_code stays 404

💡 Hint

Think about how HTTP status and error_code are independent but usually consistent, see variable_tracker for response_code and response_body.

Concept Snapshot

Error codes for machine consumption:
- Server sends HTTP status code (e.g., 404) for general error type.
- Response body includes machine-readable error_code (e.g., "NOT_FOUND") for precise handling.
- Client reads both to decide next steps.
- This helps automated clients handle errors clearly and consistently.

Full Transcript

This visual trace shows how a client sends a request to a server, which checks for errors. If an error occurs, the server sends back an HTTP status code like 404 and a JSON body with a machine-readable error_code such as "NOT_FOUND". The client receives this response and reads the error_code to handle the error properly. The execution table tracks each step from request to client handling. Variables like response_code and response_body change as the server processes and responds. Key moments clarify why both codes are needed and what happens if the client ignores the error_code. Quiz questions test understanding of response codes and client-server interaction. This helps beginners see how error codes work for machines to understand and react to problems automatically.