diff --git a/gu.lang.js b/gu.lang.js
new file mode 100644
index 0000000..acb4f62
--- /dev/null
+++ b/gu.lang.js
@@ -0,0 +1,158 @@
+/**
+ * Configuration for the english (original) translation
+ */
+
+module.exports = {
+    // Language display name. MUST BE THE SAME AS IN [inert.config.js].custom.langs
+    display: "Gujrati",
+    prefix: "/gu",
+    dir: "ltr",
+    lang: "gu",
+    // `p` stands for `paragraph`. This will contain translations of full text blocks
+    p: {
+        headline: "બ્રાઉઝર અને node.js માટે પ્રોમિસ આધારિત HTTP ક્લાયંટ",
+        subhead: `Axios એ બ્રાઉઝર અને node.js માટે એક સરળ વચન આધારિત HTTP ક્લાયંટ છે.
+                Axios ખૂબ જ એક્સ્ટેન્સિબલ ઇન્ટરફેસ સાથે નાના પેકેજમાં ઉપયોગમાં સરળ લાઇબ્રેરી પ્રદાન કરે છે.`,
+        sponsors: `<p>અમારા પ્રોજેક્ટને ટેકો આપવા બદલ વિચારણા કરવા બદલ આભાર..</p>
+               <p>જો તમે પસંદ કરેલ સ્તર આ લાભ પ્રદાન કરશે, તો તમને 24 કલાકની અંદર આપમેળે આ સૂચિમાં ઉમેરવામાં આવશે..</p>
+               <div class="social"><a class="link" href="/docs/sponsor">Read more...</a></div>
+              `
+    },
+    // `t` stands fot `translation`. This will contain translations of single words or phrases
+    t: {
+        "Get Started": "શરૂ કરો",
+        "View on GitHub": "GitHub પર જુઓ",
+        "Languages": "ભાષાઓ",
+        "Open Source": "ઓપન સોર્સ",
+        "Contribute": "ફાળો આપો",
+        "Source on GitHub": "GitHub પર સ્ત્રોત",
+        "Issues": "સમસ્યાઓ",
+        "Pull Requests": "પુલ વિનંતીઓ",
+        "Code of Conduct": "કોડ ઓફ કોંડઉક્ત",
+        "Fork on GitHub": "ફોર્ક ઓન Github",
+        "Fork the Website": "ફોર્ક ધ વેબસાઇટ",
+        "Create an Issue": "સમસ્યા બનાવો",
+        "Next": "પછી",
+        "Previous": "પેલા નું",
+        "Website Copy Right Footer": "વેબસાઇટ નું ફૂટેર કોપી કરો",
+        "View On Github": "Github પર જુઓ",
+        "Axios Project Copy Right Footer": "એક્સિઓસ પ્રોજેક્ટ કોપી રાઇટ ફૂટર",
+        "License Label Footer": "લાઇસન્સ લેબલ ફૂટર",
+        "Sponsors": "સ્પોન્સર્સ",
+        "Become a sponsor": "સ્પોન્સર્સ બનો",
+        "Gold Sponsors": "ગોલ્ડ સ્પોન્સર્સ"
+    },
+    sidebar: [
+        {
+            type: "heading",
+            text: "શરૂઆત કરવી",
+        },
+        {
+            type: "link",
+            href: "/docs/intro",
+            text: "પરિચય",
+        },
+        {
+            type: "link",
+            href: "/docs/example",
+            text: "ઉદાહરણ",
+        },
+        {
+            type: "link",
+            href: "/docs/post_example",
+            text: "પોસ્ટ વિનંતીઓ",
+        },
+        {
+            type: "heading",
+            text: "Axios એપીઈ",
+        },
+        {
+            type: "link",
+            href: "/docs/api_intro",
+            text: "Axios એપીઈ",
+        },
+        {
+            type: "link",
+            href: "/docs/instance",
+            text: "એક્સિઓસ ઉદાહરણ",
+        },
+        {
+            type: "link",
+            href: "/docs/req_config",
+            text: "વિનંતી રૂપરેખાંકન",
+        },
+        {
+            type: "link",
+            href: "/docs/res_schema",
+            text: "પ્રતિભાવ યોજના",
+        },
+        {
+            type: "link",
+            href: "/docs/config_defaults",
+            text: "કોનફિનગ ડિફોલ્ટ્સ",
+        },
+        {
+            type: "link",
+            href: "/docs/interceptors",
+            text: "ઇન્ટરસેપ્ટર્સ",
+        },
+        {
+            type: "link",
+            href: "/docs/handling_errors",
+            text: "ભૂલોનું નિરાકરણ",
+        },
+        {
+            type: "link",
+            href: "/docs/cancellation",
+            text: "રદ",
+        },
+        {
+            type: "link",
+            href: "/docs/urlencoded",
+            text: "🆕 URL-Encoding Bodies",
+        },
+        {
+            type: "link",
+            href: "/docs/multipart",
+            text: "🆕 બહુપક્ષીય સંસ્થાઓ",
+        },
+        {
+            type: "heading",
+            text: "બીજું",
+        },
+        {
+            type: "link",
+            href: "/docs/notes",
+            text: "નોંધ",
+        },
+        {
+            type: "heading",
+            text: "સમર્થકો",
+        },
+        {
+            type: "link",
+            href: "/docs/sponsor",
+            text: "axios સમર્થક",
+        },
+        {
+            type: "link",
+            href: "https://github.com/axios/axios/blob/v1.x/CODE_OF_CONDUCT.md",
+            text: "કોડ ઓફ કોંડઉક્ત",
+        },
+        {
+            type: "link",
+            href: "https://github.com/axios/axios/blob/v1.x/COLLABORATOR_GUIDE.md",
+            text: "સહયોગી માર્ગદર્શિકા",
+        },
+        {
+            type: "link",
+            href: "https://github.com/axios/axios/blob/v1.x/CONTRIBUTING.md",
+            text: "axios માં ફાળો આપો"
+        },
+        {
+            type: "link",
+            href: "/docs/translating",
+            text: "આ docs નું ભાષાંતર"
+        }
+    ],
+};
diff --git a/inert.config.js b/inert.config.js
index 8a9dd2a..7752d9f 100644
--- a/inert.config.js
+++ b/inert.config.js
@@ -25,6 +25,7 @@ const ptBRConfig = require("./ptBR.lang.js");
 const kuConfig = require("./ku.lang.js");
 const esConfig = require('./es.lang.js');
 const frConfig = require("./fr.lang.js");
+const guConfig = require('./gu.lang.js')
 const trConfig = require("./tr.lang.js");
 const krConfig = require("./kr.lang.js");
 const viConfig = require("./vi.lang.js");
@@ -88,6 +89,12 @@ const langs = [
     prefix: "/fr/",
     config: frConfig,
   },
+  {
+    dir: "ltr",
+    name: "Gujrati",
+    prefix: "/gu/",
+    config: guConfig
+  },
   {
     dir: "ltr",
     name: "Türkçe",
@@ -117,7 +124,7 @@ const langs = [
     name: "Русский",
     prefix: "/ru/",
     config: ruConfig
-  },{
+  }, {
     dir: "rtl",
     name: "Arabic",
     prefix: "/ar/",
@@ -211,10 +218,10 @@ module.exports = {
           lang.prefix === "/"
             ? acc
             : {
-                ...acc,
-                [lang.prefix.slice(1, -1) +
+              ...acc,
+              [lang.prefix.slice(1, -1) +
                 "Output"]: `:output:/${lang.prefix.slice(1, -1)}`,
-              },
+            },
         {}
       ),
       /**
@@ -226,12 +233,12 @@ module.exports = {
           lang.prefix === "/"
             ? acc
             : {
-                ...acc,
-                [lang.prefix.slice(1, -1) + "Posts"]: `:${lang.prefix.slice(
-                  1,
-                  -1
-                )}Output:/docs`,
-              },
+              ...acc,
+              [lang.prefix.slice(1, -1) + "Posts"]: `:${lang.prefix.slice(
+                1,
+                -1
+              )}Output:/docs`,
+            },
         {}
       ),
     },
diff --git a/posts/gu/api_intro.md b/posts/gu/api_intro.md
new file mode 100644
index 0000000..e23daaa
--- /dev/null
+++ b/posts/gu/api_intro.md
@@ -0,0 +1,61 @@
+---
+title: "એક્ષીયોસ એપીઆઇ"
+description: 'એક્ષીયોસ એપીઆઇ માર્ગદર્શિકા'
+prev_title: 'પોસ્ટ વિનંતી'
+prev_link: 'gu/docs/post_example'
+next_title: 'એક્ષીયોસ instance'
+next_link: '/gu/docs/instance'
+---
+
+સંબંધિત રૂપરેખાને `axios` માં પાસ કરીને વિનંતીઓ કરી શકાય છે
+
+##### axios(config)
+
+```js
+// પોસ્ટ વિનંતી મોકલો 
+axios({
+  method: 'post',
+  url: '/user/12345',
+  data: {
+    firstName: 'Fred',
+    lastName: 'Flintstone'
+  }
+});
+```
+
+```js
+//remote ઇમેજ માટે ગૅટ વિનંતી મોકલો 
+axios({
+  method: 'get',
+  url: 'http://bit.ly/2mTM3nY',
+  responseType: 'stream'
+})
+  .then(function (response) {
+    response.data.pipe(fs.createWriteStream('ada_lovelace.jpg'))
+  });
+```
+
+##### axios(url[, config])
+
+```js
+// ગૅટ વિનંતી મોકલો (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]])
+##### axios.postForm(url[, data[, config]])
+##### axios.putForm(url[, data[, config]])
+##### axios.patchForm(url[, data[, config]])
+
+> નૉૅધ: When using the alias methods `url`, `method`, and `data` properties don't need to be specified in config.
diff --git a/posts/gu/cancellation.md b/posts/gu/cancellation.md
new file mode 100644
index 0000000..3dedebb
--- /dev/null
+++ b/posts/gu/cancellation.md
@@ -0,0 +1,136 @@
+---
+title: 'Cancellation'
+prev_title: 'Handling Errors'
+prev_link: '/gu/docs/handling_errors'
+next_title: 'URL-Encoding Bodies'
+next_link: '/gu/docs/urlencoded'
+---
+
+## Cancelling requests 
+
+Setting the `timeout` property in an axios call handles **response** related timeouts. 
+
+અમુક પ્રક્રિયા માં (e.g. જ્યારે નેટ ઉપલભ્ય ના હોય) an axios call would benefit from cancelling the **connection** early. Without cancellation, the axios call can hang until the parent code/stack times out (સર્વર સાઇડ એપપસ માં થોડો વધારે સમય લે સકે ex: nextjs).
+
+Combining `timeout` and cancellation method (e.g. `signal`) should cover **response** related timeouts AND **connection** related timeouts.
+
+### `signal`: AbortController
+
+Starting from `v0.22.0` Axios supports [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) to cancel requests in fetch API way:
+
+```js
+const controller = new AbortController();
+
+axios.get('/foo/bar', {
+   signal: controller.signal
+}).then(function(response) {
+   //...
+});
+// cancel the request
+controller.abort()
+```
+
+Example with a timeout using latest [`AbortSignal.timeout()`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout) API [nodejs 17.3+]:
+```js
+axios.get('/foo/bar', {
+   signal: AbortSignal.timeout(5000) //Aborts request after 5 seconds
+}).then(function(response) {
+   //...
+});
+```
+
+Example with a timeout helper function:
+```js
+function newAbortSignal(timeoutMs) {
+  const abortController = new AbortController();
+  setTimeout(() => abortController.abort(), timeoutMs || 0);
+
+  return abortController.signal;
+}
+
+axios.get('/foo/bar', {
+   signal: newAbortSignal(5000) //Aborts request after 5 seconds
+}).then(function(response) {
+   //...
+});
+```
+
+### CancelToken `deprecated`
+
+તમે વિનંતી ને નાબૂદ કરી સકો *CancelToken* વાપરી ને 
+
+> તમે cancel token વાપરી સકો `CancelToken.source` વાપરી ને નીચે દર્શાવ્યા પ્રમાણે 
+
+```js
+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 (મેસેજ parameter વૈકલ્પિક છે)
+source.cancel('Operation canceled by the user.');
+```
+
+તમે `CancelToken` કન્સ્ટ્રક્ટરને એક્ઝિક્યુટર ફંક્શન પાસ કરીને કેન્સલ ટોકન પણ બનાવી શકો છો:
+
+```js
+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();
+```
+
+> નોંધ: તમે એક જ કેન્સલ ટોકન / સિગ્નલ વડે અનેક વિનંતીઓ રદ કરી શકો છો.
+
+સંક્રમણ સમયગાળા દરમિયાન, તમે બંને રદ કરવાના API નો ઉપયોગ કરી શકો છો, એક જ વિનંતી માટે પણ:
+
+```js
+const controller = new AbortController();
+
+const CancelToken = axios.CancelToken;
+const source = CancelToken.source();
+
+axios.get('/user/12345', {
+  cancelToken: source.token,
+  signal: controller.signal
+}).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.');
+// OR
+controller.abort(); // the message parameter is not supported
+```
\ No newline at end of file
diff --git a/posts/gu/config_defaults.md b/posts/gu/config_defaults.md
new file mode 100644
index 0000000..28a7d42
--- /dev/null
+++ b/posts/gu/config_defaults.md
@@ -0,0 +1,50 @@
+---
+title: 'Config Defaults'
+prev_title: 'Response Schema'
+prev_link: '/gu/docs/res_schema'
+next_title: 'Interceptors'
+next_link: '/gu/docs/interceptors'
+---
+
+## Config Defaults
+
+તમે દરેક વિનંતી પર લાગુ થનારા config ડિફોલ્ટનો ઉલ્લેખ કરી શકો છો.
+
+### Global axios defaults
+
+```js
+axios.defaults.baseURL = 'https://api.example.com';
+axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;
+axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded';
+```
+
+### Custom instance defaults
+
+```js
+// 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;
+```
+
+### Config order of precedence
+
+Config will be merged with an order of precedence. The order is library defaults found in [lib/defaults/index.js](https://github.com/axios/axios/blob/v1.x/lib/defaults/index.js), then `defaults` property of the instance, and finally `config` argument for the request. The latter will take precedence over the former. ઉદાહરણ.
+
+```js
+// 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
+});
+```
\ No newline at end of file
diff --git a/posts/gu/example.md b/posts/gu/example.md
new file mode 100644
index 0000000..d473200
--- /dev/null
+++ b/posts/gu/example.md
@@ -0,0 +1,69 @@
+---
+title: 'Minimal Example'
+description: 'A little example of using axios'
+prev_title: 'Introduction'
+prev_link: '/gu/docs/intro'
+next_title: 'POST Requests'
+next_link: '/gu/docs/post_example'
+---
+
+## note: CommonJS usage
+In order to gain the TypeScript typings (for intellisense / autocomplete) while using CommonJS imports with `require()` use the following approach:
+
+typescript suggestion માટે (for intellisense  / autocomplete) comonjs વાપારતી વખતે નીચે પ્રમાણે નો ઉપયોગ કરો 
+
+```js
+const axios = require('axios').default;
+
+// axios.<method> will now provide autocomplete and parameter typings
+```
+
+# Example
+
+Performing a `GET` request
+
+```js
+const axios = require('axios');
+
+// Make a request for a user with a given ID
+axios.get('/user?ID=12345')
+  .then(function (response) {
+    // handle success
+    console.log(response);
+  })
+  .catch(function (error) {
+    // handle error
+    console.log(error);
+  })
+  .finally(function () {
+    // always executed
+  });
+
+// 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);
+  }
+}
+```
+
+> **NOTE:** `async/await` is part of ECMAScript 2017 and તે internet explorer અને બીજા જૂના browser પર ઉપલબ્ધ નથી.
\ No newline at end of file
diff --git a/posts/gu/handling_errors.md b/posts/gu/handling_errors.md
new file mode 100644
index 0000000..837af3e
--- /dev/null
+++ b/posts/gu/handling_errors.md
@@ -0,0 +1,56 @@
+---
+title: 'Handling Errors'
+prev_title: 'Interceptors'
+prev_link: '/gu/docs/interceptors'
+next_title: 'Cancellation'
+next_link: '/gu/docs/cancellation'
+---
+
+અક્ષીઓસ ભૂલો નું માળખું આવી રીતે:
+- **message** - ભૂલ સંદેશ અને તે નિષ્ફળ થયેલ સ્થિતિનો ટૂંકો સારાંશ.  
+- **name** - આ ભૂલ ક્યાંથી ઉદ્ભવી તે વ્યાખ્યાયિત કરે છે. axios માટે, તે હંમેશા 'AxiosError' હશે..  
+- **stack** - ભૂલનો સ્ટેક ટ્રેસ પૂરો પાડે છે.  
+- **config** - વિનંતી કરવામાં આવી ત્યારથી વપરાશકર્તા દ્વારા વ્યાખ્યાયિત ચોક્કસ ઇન્સ્ટન્સ ગોઠવણીઓ સાથેનો એક axios રૂપરેખા ઑબ્જેક્ટ.  
+- **code** - એક એક્સિઓસ ઓળખાયેલ ભૂલ દર્શાવે છે. નીચે આપેલ કોષ્ટક આંતરિક એક્સિઓસ ભૂલ માટે ચોક્કસ વ્યાખ્યાઓ દર્શાવે છે.  
+- **status** - HTTP response status code. See [here](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes) for common HTTP response status code meanings.  
+
+```js
+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 {
+      // વિનંતી સેટ કરતી વખતે ભૂલ આવી
+      console.log('Error', error.message);
+    }
+    console.log(error.config);
+  });
+```
+
+Using the `validateStatus` config option, you can define HTTP code(s) that should throw an error.
+
+```js
+axios.get('/user/12345', {
+  validateStatus: function (status) {
+    return status < 500; // Resolve only if the status code is less than 500
+  }
+})
+```
+
+Using `toJSON` you get an object with more information about the HTTP error.
+
+```js
+axios.get('/user/12345')
+  .catch(function (error) {
+    console.log(error.toJSON());
+  });
+```
\ No newline at end of file
diff --git a/posts/gu/instance.md b/posts/gu/instance.md
new file mode 100644
index 0000000..4dfd380
--- /dev/null
+++ b/posts/gu/instance.md
@@ -0,0 +1,62 @@
+---
+title: 'The Axios Instance'
+prev_title: 'Axios API'
+prev_link: '/gu/docs/api_intro'
+next_title: 'Request Config'
+next_link: '/gu/docs/req_config'
+---
+
+### Creating an instance
+
+You can create a new instance of axios with a custom config.
+
+##### axios.create([config])
+
+```js
+const instance = axios.create({
+  baseURL: 'https://some-domain.com/api/',
+  timeout: 1000,
+  headers: {'X-Custom-Header': 'foobar'}
+});
+```
+
+### Instance પદ્ધતિઓ 
+
+ઉપલબ્ધ પદ્ધતિ instance methods માટે નીચે દર્શાવેલ છે. The specified config will be merged with the instance config.
+
+##### 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])
+
+### Calling the instance with a config object
+
+`instance.get()` અથવા `instance.post()` જેવી સુવિધાજનક પદ્ધતિઓનો ઉપયોગ કરવા ઉપરાંત, તમે instance object સાથે સીધા Axios ઇન્સ્ટન્સને પણ કૉલ કરી શકો છો. આ કાર્યાત્મક રીતે `axios(config)` ની સમકક્ષ છે, અને મૂળ રૂપરેખાંકનનો ઉપયોગ કરીને વિનંતીનો ફરીથી પ્રયાસ કરતી વખતે ખાસ કરીને ઉપયોગી છે.
+
+```js
+const instance = axios.create({ baseURL: '/api' });
+
+// Works just like axios(config)
+instance({
+  url: '/users',
+  method: 'get'
+});
+```
+
+This approach enables clean retry logic when handling authentication errors:
+
+```js
+instance.interceptors.response.use(undefined, async (error) => {
+  if (error.response?.status === 401) {
+    await refreshToken();
+    return instance(error.config); // Retry original request
+  }
+
+  throw error;
+});
+```
\ No newline at end of file
diff --git a/posts/gu/interceptors.md b/posts/gu/interceptors.md
new file mode 100644
index 0000000..a7ade4a
--- /dev/null
+++ b/posts/gu/interceptors.md
@@ -0,0 +1,55 @@
+---
+title: 'Interceptors'
+prev_title: 'Config Defaults'
+prev_link: '/gu/docs/config_defaults'
+next_title: 'Handling Errors'
+next_link: '/gu/docs/handling_errors'
+---
+
+તમે વિનંતીઓ અથવા response ને "then" અથવા "catch" દ્વારા હેન્ડલ કરવામાં આવે તે પહેલાં **જોઈ શકો છો.
+
+The `use` function adds a handler to the list of handlers to be run when the Promise is fulfilled or rejected. The handler is defined by the fulfilled and rejected functions.
+
+There is an optional `options` object that can be passed in as the third parameter. `synchronous` if the synchronous option is true. The handler is defined as asynchronous if the synchronous option is false. If the synchronous option is not provided, the handler is defined as asynchronous. `runWhen` will control when the provided interceptor will run. Provide a function that will return true or false on whether it should run, defaults to always true.
+
+```js
+// Add a request interceptor
+axios.interceptors.request.use(function (config) {
+    // Do something before request is sent
+    return config;
+  }, function (error) {
+    // Do something with request error
+    return Promise.reject(error);
+  },
+  { synchronous: true, runWhen: () => /* This function returns true */}
+);
+
+// Add a response interceptor
+axios.interceptors.response.use(function onFulfilled(response) {
+    // Any status code that lie within the range of 2xx cause this function to trigger
+    // Do something with response data
+    return response;
+  }, function onRejected(error) {
+    // Any status codes that falls outside the range of 2xx cause this function to trigger
+    // Do something with response error
+    return Promise.reject(error);
+  });
+```
+
+In normal circumstances the `onFulfilled` response interceptor is only called for responses in the 2xx range, and `onRejected` is called otherwise.
+However, this behavior depends on [validateStatus](/docs/req_config).
+For instance, if `validateStatus` is setup to always return `true`, then `onFulfilled` will be called for *all* responses.
+
+જો તમારે પછીથી interceptor દૂર કરવાની જરૂર હોય તો તમે તે કરી શકો છો.
+
+```js
+const myInterceptor = axios.interceptors.request.use(function () {/*...*/});
+axios.interceptors.request.eject(myInterceptor);
+```
+
+તમે axios ના કસ્ટમ ઇન્સ્ટન્સમાં interceptors ઉમેરી શકો છો.
+
+```js
+const instance = axios.create();
+instance.interceptors.request.use(function () {/*...*/});
+```
\ No newline at end of file
diff --git a/posts/gu/intro.md b/posts/gu/intro.md
new file mode 100644
index 0000000..763bc48
--- /dev/null
+++ b/posts/gu/intro.md
@@ -0,0 +1,73 @@
+---
+title: 'Getting Started'
+description: 'Promise based HTTP client for the browser and node.js'
+next_title: 'Minimal Example'
+next_link: '/gu/docs/example'
+---
+
+# What is Axios?
+# What is Axios?
+Axios is a *[promise-based](https://javascript.info/promise-basics)* HTTP Client for [`node.js`](https://nodejs.org) and the browser. It is *[isomorphic](https://www.lullabot.com/articles/what-is-an-isomorphic-application)* (= it can run in the browser અને nodejs દ્વારા ચાલી સકે છે સરખા codebase ઉપર). On the server-side it uses the native node.js `http` module, while on the client (browser) it uses XMLHttpRequest.
+
+# Features
+
+- Make [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) from the browser
+- Make [http](http://nodejs.org/api/http.html) requests from node.js
+- Supports the [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) API
+- Intercept request and response
+- Transform request and response data
+- Cancel requests
+- Timeouts
+- Query parameters serialization with support for nested entries
+- Automatic request body serialization to:
+    - JSON (`application/json`)
+    - Multipart / FormData (`multipart/form-data`)
+    - URL encoded form (`application/x-www-form-urlencoded`)
+- Posting HTML forms as JSON    
+- json data તેની રીતે ચાલે છે  
+- Progress capturing for browsers and node.js with extra info (speed rate, remaining time)
+- Setting bandwidth limits for node.js
+- Compatible with spec-compliant FormData and Blob (including `node.js`)
+- Client side support for protecting against [XSRF](http://en.wikipedia.org/wiki/Cross-site_request_forgery)
+
+# Installing
+
+Using npm:
+
+```bash
+$ npm install axios
+```
+
+Using bower:
+
+```bash
+$ bower install axios
+```
+
+Using yarn:
+
+```bash
+$ yarn add axios
+```
+
+Using pnpm:
+
+```bash
+$ pnpm add axios
+```
+
+Using jsDelivr CDN:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js"></script>
+
+```html
+<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
+```
+
+Prebuilt CommonJS modules for direct importing with require (if your module bundler failed to resolve them automatically)
+
+```js
+const axios = require('axios/dist/browser/axios.cjs'); // browser
+const axios = require('axios/dist/node/axios.cjs'); // node
+```
\ No newline at end of file
diff --git a/posts/gu/multipart.md b/posts/gu/multipart.md
new file mode 100644
index 0000000..992179f
--- /dev/null
+++ b/posts/gu/multipart.md
@@ -0,0 +1,171 @@
+---
+title: 'Multipart Bodies'
+prev_title: 'URL-Encoding Bodies'
+prev_link: '/gu/docs/urlencoded'
+next_title: 'Notes'
+next_link: '/gu/docs/notes'
+---
+
+## Posting data as `multipart/form-data`
+
+### Using FormData API
+
+#### Browser
+
+```js 
+const form = new FormData();
+form.append('my_field', 'my value');
+form.append('my_buffer', new Blob([1,2,3]));
+form.append('my_file', fileInput.files[0]);
+
+axios.post('https://example.com', form)
+
+```
+આંતરિક Axios serializer અને અનુરૂપ શોર્ટહેન્ડ પદ્ધતિનો ઉપયોગ કરીને સમાન પરિણામ પ્રાપ્ત કરી શકાય છે:
+
+```js
+axios.postForm('https://httpbin.org/post', {
+  my_field: 'my value',
+  my_buffer: new Blob([1,2,3]),
+  my_file:  fileInput.files // FileList will be unwrapped as separate fields
+});
+```
+
+HTML form can be passed directly as a request payload. 
+
+#### Node.js
+
+```js 
+import axios from 'axios';
+
+const form = new FormData();
+form.append('my_field', 'my value');
+form.append('my_buffer', new Blob(['some content']));
+
+axios.post('https://example.com', form)
+```
+
+node.js હાલમાં ફાઇલમાંથી `Blob` બનાવવાનું સમર્થન કરતું નથી, તેથી તમે આ હેતુ માટે બીજા પેકેજનો ઉપયોગ કરી શકો છો.
+
+```js
+import {fileFromPath} from 'formdata-node/file-from-path'
+
+form.append('my_field', 'my value');
+form.append('my_file', await fileFromPath('/foo/bar.jpg'));
+
+axios.post('https://example.com', form)
+```
+
+`v1.3.0` કરતા જૂના Axios માટે તમારે `form-data` પેકેજ આયાત કરવું આવશ્યક છે.
+
+
+```js 
+const FormData = require('form-data');
+
+const form = new FormData();
+form.append('my_field', 'my value');
+form.append('my_buffer', new Buffer(10));
+form.append('my_file', fs.createReadStream('/foo/bar.jpg'));
+
+axios.post('https://example.com', form)
+```
+
+### 🆕 Automatic serialization
+
+`v0.27.0` થી શરૂ કરીને, જો વિનંતી સામગ્રી-પ્રકાર હેડર `multipart/form-data` પર સેટ કરેલ હોય, તો Axios ફોર્મડેટા ઑબ્જેક્ટમાં સ્વચાલિત object serialization સપોર્ટ કરે છે.
+
+નીચેની વિનંતી ફોર્મડેટા ફોર્મેટ (બ્રાઉઝર અને નોડ.જેએસ) માં ડેટા સબમિટ કરશે:
+
+```js
+import axios from 'axios';
+
+axios.post('https://httpbin.org/post', {
+  user: {
+    name: 'Dmitriy'
+  },
+  file: fs.createReadStream('/foo/bar.jpg')
+}, {
+  headers: {
+    'Content-Type': 'multipart/form-data'
+  }
+}).then(({data})=> console.log(data));
+```
+
+Axios FormData serializer supports some special endings to perform the following operations:
+
+- `{}` - serialize the value with JSON.stringify
+- `[]` - unwrap the array-like object as separate fields with the same key 
+
+> નોંધ: 
+> unwrap/expand operation will be used by default on arrays and FileList objects
+
+FormData serializer supports additional options via `config.formSerializer: object` property to handle rare cases:
+
+- `visitor: Function` - user-defined visitor function that will be called recursively to serialize the data object
+to a `FormData` object by following custom rules.
+
+- `dots: boolean = false` - use dot notation instead of brackets to serialize arrays and objects;
+
+- `metaTokens: boolean = true` - add the special ending (e.g `user{}: '{"name": "John"}'`) in the FormData key. 
+The back-end body-parser could potentially use this meta-information to automatically parse the value as JSON.
+
+- `indexes: null|false|true = false` - controls how indexes will be added to unwrapped keys of `flat` array-like objects
+
+    - `null` - don't add brackets (`arr: 1`, `arr: 2`, `arr: 3`) 
+    - `false`(default) - add empty brackets (`arr[]: 1`, `arr[]: 2`, `arr[]: 3`)
+    - `true` - add brackets with indexes  (`arr[0]: 1`, `arr[1]: 2`, `arr[2]: 3`)
+
+Let's say we have an object like this one:
+
+```js
+const obj = {
+  x: 1,
+  arr: [1, 2, 3],
+  arr2: [1, [2], 3],
+  users: [{name: 'Peter', surname: 'Griffin'}, {name: 'Thomas', surname: 'Anderson'}],
+  'obj2{}': [{x:1}]
+};
+```
+
+Axios serializer દ્વારા આંતરિક રીતે નીચેના પગલાં લેવામાં આવશે:
+
+```js
+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}]');
+```
+
+```js
+import axios from 'axios';
+
+axios.post('https://httpbin.org/post', {
+  'myObj{}': {x: 1, s: "foo"},
+  'files[]': document.querySelector('#fileInput').files 
+}, {
+  headers: {
+    'Content-Type': 'multipart/form-data'
+  }
+}).then(({data})=> console.log(data));
+```
+
+Axios નીચેની શોર્ટકટ પદ્ધતિઓને સપોર્ટ કરે છે: 
+`postForm`, `putForm`, `patchForm`
+which are just the corresponding http methods with the content-type header preset to `multipart/form-data`.
+
+`FileList` object can be passed directly:
+
+```js
+await axios.postForm('https://httpbin.org/post', document.querySelector('#fileInput').files)
+```
+
+બધી ફાઇલો સમાન ફીલ્ડ નામો સાથે મોકલવામાં આવશે.: `files[]`;
\ No newline at end of file
diff --git a/posts/gu/notes.md b/posts/gu/notes.md
new file mode 100644
index 0000000..6a897f0
--- /dev/null
+++ b/posts/gu/notes.md
@@ -0,0 +1,38 @@
+---
+title: 'નોંધ'
+description: 'A couple more notes to round it off'
+prev_title: 'URL-Encoding Bodies'
+prev_link: '/gu/docs/urlencoded'
+---
+
+## Semver
+
+Until axios reaches a `1.0` release, breaking changes will be released with a new minor version. For example `0.5.1`, and `0.5.4` will have the same API, but `0.6.0` will have breaking changes.
+
+## Promises
+
+axios depends on a native ES6 Promise implementation to be [supported](http://caniuse.com/promises).
+If your environment doesn't support ES6 Promises, you can [polyfill](https://github.com/jakearchibald/es6-promise).
+
+## TypeScript
+axios includes [TypeScript](http://typescriptlang.org) definitions.
+```typescript
+import axios from 'axios';
+axios.get('/user?ID=12345');
+```
+
+## Resources
+
+* [Changelog](https://github.com/axios/axios/blob/v1.x/CHANGELOG.md)
+* [Upgrade Guide](https://github.com/axios/axios/blob/v1.x/UPGRADE_GUIDE.md)
+* [Ecosystem](https://github.com/axios/axios/blob/v1.x/ECOSYSTEM.md)
+* [Contributing Guide](https://github.com/axios/axios/blob/v1.x/CONTRIBUTING.md)
+* [Code of Conduct](https://github.com/axios/axios/blob/v1.x/CODE_OF_CONDUCT.md)
+
+## Credits
+
+axios is heavily inspired by the [$http service](https://docs.angularjs.org/api/ng/service/$http) provided in [Angular](https://angularjs.org/). Ultimately axios is an effort to provide a standalone `$http`-like service for use outside of Angular.
+
+## License
+
+[MIT](https://github.com/axios/axios/blob/v1.x/LICENSE)
\ No newline at end of file
diff --git a/posts/gu/post_example.md b/posts/gu/post_example.md
new file mode 100644
index 0000000..bd2d9ae
--- /dev/null
+++ b/posts/gu/post_example.md
@@ -0,0 +1,88 @@
+---
+title: 'POST વિનંતી'
+description: 'How to perform POST requests with Axios'
+prev_title: 'Minimal Example'
+prev_link: '/gu/docs/example'
+next_title: 'Axios API'
+next_link: '/gu/docs/api_intro'
+---
+
+## Performing a `POST` request
+
+### JSON
+
+```js
+axios.post('/user', {
+    firstName: 'Fred',
+    lastName: 'Flintstone'
+  })
+  .then(function (response) {
+    console.log(response);
+  })
+  .catch(function (error) {
+    console.log(error);
+  });
+```
+
+Performing multiple concurrent requests
+
+```js
+function getUserAccount() {
+  return axios.get('/user/12345');
+}
+
+function getUserPermissions() {
+  return axios.get('/user/12345/permissions');
+}
+
+const [acct, perm] = await Promise.all([getUserAccount(), getUserPermissions()]);
+
+// OR
+
+Promise.all([getUserAccount(), getUserPermissions()])
+  .then(function ([acct, perm]) {
+    // ...
+  });
+```
+
+Post an HTML form as JSON
+
+```js
+const {data} = await axios.post('/user', document.querySelector('#my-form'), {
+  headers: {
+    'Content-Type': 'application/json'
+  }
+})
+```
+
+### Forms
+
+- Multipart (`multipart/form-data`)
+
+```js
+const {data} = await axios.post('https://httpbin.org/post', {
+    firstName: 'Fred',
+    lastName: 'Flintstone',
+    orders: [1, 2, 3],
+    photo: document.querySelector('#fileInput').files
+  }, {
+    headers: {
+      'Content-Type': 'multipart/form-data'
+    }
+  }
+)
+```
+
+- URL encoded form (`application/x-www-form-urlencoded`)
+
+```js
+const {data} = await axios.post('https://httpbin.org/post', {
+    firstName: 'Fred',
+    lastName: 'Flintstone',
+    orders: [1, 2, 3]
+  }, {
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded'
+    }
+})
+```
\ No newline at end of file
diff --git a/posts/gu/req_config.md b/posts/gu/req_config.md
new file mode 100644
index 0000000..1cf63a5
--- /dev/null
+++ b/posts/gu/req_config.md
@@ -0,0 +1,257 @@
+---
+title: 'Request Config'
+prev_title: 'The Axios Instance'
+prev_link: '/gu/docs/instance'
+next_title: 'Response Schema'
+next_link: '/gu/docs/res_schema'
+---
+
+વિનંતીઓ કરવા માટે આ ઉપલબ્ધ config વિકલ્પો છે. ફક્ત `url` જરૂરી છે. જો `method` ઉલ્લેખિત ન હોય તો વિનંતીઓ `GET` પર ડિફોલ્ટ થશે.
+
+```js
+{
+  // `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 ને `url` માં આગળ મૂકવામાં આવશે સિવાય કે `url` સંપૂર્ણ હોય.
+  // It can be convenient to set `baseURL` for an instance of axios to pass relative URLs
+  // to methods of that instance.
+  // baseUrl ને તમે 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` વિનંતી ડેટા સર્વર પર મોકલવામાં આવે તે પહેલાં તેમાં ફેરફાર કરવાની મંજૂરી આપે છે.
+  // ઉપર આપેલી પદ્ધતિ આ 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
+  // header 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
+  // NOTE: params that are null or undefined are not rendered in the URL.
+  params: {
+    ID: 12345
+  },
+
+  // `paramsSerializer` is an optional config in charge of serializing `params`
+  paramsSerializer: {
+    encode?: (param: string): string => { /* Do custom ops here and return transformed string */ }, // custom encoder function; sends Key/Values in an iterative fashion
+    serialize?: (params: Record<string, any>, options?: ParamsSerializerOptions ), // mimic pre 1.x behavior and send entire params object to a custom serializer func. Allows consumer to control how params are serialized.
+    indexes: false // array indexes format (null - no brackets, false (default) - empty brackets, true - 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
+  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` વિનંતીનો સમય સમાપ્ત થાય તે પહેલાં મિલિસેકન્ડની સંખ્યા સ્પષ્ટ કરે છે.
+  //જો વિનંતી `timeout` કરતાં વધુ સમય લે, તો વિનંતી રદ કરવામાં આવશે..
+  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) {
+    /* ... */
+  },
+
+  // `auth` indicates that HTTP Basic auth should be used, and supplies credentials.
+  // આ એક `Authorization` હેડર સેટ કરશે, જે કોઈપણ અસ્તિત્વમાં છે તેને બદલી કરશે
+  // `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
+  responseEncoding: 'utf8', // default
+
+  // `xsrfCookieName` is the name of the cookie to use as a value for 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
+
+  // `onUploadProgress` allows handling of progress events for uploads
+  // browser only
+  onUploadProgress: function (progressEvent) {
+    // Do whatever you want with the native progress event
+  },
+
+  // `onDownloadProgress` allows handling of progress events for downloads
+  // browser only
+  onDownloadProgress: function (progressEvent) {
+    // Do whatever you want with the native progress event
+  },
+
+  // `maxContentLength` defines the max size of the http response content in bytes allowed in node.js
+  maxContentLength: 2000,
+
+  // `maxBodyLength` (માત્ર નોડ વિકલ્પ) http વિનંતી સામગ્રીના મહત્તમ કદને માન્ય બાઇટ્સમાં વ્યાખ્યાયિત કરે છે.
+  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.
+  // redirect કરતી વખતે વિનંતી વિકલ્પોને સમાયોજિત કરવા માટે આનો ઉપયોગ કરો.,
+  // 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.
+  // Disable if supplying a custom httpAgent/httpsAgent to manage proxying requests.
+  // `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',
+    port: 9000,
+    auth: {
+      username: 'mikeymike',
+      password: 'rapunz3l'
+    }
+  },
+
+  // `signal` and instance of AbortController can be used to cancel the request
+  signal: new AbortController().signal,
+
+  // (Deprecated) `cancelToken` specifies a cancel token that can also 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 
+  // આપમેળે. જો `true` પર સેટ કરેલ હોય તો 'content-encoding' હેડર પણ દૂર થશે 
+  // 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,
+  },
+
+  env: {
+    // FormData class તેની રીતે વાપરસે 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 મર્યાદા,
+    100 * 1024  // 100KB/s download મર્યાદા
+  ]
+}
+```
\ No newline at end of file
diff --git a/posts/gu/res_schema.md b/posts/gu/res_schema.md
new file mode 100644
index 0000000..288a184
--- /dev/null
+++ b/posts/gu/res_schema.md
@@ -0,0 +1,52 @@
+---
+title: 'Response Schema'
+prev_title: 'Request Config'
+prev_link: '/gu/docs/req_config'
+next_title: 'Config Defaults'
+next_link: '/gu/docs/config_defaults'
+---
+
+The response for a request contains the following information.
+
+```js
+{
+  // `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
+  // As of HTTP/2 status text is blank or unsupported.
+  // (HTTP/2 RFC: https://www.rfc-editor.org/rfc/rfc7540#section-8.1.2.4)
+  statusText: 'OK',
+
+  // `headers` the HTTP headers that the server responded with
+  // All header names are lower cased 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: {}
+}
+```
+
+`then` નો ઉપયોગ કરતી વખતે, તમને નીચે મુજબ પ્રતિભાવ મળશે:
+
+```js
+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);
+  });
+```
+
+When using `catch`, or passing a [rejection callback](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then) as second parameter of `then`, the response will be available through the `error` object as explained in the [Handling Errors](/docs/handling_errors) section.
\ No newline at end of file
diff --git a/posts/gu/sponsor.md b/posts/gu/sponsor.md
new file mode 100644
index 0000000..e025702
--- /dev/null
+++ b/posts/gu/sponsor.md
@@ -0,0 +1,88 @@
+---
+title: 'Sponsoring Axios'
+---
+
+અમારા પ્રોજેક્ટને ટેકો આપવા બદલ આભાર. તમારા પૈસા નો ઉપયોગ એક્સિઓસની જાળવણી અને વિકાસ માટે કરવામાં આવશે.
+
+અમારા મુખ્ય પ્રાયોજકોને લાભ તરીકે, અમે અમારી વેબસાઇટ પર તમારો લોગો અને સંક્ષિપ્ત માહિતી ઉમેરવાની તક પૂરી પાડીએ છીએ અને/અથવા [Readme.md](https://github.com/axios/axios)તમે પસંદ કરેલા સપોર્ટના સ્તર પર આધાર રાખીને.
+જો તમે પૈસા આપો છો તો આ પ્રક્રિયા સંપૂર્ણપણે સ્વચાલિત છે[OpenCollective.com]
+(https://opencollective.com/axios/contribute),
+તો તમારો logo ત્યાં મુકાસે 
+
+તમારો લોગો આ રીતે મૂકી શકાય છે:
+- મુખ્ય પૃષ્ઠ પરના કેરોયુઝલમાં
+- દસ્તાવેજીકરણના દરેક પૃષ્ઠ પરના કેરોયુઝલમાં
+- અમારા રેપોમાં [Readme.md](https://github.com/axios/axios) ની ટોચ પર
+
+કેરોયુઝલમાં સ્થાન આના પર આધાર રાખે છે:
+- પ્રાયોજકની નવીનતા (નવા પ્રાયોજકોને અસ્થાયી રૂપે ઉચ્ચ સ્થાન મળે છે)
+- પસંદ કરેલ સહાય સ્તર
+- આપેલી કુલ રકમ
+- પૈસા આપવાની સુસંગતતા
+
+જો તમે [GitHub](https://github.com/sponsors/axios) દ્વારા પૈસા આપો છો, તો જો તમે ઇચ્છો છો કે તમારા લોગોનો અમારા સપોર્ટ સ્તરો અનુસાર પ્રચાર કરવામાં આવે, તો તમારે પછીથી અમારો સંપર્ક કરવો પડશે.
+
+### Tiers
+
+See tiers list on [Open Collective](https://opencollective.com/axios/contribute)
+
+|                                             |   Bronze   |   Silver    |    Gold     |     Platinum     |
+|---------------------------------------------|:----------:|:-----------:|:-----------:|:----------------:|
+| Main page                                   | small logo | medium logo | large logo  | extra large logo |
+| Docs pages                                  |            |             | medium logo |    large logo    |
+| [Readme.md](https://github.com/axios/axios) |            |             | small logo  |   medium logo    |
+| Data merging from sponsor's GitHub repo     |            |      +      |      +      |        +         |
+| Links block in tooltip*                     |            |             |      +      |        +         |
+| Embedded Youtube video in tooltip*          |            |             |      +      |        +         |
+| Max description length in Readme.md (chars) |            |             |     100     |       150        |
+
+> નોંધ:
+> The extra links block and video can only be set via `sponsors.json`
+
+### Backer tier
+
+તમે એક કસ્ટમ ટાયર બનાવી શકો છો, આ કિસ્સામાં તમને સૌથી વધુ હાલના ટાયરના લાભો મળશે જેની કિંમત તમારા આપેલ પૈસા માં આવરી લેવામાં આવશે. carousel sponsors સૉર્ટ કરતી વખતે હાલના ટાયરથી ઉપરની વધારાની દાનની રકમ ધ્યાનમાં લેવામાં આવશે.
+
+### Sponsor logo 
+
+તમારો લોગો અમારા સર્વર પર ડાઉનલોડ કરવામાં આવશે, ઑપ્ટિમાઇઝ કરવામાં આવશે, ખાલી કિનારીઓ કાપવામાં આવશે અને પ્રમાણ જાળવી રાખીને તેનું કદ બદલવામાં આવશે.
+
+જો લોગોની પહોળાઈ તેની ઊંચાઈ કરતા નોંધપાત્ર રીતે વધારે હશે, તો ટેક્સ્ટ કૅપ્શન છુપાવવામાં આવશે,
+અને લોગો બધી ઉપલબ્ધ જગ્યા રોકશે. બધા સ્તરો માટે મહત્તમ લોગો ઊંચાઈ સમાન છે.
+
+### Description
+
+જો વર્ણન આપવામાં આવ્યું નથી, તો અમે તેને પ્રાયોજકના સાઇટ મેટા ટૅગ્સમાંથી વિશ્લેષણ કરવાનો પ્રયાસ કરીશું.
+
+### GitHub
+
+If you have set up your GitHub profile in your Open Collective profile,
+you can create a special repository called `axios-sponsor` with `sponsor.json` in its root to manage your sponsor profile data.
+
+The data from this file will be merged with your Open Collective profile which allows you to provide some extra info for advertising.
+
+`sponsor.json` has the following structure (each field is optional):
+
+```json
+    {
+      "displayName": "Umbrella Corporation",
+      "targetLink": "https://umbrellacorp.com/",
+      "alt": "Umbrella Corporation",
+      "image": "https://fake.com/logo.png",
+      "image_dark": "https://fake.com/logo_dark.png",
+      "description": "The Umbrella Corporation is a pharmaceutical company",  
+      "website": "https://google.com/",
+      "github": "https://github.com/fakeGitHib",
+      "icon": "https://fake.com/icon.png",
+      "video": "https://www.youtube.com/embed/isosE4Bowh0",
+      "twitter": "https://x.com/profile",
+      "showCaption": true,
+      "crown": false,
+      "hide": false,
+      "links": {
+        "link1": "https://google.com/",
+        "link2": "https://google.com/"
+      }
+    }
+```
+દર 24 કલાકે અમારું બેકએન્ડ વેબસાઇટ પર પ્રાયોજકોની સૂચિ અપડેટ કરતી વખતે આ ડેટા ખેંચશે.
\ No newline at end of file
diff --git a/posts/gu/translating.md b/posts/gu/translating.md
new file mode 100644
index 0000000..6415341
--- /dev/null
+++ b/posts/gu/translating.md
@@ -0,0 +1,47 @@
+---
+title: 'documentaion ભાષાંતર'
+---
+
+Axios ને શક્ય તેટલા વધુ લોકો સુધી સુલભ બનાવવા માટે, આ દસ્તાવેજો બધી ભાષાઓમાં વાંચી શકાય તે મહત્વપૂર્ણ છે. જે કોઈ દસ્તાવેજીકરણનો અનુવાદ કરવામાં મદદ કરવા માંગે છે તેની અમે હંમેશા પ્રશંસા કરીએ છીએ. આ માર્ગદર્શિકા આ ​​દસ્તાવેજીકરણમાં અનુવાદ ઉમેરવા માટેની સૂચનાઓ પ્રદાન કરે છે.
+
+## Structure
+
+Every translation is composed of a configuration file, `{language-shortcut}.lang.js` (for example, `en.lang.js` or `de.lang.js`) and the translated documentation files in `posts/{language-shortcut}/*.md` (for example `posts/en` or `posts/de`). `{language-shortcut}` should be replaced with your language's [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) two-letter code.
+
+
+## Configuring your language
+
+ - Copy `en.lang.js`.
+ - તમારી ભાષા માં નામ બદલો `{language-shortcut}.lang.js`.
+ - તમારી ભાષામાં, `display` ને તમારી ભાષાના નામથી બદલો. ઉદાહરણ તરીકે, જો તમે ગુજરાતી ભાષામાં અનુવાદ કરી રહ્યા છો, તો ગુજરાતી ને બદલે “Deutsch” મૂકો..
+ - Replace prefix with `/{language-shortcut}/`.
+ - Translate the values in the `p` and `t` fields.
+ - Translate all the properties labeled `text` in the sidebar. **Note:** Since the latest version of this documentation, links in the sidebar no longer need to be updated.
+
+### Registering the configuration
+
+એકવાર તમે તમારી ભાષા ગોઠવવાનું અને રૂપરેખાંકન ફાઇલમાં શબ્દસમૂહો અને લિંક્સનું ભાષાંતર કરવાનું પૂર્ણ કરી લો, પછી તમારે તેને રૂટ રૂપરેખાંકનમાં રજીસ્ટર કરવાની જરૂર પડશે. આ કરવા માટે, `inert.config.js` ખોલો અને ટોચની નજીક નીચેની લાઇન ઉમેરો:
+
+```js
+const {language-shortcut}Config = require('./{language-shortcut}.config.js');
+```
+
+ચોક્કસ,બદલવાનું યાદ રાખો `{language-shortcut}` with the correct [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) code (in the variable name, too!).
+
+હવે, `langs` કોન્સ્ટન્ટ શોધો. જો આ કોન્સ્ટન્ટ તમારા `require` સ્ટેટમેન્ટની ઉપર સ્થિત હોય, તો તમારા `require` સ્ટેટમેન્ટને તેની ઉપર ખસેડો. `langs` લિસ્ટમાં, નીચેનો ઑબ્જેક્ટ ઉમેરો:
+
+```js
+const langs = [
+  ...
+  {
+    name: 'Some name that uniquely identifies your language, for example "English" or "German"',
+    prefix: "The same prefix as in the configuration file",
+    config: {language-shortcut}Config // The configuration object you imported earlier
+  }
+  ...
+];
+```
+
+હવે, તમે ફાઇલોનું ભાષાંતર શરૂ કરી શકો છો. `posts/en` ફોલ્ડરને નવા `posts/{language-shortcut}` ફોલ્ડરમાં કોપી કરો અને બધી ફાઇલોનો અનુવાદ કરો (અલબત્ત, ફાઇલનામોનો અનુવાદ કરશો નહીં).
+
+જો તમને કોઈ સમસ્યા આવે, તો નિઃસંકોચ [create an issue](https://github.com/axios/axios-docs/issues/new/choose).
\ No newline at end of file
diff --git a/posts/gu/urlencoded.md b/posts/gu/urlencoded.md
new file mode 100644
index 0000000..0e3fd2d
--- /dev/null
+++ b/posts/gu/urlencoded.md
@@ -0,0 +1,119 @@
+---
+title: 'URL-Encoding Bodies'
+prev_title: 'Cancellation'
+prev_link: '/gu/docs/cancellation'
+next_title: 'Multipart Bodies'
+next_link: '/gu/docs/multipart'
+---
+
+By default, axios serializes JavaScript objects to `JSON`. To send data in the `application/x-www-form-urlencoded` format instead,તમે નીચેનામાંથી એક અભિગમનો ઉપયોગ કરી શકો છો.
+
+### Browser
+
+In a browser, you can use the [`URLSearchParams`](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams) API as follows:
+
+```js
+const params = new URLSearchParams();
+params.append('param1', 'value1');
+params.append('param2', 'value2');
+axios.post('/foo', params);
+```
+
+> નોંધ: `URLSearchParams` is not supported by all browsers (see [caniuse.com](http://www.caniuse.com/#feat=urlsearchparams)), but there is a [polyfill](https://github.com/WebReflection/url-search-params) available (make sure to polyfill the global environment).
+
+Alternatively, you can encode data using the [`qs`](https://github.com/ljharb/qs) library:
+
+```js
+const qs = require('qs');
+axios.post('/foo', qs.stringify({ 'bar': 123 }));
+```
+
+Or in another way (ES6),
+
+```js
+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);
+```
+
+### Node.js
+
+#### Query string
+
+In node.js, you can use the [`querystring`](https://nodejs.org/api/querystring.html) module as follows:
+
+```js
+const querystring = require('querystring');
+axios.post('http://something.com/', querystring.stringify({ foo: 'bar' }));
+```
+
+or ['URLSearchParams'](https://nodejs.org/api/url.html#url_class_urlsearchparams) from ['url module'](https://nodejs.org/api/url.html) as follows:
+
+```js
+const url = require('url');
+const params = new url.URLSearchParams({ foo: 'bar' });
+axios.post('http://something.com/', params.toString());
+```
+
+You can also use the [`qs`](https://github.com/ljharb/qs) library.
+
+> Note: The `qs` library is preferable if you need to stringify nested objects, as the `querystring` method has known issues with that use case (https://github.com/nodejs/node-v0.x-archive/issues/1665).
+
+### 🆕 Automatic serialization
+
+Axios will automatically serialize the data object to urlencoded format if the `content-type` header is set to `application/x-www-form-urlencoded`.
+
+This works both in the browser and in `node.js`:
+
+```js
+const data = {
+  x: 1,
+  arr: [1, 2, 3],
+  arr2: [1, [2], 3],
+  users: [{name: 'Peter', surname: 'Griffin'}, {name: 'Thomas', surname: 'Anderson'}],
+};
+
+await axios.post('https://postman-echo.com/post', data,
+  {headers: {'content-type': 'application/x-www-form-urlencoded'}}
+);
+```
+
+The server will handle it as 
+
+```js
+  {
+    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'
+  }
+````
+
+If your server framework's request body parser (like `body-parser` of `express.js`) supports nested objects decoding, 
+you will automatically receive the same server object that you submitted.
+
+Echo server example (`express.js`) :
+
+```js
+  var app = express();
+  
+  app.use(bodyParser.urlencoded({ extended: true })); // support url-encoded bodies
+  
+  app.post('/', function (req, res, next) {
+     res.send(JSON.stringify(req.body));
+  });
+
+  server = app.listen(3000);
+```