Table of Contents

Features

Browser Support

Installing

Package manager

$ npm install axios

$ bower install axios

$ yarn add axios

$ pnpm add axios

$ bun add axios

importaxios,{isCancel,AxiosError}from'axios';

importaxiosfrom'axios';console.log(axios.isCancel('something'));

constaxios=require('axios');console.log(axios.isCancel('something'));

import{defaultasaxios}from'axios';

constaxios=require('axios/dist/browser/axios.cjs');// browser commonJS bundle (ES2017)// const axios = require('axios/dist/node/axios.cjs'); // node commonJS bundle (ES2017)

CDN

<scriptsrc="https://cdn.jsdelivr.net/npm/axios@1.6.7/dist/axios.min.js"></script>

<scriptsrc="https://unpkg.com/axios@1.6.7/dist/axios.min.js"></script>

Example

importaxiosfrom'axios';//const axios = require('axios'); // legacy way// Make a request for a user with a given IDaxios.get('/user?ID=12345').then(function(response){// handle successconsole.log(response);}).catch(function(error){// handle errorconsole.log(error);}).finally(function(){// always executed});// Optionally the request above could also be done asaxios.get('/user',{params:{ID:12345}}).then(function(response){console.log(response);}).catch(function(error){console.log(error);}).finally(function(){// always executed});// Want to use async/await? Add the `async` keyword to your outer function/method.asyncfunctiongetUser(){try{constresponse=awaitaxios.get('/user?ID=12345');console.log(response);}catch(error){console.error(error);}}

axios.post('/user',{firstName:'Fred',lastName:'Flintstone'}).then(function(response){console.log(response);}).catch(function(error){console.log(error);});

functiongetUserAccount(){returnaxios.get('/user/12345');}functiongetUserPermissions(){returnaxios.get('/user/12345/permissions');}Promise.all([getUserAccount(),getUserPermissions()]).then(function(results){constacct=results[0];constperm=results[1];});

axios API

axios(config)

// Send a POST requestaxios({method:'post',url:'/user/12345',data:{firstName:'Fred',lastName:'Flintstone'}});

// GET request for remote image in node.jsaxios({method:'get',url:'https://bit.ly/2mTM3nY',responseType:'stream'}).then(function(response){response.data.pipe(fs.createWriteStream('ada_lovelace.jpg'))});

axios(url[, config])

// Send a GET request (default method)axios('/user/12345');

Request method aliases

axios.request(config)

axios.get(url[, config])

axios.delete(url[, config])

axios.head(url[, config])

axios.options(url[, config])

axios.post(url[, data[, config]])

axios.put(url[, data[, config]])

axios.patch(url[, data[, config]])

NOTE

Concurrency (Deprecated)

Creating an instance

axios.create([config])

constinstance=axios.create({baseURL:'https://some-domain.com/api/',timeout:1000,headers:{'X-Custom-Header':'foobar'}});

Instance methods

axios#request(config)

axios#get(url[, config])

axios#delete(url[, config])

axios#head(url[, config])

axios#options(url[, config])

axios#post(url[, data[, config]])

axios#put(url[, data[, config]])

axios#patch(url[, data[, config]])

axios#getUri([config])

Request Config

{// `url` is the server URL that will be used for the requesturl:'/user',// `method` is the request method to be used when making the requestmethod:'get',// default// `baseURL` will be prepended to `url` unless `url` is absolute and option `allowAbsoluteUrls` is set to true.// It can be convenient to set `baseURL` for an instance of axios to pass relative URLs// to methods of that instance.baseURL:'https://some-domain.com/api/',// `allowAbsoluteUrls` determines whether or not absolute URLs will override a configured `baseUrl`.// When set to true (default), absolute values for `url` will override `baseUrl`.// When set to false, absolute values for `url` will always be prepended by `baseUrl`.allowAbsoluteUrls:true,// `transformRequest` allows changes to the request data before it is sent to the server// This is only applicable for request methods 'PUT', 'POST', 'PATCH' and 'DELETE'// The last function in the array must return a string or an instance of Buffer, ArrayBuffer,// FormData or Stream// You may modify the headers object.transformRequest:[function(data,headers){// Do whatever you want to transform the datareturndata;}],// `transformResponse` allows changes to the response data to be made before// it is passed to then/catchtransformResponse:[function(data){// Do whatever you want to transform the datareturndata;}],// `headers` are custom headers to be sentheaders:{'X-Requested-With':'XMLHttpRequest'},// `params` are the URL parameters to be sent with the request// Must be a plain object or a URLSearchParams objectparams:{ID:12345},// `paramsSerializer` is an optional config that allows you to customize serializing `params`.paramsSerializer:{// Custom encoder function which sends key/value pairs in an iterative fashion.encode?:(param:string):string=>{/* Do custom operations here and return transformed string */},// Custom serializer function for the entire parameter. Allows user to mimic pre 1.x behaviour.serialize?:(params:Record<string, any>,options?:ParamsSerializerOptions),// Configuration for formatting array indexes in the params.indexes:false// Three available options: (1) indexes: null (leads to no brackets), (2) (default) indexes: false (leads to empty brackets), (3) indexes: true (leads to brackets with indexes).},// `data` is the data to be sent as the request body// Only applicable for request methods 'PUT', 'POST', 'DELETE , and 'PATCH'// When no `transformRequest` is set, must be of one of the following types:// - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams// - Browser only: FormData, File, Blob// - Node only: Stream, Buffer, FormData (form-data package)data:{firstName:'Fred'},// syntax alternative to send data into the body// method post// only the value is sent, not the keydata:'Country=Brasil&City=Belo Horizonte',// `timeout` specifies the number of milliseconds before the request times out.// If the request takes longer than `timeout`, the request will be aborted.timeout:1000,// default is `0` (no timeout)// `withCredentials` indicates whether or not cross-site Access-Control requests// should be made using credentialswithCredentials:false,// default// `adapter` allows custom handling of requests which makes testing easier.// Return a promise and supply a valid response (see lib/adapters/README.md)adapter:function(config){/* ... */},// Also, you can set the name of the built-in adapter, or provide an array with their names// to choose the first available in the environmentadapter:'xhr',// 'fetch' | 'http' | ['xhr', 'http', 'fetch']// `auth` indicates that HTTP Basic auth should be used, and supplies credentials.// This will set an `Authorization` header, overwriting any existing// `Authorization` custom headers you have set using `headers`.// Please note that only HTTP Basic auth is configurable through this parameter.// For Bearer tokens and such, use `Authorization` custom headers instead.auth:{username:'janedoe',password:'s00pers3cret'},// `responseType` indicates the type of data that the server will respond with// options are: 'arraybuffer', 'document', 'json', 'text', 'stream'//   browser only: 'blob'responseType:'json',// default// `responseEncoding` indicates encoding to use for decoding responses (Node.js only)// Note: Ignored for `responseType` of 'stream' or client-side requests// options are: 'ascii', 'ASCII', 'ansi', 'ANSI', 'binary', 'BINARY', 'base64', 'BASE64', 'base64url',// 'BASE64URL', 'hex', 'HEX', 'latin1', 'LATIN1', 'ucs-2', 'UCS-2', 'ucs2', 'UCS2', 'utf-8', 'UTF-8',// 'utf8', 'UTF8', 'utf16le', 'UTF16LE'responseEncoding:'utf8',// default// `xsrfCookieName` is the name of the cookie to use as a value for xsrf tokenxsrfCookieName:'XSRF-TOKEN',// default// `xsrfHeaderName` is the name of the http header that carries the xsrf token valuexsrfHeaderName:'X-XSRF-TOKEN',// default// `undefined` (default) - set XSRF header only for the same origin requestswithXSRFToken:boolean|undefined|((config:InternalAxiosRequestConfig)=>boolean|undefined),// `onUploadProgress` allows handling of progress events for uploads// browser & node.jsonUploadProgress:function({loaded, total, progress, bytes, estimated, rate, upload=true}){// Do whatever you want with the Axios progress event},// `onDownloadProgress` allows handling of progress events for downloads// browser & node.jsonDownloadProgress:function({loaded, total, progress, bytes, estimated, rate, download=true}){// Do whatever you want with the Axios progress event},// `maxContentLength` defines the max size of the http response content in bytes allowed in node.jsmaxContentLength:2000,// `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowedmaxBodyLength:2000,// `validateStatus` defines whether to resolve or reject the promise for a given// HTTP response status code. If `validateStatus` returns `true` (or is set to `null`// or `undefined`), the promise will be resolved; otherwise, the promise will be// rejected.validateStatus:function(status){returnstatus>=200&&status<300;// default},// `maxRedirects` defines the maximum number of redirects to follow in node.js.// If set to 0, no redirects will be followed.maxRedirects:21,// default// `beforeRedirect` defines a function that will be called before redirect.// Use this to adjust the request options upon redirecting,// to inspect the latest response headers,// or to cancel the request by throwing an error// If maxRedirects is set to 0, `beforeRedirect` is not used.beforeRedirect:(options,{ headers})=>{if(options.hostname==="example.com"){options.auth="user:password";}},// `socketPath` defines a UNIX Socket to be used in node.js.// e.g. '/var/run/docker.sock' to send requests to the docker daemon.// Only either `socketPath` or `proxy` can be specified.// If both are specified, `socketPath` is used.socketPath:null,// default// `transport` determines the transport method that will be used to make the request.// If defined, it will be used. Otherwise, if `maxRedirects` is 0,// the default `http` or `https` library will be used, depending on the protocol specified in `protocol`.// Otherwise, the `httpFollow` or `httpsFollow` library will be used, again depending on the protocol,// which can handle redirects.transport:undefined,// default// `httpAgent` and `httpsAgent` define a custom agent to be used when performing http// and https requests, respectively, in node.js. This allows options to be added like// `keepAlive` that are not enabled by default before Node.js v19.0.0. After Node.js// v19.0.0, you no longer need to customize the agent to enable `keepAlive` because// `http.globalAgent` has `keepAlive` enabled by default.httpAgent:newhttp.Agent({keepAlive:true}),httpsAgent:newhttps.Agent({keepAlive:true}),// `proxy` defines the hostname, port, and protocol of the proxy server.// You can also define your proxy using the conventional `http_proxy` and// `https_proxy` environment variables. If you are using environment variables// for your proxy configuration, you can also define a `no_proxy` environment// variable as a comma-separated list of domains that should not be proxied.// Use `false` to disable proxies, ignoring environment variables.// `auth` indicates that HTTP Basic auth should be used to connect to the proxy, and// supplies credentials.// This will set an `Proxy-Authorization` header, overwriting any existing// `Proxy-Authorization` custom headers you have set using `headers`.// If the proxy server uses HTTPS, then you must set the protocol to `https`.proxy:{protocol:'https',host:'127.0.0.1',// hostname: '127.0.0.1' // Takes precedence over 'host' if both are definedport:9000,auth:{username:'mikeymike',password:'rapunz3l'}},// `cancelToken` specifies a cancel token that can be used to cancel the request// (see Cancellation section below for details)cancelToken:newCancelToken(function(cancel){}),// an alternative way to cancel Axios requests using AbortControllersignal:newAbortController().signal,// `decompress` indicates whether or not the response body should be decompressed// automatically. If set to `true` will also remove the 'content-encoding' header// from the responses objects of all decompressed responses// - Node only (XHR cannot turn off decompression)decompress:true,// default// `insecureHTTPParser` boolean.// Indicates where to use an insecure HTTP parser that accepts invalid HTTP headers.// This may allow interoperability with non-conformant HTTP implementations.// Using the insecure parser should be avoided.// see options https://nodejs.org/dist/latest-v12.x/docs/api/http.html#http_http_request_url_options_callback// see also https://nodejs.org/en/blog/vulnerability/february-2020-security-releases/#strict-http-header-parsing-noneinsecureHTTPParser:undefined,// default// transitional options for backward compatibility that may be removed in the newer versionstransitional:{// silent JSON parsing mode// `true`  - ignore JSON parsing errors and set response.data to null if parsing failed (old behaviour)// `false` - throw SyntaxError if JSON parsing failed (Note: responseType must be set to 'json')silentJSONParsing:true,// default value for the current Axios version// try to parse the response string as JSON even if `responseType` is not 'json'forcedJSONParsing:true,// throw ETIMEDOUT error instead of generic ECONNABORTED on request timeoutsclarifyTimeoutError:false,},env:{// The FormData class to be used to automatically serialize the payload into a FormData objectFormData:window?.FormData||global?.FormData},formSerializer:{visitor:(value,key,path,helpers)=>{};// custom visitor function to serialize form valuesdots:boolean;// use dots instead of brackets formatmetaTokens:boolean;// keep special endings like {} in parameter keyindexes:boolean;// array indexes format null - no brackets, false - empty brackets, true - brackets with indexes},// http adapter only (node.js)maxRate:[100*1024,// 100KB/s upload limit,100*1024// 100KB/s download limit]}

Response Schema

{// `data` is the response that was provided by the serverdata:{},// `status` is the HTTP status code from the server responsestatus:200,// `statusText` is the HTTP status message from the server responsestatusText:'OK',// `headers` the HTTP headers that the server responded with// All header names are lowercase and can be accessed using the bracket notation.// Example: `response.headers['content-type']`headers:{},// `config` is the config that was provided to `axios` for the requestconfig:{},// `request` is the request that generated this response// It is the last ClientRequest instance in node.js (in redirects)// and an XMLHttpRequest instance in the browserrequest:{}}

axios.get('/user/12345').then(function(response){console.log(response.data);console.log(response.status);console.log(response.statusText);console.log(response.headers);console.log(response.config);});

Config Defaults

Global axios defaults

axios.defaults.baseURL='https://api.example.com';// Important: If axios is used with multiple domains, the AUTH_TOKEN will be sent to all of them.// See below for an example using Custom instance defaults instead.axios.defaults.headers.common['Authorization']=AUTH_TOKEN;axios.defaults.headers.post['Content-Type']='application/x-www-form-urlencoded';

Custom instance defaults

// Set config defaults when creating the instanceconstinstance=axios.create({baseURL:'https://api.example.com'});// Alter defaults after instance has been createdinstance.defaults.headers.common['Authorization']=AUTH_TOKEN;

Config order of precedence

// Create an instance using the config defaults provided by the library// At this point the timeout config value is `0` as is the default for the libraryconstinstance=axios.create();// Override timeout default for the library// Now all requests using this instance will wait 2.5 seconds before timing outinstance.defaults.timeout=2500;// Override timeout for this request as it's known to take a long timeinstance.get('/longRequest',{timeout:5000});

Interceptors

constinstance=axios.create();// Add a request interceptorinstance.interceptors.request.use(function(config){// Do something before request is sentreturnconfig;},function(error){// Do something with request errorreturnPromise.reject(error);});// Add a response interceptorinstance.interceptors.response.use(function(response){// Any status code that lie within the range of 2xx cause this function to trigger// Do something with response datareturnresponse;},function(error){// Any status codes that falls outside the range of 2xx cause this function to trigger// Do something with response errorreturnPromise.reject(error);});

constinstance=axios.create();constmyInterceptor=instance.interceptors.request.use(function(){/*...*/});axios.interceptors.request.eject(myInterceptor);

constinstance=axios.create();instance.interceptors.request.use(function(){/*...*/});instance.interceptors.request.clear();// Removes interceptors from requestsinstance.interceptors.response.use(function(){/*...*/});instance.interceptors.response.clear();// Removes interceptors from responses

constinstance=axios.create();instance.interceptors.request.use(function(){/*...*/});

axios.interceptors.request.use(function(config){config.headers.test='I am only a header!';returnconfig;},null,{synchronous:true});

functiononGetCall(config){returnconfig.method==='get';}axios.interceptors.request.use(function(config){config.headers.test='special get headers';returnconfig;},null,{runWhen:onGetCall});

Multiple Interceptors

Error Types

Handling Errors

axios.get('/user/12345').catch(function(error){if(error.response){// The request was made and the server responded with a status code// that falls out of the range of 2xxconsole.log(error.response.data);console.log(error.response.status);console.log(error.response.headers);}elseif(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.jsconsole.log(error.request);}else{// Something happened in setting up the request that triggered an Errorconsole.log('Error',error.message);}console.log(error.config);});

axios.get('/user/12345',{validateStatus:function(status){returnstatus<500;// Resolve only if the status code is less than 500}})

axios.get('/user/12345').catch(function(error){console.log(error.toJSON());});

Cancellation

AbortController

constcontroller=newAbortController();axios.get('/foo/bar',{signal:controller.signal}).then(function(response){//...});// cancel the requestcontroller.abort()

CancelToken👎deprecated

constCancelToken=axios.CancelToken;constsource=CancelToken.source();axios.get('/user/12345',{cancelToken:source.token}).catch(function(thrown){if(axios.isCancel(thrown)){console.log('Request canceled',thrown.message);}else{// handle error}});axios.post('/user/12345',{name:'new name'},{cancelToken:source.token})// cancel the request (the message parameter is optional)source.cancel('Operation canceled by the user.');

constCancelToken=axios.CancelToken;letcancel;axios.get('/user/12345',{cancelToken:newCancelToken(functionexecutor(c){// An executor function receives a cancel function as a parametercancel=c;})});// cancel the requestcancel();

Usingapplication/x-www-form-urlencoded format

URLSearchParams

constparams=newURLSearchParams({foo:'bar'});params.append('extraparam','value');axios.post('/foo',params);

Query string (Older browsers)

constqs=require('qs');axios.post('/foo',qs.stringify({'bar':123}));

importqsfrom'qs';constdata={'bar':123};constoptions={method:'POST',headers:{'content-type':'application/x-www-form-urlencoded'},data:qs.stringify(data),  url,};axios(options);

Older Node.js versions

constquerystring=require('querystring');axios.post('https://something.com/',querystring.stringify({foo:'bar'}));

🆕 Automatic serialization to URLSearchParams

constdata={x:1,arr:[1,2,3],arr2:[1,[2],3],users:[{name:'Peter',surname:'Griffin'},{name:'Thomas',surname:'Anderson'}],};awaitaxios.postForm('https://postman-echo.com/post',data,{headers:{'content-type':'application/x-www-form-urlencoded'}});

{x:'1','arr[]':['1','2','3'],'arr2[0]':'1','arr2[1][0]':'2','arr2[2]':'3','arr3[]':['1','2','3'],'users[0][name]':'Peter','users[0][surname]':'griffin','users[1][name]':'Thomas','users[1][surname]':'Anderson'}

varapp=express();app.use(bodyParser.urlencoded({extended:true}));// support encoded bodiesapp.post('/',function(req,res,next){// echo body as JSONres.send(JSON.stringify(req.body));});server=app.listen(3000);

Usingmultipart/form-data format

FormData

constformData=newFormData();formData.append('foo','bar');axios.post('https://httpbin.org/post',formData);

constFormData=require('form-data');constform=newFormData();form.append('my_field','my value');form.append('my_buffer',newBuffer(10));form.append('my_file',fs.createReadStream('/foo/bar.jpg'));axios.post('https://example.com',form)

🆕 Automatic serialization to FormData

importaxiosfrom'axios';axios.post('https://httpbin.org/post',{x:1},{headers:{'Content-Type':'multipart/form-data'}}).then(({data})=>console.log(data));

constaxios=require('axios');varFormData=require('form-data');axios.post('https://httpbin.org/post',{x:1,buf:newBuffer(10)},{headers:{'Content-Type':'multipart/form-data'}}).then(({data})=>console.log(data));

constobj={x:1,arr:[1,2,3],arr2:[1,[2],3],users:[{name:'Peter',surname:'Griffin'},{name:'Thomas',surname:'Anderson'}],'obj2{}':[{x:1}]};

constformData=newFormData();formData.append('x','1');formData.append('arr[]','1');formData.append('arr[]','2');formData.append('arr[]','3');formData.append('arr2[0]','1');formData.append('arr2[1][0]','2');formData.append('arr2[2]','3');formData.append('users[0][name]','Peter');formData.append('users[0][surname]','Griffin');formData.append('users[1][name]','Thomas');formData.append('users[1][surname]','Anderson');formData.append('obj2{}','[{"x":1}]');

Files Posting

awaitaxios.postForm('https://httpbin.org/post',{'myVar' :'foo','file':document.querySelector('#fileInput').files[0]});

awaitaxios.postForm('https://httpbin.org/post',{'files[]':document.querySelector('#fileInput').files});

awaitaxios.postForm('https://httpbin.org/post',document.querySelector('#fileInput').files)

🆕 HTML Form Posting (browser)

awaitaxios.postForm('https://httpbin.org/post',document.querySelector('#htmlForm'));

awaitaxios.post('https://httpbin.org/post',document.querySelector('#htmlForm'),{headers:{'Content-Type':'application/json'}})

<formid="form"><inputtype="text"name="foo"value="1"><inputtype="text"name="deep.prop"value="2"><inputtype="text"name="deep prop spaced"value="3"><inputtype="text"name="baz"value="4"><inputtype="text"name="baz"value="5"><selectname="user.age"><optionvalue="value1">Value 1</option><optionvalue="value2"selected>Value 2</option><optionvalue="value3">Value 3</option></select><inputtype="submit"value="Save"></form>

{"foo":"1","deep":{"prop":{"spaced":"3"}},"baz":["4","5"],"user":{"age":"value2"}}

🆕 Progress capturing

awaitaxios.post(url,data,{onUploadProgress:function(axiosProgressEvent){/*{      loaded: number;      total?: number;      progress?: number; // in range [0..1]      bytes: number; // how many bytes have been transferred since the last trigger (delta)      estimated?: number; // estimated time in seconds      rate?: number; // upload speed in bytes      upload: true; // upload sign    }*/},onDownloadProgress:function(axiosProgressEvent){/*{      loaded: number;      total?: number;      progress?: number;      bytes: number;      estimated?: number;      rate?: number; // download speed in bytes      download: true; // download sign    }*/}});

const{data}=awaitaxios.post(SERVER_URL,readableStream,{onUploadProgress:({progress})=>{console.log((progress*100).toFixed(2));},headers:{'Content-Length':contentLength},maxRedirects:0// avoid buffering the entire stream});

🆕 Rate limiting

const{data}=awaitaxios.post(LOCAL_SERVER_URL,myBuffer,{onUploadProgress:({progress, rate})=>{console.log(`Upload [${(progress*100).toFixed(2)}%]:${(rate/1024).toFixed(2)}KB/s`)},maxRate:[100*1024],// 100KB/s limit});

🆕 AxiosHeaders

Working with headers

axios.interceptors.request.use((request:InternalAxiosRequestConfig)=>{request.headers.set('My-header','value');request.headers.set({"My-set-header1":"my-set-value1","My-set-header2":"my-set-value2"});request.headers.set('User-Agent',false);// disable subsequent setting the header by Axiosrequest.headers.setContentType('text/plain');request.headers['My-set-header2']='newValue'// direct access is deprecatedreturnrequest;});

constheaders=newAxiosHeaders({foo:'1',bar:'2',baz:'3'});for(const[header,value]ofheaders){console.log(header,value);}// foo 1// bar 2// baz 3

new AxiosHeaders(headers?)

constructor(headers?: RawAxiosHeaders | AxiosHeaders | string);

constheaders=newAxiosHeaders(`Host: www.bing.comUser-Agent: curl/7.54.0Accept: */*`);console.log(headers);// Object [AxiosHeaders] {//   host: 'www.bing.com',//   'user-agent': 'curl/7.54.0',//   accept: '*/*'// }

AxiosHeaders#set

set(headerName,value:Axios,rewrite?:boolean);set(headerName,value,rewrite?:(this:AxiosHeaders,value:string,name:string,headers:RawAxiosHeaders)=>boolean);set(headers?:RawAxiosHeaders|AxiosHeaders|string,rewrite?:boolean);

AxiosHeaders#get(header)

  get(headerName: string, matcher?: true | AxiosHeaderMatcher): AxiosHeaderValue;  get(headerName: string, parser: RegExp): RegExpExecArray | null;

constheaders=newAxiosHeaders({'Content-Type':'multipart/form-data; boundary=Asrf456BGe4h'});console.log(headers.get('Content-Type'));// multipart/form-data; boundary=Asrf456BGe4hconsole.log(headers.get('Content-Type',true));// parse key-value pairs from a string separated with \s,;= delimiters:// [Object: null prototype] {//   'multipart/form-data': undefined,//    boundary: 'Asrf456BGe4h'// }console.log(headers.get('Content-Type',(value,name,headers)=>{returnString(value).replace(/a/g,'ZZZ');}));// multipZZZrt/form-dZZZtZZZ; boundZZZry=Asrf456BGe4hconsole.log(headers.get('Content-Type',/boundary=(\w+)/)?.[0]);// boundary=Asrf456BGe4h

AxiosHeaders#has(header, matcher?)

has(header: string, matcher?: AxiosHeaderMatcher): boolean;

AxiosHeaders#delete(header, matcher?)

delete(header: string | string[], matcher?: AxiosHeaderMatcher): boolean;

AxiosHeaders#clear(matcher?)

clear(matcher?: AxiosHeaderMatcher): boolean;

constheaders=newAxiosHeaders({'foo':'1','x-foo':'2','x-bar':'3',});console.log(headers.clear(/^x-/));// trueconsole.log(headers.toJSON());// [Object: null prototype] { foo: '1' }

AxiosHeaders#normalize(format);

constheaders=newAxiosHeaders({'foo':'1',});headers.Foo='2';headers.FOO='3';console.log(headers.toJSON());// [Object: null prototype] { foo: '1', Foo: '2', FOO: '3' }console.log(headers.normalize().toJSON());// [Object: null prototype] { foo: '3' }console.log(headers.normalize(true).toJSON());// [Object: null prototype] { Foo: '3' }

AxiosHeaders#concat(...targets)

concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;

AxiosHeaders#toJSON(asStrings?)

toJSON(asStrings?: boolean): RawAxiosHeaders;

AxiosHeaders.from(thing?)

from(thing?: AxiosHeaders | RawAxiosHeaders | string): AxiosHeaders;

AxiosHeaders.concat(...targets)

concat(...targets: Array<AxiosHeaders | RawAxiosHeaders | string | undefined | null>): AxiosHeaders;

Shortcuts

🔥 Fetch adapter

const{data}=axios.get(url,{adapter:'fetch'// by default ['xhr', 'http', 'fetch']})

constfetchAxios=axios.create({adapter:'fetch'});const{data}=fetchAxios.get(url);

🔥 Custom fetch

importcustomFetchFunctionfrom'customFetchModule';constinstance=axios.create({adapter:'fetch',onDownloadProgress(e){console.log('downloadProgress',e);},env:{fetch:customFetchFunction,Request:null,// undefined -> use the global constructorResponse:null}});

🔥 Using with Tauri

import{fetch}from"@tauri-apps/plugin-http";importaxiosfrom"axios";constinstance=axios.create({adapter:'fetch',onDownloadProgress(e){console.log('downloadProgress',e);},env:{    fetch}});const{data}=awaitinstance.get("https://google.com");

🔥 Using with SvelteKit

exportasyncfunctionload({ fetch}){const{data:post}=awaitaxios.get('https://jsonplaceholder.typicode.com/posts/1',{adapter:'fetch',env:{      fetch,Request:null,Response:null}});return{ post};}

🔥 HTTP2

constform=newFormData();form.append('foo','123');const{data, headers, status}=awaitaxios.post('https://httpbin.org/post',form,{httpVersion:2,http2Options:{// rejectUnauthorized: false,// sessionTimeout: 1000},onUploadProgress(e){console.log('upload progress',e);},onDownloadProgress(e){console.log('download progress',e);},responseType:'arraybuffer'});

Semver

Promises

TypeScript

letuser:User=null;try{const{ data}=awaitaxios.get('/user?ID=12345');user=data.userDetails;}catch(error){if(axios.isAxiosError(error)){handleAxiosError(error);}else{handleUnexpectedError(error);}}

Online one-click setup

Resources

Credits

License