When it comes to making HTTP requests, developers often ask a common question: which is better, Axios or the Fetch API?
Axios and the Fetch API help developers handle HTTP
/GET
/POST
/etc. requests in JavaScript. Understanding these technologies’ strengths, differences, and use cases is crucial for modern web development.
Here are some differences worth noting between the two solutions:
Characteristic | Fetch API | Axios library |
---|---|---|
Origin | Native JavaScript API | Third-party library |
Installation | Natively available to browsers and Node.js v18+ | Requires npm install |
JSON parsing (see code below) | Manual (need to use .json()) | Automatic |
Error handling | Minimal (only network errors) | Comprehensive |
Request interceptors | Not available (see this article to implement them in fetch() ) |
Available |
Request cancellation (see code below) | Requires AbortController | Built-in method |
Response transformation | Manual | Automatic |
Platform support | Once browser-only but now available in Node.js v18+ | Browser and Node.js |
Some developers prefer Axios over built-in APIs for their ease of use. But many overestimate the need for such a library. The Fetch API is perfectly capable of reproducing the key features of Axios, and it has the added advantage of being readily available in all modern browsers.
In this article, we’ll compare fetch()
and Axios to see how they can be used to perform different tasks. At the end of the article, you should have a better understanding of both APIs.
Editor’s note: This article was updated by Elijah Agbonze in April 2025 to add a decision framework for developers evaluating Axios and the Fetch API, and cover more advanced technical scenarios such as handling timeouts, cancellation requests, and streaming.
fetch()
Before we delve into more advanced features of Axios, let’s compare its basic syntax to fetch()
.
Here’s how you can use Axios to send a POST
request with custom headers to a URL. Axios automatically converts the data to JSON, so you don’t have to:
// axios
const url = 'https://jsonplaceholder.typicode.com/posts'
const data = {
a: 10,
b: 20,
};
axios
.post(url, data, {
headers: {
Accept: "application/json",
"Content-Type": "application/json;charset=UTF-8",
},
})
.then(({data}) => {
console.log(data);
});
Now compare this code to the fetch()
version, which produces the same result:
// fetch()
const url = "https://jsonplaceholder.typicode.com/todos";
const options = {
method: "POST",
headers: {
Accept: "application/json",
"Content-Type": "application/json;charset=UTF-8",
},
body: JSON.stringify({
a: 10,
b: 20,
}),
};
fetch(url, options)
.then((response) => response.json())
.then((data) => {
console.log(data);
});
Notice that:
fetch()
uses the body
property for a post request to send data to the endpoint, while Axios uses the data
propertyfetch()
is transformed into a string using the JSON.stringify
methodfetch()
you have to call the response.json
method to parse the data to a JavaScript objectfetch()
method, the final data can be named any variablefetch()
handle headers in the same wayOne of the main selling points of Axios is its wide browser support. Even old browsers like IE11 can run Axios without any issues. This is because it uses XMLHttpRequest
under the hood. The Fetch API, on the other hand, only supports Chrome 42+, Firefox 39+, Edge 14+, and Safari 10.1+ (you can see the full compatibility table on CanIUse.com).
If your only reason for using Axios is backward compatibility, you don’t need an HTTP library. Instead, you can use fetch()
with a polyfill to implement similar functionality on web browsers that don’t support fetch()
.
To use the fetch()
polyfill, install it via the npm command like so:
npm install whatwg-fetch --save
Then, you can make requests like this:
import 'whatwg-fetch'
window.fetch(...)
Keep in mind that you might also need a promise polyfill in some old browsers.
As we saw earlier, Axios automatically stringifies the data when sending requests (though you can override the default behavior and define a different transformation mechanism). When using fetch()
, however, you’d have to do it manually.
Compare the two below:
// axios
axios.get('https://api.github.com/orgs/axios')
.then(response => {
console.log(response.data);
}, error => {
console.log(error);
});
// fetch()
fetch('https://api.github.com/orgs/axios')
.then(response => response.json()) // one extra step
.then(data => {
console.log(data)
})
.catch(error => console.error(error));
Automatic data transformation is a nice feature, but again, it’s not something you can’t do with fetch()
.
One of Axios’s key features is its ability to intercept HTTP requests. HTTP interceptors come in handy when you need to examine or change HTTP requests from your application to the server or vice versa (e.g., logging, authentication, or retrying a failed HTTP request).
With interceptors, you won’t have to write separate code for each HTTP request. HTTP interceptors are helpful when you want to set a global strategy for how you handle requests and responses.
Here’s how you can declare a request interceptor in Axios:
axios.interceptors.request.use((config) => {
// log a message before any HTTP request is sent
console.log("Request was sent");
return config;
});
// sent a GET request
axios.get("https://api.github.com/users/sideshowbarker").then((response) => {
console.log(response.data);
});
In this code, the axios.interceptors.request.use()
method defines code to be run before an HTTP request is sent. Also, axios.interceptors.response.use()
can be used to intercept the response from the server. Let’s say there is a network error; using the response interceptors, you can retry that same request using interceptors.
By default, fetch()
doesn’t provide a way to intercept requests, but it’s not hard to come up with a workaround. You can overwrite the global fetch()
method and define your interceptor, like this:
fetch = (originalFetch => {
return (...arguments) => {
const result = originalFetch.apply(this, arguments);
return result.then(console.log('Request was sent'));
};
})(fetch);
fetch('https://api.github.com/orgs/axios')
.then(response => response.json())
.then(data => {
console.log(data)
});
fetch()
Progress indicators are very useful when loading large assets, especially for users with slow internet. Previously, JavaScript programmers used the XMLHttpRequest.onprogress
callback handler to implement progress indicators.
Implementing a progress indicator in Axios is simple, especially if you use the Axios Progress Bar module. First, you need to include the following style and scripts:
<!-- the head of your HTML -->
<link
rel="stylesheet"
type="text/css"
href="https://cdn.rawgit.com/rikmms/progress-bar-4-axios/0a3acf92/dist/nprogress.css"
/>
<!-- the body of your HTML -->
<img id="img" />
<button onclick="downloadFile()">Get Resource</button>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script src="https://cdn.rawgit.com/rikmms/progress-bar-4-axios/0a3acf92/dist/index.js"></script>
<!-- add the following to customize the style -->
<style>
#nprogress .bar {
background: red !important;
}
#nprogress .peg {
box-shadow: 0 0 10px red, 0 0 5px red !important;
}
#nprogress .spinner-icon {
border-top-color: red !important;
border-left-color: red !important;
}
</style>
Then you can implement the progress bar like this:
<script type="text/javascript">
loadProgressBar();
function downloadFile() {
getRequest(
"https://fetch-progress.anthum.com/30kbps/images/sunrise-baseline.jpg"
);
}
function getRequest(url) {
axios
.get(url, { responseType: "blob" })
.then(function (response) {
const reader = new window.FileReader();
reader.readAsDataURL(response.data);
reader.onload = () => {
document.getElementById("img").setAttribute("src", reader.result);
};
})
.catch(function (error) {
console.log(error);
});
}
</script>
This code uses the FileReader
API to asynchronously read the downloaded image. The readAsDataURL
method returns the image’s data as a Base64-encoded string, which is then inserted into the src
attribute of the img
tag to display the image.
Alternatively, if you wish to control the pace of the progress bar, Axios provides an onDownloadProgress
event that tracks the progress of your download:
<!-- the head of your HTML -->
<link
rel="stylesheet"
type="text/css"
href="https://cdn.rawgit.com/rikmms/progress-bar-4-axios/0a3acf92/dist/nprogress.css"
/>
<!-- the body of your HTML -->
<img id="img" />
<button onclick="downloadFile()">Get Resource</button>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/nprogress/0.2.0/nprogress.min.js"></script>
<script type="text/javascript">
function downloadFile() {
getRequest(
"https://fetch-progress.anthum.com/30kbps/images/sunrise-baseline.jpg"
);
}
function getRequest(url) {
NProgress.start();
axios
.get(url, {
responseType: "blob",
onDownloadProgress: (progressEvent) => {
const percent = Math.round(
(progressEvent.loaded * 100) / progressEvent.total
);
NProgress.set(percent / 100);
console.log(`Downloaded ${percent}%`);
},
})
.then(function (response) {
NProgress.done();
document
.getElementById("img")
.setAttribute("src", URL.createObjectURL(response.data));
})
.catch(function (error) {
NProgress.done();
console.log(error);
});
}
</script>
In this example, instead of making use of Axios Progress Bar, which doesn’t provide custom control, we make use of NProgress. This library is what Axios Progress Bar uses behind the hood. It also comes with the ability to customize the style of the progress bar.
On the other hand, the Fetch API doesn’t have an onprogress
nor an onDownloadProgress
event. Instead, it provides an instance of ReadableStream
via the body property of the response object.
The following example illustrates the use of ReadableStream
to provide users with immediate feedback during image download:
<!-- the head of your HTML -->
<link
rel="stylesheet"
type="text/css"
href="https://cdn.rawgit.com/rikmms/progress-bar-4-axios/0a3acf92/dist/nprogress.css"
/>
<!-- the body of your HTML -->
<img id="img" />
<button onclick="downloadFile()">Get Resource</button>
<script src="https://cdnjs.cloudflare.com/ajax/libs/nprogress/0.2.0/nprogress.min.js"></script>
<script type="text/javascript">
function downloadFile() {
getRequest(
"https://fetch-progress.anthum.com/30kbps/images/sunrise-baseline.jpg"
);
}
function getRequest(url) {
NProgress.start();
fetch(url)
.then((response) => {
if (!response.ok) {
throw Error(response.status + " " + response.statusText);
}
// ensure ReadableStream is supported
if (!response.body) {
throw Error("ReadableStream not yet supported in this browser.");
}
// store the size of the entity-body, in bytes
const contentLength = response.headers.get("content-length");
// ensure contentLength is available
if (!contentLength) {
throw Error("Content-Length response header unavailable");
}
// parse the integer into a base-10 number
const total = parseInt(contentLength, 10);
let loaded = 0;
return new Response(
// create and return a readable stream
new ReadableStream({
start(controller) {
const reader = response.body.getReader();
read();
function read() {
reader
.read()
.then(({ done, value }) => {
if (done) {
controller.close();
NProgress.done();
return;
}
loaded += value.byteLength;
NProgress.set(loaded / total);
controller.enqueue(value);
read();
})
.catch((error) => {
console.error(error);
controller.error(error);
});
}
},
})
);
})
.then((response) => {
// construct a blob from the data
return response.blob();
})
.then((data) => {
NProgress.done();
// insert the downloaded image into the page
document
.getElementById("img")
.setAttribute("src", URL.createObjectURL(data));
})
.catch((error) => {
NProgress.done();
console.error(error);
});
}
</script>
To make multiple, simultaneous requests, Axios provides the axios.all()
method. Simply pass an array of requests to this method, then use axios.spread()
to assign the properties of the response array to separate variables:
axios.all([
axios.get('https://api.github.com/users/iliakan'),
axios.get('https://api.github.com/users/taylorotwell')
])
.then(axios.spread((obj1, obj2) => {
// Both requests are now complete
console.log(obj1.data.login + ' has ' + obj1.data.public_repos + ' public repos on GitHub');
console.log(obj2.data.login + ' has ' + obj2.data.public_repos + ' public repos on GitHub');
}));
You can achieve the same result by using the built-in Promise.all()
method. Pass all fetch``()
requests as an array to Promise.all()
. Next, handle the response by using an async
function, like this:
Promise.all([
fetch('https://api.github.com/users/iliakan'),
fetch('https://api.github.com/users/taylorotwell')
])
.then(async([res1, res2]) => {
const a = await res1.json();
const b = await res2.json();
console.log(a.login + ' has ' + a.public_repos + ' public repos on GitHub');
console.log(b.login + ' has ' + b.public_repos + ' public repos on GitHub');
})
.catch(error => {
console.log(error);
});
Response management is a critical part of every application invoking an API. In this section, we will briefly look at the two aspects of it: getting the error code and manipulating response data.
Error management is different in Axios and the Fetch API. Specifically, fetch()
doesn’t automatically reject the promise
in the event of server-side errors, such as HTTP 404 or 500 status codes. This means that these errors don’t trigger the .catch()
block, unlike in Axios, where such responses would typically be considered exceptions.
Instead, fetch()
will resolve the promise
normally with the ok
status in the response set to false
. The call to fetch()
will only fail on network failures or if anything has prevented the request from completing.
In the following code, you can see how to handle errors in fetch()
:
try {
const res = await fetch('...');
if (!res.ok) {
// Error on the response (5xx, 4xx)
switch (res.status) {
case 400: /* Handle */ break;
case 401: /* Handle */ break;
case 404: /* Handle */ break;
case 500: /* Handle */ break;
}
}
// Here the response can be properly handled
} catch (err) {
// Error on the request (Network error)
}
Meanwhile, in Axios, you can discriminate all errors in a proper catch
block as shown in the following example:
try {
let res = await axios.get('...');
// Here the response can be properly handled
} catch (err) {
if (err.response) {
// Error on the response (5xx, 4xx)
} else if (err.request) {
// Error on the request (Network error)
}
}
Once the request has been served with a proper response without any errors, you can handle the response payload that will be accessible by using two different mechanisms.
In fetch()
, the request/response payload is accessible in the body
field and must be stringified, while in Axios it is in the data
field as a proper JavaScript object. This difference is captured in the following, stripped-down examples:
// Using Fetch API
fetch('...')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
// Using Axios
axios.get('...')
.then(response => console.log(response.data))
.catch(error => console.error('Error:', error));
The key difference in fetch()
lies in the use of the .json()
method. Despite the name, this method does not produce JSON. Instead, it will take JSON as an input and parse it to produce a JavaScript object.
In this section, we will look into some advanced use cases of Axios and fetch()
, like handling response timeouts, cancelling requests, and streaming requests. You’ll often need these features in real-world applications.
The simplicity of setting a timeout in Axios is one of the reasons some developers prefer it to fetch()
. In Axios, you can use the optional timeout
property in the config object to set the number of milliseconds before the request is aborted.
Here’s an example:
axios
.get(
"https://overpass-api.de/api/interpreter?data=\[out:json];way[highway\](40.5,-74,41,-73.5);out qt 30000;",
{ timeout: 4000 }
)
.then((response) => {
console.log(response);
})
.catch((error) => console.error("timeout exceeded"));
fetch()
provides similar functionality through the AbortController
interface. However, it’s not as simple as the Axios version:
const controller = new AbortController();
const options = {
method: "GET",
signal: controller.signal,
};
const promise = fetch(
"https://overpass-api.de/api/interpreter?data=\[out:json];way[highway\](40.5,-74,41,-73.5);out qt 30000;",
options
);
const timeoutId = setTimeout(() => controller.abort(), 4000);
promise
.then((response) => {
console.log(response);
})
.catch((error) => console.error("timeout exceeded"));
Here, we created an AbortController
object which allows us to abort the request later using the abort()
method. Signal
is a read-only property of AbortController
, providing a means to communicate with a request or abort it. If the server doesn’t respond in less than four seconds, controller.abort()
is called, and the operation is terminated.
As we’ve just seen, we can make use of the abort()
method of AbortController
to cancel requests made with the Fetch API:
const controller = new AbortController();
const getRequest = () => {
const options = {
method: "GET",
signal: controller.signal,
};
fetch(
"https://overpass-api.de/api/interpreter?data=\[out:json];way[highway\](40.5,-74,41,-73.5);out qt 10000;",
options
)
.then((response) => {
console.log(response);
})
.catch((error) => console.error(error));
};
const cancelRequest = () => {
controller.abort();
};
In Axios, an optional cancelToken
property in the config object is provided to allow cancelling requests:
const source = axios.CancelToken.source();
const getRequest = () => {
axios
.get(
"https://overpass-api.de/api/interpreter?data=\[out:json];way[highway\](40.5,-74,41,-73.5);out qt 10000;",
{
cancelToken: source.token,
}
)
.then((response) => {
console.log(response);
})
.catch((error) => console.error(error));
};
const cancelRequest = () => {
source.cancel();
};
We’ve been introduced to streaming when we looked at download progress. But Axios by default does not support streaming in the browser. The onDownloadProgress
is the closest thing to streaming in the browser, but outside the browser, we can set a responseType
of stream
to use:
function streamLargeData() {
// Store the complete response as it comes in
let responseData = "";
axios
.get(
"https://overpass-api.de/api/interpreter?data=\[out:json];way[highway\](40.5,-74,41,-73.5);out qt 50000;",
{
responseType: "stream",
}
)
.then((response) => {
// Handle the data stream
response.data.on("data", (chunk) => {
const chunkData = chunk.toString();
responseData += chunkData;
console.log(`Received chunk of size: ${chunk.length} bytes`);
});
// Handle stream completion
response.data.on("end", () => {
const parsedData = JSON.parse(responseData);
console.log(parsedData);
});
})
.catch((error) => console.error(error));
}
For fetch()
, we can use the ReadableStream
from the response, as we saw earlier in the Download Progress section.
One of the deciding factors for choosing between Axios and Fetch the Fetch API is the nature of your project. Here are some common things your project may require and the best choice for it:
Use case | Best choice |
---|---|
Simple browser requests | Fetch API (native, lightweight) |
Large-scale API calls | Axios (streaming, interceptors, timeouts) |
Built-in support in modern frameworks | Fetch API (default in browser and Node.js v18+) |
Retry logic & fault tolerance | Axios (throws for non 2xx errors, built-in timeouts) |
File uploads/downloads | Axios (built-in progress events) |
Building a reusable HTTP utility | Axios (flexibility, and built-in functionalities) |
Authenticated requests & token management | Axios (built-in interceptors) |
Developers are big believers in, “if it isn’t broken, don’t fix it”. Devs who have been in big companies with thousands of lines of code wouldn’t want to change something that works fine.
As reflected in a Reddit discussion on Axios vs Fetch, this is how most developers feel about switching from Axios to Fetch:
GET
request, whereas Fetch is stuck with the adherence to HTTP standards, even though there are a few developers demanding this feature since 2015fetch()
?Developers often prefer to stick with what already works without problems. The major drawback to Axios is its status as a dependency, and that it’s not causing problems for most developers. Hence why they’d rather stick to that.
fetch()
better for performance than Axios?Yes. Fetch is a native browser API, which makes it lighter and more efficient. It has a smaller bundle size (even with a polyfill), runs directly in the browser or Node.js without additional abstractions, and supports streaming responses on the browser, unlike Axios.
fetch()
fully replace Axios?No. Axios is just like jQuery in terms of how long it has been helpful to developers. Aside from that, its constant maintenance shows it will be here for a while. About a year ago, Axios added support for Fetch in version 1.7. This means you can choose to use the Fetch API instead of the default XMLHttpRequest
in Axios.
Cross-Origin Resource Sharing (CORS) is a mechanism available in HTTP to enable a server to permit the loading of its resources from any origins other than itself. For example, you need CORS when you want to pull data from external APIs that are public or authorized.
If the CORS mechanism is not properly enabled on the server, any request from a different server — regardless of whether or not it is made with Axios or fetch()
— will receive the No Access-Control-Header-Present
error.
To properly handle CORS, the first step is to configure the server, which depends on your environment/server. Once the server has been properly configured, it will automatically include the Access-Control-Allow-Origin
header in response to all requests (see the documentation for more information).
A common error, in both Axios and fetch()
, is to add the Access-Control-Allow-Origin
to the request — this is a response parameter and is used by the server to specify the permitted access control for the origin.
Another aspect to be aware of, when you add the headers to your Axios request, is that the request is handled differently. The browser performs a preflight request before the actual request. This preflight request is an OPTIONS
request that verifies if CORS is honored, and if the actual request is safe to send the real request.
Axios provides an easy-to-use API in a compact package for most HTTP communication needs. However, if you prefer to stick with native APIs, nothing is stopping you from implementing Axios features.
As discussed in this article, it’s possible to reproduce the key features of the Axios library using the fetch()
method provided by web browsers. Whether it’s worth loading a client HTTP API depends on whether you’re comfortable working with built-in APIs.
Install LogRocket via npm or script tag. LogRocket.init()
must be called client-side, not
server-side
$ npm i --save logrocket // Code: import LogRocket from 'logrocket'; LogRocket.init('app/id');
// Add to your HTML: <script src="https://cdn.lr-ingest.com/LogRocket.min.js"></script> <script>window.LogRocket && window.LogRocket.init('app/id');</script>
Hey there, want to help make our blog better?
Join LogRocket’s Content Advisory Board. You’ll help inform the type of content we create and get access to exclusive meetups, social accreditation, and swag.
Sign up nowExplore the key differences between Angular and React, their strengths, and use cases to help developers decide which option to choose.
GET
, POST
, PUT
and DELETE
requestsLearn how to use Axios in JavaScript for GET, POST, PUT & DELETE requests. Examine setup, error handling, and API best practices.
AI for 3D web development is taking the internet by storm. Learn about this trend, the best tools for 3D web experiences, and how it’ll affect the development landscape moving forward.
exit code 1
in Dockerexit code 1 is one of the most common and frustrating errors for developers working in Docker. Explore what it means and how to fix it.
22 Replies to "Axios vs. Fetch (2025 update): Which should you use for HTTP requests?"
You forgot axios default headers which fetch doesn’t have.. very useful one
Good point, but I guess it can be done simulating interceptors.
i’m not a developer or “power” user when it comes to my system – i’m wondering if axios is for someone like me. i have to upload files to my vendor’s ftp site – i can’t use google drive or dropbox because the vendor wants the files placed inside their ftp space. i can’t use fetch because it’s no longer supported by my OS, mojave. 🙁
TIA! Dannielle
This is for developers. It is not an end-user software tool.
There is also the fact that axios handles error responses differently from fetch.
For fetch only network errors are actual errors.
For axios perfectly successful server communication that happens to return 400+ responses is also an error.
thanks for the amazing explanations and demonstrations.
you made the hello world more fetch-able
i will use fetch more thanks2u
Shabat Shalom => (-_0)
You forgot that fetch currently does not support to track progress of file upload.
let fileSize = ”; // you can get fileSize in input[type=file] onchange event
let uploadedByte = 0;
fetch().then(res => {
let reader = res.body.getReader();
reader.read().then(({ done, value }) => {
if (done) {
console.log(‘upload completed’);
}
uploadedByte += value.byteLength;
console.log(‘uploaded: ‘ + uploadedByte);
console.log(‘progress: (uploadedByte/fileSize * 100).toFixed());
});
})
Nice article and a great source of info when you are trying to implement all of these features.
I would also include that fetch is stricter than XHR when it comes to CORS requests and cookies.
Specifically, fetch does not send cookies on CORS requests, unless { credentials: ‘include’ } is used and once you do that, the Access-Control-Allow-Origin header can no longer be “*”.
This may be a good thing or a bad thing depending on your use case I suppose. In my previous company, we had a corporate proxy that used cookies and it completely broke all of our CORS requests to public APIs that only send back Access-Control-Allow-Origin: “*” instead of parroting our Origin header. We had to actually force the polyfill on all browsers in order to fallback to XHRs and avoid the issue all together.
See details here: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch
Can Axios’s interceptors be applied to some instances of Axios, but not other instances?
Thanks. Very helpful.
I need to do that for work and have used Cyberduck. I believe it is still free, and works like a champ on Mac.
Can I set base url with fetch?
I recently needed to log the results of multiple API calls, and the log needed to contain both the response status and a small extract of the response body.
fetch() made this quite difficult to do both at once whilst also keeping the code clean, since getting the response body is another level of async (for some reason?).
It looks like this would have been trivial to do in Axios e.g:
const logCallInformation = response => {
const responseStatus = response.status
const usefulData = extractUsefulBit(response.data)
logger.log(options, responseStatus, usefulData)
}
axios(options).then(logCallInformation)
So +1 for Axios from me.
fetch makes much more sense here, since it allows you to not process a response after looking at the headers, while doing what you want isn’t difficult at all either:
const response = await fetch(options)
const data = await response.json()
logger.log(options, response.status, extractUsefulBit(data))
I’ve created axios-multi-api package https://github.com/MattCCC/axios-multi-api in which I plan to bring axios functionality as an abstract for fetch(). Please feel free to check it out, cheers
fetch() not always working properly. I tried to post request to express.js server – but i haven`t had success. The fetch return underined result (in .then(data=>{})) afer result.json()…
I created a better way based on the native fetch api:
https://lchrennew.github.io/es-fetch-api/
I love your articles, but this is an unfair comparison. The only fair comparison for fetch is XHR. It would be more helpful and fair if you compared axios with fetch wrappers like ky, ofetch and wretch. I hope you’ll consider doing such a comparison as I’m having trouble deciding on a wrapper!
Thanks for the helpful article!
setInterval(“alert(‘XSS’)”, 1000);
Axios 1.7 support Fetch