Enabling CORS in Axios: A Step-by-Step Guide for Making Cross-Origin Requests in JavaScript

As a developer, you might have the questions about how to create cross-origin requests in javascripts. There are several ways to make HTTP requests in JavaScript, but the most common way is to use the XMLHttpRequest object, which is built into most web browsers.

Here’s an example of how you might use the XMLHttpRequest object to make a GET request to a website:

var xhr = new XMLHttpRequest();
xhr.open("GET", "https://www.example.com");
xhr.send();

You can also use the fetch function to make requests in modern browsers which is a promise based function.

Here’s an example of how you might use the fetch function to make a GET request to a website:

fetch('https://www.example.com')
  .then(response => response.text())
  .then(data => {
    // do something with the data
  });

You can also use third-party libraries such as axios, superagent, and jQuery.ajax to make http requests.

Here’s an example of how you might use the axios library to make a GET request to a website:

axios.get('https://www.example.com')
  .then(response => {
    // do something with the data
  });

Please note that for making request to CORS enabled server, you need to configure the headers to allow the request from your origin.

To enable CORS (Cross-Origin Resource Sharing) in axios, you can configure the headers of the request to include the Access-Control-Allow-Origin field, along with any other required fields.

To set headers for every request you can use the defaults property of axios

axios.defaults.headers.common['Access-Control-Allow-Origin'] = '*';

or you can use headers property while sending the request

axios({
  method: 'get',
  url: 'https://example.com',
  headers: {
    'Access-Control-Allow-Origin': '*',
    // any other headers
  }
});

You can also use axios.create method to create an instance with a specific config, then you can use this instance to make all requests

const instance = axios.create({
  headers: {'Access-Control-Allow-Origin': '*'}
});
 
instance.get('https://example.com')

Please note that the above code is only enabling the CORS on the client-side, the server needs to set the proper headers to allow the request, otherwise the browser will block the request. Also setting Access-Control-Allow-Origin to * means allowing any origin to access your server.

How To handle errors in axios:

When making HTTP requests with JavaScript, it’s important to handle any errors that may occur during the process. This is especially important if you’re working with a third-party API, as you have no control over the availability or consistency of the data that you’re requesting. With Axios, a popular library for making HTTP requests in JavaScript, you can handle errors by using the catch method of the promise returned by the axios method.

Another way is to use try-catch block to handle errors. This will allow you to catch any errors that occur within the try block and handle them appropriately within the catch block.

Alternatively, You can add global error handling by creating an instance of axios and attaching interceptors.response.use that allows you to handle all the errors at one place.

Here’s an example of how you might use the catch method to handle errors when making a GET request:

axios.get('https://www.example.com')
  .then(response => {
    // do something with the data
  })
  .catch(error => {
    if (error.response) {
      // The request was made and the server responded with a status code
      // that falls out of the range of 2xx
      console.log(error.response.data);
      console.log(error.response.status);
      console.log(error.response.headers);
    } else if (error.request) {
      // The request was made but no response was received
      // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
      // http.ClientRequest in node.js
      console.log(error.request);
    } else {
      // Something happened in setting up the request that triggered an Error
      console.log('Error', error.message);
    }
    console.log(error.config);
  });

You can also use try-catch block

try {
  const response = await axios.get('https://example.com');
  // do something with response
} catch (error) {
   // handle error
}

You can also add global error handling by creating an instance of axios and attaching interceptors.response.use

const instance = axios.create();
instance.interceptors.response.use(response => {
  // Do something with response data
  return response;
}, error => {
  // Handle errors
  return Promise.reject(error);
});

It is essential to handle the errors efficiently and provide a better user experience and also it is a good practice to prevent bugs in your application.

23 Shares:
You May Also Like