diff --git a/Browser/gen_stub.py b/Browser/gen_stub.py
index 88199fc4b..e691508e8 100644
--- a/Browser/gen_stub.py
+++ b/Browser/gen_stub.py
@@ -69,7 +69,7 @@ def parse_kw_stubs():
 from Browser.utils .data_types import (
     MouseButton, KeyboardModifier, ScrollBehavior, ScrollBehavior, DialogAction, MouseButtonAction, NotSet, Dimensions,
     SizeFields, AreaFields, BoundingBoxFields, SelectionStrategy, ElementRole, AriaSnapshotReturnType,
-    KeyboardInputAction, KeyAction
+    KeyboardInputAction, KeyAction, TextType
 )
 from Browser.utils.types import Secret
 """
diff --git a/Browser/keywords/evaluation.py b/Browser/keywords/evaluation.py
index 0361bbb4d..69be6700d 100644
--- a/Browser/keywords/evaluation.py
+++ b/Browser/keywords/evaluation.py
@@ -20,7 +20,13 @@
 
 from ..base import LibraryComponent
 from ..generated.playwright_pb2 import Request
-from ..utils import DownloadInfo, HighlightMode, keyword, logger
+from ..utils import (
+    ROBOT_FRAMEWORK_BROWSER_NO_SET,
+    DownloadInfo,
+    HighlightMode,
+    keyword,
+    logger,
+)
 
 
 class Evaluation(LibraryComponent):
@@ -117,7 +123,7 @@ def highlight_elements(
                 Request().ElementSelectorWithDuration(
                     selector=self.resolve_selector(selector)
                     if selector
-                    else "ROBOT_FRAMEWORK_BROWSER_NO_ELEMENT",
+                    else ROBOT_FRAMEWORK_BROWSER_NO_SET,
                     duration=int(self.convert_timeout(duration)),
                     width=width,
                     style=style,
diff --git a/Browser/keywords/getters.py b/Browser/keywords/getters.py
index e0277e17c..9df8786e2 100644
--- a/Browser/keywords/getters.py
+++ b/Browser/keywords/getters.py
@@ -38,6 +38,7 @@
 from ..generated.playwright_pb2 import Request
 from ..utils import keyword, logger
 from ..utils.data_types import (
+    ROBOT_FRAMEWORK_BROWSER_NO_SET,
     AreaFields,
     AriaSnapshotReturnType,
     BoundingBox,
@@ -52,6 +53,7 @@
     SelectionStrategy,
     SelectOptions,
     SizeFields,
+    TextType,
     ViewportDimensions,
 )
 
@@ -228,36 +230,49 @@ def get_text(
         assertion_operator: AssertionOperator | None = None,
         assertion_expected: Any | None = None,
         message: str | None = None,
-    ) -> str:
+        *,
+        text_type: TextType | None = None,
+    ) -> str | list[str]:
         """Returns text attribute of the element found by ``selector``.
 
-               Keyword can also return `input` or `textarea` value property text.
+        Keyword can also return `input` or `textarea` value property text.
         See the `Finding elements` section for details about the selectors.
 
-               | =Arguments= | =Description= |
-               | ``assertion_operator`` | See `Assertions` for further details. Defaults to None. |
-               | ``assertion_expected`` | Expected value for the state |
-               | ``message`` | overrides the default error message for assertion. |
+        | =Arguments= | =Description= |
+        | ``assertion_operator`` | See `Assertions` for further details. Defaults to None. |
+        | ``assertion_expected`` | Expected value for the state |
+        | ``message`` | overrides the default error message for assertion. |
+        | ``text_type`` | How text is returned. Possible values are ``allInnerTexts``, ``allTextContents``, ``innerText``, ``inputValue``, and ``innerHTML``. |
 
-               Keyword uses strict mode, see `Finding elements` for more details about strict mode.
+        Keyword uses strict mode, see `Finding elements` for more details about strict mode.
+        The ``text_type`` argument determines how text is returned. The ``allInnerTexts`` and
+        ``allTextContents`` will return a list of strings, while other types return a single
+        string.
 
-               Optionally asserts that the text matches the specified assertion. See `Assertions`
-               for further details for the assertion arguments. By default, assertion is not done.
+        Optionally asserts that the text matches the specified assertion. See `Assertions`
+        for further details for the assertion arguments. By default, assertion is not done.
 
-               Example:
-               | ${text} =    `Get Text`    id=important                            # Returns element text without assertion.
-               | ${text} =    `Get Text`    id=important    ==    Important text    # Returns element text with assertion.
-               | ${text} =    `Get Text`    //input         ==    root              # Returns input element text with assertion.
+        Example:
+        | ${text} =    `Get Text`    id=important                                # Returns element text without assertion.
+        | ${text} =    `Get Text`    id=important    ==    Important text        # Returns element text with assertion.
+        | ${text} =    `Get Text`    //input         ==    root                  # Returns input element text with assertion.
+        | ${text} =    `Get Text`    id=important    text_type=innerHTML         # Returns element inner HTML.
+        | ${text} =    `Get Text`    id=important    text_type=allInnerTexts     # Returns element inner text as list of strings.
 
-               [https://forum.robotframework.org/t//4285|Comment >>]
+        [https://forum.robotframework.org/t//4285|Comment >>]
         """
         selector = self.presenter_mode(selector, self.strict_mode)
-        response = self._get_text(selector)
+        response = self._get_text(selector, text_type)
         logger.debug(response.log)
-        logger.info(f"Text: {response.body!r}")
+        is_all_type = text_type in (TextType.allInnerTexts, TextType.allTextContents)
+        if is_all_type:
+            value = [str(item) for item in response.items]
+        else:
+            value = [str(response.items[0])]
+        logger.info(f"Text: {value!r}")
         formatter = self.get_assertion_formatter("Get Text")
         return verify_assertion(
-            response.body,
+            value[0] if not is_all_type else value,
             assertion_operator,
             assertion_expected,
             "Text",
@@ -265,10 +280,17 @@ def get_text(
             formatter,
         )
 
-    def _get_text(self, selector: str):  # To ease unit testing
+    def _get_text(
+        self, selector: str, text_type: TextType | None
+    ):  # To ease unit testing
+        text_type_value = (
+            str(text_type.name) if text_type else ROBOT_FRAMEWORK_BROWSER_NO_SET
+        )
         with self.playwright.grpc_channel() as stub:
             return stub.GetText(
-                Request().ElementSelector(selector=selector, strict=self.strict_mode)
+                Request().ElementSelectorWithTextType(
+                    selector=selector, strict=self.strict_mode, textType=text_type_value
+                )
             )
 
     @keyword(tags=("Getter", "Assertion", "PageContent"))
diff --git a/Browser/utils/__init__.py b/Browser/utils/__init__.py
index 3e5b6ab0e..04d20abb5 100644
--- a/Browser/utils/__init__.py
+++ b/Browser/utils/__init__.py
@@ -63,8 +63,10 @@
     SelectionType,
     ServiceWorkersPermissions,
     SupportedBrowsers,
+    TextType,
     ViewportDimensions,
     convert_typed_dict,
+    ROBOT_FRAMEWORK_BROWSER_NO_SET,
 )
 from .js_utilities import get_abs_scroll_coordinates, get_rel_scroll_coordinates
 from .meta_python import find_by_id, locals_to_params
diff --git a/Browser/utils/data_types.py b/Browser/utils/data_types.py
index 37d640035..f7e438bb7 100644
--- a/Browser/utils/data_types.py
+++ b/Browser/utils/data_types.py
@@ -1483,6 +1483,27 @@ class TracingGroupMode(Enum):
     Playwright = auto()
 
 
+class TextType(Enum):
+    """Defines which Playwright method is used to get the text of an element.
+
+    ``allInnerTexts``: Returns a list of `node.innerText` values for all matching nodes.
+
+    ``allTextContents``: Returns a list of `node.textContent` values for all matching nodes.
+
+    ``innerText``: Returns the element node.innerText value, which represents the rendered text content of a node and its descendants.
+
+    ``inputValue``: Returns the value for the matching <input> or <textarea> or <select> element.
+
+    ``innerHTML``: Returns the element node.innerHTML value, which is the HTML markup contained within the element, omitting any shadow roots.
+    """
+
+    allInnerTexts = auto()
+    allTextContents = auto()
+    innerText = auto()
+    inputValue = auto()
+    innerHTML = auto()
+
+
 InstallableBrowser = Enum(
     "InstallableBrowser",
     {
@@ -1522,3 +1543,6 @@ class TracingGroupMode(Enum):
     "only-shell": "only install headless shell when installing chromium",
     "no-shell": "do not install chromium headless shell",
 }
+
+
+ROBOT_FRAMEWORK_BROWSER_NO_SET = "ROBOT_FRAMEWORK_BROWSER_NO_SET"
diff --git a/atest/test/02_Content_Keywords/basic_getters.robot b/atest/test/02_Content_Keywords/basic_getters.robot
index 37c0c0d18..7d69408c0 100644
--- a/atest/test/02_Content_Keywords/basic_getters.robot
+++ b/atest/test/02_Content_Keywords/basic_getters.robot
@@ -2,7 +2,7 @@
 Resource            imports.resource
 Library             ../../library/presenter_mode.py
 
-Suite Setup         Setup
+Suite Setup         Setup Basic Getters
 Suite Teardown      Set Retry Assertions For    ${assert_timeout}
 Test Setup          Ensure Location    ${LOGIN_URL}
 
@@ -11,33 +11,6 @@ ${UserNameLabel} =      label[for="username_field"]
 ${InputUsername} =      id=username_field
 
 *** Test Cases ***
-Get Text
-    ${h1} =    Get Text    h1
-    Should Be Equal    ${h1}    Login Page
-
-Get Text Disabled
-    [Setup]    Go To    ${ELEMENT_STATE_URL}
-    presenter_mode.Set Presenter Mode    {"color": "red", "duration": "1s", "style": "solid"}
-    ${text} =    Get Text    //input[@name="readonly_with_equals_only"]
-    [Teardown]    presenter_mode.Set Presenter Mode    False
-
-Get Text And Assert ==
-    Get Text    ${UserNameLabel}    ==    User Name:
-
-Get Text And Assert !=
-    Get Text    ${UserNameLabel}    !=
-
-Get Text Assert Validate
-    Get Text    h1    validate    value.startswith('Login')
-
-Get Text With Nonmatching Selector
-    [Tags]    no-iframe
-    Set Browser Timeout    50ms
-    Run Keyword And Expect Error
-    ...    *Error: locator.elementHandle: Timeout 50ms exceeded.*waiting for locator('notamatch')*
-    ...    Get Text    notamatch
-    [Teardown]    Set Browser Timeout    ${PLAYWRIGHT_TIMEOUT}
-
 Get Property And Assert
     Get Property    h1    innerText    ==    Login Page
     Get Property    h1    innerText    !=    ${None}
@@ -148,7 +121,7 @@ Get Element Count
     ${count} =    Get Element Count    h1
     Should Be Equal    ${count}    ${1}
     ${count} =    Get Element Count    label
-    Should Be Equal    ${count}    ${13}
+    Should Be Equal    ${count}    ${14}
     ${count} =    Get Element Count    not-existing
     Should Be Equal    ${count}    ${0}
 
@@ -156,12 +129,12 @@ Get Element Count And Assert
     [Setup]    Ensure Location    ${LOGIN_URL}
     Get Element Count    h1    ==    1
     Get Element Count    h1    ==    ${1}
-    Get Element Count    label    validate    value == 13
+    Get Element Count    label    validate    value == 14
     Get Element Count    label    >    1
     Get Element Count    not-existing    ==
     ${promise} =    Promise To    Get Element Count    label
     ${count} =    Wait For    ${promise}
-    Should Be Equal    ${count}    ${13}
+    Should Be Equal    ${count}    ${14}
 
 Get Style And Assert
     Get Style    h1    ALL    *=    align-content
@@ -353,7 +326,7 @@ Get Element States Return Flags
     Should Be Equal    ${input_state}    ${pwd_state}
 
 Get Console Log Test
-    [Setup]    Setup
+    [Setup]    Setup Basic Getters
     ${first} =    Get Console Log    then    len(value)
     Click With Options    "Click with Options"    left    ALT    SHIFT
     # Sometimes test app emist React Router Future Flag Warning: React Router ...
@@ -395,7 +368,7 @@ Get Console Log Test
     ...    $now - datetime.datetime.strptime($first_log['time'], '%Y-%m-%dT%H:%M:%S.%f%z') < datetime.timedelta(seconds=0.5)
 
 *** Keywords ***
-Setup
+Setup Basic Getters
     Close Page    ALL
     Ensure Open Page    ${LOGIN_URL}
     ${assert_timeout} =    Set Retry Assertions For    2 sec
diff --git a/atest/test/02_Content_Keywords/basic_getters_get_text.robot b/atest/test/02_Content_Keywords/basic_getters_get_text.robot
new file mode 100644
index 000000000..2830a7899
--- /dev/null
+++ b/atest/test/02_Content_Keywords/basic_getters_get_text.robot
@@ -0,0 +1,98 @@
+*** Settings ***
+Resource            imports.resource
+Library             ../../library/presenter_mode.py
+
+Suite Setup         Setup Get Text
+Suite Teardown      Set Retry Assertions For    ${assert_timeout}
+Test Setup          Ensure Location    ${LOGIN_URL}
+
+*** Variables ***
+${USERNAMELABEL} =      label[for="username_field"]
+${INPUTUSERNAME} =      id=username_field
+
+*** Test Cases ***
+Get Text
+    ${h1} =    Get Text    h1
+    Should Be Equal    ${h1}    Login Page
+
+Get Text Disabled
+    [Setup]    Go To    ${ELEMENT_STATE_URL}
+    presenter_mode.Set Presenter Mode    {"color": "red", "duration": "1s", "style": "solid"}
+    ${text} =    Get Text    //input[@name="readonly_with_equals_only"]
+    [Teardown]    presenter_mode.Set Presenter Mode    False
+
+Get Text And Assert ==
+    Get Text    ${USERNAMELABEL}    ==    User Name:
+
+Get Text And Assert !=
+    Get Text    ${USERNAMELABEL}    !=
+
+Get Text No Text Type And Input Field
+    Type Text    ${INPUTUSERNAME}    MyUserName
+    Get Text    ${INPUTUSERNAME}    ==    MyUserName
+
+Get Text Text Type As InputValue And Input Field
+    Type Text    ${INPUTUSERNAME}    MyUserName
+    Get Text    ${INPUTUSERNAME}    ==    MyUserName    text_type=inputValue
+
+Get Text No Text Type And Select Element
+    Select Options By    id=pet-select    value    dog
+    Get Text    id=pet-select    ==    dog
+
+Get Text Text Type As InputValue And Select Element
+    Select Options By    id=pet-select    value    dog
+    Get Text    id=pet-select    ==    dog    text_type=inputValue
+
+Get Text Assert Validate
+    Get Text    h1    validate    value.startswith('Login')
+
+Get Text With No Matching Selector
+    [Tags]    no-iframe
+    Set Browser Timeout    50ms
+    Run Keyword And Expect Error
+    ...    *TimeoutError: locator.evaluate: Timeout 50ms exceeded.*
+    ...    Get Text    notamatch
+    [Teardown]    Set Browser Timeout    ${PLAYWRIGHT_TIMEOUT}
+
+Get Text With Text Type As InnerHTML
+    ${text} =    Get Text    h1    ==    Login Page    text_type=innerHTML
+    Should Be Equal    ${text}    Login Page
+    ${text} =    Get Text    [name="login_form"]    text_type=innerHTML
+    Should Contain    ${text}    <label for="username_field">User Name:</label>
+    Should Contain    ${text}    <label for="password_field">Password:</label>
+
+Get Text With Text Type As InnerText
+    ${text} =    Get Text    h1    ==    Login Page    text_type=innerText
+    Should Be Equal    ${text}    Login Page
+    ${text} =    Get Text    ${USERNAMELABEL}    text_type=innerText
+    Should Be Equal    ${text}    User Name:
+
+Get Text With Text Type As All InnerTexts
+    ${texts} =    Get Text    //option    text_type=allInnerTexts
+    VAR    @{expected} =    --Please choose an option--    Dog    Cat    Hamster    Parrot    Spider    Goldfish
+    Lists Should Be Equal    ${texts}    ${expected}
+
+Get Text With Text Type As All InnerTexts On Single Element With Multiple Text
+    ${texts} =    Get Text    [name="login_form"]    text_type=allInnerTexts
+    Should Contain    ${texts[0]}    User Name:
+    Should Contain    ${texts[0]}    Password:
+    Length Should Be    ${texts}    1
+
+Get Text With Text Type As All TextContents With Multiple Text
+    ${texts} =    Get Text    //option    text_type=allTextContents
+    VAR    @{expected} =    --Please choose an option--    Dog    Cat    Hamster    Parrot    Spider    Goldfish
+    Lists Should Be Equal    ${texts}    ${expected}
+
+Text Area Access And No Text Type
+    Get Text    id=textarea51    ==    Some initial text
+    Type Text    id=textarea51    Area 51
+    Get Text    id=textarea51    ==    Area 51
+    Type Text    id=textarea51    Ufo detected
+    Get Text    id=textarea51    ==    Ufo detected    text_type=inputValue
+
+*** Keywords ***
+Setup Get Text
+    Close Page    ALL
+    Ensure Open Page    ${LOGIN_URL}
+    ${assert_timeout} =    Set Retry Assertions For    2 sec
+    VAR    ${assert_timeout} =    ${assert_timeout}    scope=SUITE
diff --git a/atest/test/02_Content_Keywords/text_keywords.robot b/atest/test/02_Content_Keywords/text_keywords.robot
index 9b6e234d5..8bdf28fae 100644
--- a/atest/test/02_Content_Keywords/text_keywords.robot
+++ b/atest/test/02_Content_Keywords/text_keywords.robot
@@ -331,13 +331,6 @@ Get Text Custom Error
     ...    Get Text    css=input#username_field    ==    username    Tidii
     [Teardown]    Set Retry Assertions For    1s
 
-Text Area Access
-    Get Text    id=textarea51    ==    Some initial text
-    Type Text    id=textarea51    Area 51
-    Get Text    id=textarea51    ==    Area 51
-    Type Text    id=textarea51    Ufo detected
-    Get Text    id=textarea51    ==    Ufo detected
-
 Type Secret With CryptoLibrary
     Type Secret
     ...    input#username_field
diff --git a/node/dynamic-test-app/src/login.tsx b/node/dynamic-test-app/src/login.tsx
index 95c699a92..3bdf22be2 100644
--- a/node/dynamic-test-app/src/login.tsx
+++ b/node/dynamic-test-app/src/login.tsx
@@ -348,6 +348,18 @@ export default function Site() {
                     </tbody>
                 </table>
 
+                <label id="pet-select-label">Choose a pet:</label>
+                <select name="pets" id="pet-select">
+                    <option value="">--Please choose an option--</option>
+                    <option value="dog">Dog</option>
+                    <option value="cat">Cat</option>
+                    <option value="hamster">Hamster</option>
+                    <option value="parrot">Parrot</option>
+                    <option value="spider">Spider</option>
+                    <option value="goldfish">Goldfish</option>
+                </select>
+                <br></br>
+
                 <input
                     type="file"
                     id="file_chooser"
diff --git a/node/playwright-wrapper/__tests__/evaluation.test.ts b/node/playwright-wrapper/__tests__/evaluation.test.ts
index 67dd71271..b322e7570 100644
--- a/node/playwright-wrapper/__tests__/evaluation.test.ts
+++ b/node/playwright-wrapper/__tests__/evaluation.test.ts
@@ -95,7 +95,7 @@ describe('highlightAll', () => {
         });
     });
 
-    describe('ROBOT_FRAMEWORK_BROWSER_NO_ELEMENT selector', () => {
+    describe('ROBOT_FRAMEWORK_BROWSER_NO_SET selector', () => {
         it('disposes all cached highlights and returns 0', async () => {
             const dispose = jest.fn().mockResolvedValue(undefined);
             highlightDisposableCache.add({ dispose });
@@ -103,7 +103,7 @@ describe('highlightAll', () => {
             mockFindLocator.mockResolvedValue(locator);
 
             const result = await highlightAll(
-                'ROBOT_FRAMEWORK_BROWSER_NO_ELEMENT',
+                'ROBOT_FRAMEWORK_BROWSER_NO_SET',
                 0,
                 '1px',
                 'dotted',
diff --git a/node/playwright-wrapper/__tests__/getters.test.ts b/node/playwright-wrapper/__tests__/getters.test.ts
index e54321a4b..cd42586cd 100644
--- a/node/playwright-wrapper/__tests__/getters.test.ts
+++ b/node/playwright-wrapper/__tests__/getters.test.ts
@@ -2,7 +2,7 @@
 
 import { beforeEach, describe, expect, it } from '@jest/globals';
 
-import { getElementStates } from '../getters';
+import { getElementStates, getText } from '../getters';
 
 // Mock playwright-invoke so findLocator returns our controlled mock locator
 jest.mock('../playwright-invoke', () => ({
@@ -264,3 +264,152 @@ describe('getElementStates', () => {
         });
     });
 });
+
+describe('getText', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    function makeTextRequest(selector = '#el', strict = false, textType = 'ROBOT_FRAMEWORK_BROWSER_NO_SET') {
+        return { selector, strict, textType } as any;
+    }
+
+    function makeTextLocator(
+        overrides: Partial<{
+            evaluate: jest.Mock;
+            inputValue: jest.Mock;
+            innerText: jest.Mock;
+            allInnerTexts: jest.Mock;
+            allTextContents: jest.Mock;
+            innerHTML: jest.Mock;
+        }> = {},
+    ) {
+        return {
+            evaluate: jest.fn().mockResolvedValue('DIV'),
+            inputValue: jest.fn().mockResolvedValue('input text'),
+            innerText: jest.fn().mockResolvedValue('inner text'),
+            allInnerTexts: jest.fn().mockResolvedValue(['text1', 'text2']),
+            allTextContents: jest.fn().mockResolvedValue(['content1', 'content2']),
+            innerHTML: jest.fn().mockResolvedValue('<span>html</span>'),
+            ...overrides,
+        } as unknown as Locator;
+    }
+
+    describe('when textType is ROBOT_FRAMEWORK_BROWSER_NO_SET', () => {
+        it('returns inputValue for a SELECT element', async () => {
+            const locator = makeTextLocator({ evaluate: jest.fn().mockResolvedValue('SELECT') });
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest(), {} as any);
+
+            expect(result.items).toEqual(['input text']);
+        });
+
+        it('returns inputValue for an INPUT element', async () => {
+            const locator = makeTextLocator({ evaluate: jest.fn().mockResolvedValue('INPUT') });
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest(), {} as any);
+
+            expect(result.items).toEqual(['input text']);
+        });
+
+        it('returns inputValue for a TEXTAREA element', async () => {
+            const locator = makeTextLocator({ evaluate: jest.fn().mockResolvedValue('TEXTAREA') });
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest(), {} as any);
+
+            expect(result.items).toEqual(['input text']);
+        });
+
+        it('falls back to innerText for a non-input element', async () => {
+            const locator = makeTextLocator({ evaluate: jest.fn().mockResolvedValue('DIV') });
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest(), {} as any);
+
+            expect(result.items).toEqual(['inner text']);
+        });
+    });
+
+    it('returns allInnerTexts for textType allInnerTexts', async () => {
+        const locator = makeTextLocator();
+        mockFindLocator.mockResolvedValue(locator);
+
+        const result = await getText(makeTextRequest('#el', false, 'allInnerTexts'), {} as any);
+
+        expect(result.items).toEqual(['text1', 'text2']);
+    });
+
+    it('returns allTextContents for textType allTextContents', async () => {
+        const locator = makeTextLocator();
+        mockFindLocator.mockResolvedValue(locator);
+
+        const result = await getText(makeTextRequest('#el', false, 'allTextContents'), {} as any);
+
+        expect(result.items).toEqual(['content1', 'content2']);
+    });
+
+    it('returns innerHTML for textType innerHTML', async () => {
+        const locator = makeTextLocator();
+        mockFindLocator.mockResolvedValue(locator);
+
+        const result = await getText(makeTextRequest('#el', false, 'innerHTML'), {} as any);
+
+        expect(result.items).toEqual(['<span>html</span>']);
+    });
+
+    it('returns inputValue for textType inputValue', async () => {
+        const locator = makeTextLocator();
+        mockFindLocator.mockResolvedValue(locator);
+
+        const result = await getText(makeTextRequest('#el', false, 'inputValue'), {} as any);
+
+        expect(result.items).toEqual(['input text']);
+    });
+
+    it('returns innerText for textType innerText', async () => {
+        const locator = makeTextLocator();
+        mockFindLocator.mockResolvedValue(locator);
+
+        const result = await getText(makeTextRequest('#el', false, 'innerText'), {} as any);
+
+        expect(result.items).toEqual(['inner text']);
+    });
+
+    describe('response log message', () => {
+        it('includes text type in log when textType is explicit', async () => {
+            const locator = makeTextLocator();
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest('#el', false, 'innerText'), {} as any);
+
+            expect(result.log).toContain('with text type innerText');
+        });
+
+        it('omits text type in log when textType is ROBOT_FRAMEWORK_BROWSER_NO_SET', async () => {
+            const locator = makeTextLocator({ evaluate: jest.fn().mockResolvedValue('DIV') });
+            mockFindLocator.mockResolvedValue(locator);
+
+            const result = await getText(makeTextRequest(), {} as any);
+
+            expect(result.log).not.toContain('with text type');
+            expect(result.log).toMatch(/successfully\.$/);
+        });
+    });
+
+    describe('error handling', () => {
+        it('re-throws errors from locator methods', async () => {
+            expect.assertions(1);
+            const locator = makeTextLocator({
+                innerText: jest.fn().mockRejectedValue(new Error('element detached')),
+            });
+            mockFindLocator.mockResolvedValue(locator);
+
+            await expect(getText(makeTextRequest('#el', false, 'innerText'), {} as any)).rejects.toThrow(
+                'element detached',
+            );
+        });
+    });
+});
diff --git a/node/playwright-wrapper/evaluation.ts b/node/playwright-wrapper/evaluation.ts
index 7fe8fea08..1ce07ae40 100644
--- a/node/playwright-wrapper/evaluation.ts
+++ b/node/playwright-wrapper/evaluation.ts
@@ -503,8 +503,8 @@ export async function highlightAll(
         logger.info(e);
         return 0;
     }
-    if (selector === 'ROBOT_FRAMEWORK_BROWSER_NO_ELEMENT') {
-        logger.info(`Dispose all highlights because ROBOT_FRAMEWORK_BROWSER_NO_ELEMENT selector was used.`);
+    if (selector === 'ROBOT_FRAMEWORK_BROWSER_NO_SET') {
+        logger.info(`Dispose all highlights because ROBOT_FRAMEWORK_BROWSER_NO_SET selector was used.`);
         await highlightDisposableCache.disposeAll();
         return 0;
     }
diff --git a/node/playwright-wrapper/getters.ts b/node/playwright-wrapper/getters.ts
index f55ffba16..3a1d08a4d 100644
--- a/node/playwright-wrapper/getters.ts
+++ b/node/playwright-wrapper/getters.ts
@@ -20,7 +20,7 @@ import { MAX_RESPONSE_CHUNK_BYTES, splitUtf8ByMaxBytes } from './chunking';
 import * as pb from './generated/playwright';
 import { exists, findLocator } from './playwright-invoke';
 import { PlaywrightState } from './playwright-state';
-import { boolResponse, intResponse, jsonResponse, stringResponse } from './response-util';
+import { boolResponse, intResponse, jsonResponse, listStringResponse, stringResponse } from './response-util';
 
 export async function getAriaSnapshot(
     request: pb.Request_AriaSnapShot,
@@ -106,34 +106,80 @@ export async function getDomProperty(
     return stringResponse(JSON.stringify(content), 'Property received successfully.');
 }
 
-async function getTextContent(locator: Locator): Promise<string> {
-    const element = await locator.elementHandle();
-    exists(element, 'Locator did not resolve to elementHandle.');
-    const tag = await (await element.getProperty('tagName')).jsonValue();
-    if (tag === 'INPUT' || tag === 'TEXTAREA') {
-        return await (await element.getProperty('value')).jsonValue();
+enum TextType {
+    allInnerTexts = 'allInnerTexts',
+    allTextContents = 'allTextContents',
+    innerText = 'innerText',
+    inputValue = 'inputValue',
+    innerHTML = 'innerHTML',
+    ROBOT_FRAMEWORK_BROWSER_NO_SET = 'ROBOT_FRAMEWORK_BROWSER_NO_SET',
+}
+
+async function _getTextContentNoTextType(locator: Locator): Promise<string[]> {
+    logger.info(`Getting text content without text type`);
+    const tag = await locator.evaluate((e) => e.tagName);
+    if (tag === 'SELECT' || tag === 'TEXTAREA' || tag === 'INPUT') {
+        logger.info(`Element is ${tag}, get inputValue`);
+        const inputValue = await locator.inputValue();
+        return [inputValue];
+    } else {
+        logger.info(`Locator was not an <input>, <textarea>, or <select> element, falling back to innerText.`);
+        const innerText = await locator.innerText();
+        return [innerText];
+    }
+}
+
+async function getTextContent(locator: Locator, textType: TextType): Promise<string[]> {
+    logger.info(`Getting text content with text type ${textType}`);
+    switch (textType) {
+        case TextType.ROBOT_FRAMEWORK_BROWSER_NO_SET:
+            return await _getTextContentNoTextType(locator);
+        case TextType.allInnerTexts:
+            logger.info(`Getting allInnerTexts`);
+            return await locator.allInnerTexts();
+        case TextType.allTextContents:
+            logger.info(`Getting allTextContents`);
+            return await locator.allTextContents();
+        case TextType.innerHTML:
+            logger.info(`Getting innerHTML`);
+            return [await locator.innerHTML()];
+        case TextType.inputValue:
+            logger.info(`Getting inputValue`);
+            return [await locator.inputValue()];
+        case TextType.innerText:
+            logger.info(`Getting innerText`);
+            return [await locator.innerText()];
     }
-    return await element.innerText();
 }
 
 export async function getText(
-    request: pb.Request_ElementSelector,
+    request: pb.Request_ElementSelectorWithTextType,
     state: PlaywrightState,
-): Promise<pb.Response_String> {
+): Promise<pb.Response_ListString> {
     const selector = request.selector;
     const strict = request.strict;
+    const textType = request.textType;
     const locator = await findLocator(state, selector, strict, true);
-    let content: string;
+    let content: string[];
+    const textTypeEnum = TextType[textType as keyof typeof TextType];
     try {
-        content = await getTextContent(locator);
-        logger.info(`Retrieved text for element ${selector} containing ${content}`);
+        content = await getTextContent(locator, textTypeEnum);
+        logger.info(
+            `Retrieved text for element ${selector} containing '${JSON.stringify(content)}' with text type ${textType}`,
+        );
     } catch (e) {
         if (e instanceof Error) {
             logger.error(e);
         }
         throw e;
     }
-    return stringResponse(content, 'Text received successfully.');
+    let textTypeString: string;
+    if (textTypeEnum !== TextType.ROBOT_FRAMEWORK_BROWSER_NO_SET) {
+        textTypeString = ` with text type ${textType}.`;
+    } else {
+        textTypeString = '.';
+    }
+    return listStringResponse(content, `Text received successfully${textTypeString}`);
 }
 
 export async function getBoolProperty(
diff --git a/node/playwright-wrapper/interaction.ts b/node/playwright-wrapper/interaction.ts
index 1734c597d..1d0299bf9 100644
--- a/node/playwright-wrapper/interaction.ts
+++ b/node/playwright-wrapper/interaction.ts
@@ -20,7 +20,7 @@ import { getSelections } from './getters';
 import { exists } from './playwright-invoke';
 import { findLocator, invokeOnKeyboard, invokeOnMouse } from './playwright-invoke';
 import { PlaywrightState } from './playwright-state';
-import { emptyWithLog } from './response-util';
+import { emptyWithLog, listStringResponse } from './response-util';
 
 export async function selectOption(
     request: pb.Request_SelectElementSelector,
@@ -254,7 +254,7 @@ export async function waitForAlerts(request: pb.Request_AlertActions, page: Page
             void dialogObject.dismiss();
         }
     }
-    return { items: alertMessages };
+    return listStringResponse(alertMessages, 'Handled all alerts');
 }
 
 export async function mouseButton(request: pb.Request_MouseButtonOptions, page?: Page): Promise<pb.Response_Empty> {
diff --git a/node/playwright-wrapper/response-util.ts b/node/playwright-wrapper/response-util.ts
index 095c4c99e..aa11a66bd 100644
--- a/node/playwright-wrapper/response-util.ts
+++ b/node/playwright-wrapper/response-util.ts
@@ -23,6 +23,7 @@ import {
     Response_JavascriptExecutionResult,
     Response_Json,
     Response_Keywords,
+    Response_ListString,
     Response_PageReportResponse,
     Response_String,
 } from './generated/playwright';
@@ -68,6 +69,10 @@ export function stringResponse(body: string, logMessage: string): Response_Strin
     return { body, log: logMessage };
 }
 
+export function listStringResponse(body: string[], logMessage: string): Response_ListString {
+    return { items: body, log: logMessage };
+}
+
 export function jsonResponse(body: string, logMessage: string, bodyPart: string = ''): Response_Json {
     return { json: body, log: logMessage, bodyPart };
 }
diff --git a/protobuf/playwright.proto b/protobuf/playwright.proto
index 7b0653ef6..37b83fd22 100644
--- a/protobuf/playwright.proto
+++ b/protobuf/playwright.proto
@@ -274,6 +274,12 @@ message Request {
     bool force = 3;
   }
 
+  message ElementSelectorWithTextType {
+    string selector = 1;
+    bool strict = 2;
+    string textType = 3;
+  }
+
   message Timeout {
     float timeout = 1;
   }
@@ -395,6 +401,7 @@ message Response {
 
   message ListString {
     repeated string items = 1;
+    string log = 2;
   }
 
   message Keywords {
@@ -489,7 +496,7 @@ service  Playwright {
   rpc ClearText(Request.ClearText) returns (Response.Empty);
   /* Gets the DOM property 'property' of selector specified element */
   rpc GetDomProperty(Request.ElementProperty) returns (Response.String);
-  rpc GetText(Request.ElementSelector) returns (Response.String);
+  rpc GetText(Request.ElementSelectorWithTextType) returns (Response.ListString);
   /* Gets the XML attribute 'attribute' of selector specified element */
   rpc GetElementAttribute(Request.ElementProperty) returns (Response.String);
   /* Gets the boolean DOM property 'property' of selector specified element */
diff --git a/utest/test_get_text.py b/utest/test_get_text.py
index ac7810ab2..81b085b77 100644
--- a/utest/test_get_text.py
+++ b/utest/test_get_text.py
@@ -5,7 +5,7 @@
 
 class Response:
     log = "Log text"
-    body = "element text"
+    items = ["element text"]
 
 
 def test_get_text(ctx: MagicMock):