Error Handling in Axios for Node.js Apps

Master error handling in Axios requests for Node.js applications.

Learn practical patterns, global interceptors, and best practices to build more resilient and user-friendly applications.

A serene abstract representation of network connections featuring interweaving translucent emerald ribbons flowing against a pure black background captured from a top-down perspective high-quality ultra-realistic cinematic 8K UHD high resolution sharp and detail

Error Handling in Axios Requests for Node.js Applications

When building robust Node.js applications, proper error handling isn’t just a best practice—it’s essential. Today, let’s dive into handling errors in Axios requests, making our applications more resilient and user-friendly.

Abstract macro photography of water droplets on a glossy surface rich brown and mahogany with cream colors creating natural patterns shot from a 45-degree angle high-quality ultra-realistic cinematic 8K UHD high resolution sharp and detail

Understanding Axios Errors

Axios errors might seem daunting at first, but they’re actually quite structured and informative. When a request fails, Axios throws an error object that contains valuable information about what went wrong.

Let’s look at some practical approaches to handle these errors effectively:

1. The Try-Catch Pattern

The most straightforward way to handle Axios errors is using try-catch blocks. Here’s a clean approach:

const fetchUserData = async (userId) => {
  try {
    const response = await axios.get(`/api/users/${userId}`);
    return response.data;
  } catch (error) {
    if (error.response) {
      // Server responded with error status
      console.error('Server Error:', error.response.status);
      throw new Error(`Failed to fetch user: ${error.response.status}`);
    } else if (error.request) {
      // Request made but no response received
      console.error('Network Error: No response received');
      throw new Error('Network error occurred');
    } else {
      // Something went wrong in request setup
      console.error('Request Error:', error.message);
      throw new Error('Failed to make request');
    }
  }
};

Dynamic fluid art composition with swirling umber walnut and iron colors against a light background photographed from a birds-eye view high-quality ultra-realistic cinematic 8K UHD high resolution sharp and detail

2. Global Error Interceptors

For consistent error handling across your application, Axios interceptors are your best friend:

axios.interceptors.response.use(
  response => response,
  error => {
    if (error.response?.status === 404) {
      // Handle 404 errors globally
      console.error('Resource not found');
    } else if (error.response?.status === 401) {
      // Handle authentication errors
      console.error('Authentication failed');
    }
    return Promise.reject(error);
  }
);

3. Custom Error Handling Functions

Create reusable error handlers to maintain consistency:

const handleAxiosError = (error) => {
  if (axios.isAxiosError(error)) {
    const status = error.response?.status;
    const message = error.response?.data?.message || error.message;

    switch (status) {
      case 400:
        return 'Invalid request. Please check your data.';
      case 401:
        return 'Please login to continue.';
      case 403:
        return 'You don't have permission to access this resource.';
      case 404:
        return 'The requested resource was not found.';
      case 500:
        return 'An internal server error occurred. Please try again later.';
      default:
        return `An error occurred: ${message}`;
    }
  }
  return 'An unexpected error occurred';
};

Best Practices for Error Handling

Always provide meaningful error messages to users
Log detailed error information for debugging
Handle different types of errors appropriately
Implement retry mechanisms for network errors
Use TypeScript for better error typing

Remember, good error handling isn’t just about catching errors—it’s about gracefully managing them to provide a smooth user experience.

Aerial view of ocean waves creating intricate patterns featuring deep blue and white foam textures captured from directly above high-quality ultra-realistic cinematic 8K UHD high resolution sharp and detail

By implementing these error handling patterns, you’ll make your Node.js applications more reliable and maintainable. Your users will thank you, and your future self will appreciate the robust error handling when debugging issues in production.