diff --git a/src/__tests__/findByApi.test.js b/src/__tests__/findByApi.test.js
index f924cb1b3..da05cba8c 100644
--- a/src/__tests__/findByApi.test.js
+++ b/src/__tests__/findByApi.test.js
@@ -18,19 +18,19 @@ test('findBy queries work asynchronously', async () => {
   } = render(<View />);
   await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
   await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findByText('Some Text', options)).rejects.toBeTruthy();
-  await expect(findAllByText('Some Text', options)).rejects.toBeTruthy();
+  await expect(findByText('Some Text', {}, options)).rejects.toBeTruthy();
+  await expect(findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
   await expect(
-    findByPlaceholderText('Placeholder Text', options)
+    findByPlaceholderText('Placeholder Text', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findAllByPlaceholderText('Placeholder Text', options)
+    findAllByPlaceholderText('Placeholder Text', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findByDisplayValue('Display Value', options)
+    findByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
   await expect(
-    findAllByDisplayValue('Display Value', options)
+    findAllByDisplayValue('Display Value', {}, options)
   ).rejects.toBeTruthy();
 
   setTimeout(
diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
index a2b2637d1..9fea5924f 100644
--- a/src/__tests__/getByApi.test.js
+++ b/src/__tests__/getByApi.test.js
@@ -1,7 +1,7 @@
 // @flow
 import React from 'react';
 import { View, Text, TextInput, Button } from 'react-native';
-import { render } from '..';
+import { render, getDefaultNormalizer } from '..';
 
 const MyComponent = () => {
   return <Text>My Component</Text>;
@@ -50,3 +50,114 @@ test('supports a regex matcher', () => {
   expect(getByTestId(/view/)).toBeTruthy();
   expect(getAllByTestId(/text/)).toHaveLength(2);
 });
+
+describe('Supports a TextMatch options', () => {
+  test('getByText, getAllByText', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a detail"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('details', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByPlaceholderText, getAllByPlaceholderText', () => {
+    const { getByPlaceholderText, getAllByPlaceholderText } = render(
+      <View>
+        <TextInput placeholder={'Placeholder with details'} />
+        <TextInput placeholder={'Placeholder with a DETAIL'} />
+      </View>
+    );
+
+    expect(getByPlaceholderText('details', { exact: false })).toBeTruthy();
+    expect(getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('getByDisplayValue, getAllByDisplayValue', () => {
+    const { getByDisplayValue, getAllByDisplayValue } = render(
+      <View>
+        <TextInput value={'Value with details'} />
+        <TextInput value={'Value with a detail'} />
+      </View>
+    );
+
+    expect(getByDisplayValue('details', { exact: false })).toBeTruthy();
+    expect(getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
+  });
+
+  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
+    const { getByText, getAllByText } = render(
+      <View>
+        <Text testID="text">Text and details</Text>
+        <Button
+          testID="button"
+          title="Button and a DeTAil"
+          onPress={jest.fn()}
+        />
+      </View>
+    );
+
+    expect(getByText('DeTaIlS', { exact: false })).toBeTruthy();
+    expect(getAllByText('detail', { exact: false })).toHaveLength(2);
+  });
+});
+
+describe('Supports normalization', () => {
+  test('trims and collapses whitespace by default', () => {
+    const { getByText } = render(
+      <View>
+        <Text>{`  Text     and
+        
+        
+        whitespace`}</Text>
+      </View>
+    );
+
+    expect(getByText('Text and whitespace')).toBeTruthy();
+  });
+
+  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
+    const testTextWithWhitespace = `  Text     and
+        
+        
+        whitespace`;
+    const { getByText } = render(
+      <View>
+        <Text>{testTextWithWhitespace}</Text>
+      </View>
+    );
+
+    expect(
+      getByText(testTextWithWhitespace, {
+        normalizer: getDefaultNormalizer({
+          trim: false,
+          collapseWhitespace: false,
+        }),
+      })
+    ).toBeTruthy();
+  });
+
+  test('normalizer function is customisable', () => {
+    const testText = 'A TO REMOVE text';
+    const normalizerFn = (textToNormalize: string) =>
+      textToNormalize.replace('TO REMOVE ', '');
+    const { getByText } = render(
+      <View>
+        <Text>{testText}</Text>
+      </View>
+    );
+
+    expect(
+      getByText('A text', {
+        normalizer: normalizerFn,
+      })
+    ).toBeTruthy();
+  });
+});
diff --git a/src/__tests__/queryByApi.test.js b/src/__tests__/queryByApi.test.js
index f7f39b991..2afc3800a 100644
--- a/src/__tests__/queryByApi.test.js
+++ b/src/__tests__/queryByApi.test.js
@@ -60,6 +60,7 @@ test('queryByText nested text across multiple <Text> in <Text>', () => {
   );
 
   expect(queryByText('Hello World!')?.props.nativeID).toBe('1');
+  expect(queryByText('hello Wo', { exact: false })?.props.nativeID).toBe('1');
 });
 
 test('queryByText with nested Text components return the closest Text', () => {
@@ -72,6 +73,7 @@ test('queryByText with nested Text components return the closest Text', () => {
   const { queryByText } = render(<NestedTexts />);
 
   expect(queryByText('My text')?.props.nativeID).toBe('2');
+  expect(queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
 test('queryByText with nested Text components each with text return the lowest one', () => {
@@ -87,6 +89,30 @@ test('queryByText with nested Text components each with text return the lowest o
   expect(queryByText('My text')?.props.nativeID).toBe('2');
 });
 
+test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', () => {
+  const { queryByText: queryByTextFirstCase } = render(
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My </Text>
+      <Text nativeID="3">text</Text>
+    </Text>
+  );
+
+  const { queryByText: queryByTextSecondCase } = render(
+    <Text nativeID="1">
+      bob
+      <Text nativeID="2">My text for test</Text>
+    </Text>
+  );
+
+  expect(
+    queryByTextFirstCase('My text', { exact: false })?.props.nativeID
+  ).toBe('1');
+  expect(
+    queryByTextSecondCase('My text', { exact: false })?.props.nativeID
+  ).toBe('2');
+});
+
 test('queryByText nested <CustomText> in <Text>', () => {
   const CustomText = ({ children }) => {
     return <Text>{children}</Text>;
diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index 7cb8b4699..286bdd677 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -12,54 +12,92 @@ import {
   getAllByDisplayValue,
 } from './getByAPI';
 import { throwRenamedFunctionError } from './errors';
+import type { TextMatchOptions } from './getByAPI';
 
 const makeFindQuery = <Text, Result>(
   instance: ReactTestInstance,
-  getQuery: (instance: ReactTestInstance) => (text: Text) => Result,
+  getQuery: (
+    instance: ReactTestInstance
+  ) => (text: Text, options?: TextMatchOptions) => Result,
   text: Text,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions
-): Promise<Result> => waitFor(() => getQuery(instance)(text), waitForOptions);
+): Promise<Result> =>
+  waitFor(() => getQuery(instance)(text, queryOptions), waitForOptions);
 
 export const findByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByTestId, testId, waitForOptions);
+) => makeFindQuery(instance, getByTestId, testId, {}, waitForOptions);
 
 export const findAllByTestId = (instance: ReactTestInstance) => (
   testId: string | RegExp,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByTestId, testId, waitForOptions);
+) => makeFindQuery(instance, getAllByTestId, testId, {}, waitForOptions);
 
 export const findByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByText, text, waitForOptions);
+) => makeFindQuery(instance, getByText, text, queryOptions, waitForOptions);
 
 export const findAllByText = (instance: ReactTestInstance) => (
   text: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByText, text, waitForOptions);
+) => makeFindQuery(instance, getAllByText, text, queryOptions, waitForOptions);
 
 export const findByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByPlaceholderText, placeholder, waitForOptions);
+) =>
+  makeFindQuery(
+    instance,
+    getByPlaceholderText,
+    placeholder,
+    queryOptions,
+    waitForOptions
+  );
 
 export const findAllByPlaceholderText = (instance: ReactTestInstance) => (
   placeholder: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
 ) =>
-  makeFindQuery(instance, getAllByPlaceholderText, placeholder, waitForOptions);
+  makeFindQuery(
+    instance,
+    getAllByPlaceholderText,
+    placeholder,
+    queryOptions,
+    waitForOptions
+  );
 
 export const findByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByDisplayValue, value, waitForOptions);
+) =>
+  makeFindQuery(
+    instance,
+    getByDisplayValue,
+    value,
+    queryOptions,
+    waitForOptions
+  );
 
 export const findAllByDisplayValue = (instance: ReactTestInstance) => (
   value: string | RegExp,
+  queryOptions?: TextMatchOptions,
   waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByDisplayValue, value, waitForOptions);
+) =>
+  makeFindQuery(
+    instance,
+    getAllByDisplayValue,
+    value,
+    queryOptions,
+    waitForOptions
+  );
 
 export const findByAPI = (instance: ReactTestInstance) => ({
   findByTestId: findByTestId(instance),
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index 844820125..75f31e44e 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -1,6 +1,8 @@
 // @flow
 import * as React from 'react';
 import prettyFormat from 'pretty-format';
+import { makeNormalizer, matches } from '../matches';
+import type { NormalizerFn } from '../matches';
 import {
   ErrorWithStack,
   createLibraryNotSupportedError,
@@ -9,9 +11,14 @@ import {
   throwRenamedFunctionError,
 } from './errors';
 
+export type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+
 const filterNodeByType = (node, type) => node.type === type;
 
-const getNodeByText = (node, text) => {
+const getNodeByText = (node, text, options?: TextMatchOptions = {}) => {
   try {
     // eslint-disable-next-line
     const { Text } = require('react-native');
@@ -20,9 +27,11 @@ const getNodeByText = (node, text) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return typeof text === 'string'
-          ? text === textToTest
-          : text.test(textToTest);
+        const { exact, normalizer } = options;
+        const normalizerFn = makeNormalizer({
+          normalizer,
+        });
+        return matches(textToTest, text, normalizerFn, exact);
       }
     }
     return false;
@@ -59,30 +68,42 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
   return textContent;
 };
 
-const getTextInputNodeByPlaceholderText = (node, placeholder) => {
+const getTextInputNodeByPlaceholderText = (
+  node,
+  placeholder,
+  options?: TextMatchOptions = {}
+) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
+    const normalizerFn = makeNormalizer({
+      normalizer,
+    });
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof placeholder === 'string'
-        ? placeholder === node.props.placeholder
-        : placeholder.test(node.props.placeholder))
+      matches(node.props.placeholder, placeholder, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
   }
 };
 
-const getTextInputNodeByDisplayValue = (node, value) => {
+const getTextInputNodeByDisplayValue = (
+  node,
+  value,
+  options?: TextMatchOptions = {}
+) => {
   try {
     // eslint-disable-next-line
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
+    const normalizerFn = makeNormalizer({
+      normalizer,
+    });
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof value === 'string'
-        ? value === node.props.value
-        : value.test(node.props.value))
+      matches(node.props.value, value, normalizerFn, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -96,19 +117,45 @@ const getNodeByTestId = (node, testID) => {
 };
 
 export const getByText = (instance: ReactTestInstance) =>
-  function getByTextFn(text: string | RegExp) {
+  function getByTextFn(
+    text: string | RegExp,
+    options: TextMatchOptions = { exact: true }
+  ) {
     try {
-      return instance.find((node) => getNodeByText(node, text));
+      const matches = instance.findAll((node) =>
+        getNodeByText(node, text, options)
+      );
+
+      if (matches.length === 0) {
+        throw new ErrorWithStack(
+          `No instances found with text: ${String(text)}`,
+          getByTextFn
+        );
+      }
+
+      if (options.exact && matches.length > 1) {
+        throw new ErrorWithStack(
+          `Expected 1 but found ${
+            matches.length
+          } instances matching text ${String(text)}`,
+          getByTextFn
+        );
+      }
+      // when using exact === false we want to return last match (most deeply nested in component tree)
+      return matches[matches.length - 1];
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByTextFn);
     }
   };
 
 export const getByPlaceholderText = (instance: ReactTestInstance) =>
-  function getByPlaceholderTextFn(placeholder: string | RegExp) {
+  function getByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
       return instance.find((node) =>
-        getTextInputNodeByPlaceholderText(node, placeholder)
+        getTextInputNodeByPlaceholderText(node, placeholder, options)
       );
     } catch (error) {
       throw new ErrorWithStack(
@@ -119,10 +166,13 @@ export const getByPlaceholderText = (instance: ReactTestInstance) =>
   };
 
 export const getByDisplayValue = (instance: ReactTestInstance) =>
-  function getByDisplayValueFn(placeholder: string | RegExp) {
+  function getByDisplayValueFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     try {
       return instance.find((node) =>
-        getTextInputNodeByDisplayValue(node, placeholder)
+        getTextInputNodeByDisplayValue(node, placeholder, options)
       );
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByDisplayValueFn);
@@ -149,8 +199,10 @@ export const getByTestId = (instance: ReactTestInstance) =>
   };
 
 export const getAllByText = (instance: ReactTestInstance) =>
-  function getAllByTextFn(text: string | RegExp) {
-    const results = instance.findAll((node) => getNodeByText(node, text));
+  function getAllByTextFn(text: string | RegExp, options?: TextMatchOptions) {
+    const results = instance.findAll((node) =>
+      getNodeByText(node, text, options)
+    );
     if (results.length === 0) {
       throw new ErrorWithStack(
         `No instances found with text: ${String(text)}`,
@@ -161,9 +213,12 @@ export const getAllByText = (instance: ReactTestInstance) =>
   };
 
 export const getAllByPlaceholderText = (instance: ReactTestInstance) =>
-  function getAllByPlaceholderTextFn(placeholder: string | RegExp) {
+  function getAllByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     const results = instance.findAll((node) =>
-      getTextInputNodeByPlaceholderText(node, placeholder)
+      getTextInputNodeByPlaceholderText(node, placeholder, options)
     );
     if (results.length === 0) {
       throw new ErrorWithStack(
@@ -175,9 +230,12 @@ export const getAllByPlaceholderText = (instance: ReactTestInstance) =>
   };
 
 export const getAllByDisplayValue = (instance: ReactTestInstance) =>
-  function getAllByDisplayValueFn(value: string | RegExp) {
+  function getAllByDisplayValueFn(
+    value: string | RegExp,
+    options?: TextMatchOptions
+  ) {
     const results = instance.findAll((node) =>
-      getTextInputNodeByDisplayValue(node, value)
+      getTextInputNodeByDisplayValue(node, value, options)
     );
     if (results.length === 0) {
       throw new ErrorWithStack(
diff --git a/src/helpers/queryByAPI.js b/src/helpers/queryByAPI.js
index 3d5ce8488..fef7abcf2 100644
--- a/src/helpers/queryByAPI.js
+++ b/src/helpers/queryByAPI.js
@@ -19,29 +19,39 @@ import {
   throwRemovedFunctionError,
   throwRenamedFunctionError,
 } from './errors';
+import type { TextMatchOptions } from './getByAPI';
 
 export const queryByText = (instance: ReactTestInstance) =>
-  function queryByTextFn(text: string | RegExp) {
+  function queryByTextFn(
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) {
     try {
-      return getByText(instance)(text);
+      return getByText(instance)(text, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByTextFn);
     }
   };
 
 export const queryByPlaceholderText = (instance: ReactTestInstance) =>
-  function queryByPlaceholderTextFn(placeholder: string | RegExp) {
+  function queryByPlaceholderTextFn(
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) {
     try {
-      return getByPlaceholderText(instance)(placeholder);
+      return getByPlaceholderText(instance)(placeholder, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByPlaceholderTextFn);
     }
   };
 
 export const queryByDisplayValue = (instance: ReactTestInstance) =>
-  function queryByDisplayValueFn(value: string | RegExp) {
+  function queryByDisplayValueFn(
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) {
     try {
-      return getByDisplayValue(instance)(value);
+      return getByDisplayValue(instance)(value, queryOptions);
     } catch (error) {
       return createQueryByError(error, queryByDisplayValueFn);
     }
@@ -57,30 +67,33 @@ export const queryByTestId = (instance: ReactTestInstance) =>
   };
 
 export const queryAllByText = (instance: ReactTestInstance) => (
-  text: string | RegExp
+  text: string | RegExp,
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByText(instance)(text);
+    return getAllByText(instance)(text, queryOptions);
   } catch (error) {
     return [];
   }
 };
 
 export const queryAllByPlaceholderText = (instance: ReactTestInstance) => (
-  placeholder: string | RegExp
+  placeholder: string | RegExp,
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByPlaceholderText(instance)(placeholder);
+    return getAllByPlaceholderText(instance)(placeholder, queryOptions);
   } catch (error) {
     return [];
   }
 };
 
 export const queryAllByDisplayValue = (instance: ReactTestInstance) => (
-  value: string | RegExp
+  value: string | RegExp,
+  queryOptions?: TextMatchOptions
 ) => {
   try {
-    return getAllByDisplayValue(instance)(value);
+    return getAllByDisplayValue(instance)(value, queryOptions);
   } catch (error) {
     return [];
   }
diff --git a/src/matches.js b/src/matches.js
new file mode 100644
index 000000000..2d2f31106
--- /dev/null
+++ b/src/matches.js
@@ -0,0 +1,51 @@
+// @flow
+export type NormalizerFn = (textToNormalize: string) => string;
+
+function matches(
+  textToMatch: string,
+  matcher: string | RegExp,
+  normalizer: NormalizerFn,
+  exact?: boolean = true
+) {
+  if (typeof textToMatch !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(textToMatch);
+  if (typeof matcher === 'string') {
+    return exact
+      ? normalizedText === matcher
+      : normalizedText.toLowerCase().includes(matcher.toLowerCase());
+  } else {
+    return matcher.test(normalizedText);
+  }
+}
+
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+
+function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true,
+}: NormalizerConfig = {}): NormalizerFn {
+  return (text: string) => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace
+      ? normalizedText.replace(/\s+/g, ' ')
+      : normalizedText;
+    return normalizedText;
+  };
+}
+
+type NormalizerInput = {
+  normalizer?: NormalizerFn,
+};
+
+function makeNormalizer({ normalizer }: NormalizerInput = {}): NormalizerFn {
+  return normalizer ? normalizer : getDefaultNormalizer();
+}
+
+export { matches, getDefaultNormalizer, makeNormalizer };
diff --git a/src/pure.js b/src/pure.js
index b36edc6aa..61d9c5414 100644
--- a/src/pure.js
+++ b/src/pure.js
@@ -8,6 +8,7 @@ import shallow from './shallow';
 import waitFor, { waitForElement } from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
+import { getDefaultNormalizer } from './matches';
 
 export { act };
 export { cleanup };
@@ -18,3 +19,4 @@ export { shallow };
 export { waitFor, waitForElement };
 export { waitForElementToBeRemoved };
 export { within, getQueriesForElement };
+export { getDefaultNormalizer };
diff --git a/typings/index.d.ts b/typings/index.d.ts
index 898e504da..e088019d6 100644
--- a/typings/index.d.ts
+++ b/typings/index.d.ts
@@ -14,17 +14,20 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
+type TextMatch = string | RegExp
+
 interface GetByAPI {
-  getByText: (text: string | RegExp) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance;
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance;
-  getByTestId: (testID: string | RegExp) => ReactTestInstance;
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>;
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>;
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (placeholder: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByTestId: (testID: TextMatch) => ReactTestInstance;
+  getAllByTestId: (testID: TextMatch) => Array<ReactTestInstance>;
+  getAllByText: (text: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -64,19 +67,22 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: string | RegExp) => ReactTestInstance | null;
+  queryByText: (name: TextMatch, options?: TextMatchOptions) => ReactTestInstance | null;
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions,
   ) => ReactTestInstance | null;
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null;
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null;
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance> | [];
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance> | [];
+  queryByDisplayValue: (value: TextMatch, options?: TextMatchOptions) => ReactTestInstance | null;
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  queryAllByText: (text: TextMatch, options?: TextMatchOptions) => Array<ReactTestInstance> | [];
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
-    value: string | RegExp
+    value: TextMatch,
+    options?: TextMatchOptions,
   ) => Array<ReactTestInstance> | [];
 
   // Unsafe aliases
@@ -126,32 +132,38 @@ interface QueryByAPI {
 
 interface FindByAPI {
   findByText: (
-    text: string | RegExp,
-    waitForOptions?: WaitForOptions
+    text: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
   findByPlaceholderText: (
-    placeholder: string | RegExp,
-    waitForOptions?: WaitForOptions
+    placeholder: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
   findByDisplayValue: (
-    value: string | RegExp,
-    waitForOptions?: WaitForOptions
+    value: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindReturn;
-  findByTestId: (testID: string | RegExp, waitForOptions?: WaitForOptions) => FindReturn;
+  findByTestId: (testID: TextMatch, waitForOptions?: WaitForOptions) => FindReturn;
   findAllByText: (
-    text: string | RegExp,
-    waitForOptions?: WaitForOptions
+    text: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByPlaceholderText: (
-    placeholder: string | RegExp,
-    waitForOptions?: WaitForOptions
+    placeholder: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByDisplayValue: (
-    value: string | RegExp,
-    waitForOptions?: WaitForOptions
+    value: TextMatch,
+    waitForOptions?: WaitForOptions,
+    options?: TextMatchOptions,
   ) => FindAllReturn;
   findAllByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -166,54 +178,54 @@ export type A11yValue = {
 
 type A11yAPI = {
   // Label
-  getByA11yLabel: (matcher: string | RegExp) => GetReturn;
-  getByLabelText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yLabel: (matcher: string | RegExp) => GetAllReturn;
-  getAllByLabelText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yLabel: (matcher: string | RegExp) => QueryReturn;
-  queryByLabelText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yLabel: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByLabelText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yLabel: (matcher: TextMatch) => GetReturn;
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yLabel: (matcher: TextMatch) => GetAllReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yLabel: (matcher: TextMatch) => QueryReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yLabel: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: string | RegExp) => GetReturn;
-  getByHintText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yHint: (matcher: string | RegExp) => GetAllReturn;
-  getAllByHintText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yHint: (matcher: string | RegExp) => QueryReturn;
-  queryByHintText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yHint: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByHintText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yHint: (matcher: TextMatch) => GetReturn;
+  getByHintText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yHint: (matcher: TextMatch) => GetAllReturn;
+  getAllByHintText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yHint: (matcher: TextMatch) => QueryReturn;
+  queryByHintText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yHint: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByHintText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -325,6 +337,16 @@ export declare const render: (
 export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
+type NormalizerFn = (textToNormalize: string) => string;
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+
 type WaitForOptions = {
   timeout?: number;
   interval?: number;
@@ -350,6 +372,8 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
+export declare const getDefaultNormalizer: (normalizerConfig: NormalizerConfig) => NormalizerFn;
+
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.
  */
diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 43dfcdb82..c518e9b51 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -44,7 +44,7 @@ In order to properly use `findBy` and `findAllBy` queries you need at least Reac
 
 _Note: most methods like this one return a [`ReactTestInstance`](https://reactjs.org/docs/test-renderer.html#testinstance) with following properties that you may be interested in:_
 
-```jsx
+```typescript
 type ReactTestInstance = {
   type: string | Function,
   props: { [propName: string]: any },
@@ -53,6 +53,10 @@ type ReactTestInstance = {
 };
 ```
 
+### Options
+
+Query first argument can be a **string** or a **regex**. Some queries accept optional argument which change string matching behaviour. See [TextMatch](api-queries#textmatch) for more info.
+
 ### `ByText`
 
 > getByText, getAllByText, queryByText, queryAllByText, findByText, findAllByText
@@ -199,6 +203,91 @@ const { getByA11yValue } = render(<Component />);
 const element = getByA11yValue({ min: 40 });
 ```
 
+## TextMatch
+
+
+Several APIs accept a `TextMatch` which can be a `string` or `regex`.
+
+```typescript
+type TextMatchOptions = {
+  exact?: boolean;
+  normalizer?: (textToNormalize: string) => string;
+  trim?: boolean;
+  collapseWhitespace?: boolean;
+};
+```
+
+`exact` option defaults to `true` but if you want to search for a text slice or make text matching case-insensitive you can override it. That being said we advise you to use regex in more complex scenarios.
+
+### Normalization
+
+Before running any matching logic against text, it is automatically normalized. By default, normalization consists of trimming whitespace from the start and end of text, and collapsing multiple adjacent whitespace characters into a single space.
+
+If you want to prevent that normalization, or provide alternative normalization (e.g. to remove Unicode control characters), you can provide a `normalizer` function in the options object. This function will be given a string and is expected to return a normalized version of that string.
+
+:::info
+Specifying a value for `normalizer` replaces the built-in normalization, but you can call `getDefaultNormalizer` to obtain a built-in normalizer, either to adjust that normalization or to call it from your own normalizer.
+:::
+
+`getDefaultNormalizer` take options object which allows the selection of behaviour:
+
+- `trim`: Defaults to `true`. Trims leading and trailing whitespace.
+- `collapseWhitespace`: Defaults to `true`. Collapses inner whitespace (newlines, tabs repeated spaces) into a single space.
+
+#### Normalization Examples
+
+To perform a match against text without trimming:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: getDefaultNormalizer({ trim: false }),
+});
+```
+
+To override normalization to remove some Unicode characters whilst keeping some (but not all) of the built-in normalization behavior:
+
+```typescript
+getByText(node, 'text', {
+  normalizer: (str) =>
+    getDefaultNormalizer({ trim: false })(str).replace(/[\u200E-\u200F]*/g, ''),
+});
+```
+
+### TextMatch Examples
+
+Given the following render:
+
+```jsx
+const { getByText } = render(<Text>Hello World</Text>);
+```
+
+Will **find a match**:
+
+```js
+// Matching a string:
+getByText('Hello World'); // full string match
+getByText('llo Worl', { exact: false }); // substring match
+getByText('hello world', { exact: false }); // ignore case-sensitivity
+
+// Matching a regex:
+getByText(/World/); // substring match
+getByText(/world/i); // substring match, ignore case
+getByText(/^hello world$/i); // full string match, ignore case-sensitivity
+getByText(/Hello W?oRlD/i); // advanced regex
+```
+
+Will **NOT find a match**
+
+```js
+// substring does not match
+getByText('llo Worl');
+// full string does not match
+getByText('Goodbye World');
+
+// case-sensitive regex with different case
+getByText(/hello world/);
+```
+
 ## Unit testing helpers
 
 > Use sparingly and responsibly, escape hatches here