axios

$ npm install axios

$ bower install axios

$ yarn add axios

$ pnpm add axios

$ bun add axios

import axios, { isCancel, AxiosError } from "axios";

import axios from "axios";

console.log(axios.isCancel("something"));

const axios = require("axios");

console.log(axios.isCancel("something"));

import { default as axios } from "axios";

const axios = require("axios/dist/browser/axios.cjs"); // browser commonJS bundle (ES2017)

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

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

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

import axios from "axios";

//const axios = require('axios'); // legacy way

try {

  const response = await axios.get("/user?ID=12345");

  console.log(response);

} catch (error) {

  console.error(error);

}

// Optionally the request above could also be done as

axios

  .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.

async function getUser() {

  try {

    const response = await axios.get("/user?ID=12345");

    console.log(response);

  } catch (error) {

    console.error(error);

  }

}

const response = await axios.post("/user", {

  firstName: "Fred",

  lastName: "Flintstone",

});

console.log(response);

function getUserAccount() {

  return axios.get("/user/12345");

}

function getUserPermissions() {

  return axios.get("/user/12345/permissions");

}

Promise.all([getUserAccount(), getUserPermissions()]).then(function (results) {

  const acct = results[0];

  const perm = results[1];

});

// Send a POST request

axios({

  method: "post",

  url: "/user/12345",

  data: {

    firstName: "Fred",

    lastName: "Flintstone",

  },

});

// GET request for remote image in node.js

const response = await axios({

  method: "get",

  url: "https://bit.ly/2mTM3nY",

  responseType: "stream",

});

response.data.pipe(fs.createWriteStream("ada_lovelace.jpg"));

// Send a GET request (default method)

axios("/user/12345");

const instance = axios.create({

  baseURL: "https://some-domain.com/api/",

  timeout: 1000,

  headers: { "X-Custom-Header": "foobar" },

});

{

  // `url` is the server URL that will be used for the request

  url: '/user',

  // `method` is the request method to be used when making the request

  method: 'get', // default

  // `baseURL` will be prepended to `url` unless `url` is absolute and the option `allowAbsoluteUrls` is set to true.

  // It can be convenient to set `baseURL` for an instance of axios to pass relative URLs

  // to the 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 data

    return data;

  }],

  // `transformResponse` allows changes to the response data to be made before

  // it is passed to then/catch

  transformResponse: [function (data) {

    // Do whatever you want to transform the data

    return data;

  }],

  // `headers` are custom headers to be sent

  headers: {'X-Requested-With': 'XMLHttpRequest'},

  // `params` are the URL parameters to be sent with the request

  // Must be a plain object or a URLSearchParams object

  params: {

    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 the 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, it 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 key

  data: '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 credentials

  withCredentials: 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 environment

  adapter: '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 the xsrf token

  xsrfCookieName: 'XSRF-TOKEN', // default

  // `xsrfHeaderName` is the name of the http header that carries the xsrf token value

  xsrfHeaderName: 'X-XSRF-TOKEN', // default

  // `undefined` (default) - set XSRF header only for the same origin requests

  withXSRFToken: boolean | undefined | ((config: InternalAxiosRequestConfig) => boolean | undefined),

  // `onUploadProgress` allows handling of progress events for uploads

  // browser & node.js

  onUploadProgress: 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.js

  onDownloadProgress: 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.js

  maxContentLength: 2000,

  // `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed

  maxBodyLength: 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) {

    return status >= 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: new http.Agent({ keepAlive: true }),

  httpsAgent: new https.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 a `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 defined

    port: 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: new CancelToken(function (cancel) {

  }),

  // an alternative way to cancel Axios requests using AbortController

  signal: new AbortController().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-none

  insecureHTTPParser: undefined, // default

  // transitional options for backward compatibility that may be removed in the newer versions

  transitional: {

    // 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 timeouts

    clarifyTimeoutError: false,

    // use the legacy interceptor request/response ordering

    legacyInterceptorReqResOrdering: true, // default

  },

  env: {

    // The FormData class to be used to automatically serialize the payload into a FormData object

    FormData: window?.FormData || global?.FormData

  },

  formSerializer: {

      visitor: (value, key, path, helpers) => {}; // custom visitor function to serialize form values

      dots: boolean; // use dots instead of brackets format

      metaTokens: boolean; // keep special endings like {} in parameter key

      indexes: 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

  ]

}

{

  // `data` is the response that was provided by the server

  data: {},

  // `status` is the HTTP status code from the server response

  status: 200,

  // `statusText` is the HTTP status message from the server response

  statusText: '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 request

  config: {},

  // `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 browser

  request: {}

}

const response = await axios.get("/user/12345");

console.log(response.data);

console.log(response.status);

console.log(response.statusText);

console.log(response.headers);

console.log(response.config);

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";

// Set config defaults when creating the instance

const instance = axios.create({

  baseURL: "https://api.example.com",

});

// Alter defaults after instance has been created

instance.defaults.headers.common["Authorization"] = AUTH_TOKEN;

// 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 library

const instance = axios.create();

// Override timeout default for the library

// Now all requests using this instance will wait 2.5 seconds before timing out

instance.defaults.timeout = 2500;

// Override timeout for this request as it's known to take a long time

instance.get("/longRequest", {

  timeout: 5000,

});

const instance = axios.create();

// Add a request interceptor

instance.interceptors.request.use(

  function (config) {

    // Do something before the request is sent

    return config;

  },

  function (error) {

    // Do something with the request error

    return Promise.reject(error);

  },

);

// Add a response interceptor

instance.interceptors.response.use(

  function (response) {

    // Any status code that lies within the range of 2xx causes this function to trigger

    // Do something with response data

    return response;

  },

  function (error) {

    // Any status codes that fall outside the range of 2xx cause this function to trigger

    // Do something with response error

    return Promise.reject(error);

  },

);

const instance = axios.create();

const myInterceptor = instance.interceptors.request.use(function () {

  /*...*/

});

axios.interceptors.request.eject(myInterceptor);

const instance = axios.create();

instance.interceptors.request.use(function () {

  /*...*/

});

instance.interceptors.request.clear(); // Removes interceptors from requests

instance.interceptors.response.use(function () {

  /*...*/

});

instance.interceptors.response.clear(); // Removes interceptors from responses

const instance = axios.create();

instance.interceptors.request.use(function () {

  /*...*/

});

axios.interceptors.request.use(

  function (config) {

    config.headers.test = "I am only a header!";

    return config;

  },

  null,

  { synchronous: true },

);

function onGetCall(config) {

  return config.method === "get";

}

axios.interceptors.request.use(

  function (config) {

    config.headers.test = "special get headers";

    return config;

  },

  null,

  { runWhen: onGetCall },

);

const instance = axios.create();

const interceptor = (id) => (base) => {

  console.log(id);

  return base;

};

instance.interceptors.request.use(interceptor("Request Interceptor 1"));

instance.interceptors.request.use(interceptor("Request Interceptor 2"));

instance.interceptors.request.use(interceptor("Request Interceptor 3"));

instance.interceptors.response.use(interceptor("Response Interceptor 1"));

instance.interceptors.response.use(interceptor("Response Interceptor 2"));

instance.interceptors.response.use(interceptor("Response Interceptor 3"));

// Console output:

// Request Interceptor 3

// Request Interceptor 2

// Request Interceptor 1

// [HTTP request is made]

// Response Interceptor 1

// Response Interceptor 2

// Response Interceptor 3

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 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);

});

axios.get("/user/12345", {

  validateStatus: function (status) {

    return status < 500; // Resolve only if the status code is less than 500

  },

});

axios.get("/user/12345").catch(function (error) {

  console.log(error.toJSON());

});

async function fetchWithTimeout() {

  try {

    const response = await axios.get("https://example.com/data", {

      timeout: 5000, // 5 seconds

    });

    console.log("Response:", response.data);

  } catch (error) {

    if (axios.isAxiosError(error) && error.code === "ECONNABORTED") {

      console.error("❌ Request timed out!");

    } else {

      console.error("❌ Error:", error.message);

    }

  }

}

const controller = new AbortController();

axios

  .get("/foo/bar", {

    signal: controller.signal,

  })

  .then(function (response) {

    //...

  });

// cancel the request

controller.abort();

const CancelToken = axios.CancelToken;

const source = 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.");

const CancelToken = axios.CancelToken;

let cancel;

axios.get("/user/12345", {

  cancelToken: new CancelToken(function executor(c) {

    // An executor function receives a cancel function as a parameter

    cancel = c;

  }),

});

// cancel the request

cancel();

const params = new URLSearchParams({ foo: "bar" });

params.append("extraparam", "value");

axios.post("/foo", params);

const qs = require("qs");

axios.post("/foo", qs.stringify({ bar: 123 }));

import qs from "qs";

const data = { bar: 123 };

const options = {

  method: "POST",

  headers: { "content-type": "application/x-www-form-urlencoded" },

  data: qs.stringify(data),

  url,

};

axios(options);

const querystring = require("querystring");

axios.post("https://something.com/", querystring.stringify({ foo: "bar" }));

const data = {

  x: 1,

  arr: [1, 2, 3],

  arr2: [1, [2], 3],

  users: [

    { name: "Peter", surname: "Griffin" },

    { name: "Thomas", surname: "Anderson" },

  ],

};

await axios.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'

  }

const app = express();

app.use(bodyParser.urlencoded({ extended: true })); // support encoded bodies

app.post("/", function (req, res, next) {

  // echo body as JSON

  res.send(JSON.stringify(req.body));

});

server = app.listen(3000);

const formData = new FormData();

formData.append("foo", "bar");

axios.post("https://httpbin.org/post", formData);

const FormData = require("form-data");

const form = new FormData();

form.append("my_field", "my value");

form.append("my_buffer", Buffer.alloc(10));

form.append("my_file", fs.createReadStream("/foo/bar.jpg"));

axios.post("https://example.com", form);

import axios from "axios";

axios

  .post(

    "https://httpbin.org/post",

    { x: 1 },

    {

      headers: {

        "Content-Type": "multipart/form-data",

      },

    },

  )

  .then(({ data }) => console.log(data));

const axios = require("axios");

var FormData = require("form-data");

axios

  .post(

    "https://httpbin.org/post",

    { x: 1, buf: Buffer.alloc(10) },

    {

      headers: {

        "Content-Type": "multipart/form-data",

      },

    },

  )

  .then(({ data }) => console.log(data));

const obj = {

  x: 1,

  arr: [1, 2, 3],

  arr2: [1, [2], 3],

  users: [

    { name: "Peter", surname: "Griffin" },

    { name: "Thomas", surname: "Anderson" },

  ],

  "obj2{}": [{ x: 1 }],

};

const formData = new FormData();

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}]');

await axios.postForm("https://httpbin.org/post", {

  myVar: "foo",

  file: document.querySelector("#fileInput").files[0],

});

await axios.postForm("https://httpbin.org/post", {

  "files[]": document.querySelector("#fileInput").files,

});

await axios.postForm(

  "https://httpbin.org/post",

  document.querySelector("#fileInput").files,

);

await axios.postForm(

  "https://httpbin.org/post",

  document.querySelector("#htmlForm"),

);

await axios.post(

  "https://httpbin.org/post",

  document.querySelector("#htmlForm"),

  {

    headers: {

      "Content-Type": "application/json",

    },

  },

);

<form id="form">

  <input type="text" name="foo" value="1" />

  <input type="text" name="deep.prop" value="2" />

  <input type="text" name="deep prop spaced" value="3" />

  <input type="text" name="baz" value="4" />

  <input type="text" name="baz" value="5" />

  <select name="user.age">

    <option value="value1">Value 1</option>

    <option value="value2" selected>Value 2</option>

    <option value="value3">Value 3</option>

  </select>

  <input type="submit" value="Save" />

</form>

{

  "foo": "1",

  "deep": {

    "prop": {

      "spaced": "3"

    }

  },

  "baz": [

    "4",

    "5"

  ],

  "user": {

    "age": "value2"

  }

}

await axios.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 } = await axios.post(SERVER_URL, readableStream, {

  onUploadProgress: ({ progress }) => {

    console.log((progress * 100).toFixed(2));

  },

  headers: {

    "Content-Length": contentLength,

  },

  maxRedirects: 0, // avoid buffering the entire stream

});

const { data } = await axios.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

});

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 Axios

  request.headers.setContentType("text/plain");

  request.headers["My-set-header2"] = "newValue"; // direct access is deprecated

  return request;

});

const headers = new AxiosHeaders({

  foo: "1",

  bar: "2",

  baz: "3",

});

for (const [header, value] of headers) {

  console.log(header, value);

}

// foo 1

// bar 2

// baz 3

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

const headers = new AxiosHeaders(`

Host: www.bing.com

User-Agent: curl/7.54.0

Accept: */*`);

console.log(headers);

// Object [AxiosHeaders] {

//   host: 'www.bing.com',

//   'user-agent': 'curl/7.54.0',

//   accept: '*/*'

// }

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);

  get(headerName: string, matcher?: true | AxiosHeaderMatcher): AxiosHeaderValue;

  get(headerName: string, parser: RegExp): RegExpExecArray | null;

const headers = new AxiosHeaders({

  "Content-Type": "multipart/form-data; boundary=Asrf456BGe4h",

});

console.log(headers.get("