Stop Waiting for the Backend • Part 4 of 124 min read•2026-02-24

How to Test API Error States in React Without a Real Backend

Learn how to test 400, 401, 403, 404, and 500 API error states, React error boundaries, and retry logic without intentionally crashing a backend server.

Nilesh Kumar

Creator of Playground API

How to Test API Error States in React Without a Real Backend

Suggested URL Slug: test-api-error-states-in-react

Primary Keyword: test API errors in React

Secondary Keywords: React error handling, mock API errors, HTTP status codes testing, React error boundary API

Meta Description: Learn how to test 400, 401, 403, 404, and 500 API error states, React error boundaries, and retry logic without intentionally crashing a backend server.

Suggested Dev.to Tags: #react, #webdev, #javascript, #testing

Almost every frontend developer writes code assuming the "Happy Path":

The API is online.
The network connection is stable.
The server responds with 200 OK in 50 milliseconds.
The JSON response matches the expected TypeScript type definition perfectly.

Then your application goes to production, and real life happens:

A database query times out, returning a 500 Internal Server Error.
A session expires, returning a 401 Unauthorized.
An invalid query parameter triggers a 400 Bad Request.
A user visits an expired URL, receiving a 404 Not Found.

If your React application hasn't been tested against these error states, the user is often greeted with a blank white screen, an unhandled Promise rejection, or a broken spinner that spins forever.

How can you test how your UI handles errors without manually modifying backend code to throw exceptions or turning off your Wi-Fi?

The Common HTTP Error Codes Every React App Must Handle

Before diving into code, let's categorize the common HTTP status codes frontend applications encounter:

Status Code	Meaning	Expected Frontend Behavior
`400 Bad Request`	Malformed input / validation failure	Display field-level inline error messages.
`401 Unauthorized`	Missing or invalid auth token	Redirect to Login modal or trigger silent token refresh.
`403 Forbidden`	Insufficient permissions / RBAC	Show "Access Denied / Upgrade Plan" screen.
`404 Not Found`	Resource does not exist	Render a friendly "Item Not Found" card with a back button.
`429 Too Many Requests`	Rate limit exceeded	Display countdown timer based on `Retry-After` header.
`500 Internal Server Error`	Unhandled server crash	Render an Error Boundary fallback with a "Retry" button.

How to Simulate API Errors on Demand

Instead of editing server routes to throw fake errors or hardcoding if (debug) throw new Error() inside React components, you can use on-demand error simulation headers and query parameters.

Playground API by Niles Labs supports built-in error simulation using either query parameters or HTTP headers on any endpoint:

javascript

// Via Query Parameter:

GET https://playground.nileslabs.com/api/v1/posts?_status=500

GET https://playground.nileslabs.com/api/v1/users/1?_status=404

// Via HTTP Header:

X-Simulate-Status: 403

X-Simulate-Status: 429

When this parameter or header is sent, the server immediately halts standard execution and responds with the requested HTTP status code and a structured RFC 7807 error payload.

Building a Robust React Error Boundary & Retry Component

Let's build an interactive user profile card in React that gracefully handles 404 Not Found, 500 Server Error, and network failures with automated retry logic.

1. The Data Fetcher with Error Parsing (`userService.js`)

javascript

// src/services/userService.js

const BASE_URL = 'https://playground.nileslabs.com/api/v1';

export async function fetchUserProfile(userId, forcedStatus = null) {

// If forcedStatus is provided, append ?_status=XXX for testing

const url = forcedStatus

? ${BASE_URL}/users/${userId}?_status=${forcedStatus}

: ${BASE_URL}/users/${userId};

const response = await fetch(url);

if (!response.ok) {

let errorDetails = 'Unknown error occurred.';

try {

const errorJson = await response.json();

errorDetails = errorJson.message || errorJson.error || response.statusText;

} catch {

errorDetails = response.statusText;

}

const error = new Error(Request failed with status ${response.status});

error.status = response.status;

error.details = errorDetails;

throw error;

}

return response.json();

}

2. The React Component with Status-Specific UI States

jsx

// src/components/UserProfileCard.jsx

import React, { useState, useEffect } from 'react';

import { fetchUserProfile } from '../services/userService';

export default function UserProfileCard({ userId }) {

const [user, setUser] = useState(null);

const [loading, setLoading] = useState(true);

const [error, setError] = useState(null);

const [simulatedStatus, setSimulatedStatus] = useState('');

const loadUser = async () => {

try {

setLoading(true);

setError(null);

const data = await fetchUserProfile(userId, simulatedStatus || null);

setUser(data);

} catch (err) {

setError({

status: err.status,

message: err.details || err.message,

});

setUser(null);

} finally {

setLoading(false);

}

};

useEffect(() => {

loadUser();

}, [userId, simulatedStatus]);

return (

<h3>👤 User Profile Inspector</h3>

{/* Simulator Toolbar for QA / Testing */}

<label style={{ fontSize: '13px', fontWeight: 'bold' }}>Simulate API Status: </label>

<select

value={simulatedStatus}

onChange={(e) => setSimulatedStatus(e.target.value)}

style={{ marginLeft: '8px', padding: '4px 8px' }}

<option value="">Normal (200 OK)</option>

<option value="400">400 Bad Request</option>

<option value="401">401 Unauthorized</option>

<option value="403">403 Forbidden</option>

<option value="404">404 Not Found</option>

<option value="500">500 Internal Server Error</option>

</select>

</div>

{/* Loading State */}

{loading && <div style={{ color: '#64748b' }}>⏳ Fetching user profile...</div>}

{/* Error State Handler */}

{!loading && error && (

<div style={{

backgroundColor: error.status === 404 ? '#fffbeb' : '#fef2f2',

border: 1px solid ${error.status === 404 ? '#fde68a' : '#fecaca'},

borderRadius: '6px',

padding: '1rem',

color: error.status === 404 ? '#92400e' : '#991b1b'

}}>

<h4>

{error.status === 404 ? '🔍 User Not Found (404)' :

error.status === 401 ? '🔒 Session Expired (401)' :

error.status === 403 ? '🚫 Access Denied (403)' :

⚠️ Server Error (${error.status})}

</h4>

<p style={{ margin: '8px 0', fontSize: '14px' }}>{error.message}</p>

<button

onClick={() => { setSimulatedStatus(''); loadUser(); }}

style={{ padding: '6px 12px', background: '#0f172a', color: '#fff', border: 'none', borderRadius: '4px', cursor: 'pointer' }}

🔄 Reset & Retry

</button>

</div>

)}

{/* Success State */}

{!loading && !error && user && (

<div>

<h4>{user.name} (@{user.username})</h4>

<p>📧 {user.email}</p>

<p>🏢 {user.company?.name}</p>

</div>

)}

</div>

);

}

3 Golden Rules for Frontend API Error Handling

Never Show Raw JSON Exceptions to End Users:

Always parse backend error payloads into human-readable action steps (e.g. "We couldn't find that article. Check the link or return home.").

Always Provide a Recovery Action:

Every error state should have a "Retry", "Refresh", or "Back to Safety" CTA button. Never leave a user stuck on a dead-end screen.

Log Unhandled Errors to Monitoring (Sentry / LogRocket):

If an error is unexpected (such as a 500 error), catch it in a top-level React <ErrorBoundary> component and dispatch the telemetry before rendering a fallback card.

Conclusion

Testing error states is just as important as testing happy paths. By leveraging simulated HTTP error statuses in your sandbox API, you can stress-test edge cases, error boundaries, and user feedback mechanisms before your code ever touches production.

To test error states and simulate HTTP failures in your application, start with Playground API by Niles Labs.

Tags:#react#webdev#javascript#testing

Series: Stop Waiting for the Backend

Part 4 of 12

Previous Article (#3)

What If Your Mock API Actually Remembered Your POST Requests?

Next Article (#5)

How to Test Slow APIs and Network Latency in Frontend Applications