diff --git a/packages/bruno-app/package.json b/packages/bruno-app/package.json
index 7f1dfe7c54..5453ed1a8b 100644
--- a/packages/bruno-app/package.json
+++ b/packages/bruno-app/package.json
@@ -95,6 +95,7 @@
     "html-loader": "^3.0.1",
     "html-webpack-plugin": "^5.5.0",
     "mini-css-extract-plugin": "^2.4.5",
+    "oauth-1.0a": "^2.2.6",
     "postcss": "^8.4.35",
     "style-loader": "^3.3.1",
     "tailwindcss": "^3.4.1",
diff --git a/packages/bruno-app/src/components/RequestPane/Auth/AuthMode/index.js b/packages/bruno-app/src/components/RequestPane/Auth/AuthMode/index.js
index c12ceffe88..b6365588ca 100644
--- a/packages/bruno-app/src/components/RequestPane/Auth/AuthMode/index.js
+++ b/packages/bruno-app/src/components/RequestPane/Auth/AuthMode/index.js
@@ -13,7 +13,7 @@ const AuthMode = ({ item, collection }) => {
   const onDropdownCreate = (ref) => (dropdownTippyRef.current = ref);
   const authMode = item.draft ? get(item, 'draft.request.auth.mode') : get(item, 'request.auth.mode');
 
-  const authModes = ['awsv4', 'basic', 'bearer', 'digest', 'oauth2', 'inherit', 'none'];
+  const authModes = ['awsv4', 'basic', 'bearer', 'digest', 'oauth1', 'oauth2', 'inherit', 'none'];
 
   const Icon = forwardRef((props, ref) => {
     return (
diff --git a/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/StyledWrapper.js b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/StyledWrapper.js
new file mode 100644
index 0000000000..856f35b9b9
--- /dev/null
+++ b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/StyledWrapper.js
@@ -0,0 +1,16 @@
+import styled from 'styled-components';
+
+const Wrapper = styled.div`
+  label {
+    font-size: 0.8125rem;
+  }
+  .single-line-editor-wrapper {
+    max-width: 400px;
+    padding: 0.15rem 0.4rem;
+    border-radius: 3px;
+    border: solid 1px ${(props) => props.theme.input.border};
+    background-color: ${(props) => props.theme.input.bg};
+  }
+`;
+
+export default Wrapper;
diff --git a/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/index.js b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/index.js
new file mode 100644
index 0000000000..7768ef5d2b
--- /dev/null
+++ b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/index.js
@@ -0,0 +1,82 @@
+import React, { useRef } from 'react';
+import get from 'lodash/get';
+import { useTheme } from 'providers/Theme';
+import { useDispatch } from 'react-redux';
+import SingleLineEditor from 'components/SingleLineEditor';
+import { updateAuth } from 'providers/ReduxStore/slices/collections';
+import { sendRequest, saveRequest } from 'providers/ReduxStore/slices/collections/actions';
+import StyledWrapper from './StyledWrapper';
+import { inputsConfig } from './inputsConfig';
+import Dropdown from 'components/Dropdown';
+
+const OAuth1 = ({ item, collection }) => {
+  const dispatch = useDispatch();
+  const { storedTheme } = useTheme();
+  
+  const oAuth1 = item.draft ? get(item, 'draft.request.auth.oauth1', {}) : get(item, 'request.auth.oauth1', {});
+
+  const handleRun = () => dispatch(sendRequest(item, collection.uid));
+  const handleSave = () => dispatch(saveRequest(item.uid, collection.uid));
+
+  const dropdownTippyRef = useRef();
+  const onDropdownCreate = (ref) => (dropdownTippyRef.current = ref);
+
+  const handleChange = (key, val) => {
+    console.log(key, val);
+    dispatch(
+      updateAuth({
+        mode: 'oauth1',
+        collectionUid: collection.uid,
+        itemUid: item.uid,
+        content: {
+          ...oAuth1,  [key]: val
+        }
+      })
+    );
+  }
+
+  return (
+    <StyledWrapper className="mt-2 flex w-full gap-4 flex-col">
+      {inputsConfig.map((input) => {
+        const { key, label, options } = input;
+        return (
+          <div className="flex flex-col w-full gap-1" key={`input-${key}`}>
+            <label className="block font-medium">{label}</label>
+            {options ?
+              <div className="inline-flex items-center cursor-pointer grant-type-mode-selector w-fit">
+                <Dropdown icon={(<div>{ oAuth1[key]  || '<select>'}</div>)}
+                          onCreate={onDropdownCreate}
+                          placement="bottom-end"
+                          children={options.map((option) => (
+                            <div
+                              className="dropdown-item"
+                              onClick={() => {
+                                handleChange(key, option.key ? option.key : option);
+                              }}>
+                              {option.value ? option.value : option}
+                            </div>
+                          ))}
+                />
+              </div>
+
+              :
+              <div className="single-line-editor-wrapper">
+                <SingleLineEditor
+                  value={oAuth1[key] || ''}
+                  theme={storedTheme}
+                  onSave={handleSave}
+                  onChange={(val) => handleChange(key, val)}
+                  onRun={handleRun}
+                  collection={collection}
+                  item={item}
+                />
+              </div>
+            }
+          </div>
+        );
+      })}
+    </StyledWrapper>
+  );
+};
+
+export default OAuth1;
diff --git a/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/inputsConfig.js b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/inputsConfig.js
new file mode 100644
index 0000000000..3706d043d3
--- /dev/null
+++ b/packages/bruno-app/src/components/RequestPane/Auth/OAuth1/inputsConfig.js
@@ -0,0 +1,59 @@
+const inputsConfig = [
+  {
+    key: 'consumerKey',
+    label: 'Consumer Key',
+  },
+  {
+    key: 'consumerSecret',
+    label: 'Consumer Secret'
+  },
+  {
+    key: 'requestTokenUrl',
+    label: 'Request Token URL'
+  },
+  {
+    key: 'accessTokenUrl',
+    label: 'Access Token URL'
+  },
+  {
+    key: 'authorizeUrl',
+    label: 'Authorize URL'
+  },
+  {
+    key: 'callbackUrl',
+    label: 'Callback URL'
+  },
+  {
+    key: 'accessToken',
+    label: 'Access Token'
+  },
+  {
+    key: 'accessTokenSecret',
+    label: 'Access Token Secret'
+  },
+  {
+    key: 'authorizationMethod',
+    label: 'Authorization Method',
+    options: [
+      {
+        key: 'authorizationHeader',
+        value: 'Authorization Header'
+      },
+      {
+        key: 'requestBody',
+        value: 'Request Body'
+      },
+      {
+        key: 'queryParam',
+        value: 'Query Parameter'
+      }
+    ]
+  },
+  {
+    key: 'signatureMethod',
+    label: 'Signature Method',
+    options: ['HMAC-SHA1', 'HMAC-SHA256', 'RSA-SHA1', 'PLAINTEXT']
+  }
+];
+
+export { inputsConfig };
diff --git a/packages/bruno-app/src/components/RequestPane/Auth/index.js b/packages/bruno-app/src/components/RequestPane/Auth/index.js
index 51a1450f1e..83392e481a 100644
--- a/packages/bruno-app/src/components/RequestPane/Auth/index.js
+++ b/packages/bruno-app/src/components/RequestPane/Auth/index.js
@@ -1,13 +1,14 @@
 import React from 'react';
 import get from 'lodash/get';
+import StyledWrapper from './StyledWrapper';
+import { humanizeRequestAuthMode } from 'utils/collections';
 import AuthMode from './AuthMode';
 import AwsV4Auth from './AwsV4Auth';
 import BearerAuth from './BearerAuth';
 import BasicAuth from './BasicAuth';
 import DigestAuth from './DigestAuth';
-import StyledWrapper from './StyledWrapper';
-import { humanizeRequestAuthMode } from 'utils/collections/index';
-import OAuth2 from './OAuth2/index';
+import OAuth1 from './OAuth1';
+import OAuth2 from './OAuth2';
 
 const Auth = ({ item, collection }) => {
   const authMode = item.draft ? get(item, 'draft.request.auth.mode') : get(item, 'request.auth.mode');
@@ -29,6 +30,9 @@ const Auth = ({ item, collection }) => {
       case 'digest': {
         return <DigestAuth collection={collection} item={item} />;
       }
+      case 'oauth1': {
+        return <OAuth1 collection={collection} item={item} />;
+      }
       case 'oauth2': {
         return <OAuth2 collection={collection} item={item} />;
       }
diff --git a/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js b/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
index ca66ac2eac..951b01fe6d 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
@@ -473,6 +473,10 @@ export const collectionsSlice = createSlice({
               item.draft.request.auth.mode = 'digest';
               item.draft.request.auth.digest = action.payload.content;
               break;
+            case 'oauth1':
+              item.draft.request.auth.mode = 'oauth1';
+              item.draft.request.auth.oauth1 = action.payload.content;
+              break;
             case 'oauth2':
               item.draft.request.auth.mode = 'oauth2';
               item.draft.request.auth.oauth2 = action.payload.content;
diff --git a/packages/bruno-app/src/utils/collections/index.js b/packages/bruno-app/src/utils/collections/index.js
index 7dc9f2e578..91fe1943e2 100644
--- a/packages/bruno-app/src/utils/collections/index.js
+++ b/packages/bruno-app/src/utils/collections/index.js
@@ -335,6 +335,20 @@ export const transformCollectionToSaveToExportAsFile = (collection, options = {}
               password: get(si.request, 'auth.digest.password', '')
             };
             break;
+          case 'oauth1':
+            di.request.auth.oauth1 = {
+              username: get(si.request, 'auth.oauth1.username', ''),
+              consumerKey: get(si.request, 'auth.oauth1.consumerKey', ''),
+              consumerSecret: get(si.request, 'auth.oauth1.consumerSecret', ''),
+              requestTokenUrl: get(si.request, 'auth.oauth1.requestTokenUrl', ''),
+              accessTokenUrl: get(si.request, 'auth.oauth1.accessTokenUrl', ''),
+              authorizeUrl: get(si.request, 'auth.oauth1.authorizeUrl', ''),
+              callbackUrl: get(si.request, 'auth.oauth1.callbackUrl', ''),
+              accessToken: get(si.request, 'auth.oauth1.accessToken', ''),
+              accessTokenSecret: get(si.request, 'auth.oauth1.accessTokenSecret', ''),
+              signatureMethod: get(si.request, 'auth.oauth1.signatureMethod', '')
+            };
+            break;
           case 'oauth2':
             let grantType = get(si.request, 'auth.oauth2.grantType', '');
             switch (grantType) {
@@ -657,6 +671,10 @@ export const humanizeRequestAuthMode = (mode) => {
       label = 'Digest Auth';
       break;
     }
+    case 'oauth1': {
+      label = 'OAuth 1.0';
+      break;
+    }
     case 'oauth2': {
       label = 'OAuth 2.0';
       break;
diff --git a/packages/bruno-electron/src/ipc/network/index.js b/packages/bruno-electron/src/ipc/network/index.js
index bbdcdb55b6..83a8bd4f59 100644
--- a/packages/bruno-electron/src/ipc/network/index.js
+++ b/packages/bruno-electron/src/ipc/network/index.js
@@ -31,6 +31,7 @@ const { addDigestInterceptor } = require('./digestauth-helper');
 const { shouldUseProxy, PatchedHttpsProxyAgent } = require('../../utils/proxy-util');
 const { chooseFileToSave, writeBinaryFile, writeFile } = require('../../utils/filesystem');
 const { getCookieStringForUrl, addCookieToJar, getDomainsWithCookies } = require('../../utils/cookies');
+const { addOAuth1Authorization } = require('./oauth1-helper');
 const {
   resolveOAuth2AuthorizationCodeAccessToken,
   transformClientCredentialsRequest,
@@ -211,6 +212,10 @@ const configureRequest = async (
   }
 
   const axiosInstance = makeAxiosInstance();
+  if (request.oauth1) {
+    interpolateVars(request, envVars, runtimeVariables, processEnvVars);
+    await addOAuth1Authorization(request);
+  }
 
   if (request.oauth2) {
     let requestCopy = cloneDeep(request);
diff --git a/packages/bruno-electron/src/ipc/network/interpolate-vars.js b/packages/bruno-electron/src/ipc/network/interpolate-vars.js
index 899b3d0f29..a30a625aa8 100644
--- a/packages/bruno-electron/src/ipc/network/interpolate-vars.js
+++ b/packages/bruno-electron/src/ipc/network/interpolate-vars.js
@@ -132,6 +132,10 @@ const interpolateVars = (request, envVars = {}, runtimeVariables = {}, processEn
     delete request.auth;
   }
 
+  if (request?.oauth1) {
+    Object.keys(request.oauth1).forEach(key => request.oauth1[key] = _interpolate(request.oauth1[key]));
+  }
+
   if (request?.oauth2?.grantType) {
     let username, password, scope, clientId, clientSecret;
     switch (request.oauth2.grantType) {
diff --git a/packages/bruno-electron/src/ipc/network/oauth1-helper.js b/packages/bruno-electron/src/ipc/network/oauth1-helper.js
new file mode 100644
index 0000000000..8bc7a8cc9f
--- /dev/null
+++ b/packages/bruno-electron/src/ipc/network/oauth1-helper.js
@@ -0,0 +1,174 @@
+const OAuth = require('oauth-1.0a');
+const crypto = require('crypto');
+const axios = require('axios');
+const { BrowserWindow } = require('electron');
+const { preferencesUtil } = require('../../store/preferences');
+
+const addOAuth1Authorization = async (request) => {
+
+  const oauth = OAuth({
+    consumer: {
+      key: request.oauth1.consumerKey,
+      secret: request.oauth1.consumerSecret
+    },
+    signature_method: request.oauth1.signatureMethod,
+    hash_function(base_string, key) {
+      return crypto
+        .createHmac('sha1', key)
+        .update(base_string)
+        .digest('base64');
+    }
+  });
+
+  // https://oauth.net/core/1.0a/#auth_step1
+  // 6.1.  Obtaining an Unauthorized Request Token
+  const getRequestToken = async () => {
+    try {
+      const requestTokenRequest = {
+        url: request.oauth1.requestTokenUrl,
+        method: 'POST',
+        data: {
+          oauth_callback: request.oauth1.callbackUrl
+        }
+      };
+      const signingToken = {
+        // requestToken does not need signing
+      }
+      const authHeader = oauth.toHeader(oauth.authorize(requestTokenRequest, signingToken));
+      const requestTokenResponse = await axios.post(requestTokenRequest.url, requestTokenRequest.data, { headers: authHeader });
+      const formattedResponse = Object.fromEntries(new URLSearchParams(requestTokenResponse.data));
+      console.info('Request Token Response:', requestTokenResponse.status, formattedResponse);
+      return formattedResponse
+    } catch (error) {
+      console.error('Error obtaining request token:', error.response.data);
+      throw error;
+    }
+  };
+
+  // https://oauth.net/core/1.0a/#auth_step2
+  // 6.2.  Obtaining User Authorization
+  const requestUserAuthorization = (requestTokenResponse) => {
+    return new Promise(async (resolve, reject) => {
+      const matchesCallbackUrl = (url, callbackUrl) => {
+        return url ? url.href.startsWith(callbackUrl.href) : false;
+      };
+
+      let finalUrl;
+      let window;
+      const onRedirect = (_, url) => {
+        try {
+          if (matchesCallbackUrl(new URL(url), new URL(request.oauth1.callbackUrl))) {
+            finalUrl = url;
+            window.close();
+          }
+        } catch (error) {
+          console.error("Error parsing redirect URL:", error);
+        }
+      };
+
+      try {
+        window = new BrowserWindow({
+          webPreferences: {
+            nodeIntegration: false
+          }
+        });
+        window.on('ready-to-show', () => window.show());
+        window.webContents.on('certificate-error', (event, url, error, certificate, callback) => {
+          event.preventDefault();
+          callback(!preferencesUtil.shouldVerifyTls());
+        });
+        window.webContents.on('did-navigate', onRedirect);
+        window.webContents.on('will-redirect', onRedirect);
+
+        window.on('close', () => {
+          window.webContents.removeListener('did-navigate', onRedirect);
+          window.webContents.removeListener('will-redirect', onRedirect);
+
+          if (finalUrl) {
+            try {
+              const callbackUrlWithVerifier = new URL(finalUrl);
+              const params = Object.fromEntries(callbackUrlWithVerifier.searchParams);
+              console.log("Authorization successful:", params);
+              resolve(params);
+            } catch (error) {
+              console.error("Error processing final URL:", error);
+              reject(new Error('Invalid authorization response'));
+            }
+          } else {
+            console.warn('Authorization window closed by user');
+            reject(new Error('Authorization window closed by user'));
+          }
+        });
+
+        const authorizeUrl = new URL(request.oauth1.authorizeUrl);
+        authorizeUrl.searchParams.append('oauth_token', requestTokenResponse.oauth_token);
+
+        window.loadURL(authorizeUrl.toString()).catch((error) => {
+          console.error("Error loading authorization URL:", error);
+          reject(new Error('Failed to load authorization URL'));
+          window.close();
+        });
+      } catch (error) {
+        console.error("Error during user authorization setup:", error);
+        if (window) window.close();
+        reject(new Error('User authorization setup failed'));
+      }
+    });
+  };
+
+  // https://oauth.net/core/1.0/#auth_step3
+  // 6.3.  Obtaining an Access Token
+  const exchangeRequestTokenForAccessToken = async (requestTokenResponse, authorizationResponse) => {
+    try {
+      const accessTokenRequestData = {
+        url: request.oauth1.accessTokenUrl,
+        method: 'POST',
+        data: {
+          oauth_token: authorizationResponse.oauth_token,
+          oauth_verifier: authorizationResponse.oauth_verifier
+        }
+      };
+      const signingToken = {
+        key: request.oauth1.consumerSecret,
+        secret: requestTokenResponse.oauth_token_secret
+      }
+      const authHeader = oauth.toHeader(oauth.authorize(accessTokenRequestData, signingToken));
+      const accessTokenRequestUrl = new URL(accessTokenRequestData.url);
+      const accessTokenResponse = await axios.post(accessTokenRequestUrl.toString(), {},{ headers: authHeader });
+      const formattedResponse = Object.fromEntries(new URLSearchParams(accessTokenResponse.data));
+      console.log("Access Token Response", accessTokenResponse.status, formattedResponse);
+      return formattedResponse;
+    } catch (error) {
+      console.error("Invalid Access Token Response", error.code, error.message);
+      throw error;
+    }
+  };
+
+  // https://oauth.net/core/1.0/#anchor13
+  // 7.  Accessing Protected Resources
+  const addAuthorizationToRequest = (request, accessTokenResponse) => {
+    const requestData = {
+      url: request.url,
+      method: request.method,
+      data: request.data
+    }
+    const token = {
+      key: accessTokenResponse.oauth_token,
+      secret: accessTokenResponse.oauth_token_secret
+    }
+    const authHeader = oauth.toHeader(oauth.authorize(requestData, token));
+    request.headers['Authorization'] = authHeader.Authorization
+  }
+
+  try {
+    const requestTokenResponse = await getRequestToken();
+    const authorizationResponse = await requestUserAuthorization(requestTokenResponse);
+    const accessTokenResponse = await exchangeRequestTokenForAccessToken(requestTokenResponse, authorizationResponse);
+    addAuthorizationToRequest(request, accessTokenResponse);
+  } catch (error) {
+    console.error("OAuth flow failed", error.message);
+    throw error;
+  }
+};
+
+module.exports = { addOAuth1Authorization };
\ No newline at end of file
diff --git a/packages/bruno-electron/src/ipc/network/prepare-request.js b/packages/bruno-electron/src/ipc/network/prepare-request.js
index 74cb85ac6e..96119b335b 100644
--- a/packages/bruno-electron/src/ipc/network/prepare-request.js
+++ b/packages/bruno-electron/src/ipc/network/prepare-request.js
@@ -246,6 +246,20 @@ const setAuthHeaders = (axiosRequest, request, collectionRoot) => {
           password: get(request, 'auth.digest.password')
         };
         break;
+      case 'oauth1':
+        axiosRequest.oauth1 = {
+          consumerKey: get(request, 'auth.oauth1.consumerKey'),
+          consumerSecret: get(request, 'auth.oauth1.consumerSecret'),
+          requestTokenUrl: get(request, 'auth.oauth1.requestTokenUrl'),
+          accessTokenUrl: get(request, 'auth.oauth1.accessTokenUrl'),
+          authorizeUrl: get(request, 'auth.oauth1.authorizeUrl'),
+          callbackUrl: get(request, 'auth.oauth1.callbackUrl'),
+          accessToken: get(request, 'auth.oauth1.accessToken'),
+          accessTokenSecret: get(request, 'auth.oauth1.accessTokenSecret'),
+          authorizationMethod: get(request, 'auth.oauth1.authorizationMethod'),
+          signatureMethod: get(request, 'auth.oauth1.signatureMethod')
+        }
+        break;
       case 'oauth2':
         const grantType = get(request, 'auth.oauth2.grantType');
         switch (grantType) {
diff --git a/packages/bruno-lang/v2/src/bruToJson.js b/packages/bruno-lang/v2/src/bruToJson.js
index 08e4332c59..11f2c27038 100644
--- a/packages/bruno-lang/v2/src/bruToJson.js
+++ b/packages/bruno-lang/v2/src/bruToJson.js
@@ -23,7 +23,7 @@ const { outdentString } = require('../../v1/src/utils');
  */
 const grammar = ohm.grammar(`Bru {
   BruFile = (meta | http | query | params | headers | auths | bodies | varsandassert | script | tests | docs)*
-  auths = authawsv4 | authbasic | authbearer | authdigest | authOAuth2
+  auths = authawsv4 | authbasic | authbearer | authdigest | authOAuth1 | authOAuth2
   bodies = bodyjson | bodytext | bodyxml | bodysparql | bodygraphql | bodygraphqlvars | bodyforms | body
   bodyforms = bodyformurlencoded | bodymultipart
   params = paramspath | paramsquery
@@ -87,6 +87,7 @@ const grammar = ohm.grammar(`Bru {
   authbasic = "auth:basic" dictionary
   authbearer = "auth:bearer" dictionary
   authdigest = "auth:digest" dictionary
+  authOAuth1 = "auth:oauth1" dictionary
   authOAuth2 = "auth:oauth2" dictionary
 
   body = "body" st* "{" nl* textblock tagend
@@ -433,6 +434,35 @@ const sem = grammar.createSemantics().addAttribute('ast', {
       }
     };
   },
+  authOAuth1(_1, dictionary) {
+    const auth = mapPairListToKeyValPairs(dictionary.ast, false);
+    const consumerKey = _.find(auth, { name: 'consumerKey' });
+    const consumerSecret = _.find(auth, { name: 'consumerSecret' });
+    const requestTokenUrl = _.find(auth, { name: 'requestTokenUrl' });
+    const accessTokenUrl = _.find(auth, { name: 'accessTokenUrl' });
+    const authorizeUrl = _.find(auth, { name: 'authorizeUrl' });
+    const callbackUrl = _.find(auth, { name: 'callbackUrl' });
+    const accessToken = _.find(auth, { name: 'accessToken' });
+    const accessTokenSecret = _.find(auth, { name: 'accessTokenSecret' });
+    const authorizationMethod = _.find(auth, { name: 'authorizationMethod' });
+    const signatureMethod = _.find(auth, { name: 'signatureMethod' });
+    return {
+      auth: {
+        oauth1: {
+          consumerKey: consumerKey ? consumerKey.value : '',
+          consumerSecret: consumerSecret ? consumerSecret.value : '',
+          requestTokenUrl: requestTokenUrl ? requestTokenUrl.value : '',
+          accessTokenUrl: accessTokenUrl ? accessTokenUrl.value : '',
+          authorizeUrl: authorizeUrl ? authorizeUrl.value : '',
+          callbackUrl: callbackUrl ? callbackUrl.value : '',
+          accessToken: accessToken ? accessToken.value : '',
+          accessTokenSecret: accessTokenSecret ? accessTokenSecret.value : '',
+          authorizationMethod: authorizationMethod ? authorizationMethod.value : '',
+          signatureMethod: signatureMethod ? signatureMethod.value : ''
+        }
+      }
+    };
+  },
   authOAuth2(_1, dictionary) {
     const auth = mapPairListToKeyValPairs(dictionary.ast, false);
     const grantTypeKey = _.find(auth, { name: 'grant_type' });
diff --git a/packages/bruno-lang/v2/src/collectionBruToJson.js b/packages/bruno-lang/v2/src/collectionBruToJson.js
index 3c02a62255..4ef2d3e2a1 100644
--- a/packages/bruno-lang/v2/src/collectionBruToJson.js
+++ b/packages/bruno-lang/v2/src/collectionBruToJson.js
@@ -4,7 +4,7 @@ const { outdentString } = require('../../v1/src/utils');
 
 const grammar = ohm.grammar(`Bru {
   BruFile = (meta | query | headers | auth | auths | vars | script | tests | docs)*
-  auths = authawsv4 | authbasic | authbearer | authdigest | authOAuth2
+  auths = authawsv4 | authbasic | authbearer | authdigest | authOAuth1 | authOAuth2
 
   nl = "\\r"? "\\n"
   st = " " | "\\t"
@@ -42,6 +42,7 @@ const grammar = ohm.grammar(`Bru {
   authbasic = "auth:basic" dictionary
   authbearer = "auth:bearer" dictionary
   authdigest = "auth:digest" dictionary
+  authOAuth1 = "auth:oauth1" dictionary
   authOAuth2 = "auth:oauth2" dictionary
 
   script = scriptreq | scriptres
@@ -243,6 +244,35 @@ const sem = grammar.createSemantics().addAttribute('ast', {
       }
     };
   },
+  authOAuth1(_1, dictionary) {
+    const auth = mapPairListToKeyValPairs(dictionary.ast, false);
+    const consumerKey = _.find(auth, { name: 'consumerKey' });
+    const consumerSecret = _.find(auth, { name: 'consumerSecret' });
+    const requestTokenUrl = _.find(auth, { name: 'requestTokenUrl' });
+    const accessTokenUrl = _.find(auth, { name: 'accessTokenUrl' });
+    const authorizeUrl = _.find(auth, { name: 'authorizeUrl' });
+    const callbackUrl = _.find(auth, { name: 'callbackUrl' });
+    const accessToken = _.find(auth, { name: 'accessToken' });
+    const accessTokenSecret = _.find(auth, { name: 'accessTokenSecret' });
+    const signatureMethod = _.find(auth, { name: 'signatureMethod' });
+    const authorizationMethod = _.find(auth, { name: 'authorizationMethod' });
+    return {
+      auth: {
+        oauth1: {
+          consumerKey: consumerKey ? consumerKey.value : '',
+          consumerSecret: consumerSecret ? consumerSecret.value : '',
+          requestTokenUrl: requestTokenUrl ? requestTokenUrl.value : '',
+          accessTokenUrl: accessTokenUrl ? accessTokenUrl.value : '',
+          authorizeUrl: authorizeUrl ? authorizeUrl.value : '',
+          callbackUrl: callbackUrl ? callbackUrl.value : '',
+          accessToken: accessToken ? accessToken.value : '',
+          accessTokenSecret: accessTokenSecret ? accessTokenSecret.value : '',
+          authorizationMethod: authorizationMethod ? authorizationMethod.value : '',
+          signatureMethod: signatureMethod ? signatureMethod.value : ''
+        }
+      }
+    };
+  },
   authOAuth2(_1, dictionary) {
     const auth = mapPairListToKeyValPairs(dictionary.ast, false);
     const grantTypeKey = _.find(auth, { name: 'grant_type' });
diff --git a/packages/bruno-lang/v2/src/jsonToBru.js b/packages/bruno-lang/v2/src/jsonToBru.js
index dd3be5947f..6345bb0fe9 100644
--- a/packages/bruno-lang/v2/src/jsonToBru.js
+++ b/packages/bruno-lang/v2/src/jsonToBru.js
@@ -153,6 +153,22 @@ ${indentString(`username: ${auth?.digest?.username || ''}`)}
 ${indentString(`password: ${auth?.digest?.password || ''}`)}
 }
 
+`;
+  }
+  if (auth && auth.oauth1) {
+    bru += `auth:oauth1 {
+${indentString(`consumerKey: ${auth?.oauth1?.consumerKey || ''}`)}
+${indentString(`consumerSecret: ${auth?.oauth1?.consumerSecret || ''}`)}
+${indentString(`requestTokenUrl: ${auth?.oauth1?.requestTokenUrl || ''}`)}
+${indentString(`accessTokenUrl: ${auth?.oauth1?.accessTokenUrl || ''}`)}
+${indentString(`authorizeUrl: ${auth?.oauth1?.authorizeUrl || ''}`)}
+${indentString(`callbackUrl: ${auth?.oauth1?.callbackUrl || ''}`)}
+${indentString(`accessToken: ${auth?.oauth1?.accessToken || ''}`)}
+${indentString(`accessTokenSecret: ${auth?.oauth1?.accessTokenSecret || ''}`)}
+${indentString(`authorizationMethod: ${auth?.oauth1?.authorizationMethod || ''}`)}
+${indentString(`signatureMethod: ${auth?.oauth1?.signatureMethod || ''}`)}
+}
+
 `;
   }
 
diff --git a/packages/bruno-lang/v2/src/jsonToCollectionBru.js b/packages/bruno-lang/v2/src/jsonToCollectionBru.js
index 11df88da4f..defd52a3c1 100644
--- a/packages/bruno-lang/v2/src/jsonToCollectionBru.js
+++ b/packages/bruno-lang/v2/src/jsonToCollectionBru.js
@@ -111,6 +111,23 @@ ${indentString(`username: ${auth.digest.username}`)}
 ${indentString(`password: ${auth.digest.password}`)}
 }
 
+`;
+  }
+
+  if (auth && auth.oauth1) {
+    bru += `auth:oauth1 {
+${indentString(`consumerKey: ${auth?.oauth1?.consumerKey || ''}`)}
+${indentString(`consumerSecret: ${auth?.oauth1?.consumerSecret || ''}`)}
+${indentString(`requestTokenUrl: ${auth?.oauth1?.requestTokenUrl || ''}`)}
+${indentString(`accessTokenUrl: ${auth?.oauth1?.accessTokenUrl || ''}`)}
+${indentString(`authorizeUrl: ${auth?.oauth1?.authorizeUrl || ''}`)}
+${indentString(`callbackUrl: ${auth?.oauth1?.callbackUrl || ''}`)}
+${indentString(`accessToken: ${auth?.oauth1?.accessToken || ''}`)}
+${indentString(`accessTokenSecret: ${auth?.oauth1?.accessTokenSecret || ''}`)}
+${indentString(`authorizationMethod: ${auth?.oauth1?.authorizationMethod || ''}`)}
+${indentString(`signatureMethod: ${auth?.oauth1?.signatureMethod || ''}`)}
+}
+
 `;
   }
 
diff --git a/packages/bruno-schema/src/collections/index.js b/packages/bruno-schema/src/collections/index.js
index eeb4e83d67..4016c45546 100644
--- a/packages/bruno-schema/src/collections/index.js
+++ b/packages/bruno-schema/src/collections/index.js
@@ -119,6 +119,21 @@ const authDigestSchema = Yup.object({
   .noUnknown(true)
   .strict();
 
+const oauth1Schema = Yup.object({
+  consumerKey: Yup.string().required(),
+  consumerSecret: Yup.string().required(),
+  requestTokenUrl: Yup.string().nullable(),
+  accessTokenUrl: Yup.string().nullable(),
+  authorizeUrl: Yup.string().nullable(),
+  callbackUrl: Yup.string().nullable(),
+  accessToken: Yup.string().nullable(),
+  accessTokenSecret: Yup.string().nullable(),
+  authorizationMethod: Yup.string().oneOf(['authorizationHeader', 'requestBody', 'queryParam']).nullable(),
+  signatureMethod: Yup.string().oneOf(['HMAC-SHA1', 'HMAC-SHA256', 'RSA-SHA1', 'PLAINTEXT']).nullable()
+})
+  .noUnknown(true)
+  .strict();
+
 const oauth2Schema = Yup.object({
   grantType: Yup.string()
     .oneOf(['client_credentials', 'password', 'authorization_code'])
@@ -179,12 +194,13 @@ const oauth2Schema = Yup.object({
 
 const authSchema = Yup.object({
   mode: Yup.string()
-    .oneOf(['inherit', 'none', 'awsv4', 'basic', 'bearer', 'digest', 'oauth2'])
+    .oneOf(['inherit', 'none', 'awsv4', 'basic', 'bearer', 'digest', 'oauth1', 'oauth2'])
     .required('mode is required'),
   awsv4: authAwsV4Schema.nullable(),
   basic: authBasicSchema.nullable(),
   bearer: authBearerSchema.nullable(),
   digest: authDigestSchema.nullable(),
+  oauth1: oauth1Schema.nullable(),
   oauth2: oauth2Schema.nullable()
 })
   .noUnknown(true)