diff --git a/package-lock.json b/package-lock.json
index 5a2b2a8e0..4ef0ae308 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -26860,6 +26860,7 @@
         "graphiql": "3.7.1",
         "graphql": "^16.6.0",
         "graphql-request": "^3.7.0",
+        "hexy": "^0.3.5",
         "httpsnippet": "^3.0.9",
         "i18next": "24.1.2",
         "idb": "^7.0.0",
diff --git a/packages/bruno-app/package.json b/packages/bruno-app/package.json
index a55bb9f64..1959a15dc 100644
--- a/packages/bruno-app/package.json
+++ b/packages/bruno-app/package.json
@@ -37,6 +37,7 @@
     "graphiql": "3.7.1",
     "graphql": "^16.6.0",
     "graphql-request": "^3.7.0",
+    "hexy": "^0.3.5",
     "httpsnippet": "^3.0.9",
     "i18next": "24.1.2",
     "idb": "^7.0.0",
diff --git a/packages/bruno-app/src/components/RequestPane/QueryUrl/index.js b/packages/bruno-app/src/components/RequestPane/QueryUrl/index.js
index cfbe77f58..a1d7dd86a 100644
--- a/packages/bruno-app/src/components/RequestPane/QueryUrl/index.js
+++ b/packages/bruno-app/src/components/RequestPane/QueryUrl/index.js
@@ -41,9 +41,9 @@ const QueryUrl = ({ item, collection, handleRun }) => {
     if (!editorRef.current?.editor) return;
     const editor = editorRef.current.editor;
     const cursor = editor.getCursor();
-  
+
     const finalUrl = value?.trim() ?? value;
-  
+
     dispatch(
       requestUrlChanged({
         itemUid: item.uid,
@@ -51,7 +51,7 @@ const QueryUrl = ({ item, collection, handleRun }) => {
         url: finalUrl
       })
     );
-  
+
     // Restore cursor position only if URL was trimmed
     if (finalUrl !== value) {
       setTimeout(() => {
@@ -81,7 +81,9 @@ const QueryUrl = ({ item, collection, handleRun }) => {
     }
   };
 
-  const handleCancelRequest = () => {
+  const handleCancelRequest = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
     dispatch(cancelRequest(item.cancelTokenUid, item, collection));
   };
 
@@ -92,7 +94,6 @@ const QueryUrl = ({ item, collection, handleRun }) => {
           <div className="flex items-center justify-center h-full w-16">
             <span className="text-xs text-indigo-500 font-bold">gRPC</span>
           </div>
-          
         ) : (
           <HttpMethodSelector method={method} onMethodSelect={onMethodSelect} />
         )}
@@ -126,15 +127,8 @@ const QueryUrl = ({ item, collection, handleRun }) => {
               handleGenerateCode(e);
             }}
           >
-            <IconCode
-              color={theme.requestTabs.icon.color}
-              strokeWidth={1.5}
-              size={22}
-              className={'cursor-pointer'}
-            />
-            <span className="infotiptext text-xs">
-              Generate Code
-            </span>
+            <IconCode color={theme.requestTabs.icon.color} strokeWidth={1.5} size={22} className="cursor-pointer" />
+            <span className="infotiptext text-xs">Generate Code</span>
           </div>
           <div
             title="Save Request"
@@ -155,10 +149,9 @@ const QueryUrl = ({ item, collection, handleRun }) => {
               Save <span className="shortcut">({saveShortcut})</span>
             </span>
           </div>
-
-          {isLoading ? (
+          {isLoading || item.response?.stream?.running ? (
             <IconSquareRoundedX
-              color={theme.requestTabPanel.url.icon}
+              color={theme.requestTabPanel.url.iconDanger}
               strokeWidth={1.5}
               size={22}
               data-testid="cancel-request-icon"
@@ -175,7 +168,11 @@ const QueryUrl = ({ item, collection, handleRun }) => {
         </div>
       </div>
       {generateCodeItemModalOpen && (
-        <GenerateCodeItem collectionUid={collection.uid} item={item} onClose={() => setGenerateCodeItemModalOpen(false)} />
+        <GenerateCodeItem
+          collectionUid={collection.uid}
+          item={item}
+          onClose={() => setGenerateCodeItemModalOpen(false)}
+        />
       )}
     </StyledWrapper>
   );
diff --git a/packages/bruno-app/src/components/RequestTabPanel/index.js b/packages/bruno-app/src/components/RequestTabPanel/index.js
index f7880e509..f8d3aba83 100644
--- a/packages/bruno-app/src/components/RequestTabPanel/index.js
+++ b/packages/bruno-app/src/components/RequestTabPanel/index.js
@@ -10,7 +10,7 @@ import GrpcResponsePane from 'components/ResponsePane/GrpcResponsePane';
 import Welcome from 'components/Welcome';
 import { findItemInCollection } from 'utils/collections';
 import { updateRequestPaneTabWidth } from 'providers/ReduxStore/slices/tabs';
-import { sendRequest } from 'providers/ReduxStore/slices/collections/actions';
+import { cancelRequest, sendRequest } from 'providers/ReduxStore/slices/collections/actions';
 import RequestNotFound from './RequestNotFound';
 import QueryUrl from 'components/RequestPane/QueryUrl/index';
 import GrpcQueryUrl from 'components/RequestPane/GrpcQueryUrl/index';
@@ -263,11 +263,17 @@ const RequestTabPanel = () => {
       return;
     }
 
-    dispatch(sendRequest(item, collection.uid)).catch((err) =>
-      toast.custom((t) => <NetworkError onClose={() => toast.dismiss(t.id)} />, {
-        duration: 5000
-      })
-    );
+    if (item.response?.stream?.running) {
+      dispatch(cancelRequest(item.cancelTokenUid, item, collection)).catch((err) =>
+        toast.custom((t) => <NetworkError onClose={() => toast.dismiss(t.id)} />, {
+          duration: 5000
+        }));
+    } else if (item.requestState !== 'sending' && item.requestState !== 'queued') {
+      dispatch(sendRequest(item, collection.uid)).catch((err) =>
+        toast.custom((t) => <NetworkError onClose={() => toast.dismiss(t.id)} />, {
+          duration: 5000
+        }));
+    }
   };
 
   // TODO: reaper, improve selection of panes
diff --git a/packages/bruno-app/src/components/ResponsePane/ResponseBookmark/index.js b/packages/bruno-app/src/components/ResponsePane/ResponseBookmark/index.js
index b00440c3a..9efe51f2e 100644
--- a/packages/bruno-app/src/components/ResponsePane/ResponseBookmark/index.js
+++ b/packages/bruno-app/src/components/ResponsePane/ResponseBookmark/index.js
@@ -12,12 +12,25 @@ import { getInitialExampleName } from 'utils/collections/index';
 import classnames from 'classnames';
 import StyledWrapper from './StyledWrapper';
 
+const getTitleText = ({ isResponseTooLarge, isStreamingResponse }) => {
+  if (isStreamingResponse) {
+    return 'Response Examples aren\'t supported in streaming responses yet.';
+  }
+
+  if (isResponseTooLarge) {
+    return 'Response size exceeds 5MB limit. Cannot save as example.';
+  }
+
+  return 'Save current response as example';
+};
+
 const ResponseBookmark = ({ item, collection, responseSize }) => {
   const dispatch = useDispatch();
   const [showSaveResponseExampleModal, setShowSaveResponseExampleModal] = useState(false);
   const response = item.response || {};
 
   const isResponseTooLarge = responseSize >= 5 * 1024 * 1024; // 5 MB
+  const isStreamingResponse = response.stream;
 
   // Only show for HTTP requests
   if (item.type !== 'http-request') {
@@ -96,19 +109,22 @@ const ResponseBookmark = ({ item, collection, responseSize }) => {
     toast.success(`Example "${name}" created successfully`);
   };
 
+  const disabledMessage = getTitleText({
+    isResponseTooLarge,
+    isStreamingResponse
+  });
+
   return (
     <>
       <StyledWrapper className="ml-2 flex items-center">
         <button
           onClick={handleSaveClick}
-          disabled={isResponseTooLarge}
+          disabled={isResponseTooLarge || isStreamingResponse}
           title={
-            isResponseTooLarge
-              ? 'Response size exceeds 5MB limit. Cannot save as example.'
-              : 'Save current response as example'
+            disabledMessage
           }
           className={classnames('p-1', {
-            'opacity-50 cursor-not-allowed': isResponseTooLarge
+            'opacity-50 cursor-not-allowed': isResponseTooLarge || isStreamingResponse
           })}
           data-testid="response-bookmark-btn"
         >
diff --git a/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/StyledWrapper.js b/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/StyledWrapper.js
new file mode 100644
index 000000000..c2fe19cfb
--- /dev/null
+++ b/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/StyledWrapper.js
@@ -0,0 +1,10 @@
+import styled from 'styled-components';
+
+const Wrapper = styled.div`
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: ${(props) => props.theme.requestTabPanel.responseStatus};
+  text-align: center;
+`;
+
+export default Wrapper;
diff --git a/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/index.js b/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/index.js
new file mode 100644
index 000000000..f434baccc
--- /dev/null
+++ b/packages/bruno-app/src/components/ResponsePane/ResponseStopWatch/index.js
@@ -0,0 +1,27 @@
+import React, { useState, useEffect } from 'react';
+import StyledWrapper from './StyledWrapper';
+
+const ResponseStopWatch = ({ startMillis }) => {
+  const [milliseconds, setMilliseconds] = useState(startMillis);
+
+  const tickInterval = 100;
+  const tick = () => {
+    setMilliseconds((_milliseconds) => _milliseconds + tickInterval);
+  };
+
+  useEffect(() => {
+    let timerID = setInterval(() => {
+      tick();
+    }, tickInterval);
+    return () => {
+      clearInterval(timerID);
+    };
+  }, []);
+
+  let seconds = milliseconds / 1000;
+  let secondsFormatted = `${seconds.toFixed(1)}s`;
+  let width = secondsFormatted.length * 0.4; // Calculate width manually to stop parent layout from "flickering" by changing width too fast
+  return <StyledWrapper className="ml-4" style={{ width: `${width}rem` }}>{secondsFormatted}</StyledWrapper>;
+};
+
+export default React.memo(ResponseStopWatch);
diff --git a/packages/bruno-app/src/components/ResponsePane/StatusCode/index.js b/packages/bruno-app/src/components/ResponsePane/StatusCode/index.js
index 222aad9e8..302b9a5e2 100644
--- a/packages/bruno-app/src/components/ResponsePane/StatusCode/index.js
+++ b/packages/bruno-app/src/components/ResponsePane/StatusCode/index.js
@@ -4,7 +4,7 @@ import statusCodePhraseMap from './get-status-code-phrase';
 import StyledWrapper from './StyledWrapper';
 
 // Todo: text-error class is not getting pulled in for 500 errors
-const StatusCode = ({ status, statusText }) => {
+const StatusCode = ({ status, statusText, isStreaming }) => {
   const getTabClassname = (status) => {
     return classnames('ml-2', {
       'text-ok': status >= 100 && status < 200,
@@ -17,7 +17,7 @@ const StatusCode = ({ status, statusText }) => {
 
   return (
     <StyledWrapper className={`response-status-code ${getTabClassname(status)}`} data-testid="response-status-code">
-      {status} {statusText || statusCodePhraseMap[status]}
+      {status} {statusText || statusCodePhraseMap[status]} {isStreaming ? ' - STREAMING' : null}
     </StyledWrapper>
   );
 };
diff --git a/packages/bruno-app/src/components/ResponsePane/WsResponsePane/WSMessagesList/index.js b/packages/bruno-app/src/components/ResponsePane/WsResponsePane/WSMessagesList/index.js
index 8762863db..ce1e51f70 100644
--- a/packages/bruno-app/src/components/ResponsePane/WsResponsePane/WSMessagesList/index.js
+++ b/packages/bruno-app/src/components/ResponsePane/WsResponsePane/WSMessagesList/index.js
@@ -195,7 +195,7 @@ const WSMessagesList = ({ order = -1, messages = [] }) => {
     <StyledWrapper className="ws-messages-list mt-1 flex flex-col">
       {ordered.map((msg, idx, src) => {
         const inFocus = order === -1 ? src.length - 1 === idx : idx === 0;
-        return <WSMessageItem inFocus={inFocus} id={idx} message={msg} />;
+        return <WSMessageItem key={msg.timestamp} inFocus={inFocus} id={idx} message={msg} />;
       })}
     </StyledWrapper>
   );
diff --git a/packages/bruno-app/src/components/ResponsePane/index.js b/packages/bruno-app/src/components/ResponsePane/index.js
index 6feb98bdb..b098570e2 100644
--- a/packages/bruno-app/src/components/ResponsePane/index.js
+++ b/packages/bruno-app/src/components/ResponsePane/index.js
@@ -23,6 +23,8 @@ import SkippedRequest from './SkippedRequest';
 import ClearTimeline from './ClearTimeline/index';
 import ResponseLayoutToggle from './ResponseLayoutToggle';
 import HeightBoundContainer from 'ui/HeightBoundContainer';
+import ResponseStopWatch from 'components/ResponsePane/ResponseStopWatch';
+import WSMessagesList from './WsResponsePane/WSMessagesList';
 
 const ResponsePane = ({ item, collection }) => {
   const dispatch = useDispatch();
@@ -71,6 +73,10 @@ const ResponsePane = ({ item, collection }) => {
   const getTabPanel = (tab) => {
     switch (tab) {
       case 'response': {
+        const isStream = item.response?.stream ?? false;
+        if (isStream) {
+          return <WSMessagesList order={-1} messages={item.response.data} />;
+        }
         return (
           <QueryResult
             item={item}
@@ -184,8 +190,10 @@ const ResponsePane = ({ item, collection }) => {
                 <ResponseClear item={item} collection={collection} />
                 <ResponseSave item={item} />
                 <ResponseBookmark item={item} collection={collection} responseSize={responseSize} />
-                <StatusCode status={response.status} />
-                <ResponseTime duration={response.duration} />
+                <StatusCode status={response.status} isStreaming={item.response?.stream?.running} />
+                {item.response?.stream?.running
+                  ? <ResponseStopWatch startMillis={response.duration} />
+                  : <ResponseTime duration={response.duration} />}
                 <ResponseSize size={responseSize} />
               </>
             ) : null}
diff --git a/packages/bruno-app/src/providers/App/useIpcEvents.js b/packages/bruno-app/src/providers/App/useIpcEvents.js
index 7ee1b8e02..b405269fa 100644
--- a/packages/bruno-app/src/providers/App/useIpcEvents.js
+++ b/packages/bruno-app/src/providers/App/useIpcEvents.js
@@ -15,9 +15,11 @@ import {
   collectionUnlinkEnvFileEvent,
   collectionUnlinkFileEvent,
   processEnvUpdateEvent,
+  requestCancelled,
   runFolderEvent,
   runRequestEvent,
-  scriptEnvironmentUpdateEvent
+  scriptEnvironmentUpdateEvent,
+  streamDataReceived
 } from 'providers/ReduxStore/slices/collections';
 import { collectionAddEnvFileEvent, openCollectionEvent, hydrateCollectionWithUiStateSnapshot, mergeAndPersistEnvironment } from 'providers/ReduxStore/slices/collections/actions';
 import toast from 'react-hot-toast';
@@ -137,8 +139,8 @@ const useIpcEvents = () => {
       dispatch(processEnvUpdateEvent(val));
     });
 
-    const removeConsoleLogListener = ipcRenderer.on('main:console-log', (val) => { 
-      console[val.type](...val.args);    
+    const removeConsoleLogListener = ipcRenderer.on('main:console-log', (val) => {
+      console[val.type](...val.args);
       dispatch(addLog({
         type: val.type,
         args: val.args,
@@ -188,6 +190,14 @@ const useIpcEvents = () => {
       dispatch(collectionAddOauth2CredentialsByUrl(payload));
     });
 
+    const removeHttpStreamNewDataListener = ipcRenderer.on('main:http-stream-new-data', (val) => {
+      dispatch(streamDataReceived(val));
+    });
+
+    const removeHttpStreamEndListener = ipcRenderer.on('main:http-stream-end', (val) => {
+      dispatch(requestCancelled(val));
+    });
+
     const removeCollectionLoadingStateListener = ipcRenderer.on('main:collection-loading-state-updated', (val) => {
       dispatch(updateCollectionLoadingState(val));
     });
@@ -212,6 +222,8 @@ const useIpcEvents = () => {
       removeGlobalEnvironmentsUpdatesListener();
       removeSnapshotHydrationListener();
       removeCollectionOauth2CredentialsUpdatesListener();
+      removeHttpStreamNewDataListener();
+      removeHttpStreamEndListener();
       removeCollectionLoadingStateListener();
       removePersistentEnvVariablesUpdateListener();
       removeSystemResourcesListener();
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 e6c7ae880..07e3792a8 100644
--- a/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
+++ b/packages/bruno-app/src/providers/ReduxStore/slices/collections/index.js
@@ -2,6 +2,7 @@ import { parseQueryParams, buildQueryString as stringifyQueryParams } from '@use
 import { uuid } from 'utils/common';
 import { find, map, forOwn, concat, filter, each, cloneDeep, get, set, findIndex } from 'lodash';
 import { createSlice } from '@reduxjs/toolkit';
+import { hexy as hexdump } from 'hexy';
 import {
   addDepth,
   areItemsTheSameExceptSeqUpdate,
@@ -380,9 +381,17 @@ export const collectionsSlice = createSlice({
       if (collection) {
         const item = findItemInCollection(collection, itemUid);
         if (item) {
-          item.response = null;
+          if (item.response?.stream?.running) {
+            item.response.stream.running = null;
+
+            const startTimestamp = item.requestSent.timestamp;
+            item.response.duration = startTimestamp ? Date.now() - startTimestamp : item.response.duration;
+            item.response.data = [{ type: 'info', timestamp: Date.now(), message: 'Connection Closed' }].concat(item.response.data);
+          } else {
+            item.response = null;
+            item.requestUid = null;
+          }
           item.cancelTokenUid = null;
-          item.requestUid = null;
           item.requestStartTime = null;
         }
       }
@@ -395,7 +404,7 @@ export const collectionsSlice = createSlice({
         if (item) {
           item.requestState = 'received';
           item.response = action.payload.response;
-          item.cancelTokenUid = null;
+          item.cancelTokenUid = item.response.stream?.running ? item.cancelTokenUid : null;
           item.requestStartTime = null;
 
           if (!collection.timeline) {
@@ -590,6 +599,11 @@ export const collectionsSlice = createSlice({
       if (collection) {
         const item = findItemInCollection(collection, action.payload.itemUid);
         if (item) {
+          if (item.response && item.response.stream?.running) {
+            item.response.data = '';
+            item.response.size = 0;
+            return;
+          }
           item.response = null;
         }
       }
@@ -2936,7 +2950,25 @@ export const collectionsSlice = createSlice({
         set(folder, 'draft.request.auth.mode', action.payload.mode);
       }
     },
+    streamDataReceived: (state, action) => {
+      const { itemUid, collectionUid, data } = action.payload;
+      const collection = findCollectionByUid(state.collections, collectionUid);
 
+      if (collection) {
+        const item = findItemInCollection(collection, itemUid);
+        if (data.data) {
+          item.response.data ||= [];
+          item.response.data = [{
+            type: 'incoming',
+            message: data.data,
+            messageHexdump: hexdump(data.data),
+            timestamp: Date.now()
+          }].concat(item.response.data);
+        }
+        item.response.dataBuffer = Buffer.concat([Buffer.from(item.response.dataBuffer), Buffer.from(data.dataBuffer)]);
+        item.response.size = data.data?.length + (item.response.size || 0);
+      }
+    },
     addRequestTag: (state, action) => {
       const { tag, collectionUid, itemUid } = action.payload;
       const collection = findCollectionByUid(state.collections, collectionUid);
@@ -3298,6 +3330,7 @@ export const {
   updateRequestDocs,
   updateFolderDocs,
   moveCollection,
+  streamDataReceived,
   collectionAddOauth2CredentialsByUrl,
   collectionClearOauth2CredentialsByUrl,
   collectionGetOauth2CredentialsByUrl,
diff --git a/packages/bruno-app/src/themes/dark.js b/packages/bruno-app/src/themes/dark.js
index 34cb27874..7c5af6554 100644
--- a/packages/bruno-app/src/themes/dark.js
+++ b/packages/bruno-app/src/themes/dark.js
@@ -115,6 +115,7 @@ const darkTheme = {
     url: {
       bg: '#3D3D3D',
       icon: 'rgb(204, 204, 204)',
+      iconDanger: '#fa5343',
       errorHoverBg: '#4a2a2a'
     },
     dragbar: {
diff --git a/packages/bruno-app/src/themes/light.js b/packages/bruno-app/src/themes/light.js
index 794925883..05b40766e 100644
--- a/packages/bruno-app/src/themes/light.js
+++ b/packages/bruno-app/src/themes/light.js
@@ -115,6 +115,7 @@ const lightTheme = {
     url: {
       bg: '#f3f3f3',
       icon: '#515151',
+      iconDanger: '#d91f11',
       errorHoverBg: '#fef2f2'
     },
     dragbar: {
diff --git a/packages/bruno-app/src/utils/network/index.js b/packages/bruno-app/src/utils/network/index.js
index 6ae94d9b0..89a19a2a3 100644
--- a/packages/bruno-app/src/utils/network/index.js
+++ b/packages/bruno-app/src/utils/network/index.js
@@ -10,6 +10,7 @@ export const sendNetworkRequest = async (item, collection, environment, runtimeV
           if (response?.error) {
             resolve(response)
           }
+
           resolve({
             state: 'success',
             data: response.data,
@@ -20,7 +21,8 @@ export const sendNetworkRequest = async (item, collection, environment, runtimeV
             status: response.status,
             statusText: response.statusText,
             duration: response.duration,
-            timeline: response.timeline
+            timeline: response.timeline,
+            stream: response.stream
           });
         })
         .catch((err) => reject(err));
diff --git a/packages/bruno-electron/src/ipc/network/index.js b/packages/bruno-electron/src/ipc/network/index.js
index 611182a27..4fa7c2274 100644
--- a/packages/bruno-electron/src/ipc/network/index.js
+++ b/packages/bruno-electron/src/ipc/network/index.js
@@ -69,6 +69,37 @@ const getJsSandboxRuntime = (collection) => {
   return 'vm2';
 };
 
+const hasStreamHeaders = (headers) => {
+  const headerSplit = (headers.get('content-type') ?? '').split(';').map((d) => d.trim());
+  return headerSplit.indexOf('text/event-stream') > -1;
+};
+
+const promisifyStream = async (stream, abortController, closeOnFirst) => {
+  const chunks = [];
+
+  return new Promise((resolve, reject) => {
+    const doResolve = () => {
+      const fullBuffer = Buffer.concat(chunks);
+      resolve(fullBuffer.buffer.slice(fullBuffer.byteOffset, fullBuffer.byteOffset + fullBuffer.byteLength));
+    };
+
+    stream.on('data', (chunk) => {
+      chunks.push(chunk);
+
+      if (closeOnFirst) {
+        doResolve();
+
+        if (abortController) {
+          abortController.abort();
+        }
+      }
+    });
+
+    stream.on('close', doResolve);
+    stream.on('error', (err) => reject(err));
+  });
+};
+
 const configureRequest = async (
   collectionUid,
   collection,
@@ -595,6 +626,10 @@ const registerNetworkIpc = (mainWindow) => {
     const abortController = new AbortController();
     const request = await prepareRequest(item, collection, abortController);
     request.__bruno__executionMode = 'standalone';
+    request.responseType = 'stream';
+    // flag to see if the stream needs to be handled as an actual stream or
+    // is it just a data stream from axios
+    let isResponseStream = false;
     const brunoConfig = getBrunoConfig(collectionUid, collection);
     const scriptingConfig = get(brunoConfig, 'scripts', {});
     scriptingConfig.runtime = getJsSandboxRuntime(collection);
@@ -668,7 +703,8 @@ const registerNetworkIpc = (mainWindow) => {
         method: request.method,
         headers: headersSent,
         data: requestData,
-        dataBuffer: requestDataBuffer
+        dataBuffer: requestDataBuffer,
+        timestamp: Date.now()
       }
 
       !runInBackground && mainWindow.webContents.send('main:run-request-event', {
@@ -691,10 +727,15 @@ const registerNetworkIpc = (mainWindow) => {
         });
       }
 
-      let response, responseTime;
+      let response, responseTime, axiosDataStream;
       try {
         /** @type {import('axios').AxiosResponse} */
         response = await axiosInstance(request);
+        isResponseStream = hasStreamHeaders(response.headers);
+
+        if (!isResponseStream) {
+          response.data = await promisifyStream(response.data);
+        }
 
         // Prevents the duration on leaking to the actual result
         responseTime = response.headers.get('request-duration');
@@ -719,6 +760,10 @@ const registerNetworkIpc = (mainWindow) => {
           // Prevents the duration on leaking to the actual result
           responseTime = response.headers.get('request-duration');
           response.headers.delete('request-duration');
+          isResponseStream = hasStreamHeaders(response.headers);
+          if (!isResponseStream) {
+            response.data = await promisifyStream(response.data);
+          }
         } else {
           await executeRequestOnFailHandler(request, error);
 
@@ -734,8 +779,13 @@ const registerNetworkIpc = (mainWindow) => {
       }
 
       // Continue with the rest of the request lifecycle - post response vars, script, assertions, tests
+      if (isResponseStream) {
+        axiosDataStream = response.data;
+      }
 
-      const { data, dataBuffer } = parseDataFromResponse(response, request.__brunoDisableParsingResponseJson);
+      const { data, dataBuffer } = isResponseStream
+        ? { data: '', dataBuffer: Buffer.alloc(0) }
+        : parseDataFromResponse(response, request.__brunoDisableParsingResponseJson);
       response.data = data;
       response.dataBuffer = dataBuffer;
 
@@ -752,140 +802,141 @@ const registerNetworkIpc = (mainWindow) => {
       mainWindow.webContents.send('main:cookies-update', safeParseJSON(safeStringifyJSON(domainsWithCookies)));
       cookiesStore.saveCookieJar();
 
-      let postResponseScriptResult = null;
-      let postResponseError = null;
-      try {
-        postResponseScriptResult = await runPostResponse(
-          request,
-          response,
-          requestUid,
-          envVars,
-          collectionPath,
-          collection,
-          collectionUid,
-          runtimeVariables,
-          processEnvVars,
-          scriptingConfig,
-          runRequestByItemPathname
-        );
-      } catch (error) {
-        console.error('Post-response script error:', error);
-        postResponseError = error;
-      }
-      
-      if (postResponseScriptResult?.results) {
-        mainWindow.webContents.send('main:run-request-event', {
-          type: 'test-results-post-response',
-          results: postResponseScriptResult.results,
-          itemUid: item.uid,
-          requestUid,
-          collectionUid
-        });
-      }
-
-      !runInBackground && notifyScriptExecution({
-        channel: 'main:run-request-event',
-        basePayload: { requestUid, collectionUid, itemUid: item.uid },
-        scriptType: 'post-response',
-        error: postResponseError
-      });
-
-      // run assertions
-      const assertions = get(request, 'assertions');
-      if (assertions) {
-        const assertRuntime = new AssertRuntime({ runtime: scriptingConfig?.runtime });
-        const results = assertRuntime.runAssertions(
-          assertions,
-          request,
-          response,
-          envVars,
-          runtimeVariables,
-          processEnvVars
-        );
-
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'assertion-results',
-          results: results,
-          itemUid: item.uid,
-          requestUid,
-          collectionUid
-        });
-      }
-
-      const testFile = get(request, 'tests');
-      const collectionName = collection?.name
-      if (typeof testFile === 'string') {
-        const testRuntime = new TestRuntime({ runtime: scriptingConfig?.runtime });
-        let testResults = null;
-        let testError = null;
-
+      const runPostScripts = async () => {
+        let postResponseScriptResult = null;
+        let postResponseError = null;
         try {
-          testResults = await testRuntime.runTests(
-            decomment(testFile),
-            request,
+          postResponseScriptResult = await runPostResponse(request,
             response,
+            requestUid,
             envVars,
-            runtimeVariables,
             collectionPath,
-            onConsoleLog,
+            collection,
+            collectionUid,
+            runtimeVariables,
             processEnvVars,
             scriptingConfig,
-            runRequestByItemPathname,
-            collectionName
-          );
+            runRequestByItemPathname);
         } catch (error) {
-          testError = error;
-          
-          if (error.partialResults) {
-            testResults = error.partialResults;
-          } else {
-            testResults = {
-              request,
-              envVariables: envVars,
-              runtimeVariables,
-              globalEnvironmentVariables: request?.globalEnvironmentVariables || {},
-              results: [],
-              nextRequestName: null
-            };
-          }
+          console.error('Post-response script error:', error);
+          postResponseError = error;
         }
 
-        !runInBackground && mainWindow.webContents.send('main:run-request-event', {
-          type: 'test-results',
-          results: testResults.results,
-          itemUid: item.uid,
-          requestUid,
-          collectionUid
-        });
-
-        mainWindow.webContents.send('main:script-environment-update', {
-          envVariables: testResults.envVariables,
-          runtimeVariables: testResults.runtimeVariables,
-          requestUid,
-          collectionUid
-        });
-
-        mainWindow.webContents.send('main:persistent-env-variables-update', {
-          persistentEnvVariables: testResults.persistentEnvVariables,
-          collectionUid
-        });
-
-        mainWindow.webContents.send('main:global-environment-variables-update', {
-          globalEnvironmentVariables: testResults.globalEnvironmentVariables
-        });
-
-        collection.globalEnvironmentVariables = testResults.globalEnvironmentVariables;
+        if (postResponseScriptResult?.results) {
+          mainWindow.webContents.send('main:run-request-event', {
+            type: 'test-results-post-response',
+            results: postResponseScriptResult.results,
+            itemUid: item.uid,
+            requestUid,
+            collectionUid
+          });
+        }
 
         !runInBackground && notifyScriptExecution({
           channel: 'main:run-request-event',
           basePayload: { requestUid, collectionUid, itemUid: item.uid },
-          scriptType: 'test',
-          error: testError
+          scriptType: 'post-response',
+          error: postResponseError
         });
 
-        const domainsWithCookiesTest = await getDomainsWithCookies();
-        mainWindow.webContents.send('main:cookies-update', safeParseJSON(safeStringifyJSON(domainsWithCookiesTest)));
-        cookiesStore.saveCookieJar();
+        // run assertions
+        const assertions = get(request, 'assertions');
+        if (assertions) {
+          const assertRuntime = new AssertRuntime({ runtime: scriptingConfig?.runtime });
+          const results = assertRuntime.runAssertions(assertions,
+            request,
+            response,
+            envVars,
+            runtimeVariables,
+            processEnvVars);
+
+          !runInBackground && mainWindow.webContents.send('main:run-request-event', {
+            type: 'assertion-results',
+            results: results,
+            itemUid: item.uid,
+            requestUid,
+            collectionUid
+          });
+        }
+
+        const testFile = get(request, 'tests');
+        const collectionName = collection?.name;
+        if (typeof testFile === 'string') {
+          const testRuntime = new TestRuntime({ runtime: scriptingConfig?.runtime });
+          let testResults = null;
+          let testError = null;
+
+          try {
+            testResults = await testRuntime.runTests(decomment(testFile),
+              request,
+              response,
+              envVars,
+              runtimeVariables,
+              collectionPath,
+              onConsoleLog,
+              processEnvVars,
+              scriptingConfig,
+              runRequestByItemPathname,
+              collectionName);
+          } catch (error) {
+            testError = error;
+
+            if (error.partialResults) {
+              testResults = error.partialResults;
+            } else {
+              testResults = {
+                request,
+                envVariables: envVars,
+                runtimeVariables,
+                globalEnvironmentVariables: request?.globalEnvironmentVariables || {},
+                results: [],
+                nextRequestName: null
+              };
+            }
+          }
+
+          !runInBackground && mainWindow.webContents.send('main:run-request-event', {
+            type: 'test-results',
+            results: testResults.results,
+            itemUid: item.uid,
+            requestUid,
+            collectionUid
+          });
+
+          mainWindow.webContents.send('main:script-environment-update', {
+            envVariables: testResults.envVariables,
+            runtimeVariables: testResults.runtimeVariables,
+            requestUid,
+            collectionUid
+          });
+
+          mainWindow.webContents.send('main:persistent-env-variables-update', {
+            persistentEnvVariables: testResults.persistentEnvVariables,
+            collectionUid
+          });
+
+          mainWindow.webContents.send('main:global-environment-variables-update', {
+            globalEnvironmentVariables: testResults.globalEnvironmentVariables
+          });
+
+          collection.globalEnvironmentVariables = testResults.globalEnvironmentVariables;
+
+          !runInBackground && notifyScriptExecution({
+            channel: 'main:run-request-event',
+            basePayload: { requestUid, collectionUid, itemUid: item.uid },
+            scriptType: 'test',
+            error: testError
+          });
+
+          const domainsWithCookiesTest = await getDomainsWithCookies();
+          mainWindow.webContents.send('main:cookies-update', safeParseJSON(safeStringifyJSON(domainsWithCookiesTest)));
+          cookiesStore.saveCookieJar();
+        }
+      };
+      if (isResponseStream) {
+        axiosDataStream.on('close', () => runPostScripts().then());
+      } else {
+        await runPostScripts();
       }
 
       return {
@@ -894,6 +945,8 @@ const registerNetworkIpc = (mainWindow) => {
         headers: response.headers,
         data: response.data,
         dataBuffer: response.dataBuffer.toString('base64'),
+        stream: isResponseStream ? axiosDataStream : null,
+        cancelTokenUid: cancelTokenUid,
         size: Buffer.byteLength(response.dataBuffer),
         duration: responseTime ?? 0,
         url: response.request ? response.request.protocol + '//' + response.request.host + response.request.path : null,
@@ -917,7 +970,26 @@ const registerNetworkIpc = (mainWindow) => {
     const collectionUid = collection.uid;
     const envVars = getEnvVars(environment);
     const processEnvVars = getProcessEnvVars(collectionUid);
-    return await runRequest({ item, collection, envVars, processEnvVars, runtimeVariables, runInBackground: false });
+    const response = await runRequest({ item, collection, envVars, processEnvVars, runtimeVariables, runInBackground: false });
+    if (response.stream) {
+      const stream = response.stream;
+      response.stream = { running: response.status >= 200 && response.status < 300 };
+
+      stream.on('data', (newData) => {
+        const parsed = parseDataFromResponse({ data: newData, headers: {} });
+        mainWindow.webContents.send('main:http-stream-new-data', { collectionUid, itemUid: item.uid, data: parsed });
+      });
+
+      stream.on('close', () => {
+        if (!cancelTokens[response.cancelTokenUid]) {
+          return;
+        }
+
+        mainWindow.webContents.send('main:http-stream-end', { collectionUid, itemUid: item.uid });
+        deleteCancelToken(response.cancelTokenUid);
+      });
+    }
+    return response;
   });
 
   ipcMain.handle('clear-oauth2-cache', async (event, uid, url, credentialsId) => {
@@ -935,8 +1007,9 @@ const registerNetworkIpc = (mainWindow) => {
   ipcMain.handle('cancel-http-request', async (event, cancelTokenUid) => {
     return new Promise((resolve, reject) => {
       if (cancelTokenUid && cancelTokens[cancelTokenUid]) {
-        cancelTokens[cancelTokenUid].abort();
+        const abortController = cancelTokens[cancelTokenUid];
         deleteCancelToken(cancelTokenUid);
+        abortController.abort();
         resolve();
       } else {
         reject(new Error('cancel token not found'));
@@ -960,10 +1033,17 @@ const registerNetworkIpc = (mainWindow) => {
       const envVars = getEnvVars(environment);
       const processEnvVars = getProcessEnvVars(collectionUid);
       let stopRunnerExecution = false;
+      let currentAbortController;
 
       const abortController = new AbortController();
       saveCancelToken(cancelTokenUid, abortController);
 
+      abortController.signal.addEventListener('abort', () => {
+        if (currentAbortController) {
+          currentAbortController.abort();
+        }
+      });
+
       const runRequestByItemPathname = async (relativeItemPathname) => {
         return new Promise(async (resolve, reject) => {
           let itemPathname = path.join(collection?.pathname, relativeItemPathname);
@@ -1154,7 +1234,8 @@ const registerNetworkIpc = (mainWindow) => {
               method: request.method,
               headers: headersSent,
               data: requestData,
-              dataBuffer: requestDataBuffer
+              dataBuffer: requestDataBuffer,
+              timestamp: Date.now()
             }
 
             // todo:
@@ -1166,7 +1247,9 @@ const registerNetworkIpc = (mainWindow) => {
               ...eventData
             });
 
-            request.signal = abortController.signal;
+            currentAbortController = new AbortController();
+            request.signal = currentAbortController.signal;
+            request.responseType = 'stream';
             const axiosInstance = await configureRequest(
               collectionUid,
               collection,
@@ -1213,6 +1296,7 @@ const registerNetworkIpc = (mainWindow) => {
 
               /** @type {import('axios').AxiosResponse} */
               response = await axiosInstance(request);
+              response.data = await promisifyStream(response.data, currentAbortController, false);
               timeEnd = Date.now();
 
               const { data, dataBuffer } = parseDataFromResponse(response, request.__brunoDisableParsingResponseJson);
@@ -1254,6 +1338,7 @@ const registerNetworkIpc = (mainWindow) => {
               }
 
               if (error?.response) {
+                error.response.data = await promisifyStream(error.response.data, currentAbortController, true);
                 const { data, dataBuffer } = parseDataFromResponse(error.response);
                 error.response.responseTime = error.response.headers.get('request-duration');
                 error.response.headers.delete('request-duration');