diff --git a/example/src/App.tsx b/example/src/App.tsx
index c29982a97..831d68fd6 100644
--- a/example/src/App.tsx
+++ b/example/src/App.tsx
@@ -12,13 +12,41 @@ import { Route } from "@react-navigation/native";
 import { NestedNavigator } from './screens/NestedNavigator/NestedNavigator';
 import { getDatadogConfig, onDatadogInitialization } from './ddUtils';
 import { TrackingConsent } from '@datadog/mobile-react-native';
+import { NavigationTrackingOptions, ParamsTrackingPredicate, ViewTrackingPredicate } from '@datadog/mobile-react-navigation/src/rum/instrumentation/DdRumReactNavigationTracking';
 
 const Tab = createBottomTabNavigator();
 
-const viewPredicate: ViewNamePredicate = function customViewNamePredicate(route: Route<string, any | undefined>, trackedName: string) {
+// === Navigation Tracking custom predicates
+const viewNamePredicate: ViewNamePredicate = function customViewNamePredicate(route: Route<string, any | undefined>, trackedName: string) {
   return "Custom RN " + trackedName;
 }
 
+const viewTrackingPredicate: ViewTrackingPredicate = function customViewTrackingPredicate(route: Route<string, any | undefined>) { 
+  if (route.name === "AlertModal") {
+    return false;
+  }
+
+  return true;
+}
+
+const paramsTrackingPredicate: ParamsTrackingPredicate = function customParamsTrackingPredicate(route: Route<string, any | undefined>) { 
+  const filteredParams: any = {};
+  if (route.params?.creditCardNumber) {
+    filteredParams["creditCardNumber"] = "XXXX XXXX XXXX XXXX";
+  }
+
+  if (route.params?.username) {
+    filteredParams["username"] = route.params.username;
+  }
+
+  return filteredParams;
+}
+
+const navigationTrackingOptions: NavigationTrackingOptions = {
+  viewNamePredicate,
+  viewTrackingPredicate,
+  paramsTrackingPredicate,
+}
 // === Datadog Provider Configuration schemes ===
 
 // 1.- Direct configuration
@@ -39,7 +67,9 @@ export default function App() {
   return (
     <DatadogProvider configuration={configuration} onInitialization={onDatadogInitialization}>
       <NavigationContainer ref={navigationRef} onReady={() => {
-        DdRumReactNavigationTracking.startTrackingViews(navigationRef.current, viewPredicate)
+        DdRumReactNavigationTracking.startTrackingViews(
+          navigationRef.current,
+          navigationTrackingOptions)
       }}>
         <Tab.Navigator screenOptions={{
           tabBarLabelStyle: style.tabLabelStyle,
diff --git a/example/src/WixApp.tsx b/example/src/WixApp.tsx
index 55e93f6e4..809912843 100644
--- a/example/src/WixApp.tsx
+++ b/example/src/WixApp.tsx
@@ -11,18 +11,43 @@ import {
 } from '@datadog/mobile-react-native-navigation';
 
 import styles from './screens/styles';
-import { DdTrace } from '@datadog/mobile-react-native';
 import TraceScreen from './screens/TraceScreen';
+import { NavigationTrackingOptions, ParamsTrackingPredicate, ViewTrackingPredicate } from '@datadog/mobile-react-native-navigation/src/rum/instrumentation/DdRumReactNativeNavigationTracking';
 
-const viewPredicate: ViewNamePredicate = (
-    _event: ComponentDidAppearEvent,
-    trackedName: string
-) => {
-    return 'Custom RNN ' + trackedName;
-};
+// === Navigation Tracking custom predicates
+const viewNamePredicate: ViewNamePredicate = function customViewNamePredicate(_event: ComponentDidAppearEvent, trackedName: string) {
+    return "Custom RN " + trackedName;
+}
+
+const viewTrackingPredicate: ViewTrackingPredicate = function customViewTrackingPredicate(event: ComponentDidAppearEvent) { 
+    if (event.name === "AlertModal") {
+        return false;
+    }
+
+    return true;
+}
+
+const paramsTrackingPredicate: ParamsTrackingPredicate = function customParamsTrackingPredicate(event: ComponentDidAppearEvent) { 
+    const filteredParams: any = {};
+    if (event.passProps?.creditCardNumber) {
+        filteredParams["creditCardNumber"] = "XXXX XXXX XXXX XXXX";
+    }
+
+    if (event.passProps?.username) {
+        filteredParams["username"] = event.passProps.username;
+    }
+
+    return filteredParams;
+}
+
+const navigationTrackingOptions: NavigationTrackingOptions = {
+  viewNamePredicate,
+  viewTrackingPredicate,
+  paramsTrackingPredicate,
+}
 
 function startReactNativeNavigation() {
-    DdRumReactNativeNavigationTracking.startTracking(viewPredicate);
+    DdRumReactNativeNavigationTracking.startTracking(navigationTrackingOptions);
     registerScreens();
     Navigation.events().registerAppLaunchedListener(async () => {
         Navigation.setRoot({
@@ -80,7 +105,12 @@ const HomeScreen = props => {
                 title="About"
                 onPress={() => {
                     Navigation.push(props.componentId, {
-                        component: { name: 'About' }
+                        component: { name: 'About',
+                                    passProps: {
+                                        username: "test",
+                                        creditCardNumber: "4242 4242 4242 4242"
+                                    } 
+                                }
                     });
                 }}
             />
diff --git a/example/src/screens/NestedNavigator/ScreenWithLinks.tsx b/example/src/screens/NestedNavigator/ScreenWithLinks.tsx
index 965236fd6..7419331cb 100644
--- a/example/src/screens/NestedNavigator/ScreenWithLinks.tsx
+++ b/example/src/screens/NestedNavigator/ScreenWithLinks.tsx
@@ -5,6 +5,6 @@ import {useNavigation} from '@react-navigation/native'
 export const ScreenWithLinks = (props: {links: { routeName: string}[]}) => {
     const {navigate} = useNavigation()
     return (<>
-    {props.links.map(link => <Button title={`go to ${link.routeName}`} onPress={() => navigate(link.routeName)} key={link.routeName} />)}
+    {props.links.map(link => <Button title={`go to ${link.routeName}`} onPress={() => navigate(link.routeName, {username: "test", creditCardNumber: "4242 4242 4242 4242"})} key={link.routeName} />)}
     </>)
-}
\ No newline at end of file
+}
diff --git a/packages/react-native-navigation/src/__tests__/rum/instrumentation/DdRumReactNativeNavigationTracking.test.tsx b/packages/react-native-navigation/src/__tests__/rum/instrumentation/DdRumReactNativeNavigationTracking.test.tsx
index 9baa94d0c..782ccc0f9 100644
--- a/packages/react-native-navigation/src/__tests__/rum/instrumentation/DdRumReactNativeNavigationTracking.test.tsx
+++ b/packages/react-native-navigation/src/__tests__/rum/instrumentation/DdRumReactNativeNavigationTracking.test.tsx
@@ -16,7 +16,11 @@ import { Navigation } from 'react-native-navigation';
 import { AppState, Button } from 'react-native';
 import React from 'react';
 
-import type { ViewNamePredicate } from '../../../rum/instrumentation/DdRumReactNativeNavigationTracking';
+import type {
+    ParamsTrackingPredicate,
+    ViewNamePredicate,
+    ViewTrackingPredicate
+} from '../../../rum/instrumentation/DdRumReactNativeNavigationTracking';
 import { DdRumReactNativeNavigationTracking } from '../../../rum/instrumentation/DdRumReactNativeNavigationTracking';
 
 import { AppStateMockLegacy } from './__utils__/AppStateMockLegacy';
@@ -104,7 +108,7 @@ it('M send a RUM ViewEvent W startTracking() for the first view', async () => {
     );
 });
 
-it('M send a RUM ViewEvent W startTracking() componentDidAppear { custom viewPredicate }', async () => {
+it('M send a RUM ViewEvent W startTracking() componentDidAppear { custom viewNamePredicate }', async () => {
     // GIVEN
 
     // eslint-disable-next-line func-names
@@ -117,7 +121,9 @@ it('M send a RUM ViewEvent W startTracking() componentDidAppear { custom viewPre
         }
         return _trackedName;
     };
-    DdRumReactNativeNavigationTracking.startTracking(predicate);
+    DdRumReactNativeNavigationTracking.startTracking({
+        viewNamePredicate: predicate
+    });
 
     // WHEN
     const { findByText } = render(
@@ -135,7 +141,7 @@ it('M send a RUM ViewEvent W startTracking() componentDidAppear { custom viewPre
     );
 });
 
-it('M not send a RUM ViewEvent W startTracking() componentDidAppear { viewPredicate returns null }', async () => {
+it('M not send a RUM ViewEvent W startTracking() componentDidAppear { viewNamePredicate returns null }', async () => {
     // GIVEN
     let viewDropped = false;
 
@@ -150,7 +156,9 @@ it('M not send a RUM ViewEvent W startTracking() componentDidAppear { viewPredic
         }
         return _trackedName;
     };
-    DdRumReactNativeNavigationTracking.startTracking(predicate);
+    DdRumReactNativeNavigationTracking.startTracking({
+        viewNamePredicate: predicate
+    });
 
     // WHEN
     const { findByText } = render(
@@ -165,6 +173,101 @@ it('M not send a RUM ViewEvent W startTracking() componentDidAppear { viewPredic
     expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'Home');
 });
 
+it('M send a RUM ViewEvent W startTracking() componentDidAppear { viewTrackingPredicate always returns true }', async () => {
+    // GIVEN
+    // eslint-disable-next-line func-names
+    let hasRunPredicate = false;
+    const predicate: ViewTrackingPredicate = function (
+        _event: ComponentDidAppearEvent
+    ) {
+        hasRunPredicate = true;
+        return true;
+    };
+    DdRumReactNativeNavigationTracking.startTracking({
+        viewTrackingPredicate: predicate
+    });
+
+    // WHEN
+    const { findByText } = render(
+        <ApplicationMock entryPoint={() => startPlayground()} />
+    );
+    const button = await findByText('Go to About');
+    await fireEvent(button, 'press');
+    await waitFor(() => hasRunPredicate);
+
+    // THEN
+    expect(DdRum.startView).toHaveBeenCalledTimes(2);
+    expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'Home');
+    expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'About');
+});
+
+it('M send a RUM ViewEvent W startTracking() componentDidAppear { viewTrackingPredicate skips tracking About screen }', async () => {
+    // GIVEN
+    // eslint-disable-next-line func-names
+    let hasRunPredicate = false;
+    const predicate: ViewTrackingPredicate = function (
+        _event: ComponentDidAppearEvent
+    ) {
+        hasRunPredicate = true;
+        return _event.componentName !== 'About';
+    };
+    DdRumReactNativeNavigationTracking.startTracking({
+        viewTrackingPredicate: predicate
+    });
+
+    // WHEN
+    const { findByText } = render(
+        <ApplicationMock entryPoint={() => startPlayground()} />
+    );
+    const button = await findByText('Go to About');
+    await fireEvent(button, 'press');
+    await waitFor(() => hasRunPredicate);
+
+    // THEN
+    expect(DdRum.startView).toHaveBeenCalledTimes(1);
+    expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'Home');
+    expect(DdRum.startView).not.toHaveBeenCalledWith(
+        expect.any(String),
+        'About'
+    );
+});
+
+it('M send a RUM ViewEvent W startTracking() componentDidAppear { paramsTrackingPredicate adds custom parameters }', async () => {
+    // GIVEN
+    // eslint-disable-next-line func-names
+    let hasRunPredicate = false;
+    const testPassProps = {
+        param1: true,
+        param2: 'abc'
+    };
+    const predicate: ParamsTrackingPredicate = function (
+        _event: ComponentDidAppearEvent
+    ) {
+        hasRunPredicate = true;
+        return testPassProps;
+    };
+    DdRumReactNativeNavigationTracking.startTracking({
+        paramsTrackingPredicate: predicate
+    });
+
+    // WHEN
+    const { findByText } = render(
+        <ApplicationMock entryPoint={() => startPlayground()} />
+    );
+    const button = await findByText('Go to About');
+    await fireEvent(button, 'press');
+    await waitFor(() => hasRunPredicate);
+
+    // THEN
+    expect(DdRum.startView).toHaveBeenCalledTimes(2);
+    expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'Home', {
+        passProps: testPassProps
+    });
+    expect(DdRum.startView).toHaveBeenCalledWith(expect.any(String), 'About', {
+        passProps: testPassProps
+    });
+});
+
 describe.each([
     ['react-native 0.63-0.64', AppStateMockLegacy],
     ['react-native 0.65+', AppStateMock]
diff --git a/packages/react-native-navigation/src/index.tsx b/packages/react-native-navigation/src/index.tsx
index 284be250d..8b5d6b566 100644
--- a/packages/react-native-navigation/src/index.tsx
+++ b/packages/react-native-navigation/src/index.tsx
@@ -4,11 +4,21 @@
  * Copyright 2016-Present Datadog, Inc.
  */
 
-import type { ViewNamePredicate } from './rum/instrumentation/DdRumReactNativeNavigationTracking';
+import type {
+    ViewNamePredicate,
+    ViewTrackingPredicate,
+    ParamsTrackingPredicate,
+    NavigationTrackingOptions
+} from './rum/instrumentation/DdRumReactNativeNavigationTracking';
 import { DdRumReactNativeNavigationTracking } from './rum/instrumentation/DdRumReactNativeNavigationTracking';
 
 export { DdRumReactNativeNavigationTracking };
 
-export type { ViewNamePredicate };
+export type {
+    ViewNamePredicate,
+    ViewTrackingPredicate,
+    ParamsTrackingPredicate,
+    NavigationTrackingOptions
+};
 
 export * from 'react-native-navigation';
diff --git a/packages/react-native-navigation/src/rum/instrumentation/DdRumReactNativeNavigationTracking.tsx b/packages/react-native-navigation/src/rum/instrumentation/DdRumReactNativeNavigationTracking.tsx
index 51e59f80d..9bc83dd30 100644
--- a/packages/react-native-navigation/src/rum/instrumentation/DdRumReactNativeNavigationTracking.tsx
+++ b/packages/react-native-navigation/src/rum/instrumentation/DdRumReactNativeNavigationTracking.tsx
@@ -14,11 +14,38 @@ import type {
 } from 'react-native';
 import { AppState } from 'react-native';
 
+export type NavigationTrackingOptions = {
+    viewNamePredicate?: ViewNamePredicate;
+    viewTrackingPredicate?: ViewTrackingPredicate;
+    paramsTrackingPredicate?: ParamsTrackingPredicate;
+};
+
 export type ViewNamePredicate = (
     event: ComponentDidAppearEvent,
     trackedName: string
 ) => string | null;
 
+export type ViewTrackingPredicate = (event: ComponentDidAppearEvent) => boolean;
+
+export type ParamsTrackingPredicate = (
+    event: ComponentDidAppearEvent
+) => object | undefined;
+
+function defaultViewNamePredicate(
+    _event: ComponentDidAppearEvent,
+    trackedName: string
+) {
+    return trackedName;
+}
+
+function defaultParamsPredicate(_event: ComponentDidAppearEvent) {
+    return undefined;
+}
+
+function defaultViewTrackingPredicate(_event: ComponentDidAppearEvent) {
+    return true;
+}
+
 // AppStateStatus can have values:
 //     'active' - The app is running in the foreground
 //     'background' - The app is running in the background. The user is either in another app or on the home screen
@@ -38,6 +65,8 @@ export class DdRumReactNativeNavigationTracking {
     private static appStateSubscription?: NativeEventSubscription;
 
     private static viewNamePredicate: ViewNamePredicate;
+    private static viewTrackingPredicate: ViewTrackingPredicate;
+    private static paramsTrackingPredicate: ParamsTrackingPredicate;
     private static lastView?:
         | {
               key: string;
@@ -48,27 +77,39 @@ export class DdRumReactNativeNavigationTracking {
     /**
      * Starts tracking the Navigation and sends a RUM View event every time a root View component appear/disappear.
      */
-    static startTracking(
-        // eslint-disable-next-line func-names
-        viewNamePredicate: ViewNamePredicate = function (
-            _event: ComponentDidAppearEvent,
-            trackedName: string
-        ) {
-            return trackedName;
-        }
-    ): void {
+    static startTracking(trackingOptions?: NavigationTrackingOptions): void {
         // extra safety to avoid wrapping more than 1 time this function
         if (DdRumReactNativeNavigationTracking.isTracking) {
             return;
         }
 
+        const {
+            viewNamePredicate = defaultViewNamePredicate,
+            viewTrackingPredicate = defaultViewTrackingPredicate,
+            paramsTrackingPredicate = defaultParamsPredicate
+        } = trackingOptions ?? {};
+
         DdRumReactNativeNavigationTracking.eventSubscription = Navigation.events().registerComponentDidAppearListener(
             (event: ComponentDidAppearEvent) => {
                 const predicate =
                     DdRumReactNativeNavigationTracking.viewNamePredicate;
                 const screenName = predicate(event, event.componentName);
-                if (screenName !== null) {
-                    DdRum.startView(event.componentId, screenName);
+                const shouldTrack = DdRumReactNativeNavigationTracking.viewTrackingPredicate(
+                    event
+                );
+                if (screenName !== null && shouldTrack) {
+                    const passProps = DdRumReactNativeNavigationTracking.paramsTrackingPredicate(
+                        event
+                    );
+
+                    if (passProps) {
+                        DdRum.startView(event.componentId, screenName, {
+                            passProps
+                        });
+                    } else {
+                        DdRum.startView(event.componentId, screenName);
+                    }
+
                     DdRumReactNativeNavigationTracking.lastView = {
                         key: event.componentId,
                         name: screenName
@@ -79,6 +120,8 @@ export class DdRumReactNativeNavigationTracking {
 
         DdRumReactNativeNavigationTracking.isTracking = true;
         DdRumReactNativeNavigationTracking.viewNamePredicate = viewNamePredicate;
+        DdRumReactNativeNavigationTracking.viewTrackingPredicate = viewTrackingPredicate;
+        DdRumReactNativeNavigationTracking.paramsTrackingPredicate = paramsTrackingPredicate;
         this.appStateSubscription = AppState.addEventListener(
             'change',
             DdRumReactNativeNavigationTracking.appStateListener
@@ -110,6 +153,9 @@ export class DdRumReactNativeNavigationTracking {
 
         DdRumReactNativeNavigationTracking.lastView = undefined;
         DdRumReactNativeNavigationTracking.isTracking = false;
+        DdRumReactNativeNavigationTracking.viewNamePredicate = defaultViewNamePredicate;
+        DdRumReactNativeNavigationTracking.viewTrackingPredicate = defaultViewTrackingPredicate;
+        DdRumReactNativeNavigationTracking.paramsTrackingPredicate = defaultParamsPredicate;
 
         // eslint-disable-next-line func-names
         DdRumReactNativeNavigationTracking.viewNamePredicate = function (
diff --git a/packages/react-navigation/src/__tests__/rum/instrumentation/DdRumReactNavigationTracking.test.tsx b/packages/react-navigation/src/__tests__/rum/instrumentation/DdRumReactNavigationTracking.test.tsx
index ba80256f3..150257c42 100644
--- a/packages/react-navigation/src/__tests__/rum/instrumentation/DdRumReactNavigationTracking.test.tsx
+++ b/packages/react-navigation/src/__tests__/rum/instrumentation/DdRumReactNavigationTracking.test.tsx
@@ -12,7 +12,11 @@ import mockBackHandler from 'react-native/Libraries/Utilities/__mocks__/BackHand
 import { AppState, BackHandler } from 'react-native';
 import React, { createRef } from 'react';
 
-import type { ViewNamePredicate } from '../../../rum/instrumentation/DdRumReactNavigationTracking';
+import type {
+    ParamsTrackingPredicate,
+    ViewNamePredicate,
+    ViewTrackingPredicate
+} from '../../../rum/instrumentation/DdRumReactNavigationTracking';
 import { DdRumReactNavigationTracking } from '../../../rum/instrumentation/DdRumReactNavigationTracking';
 
 import { AppStateMockLegacy } from './__utils__/AppStateMockLegacy';
@@ -164,7 +168,9 @@ describe.each([
                 };
                 DdRumReactNavigationTracking.startTrackingViews(
                     navigationRef.current,
-                    predicate
+                    {
+                        viewNamePredicate: predicate
+                    }
                 );
 
                 // WHEN
@@ -196,7 +202,9 @@ describe.each([
 
                 DdRumReactNavigationTracking.startTrackingViews(
                     navigationRef.current,
-                    predicate
+                    {
+                        viewNamePredicate: predicate
+                    }
                 );
 
                 // WHEN
@@ -207,6 +215,126 @@ describe.each([
                 expect(DdRum.startView).not.toHaveBeenCalled();
             });
 
+            it('sends a related RUM ViewEvent when switching screens { viewTrackingPredicate returns true }', async () => {
+                // GIVEN
+                const navigationRef = createRef<any>();
+                const { getByText } = render(
+                    <FakeNavigator1 navigationRef={navigationRef} />
+                );
+                const goToAboutButton = getByText('Go to About');
+
+                // eslint-disable-next-line func-names
+                const predicate: ViewTrackingPredicate = function (
+                    _route: Route<string, any | undefined>
+                ) {
+                    return true;
+                };
+
+                DdRumReactNavigationTracking.startTrackingViews(
+                    navigationRef.current,
+                    {
+                        viewTrackingPredicate: predicate
+                    }
+                );
+
+                // WHEN
+                expect(goToAboutButton).toBeTruthy();
+                fireEvent(goToAboutButton, 'press');
+
+                // THEN
+                expect(DdRum.startView).toHaveBeenCalledTimes(2);
+                expect(DdRum.startView).toHaveBeenCalledWith(
+                    expect.any(String),
+                    'Home'
+                );
+                expect(DdRum.startView).toHaveBeenCalledWith(
+                    expect.any(String),
+                    'About'
+                );
+            });
+
+            it('sends a related RUM ViewEvent when switching screens { viewTrackingPredicate returns true for Home screen only }', async () => {
+                // GIVEN
+                const navigationRef = createRef<any>();
+                const { getByText } = render(
+                    <FakeNavigator1 navigationRef={navigationRef} />
+                );
+                const goToAboutButton = getByText('Go to About');
+
+                // eslint-disable-next-line func-names
+                const predicate: ViewTrackingPredicate = function (
+                    _route: Route<string, any | undefined>
+                ) {
+                    return _route.name === 'Home';
+                };
+
+                DdRumReactNavigationTracking.startTrackingViews(
+                    navigationRef.current,
+                    {
+                        viewTrackingPredicate: predicate
+                    }
+                );
+
+                // WHEN
+                expect(goToAboutButton).toBeTruthy();
+                fireEvent(goToAboutButton, 'press');
+
+                // THEN
+                expect(DdRum.startView).toHaveBeenCalledTimes(1);
+                expect(DdRum.startView).toHaveBeenCalledWith(
+                    expect.any(String),
+                    'Home'
+                );
+                expect(DdRum.startView).not.toHaveBeenCalledWith(
+                    expect.any(String),
+                    'About'
+                );
+            });
+
+            it('sends a related RUM ViewEvent when switching screens { viewParamsPredicate returns params object }', async () => {
+                // GIVEN
+                const navigationRef = createRef<any>();
+                const { getByText } = render(
+                    <FakeNavigator1 navigationRef={navigationRef} />
+                );
+                const goToAboutButton = getByText('Go to About');
+                const testParams = {
+                    param1: true,
+                    param2: 'abc'
+                };
+
+                // eslint-disable-next-line func-names
+                const predicate: ParamsTrackingPredicate = function (
+                    _route: Route<string, any | undefined>
+                ) {
+                    return testParams;
+                };
+
+                DdRumReactNavigationTracking.startTrackingViews(
+                    navigationRef.current,
+                    {
+                        paramsTrackingPredicate: predicate
+                    }
+                );
+
+                // WHEN
+                expect(goToAboutButton).toBeTruthy();
+                fireEvent(goToAboutButton, 'press');
+
+                // THEN
+                expect(DdRum.startView).toHaveBeenCalledTimes(2);
+                expect(DdRum.startView).toHaveBeenCalledWith(
+                    expect.any(String),
+                    'Home',
+                    { params: testParams }
+                );
+                expect(DdRum.startView).toHaveBeenCalledWith(
+                    expect.any(String),
+                    'About',
+                    { params: testParams }
+                );
+            });
+
             it('only registers once when startTrackingViews{ multiple times }', async () => {
                 // GIVEN
                 const navigationRef = createRef<any>();
diff --git a/packages/react-navigation/src/index.tsx b/packages/react-navigation/src/index.tsx
index 351b49f52..3dddbdcb4 100644
--- a/packages/react-navigation/src/index.tsx
+++ b/packages/react-navigation/src/index.tsx
@@ -4,9 +4,19 @@
  * Copyright 2016-Present Datadog, Inc.
  */
 
-import type { ViewNamePredicate } from './rum/instrumentation/DdRumReactNavigationTracking';
+import type {
+    NavigationTrackingOptions,
+    ViewNamePredicate,
+    ViewTrackingPredicate,
+    ParamsTrackingPredicate
+} from './rum/instrumentation/DdRumReactNavigationTracking';
 import { DdRumReactNavigationTracking } from './rum/instrumentation/DdRumReactNavigationTracking';
 
 export { DdRumReactNavigationTracking };
 
-export type { ViewNamePredicate };
+export type {
+    NavigationTrackingOptions,
+    ViewNamePredicate,
+    ViewTrackingPredicate,
+    ParamsTrackingPredicate
+};
diff --git a/packages/react-navigation/src/rum/instrumentation/DdRumReactNavigationTracking.tsx b/packages/react-navigation/src/rum/instrumentation/DdRumReactNavigationTracking.tsx
index 825e1afb1..913aa6e7b 100644
--- a/packages/react-navigation/src/rum/instrumentation/DdRumReactNavigationTracking.tsx
+++ b/packages/react-navigation/src/rum/instrumentation/DdRumReactNavigationTracking.tsx
@@ -24,11 +24,40 @@ import type {
 //     'extension' [iOS] - The app is running as an app extension
 declare type AppStateListener = (appStateStatus: AppStateStatus) => void | null;
 
+export type NavigationTrackingOptions = {
+    viewNamePredicate?: ViewNamePredicate;
+    viewTrackingPredicate?: ViewTrackingPredicate;
+    paramsTrackingPredicate?: ParamsTrackingPredicate;
+};
+
 export type ViewNamePredicate = (
     route: Route<string, any | undefined>,
     trackedName: string
 ) => string | null;
 
+export type ViewTrackingPredicate = (
+    route: Route<string, any | undefined>
+) => boolean;
+
+export type ParamsTrackingPredicate = (
+    route: Route<string, any | undefined>
+) => object | undefined;
+
+function defaultViewNamePredicate(
+    _route: Route<string, any | undefined>,
+    trackedName: string
+) {
+    return trackedName;
+}
+
+function defaultParamsPredicate(_route: Route<string, any | undefined>) {
+    return undefined;
+}
+
+function defaultViewTrackingPredicate(_route: Route<string, any | undefined>) {
+    return true;
+}
+
 /**
  * Provides RUM integration for the [ReactNavigation](https://reactnavigation.org/) API.
  */
@@ -52,6 +81,10 @@ export class DdRumReactNavigationTracking {
 
     private static viewNamePredicate: ViewNamePredicate;
 
+    private static viewTrackingPredicate: ViewTrackingPredicate;
+
+    private static paramsTrackingPredicate: ParamsTrackingPredicate;
+
     private static backHandler: NativeEventSubscription | null;
 
     private static appStateSubscription?: NativeEventSubscription;
@@ -112,20 +145,23 @@ export class DdRumReactNavigationTracking {
     /**
      * Starts tracking the NavigationContainer and sends a RUM View event every time the navigation route changed.
      * @param navigationRef the reference to the real NavigationContainer.
+     * @param trackingOptions the options object defining how views will be tracked. It contains:
+     *      viewNamePredicate: the predicate to rename views.
+     *      viewTrackingPredicate: the predicate to determine if a view should be tracked or not.
+     *      paramsTrackingPredicate: the predicate to determine which parameters should be tracked for a given view.
      */
     static startTrackingViews(
         navigationRef: NavigationContainerRef | null,
-
-        // eslint-disable-next-line func-names
-        viewNamePredicate: ViewNamePredicate = function (
-            _route: Route<string, any | undefined>,
-            trackedName: string
-        ) {
-            return trackedName;
-        }
+        trackingOptions?: NavigationTrackingOptions
     ): void {
         this.navigationTimeline?.addStartTrackingEvent();
 
+        const {
+            viewNamePredicate = defaultViewNamePredicate,
+            viewTrackingPredicate = defaultViewTrackingPredicate,
+            paramsTrackingPredicate = defaultParamsPredicate
+        } = trackingOptions ?? {};
+
         if (navigationRef == null) {
             InternalLog.log(
                 DdRumReactNavigationTracking.NULL_NAVIGATION_REF_ERROR_MESSAGE,
@@ -144,6 +180,8 @@ export class DdRumReactNavigationTracking {
             );
         } else if (DdRumReactNavigationTracking.registeredContainer == null) {
             DdRumReactNavigationTracking.viewNamePredicate = viewNamePredicate;
+            DdRumReactNavigationTracking.viewTrackingPredicate = viewTrackingPredicate;
+            DdRumReactNavigationTracking.paramsTrackingPredicate = paramsTrackingPredicate;
             DdRumReactNavigationTracking.registeredContainer = navigationRef;
 
             const listener = DdRumReactNavigationTracking.resolveNavigationStateChangeListener();
@@ -180,14 +218,9 @@ export class DdRumReactNavigationTracking {
             DdRumReactNavigationTracking.backHandler = null;
             DdRumReactNavigationTracking.registeredContainer = null;
             DdRumReactNavigationTracking.navigationStateChangeListener = null;
-
-            // eslint-disable-next-line func-names
-            DdRumReactNavigationTracking.viewNamePredicate = function (
-                _route: Route<string, any | undefined>,
-                trackedName: string
-            ) {
-                return trackedName;
-            };
+            DdRumReactNavigationTracking.viewNamePredicate = defaultViewNamePredicate;
+            DdRumReactNavigationTracking.viewTrackingPredicate = defaultViewTrackingPredicate;
+            DdRumReactNavigationTracking.paramsTrackingPredicate = defaultParamsPredicate;
         }
 
         // For versions of React Native below 0.65, addEventListener does not return a subscription.
@@ -242,7 +275,16 @@ export class DdRumReactNavigationTracking {
                         trackingState: this.trackingState
                     }
                 );
-                DdRum.startView(key, screenName);
+                if (DdRumReactNavigationTracking.viewTrackingPredicate(route)) {
+                    const params = DdRumReactNavigationTracking.paramsTrackingPredicate(
+                        route
+                    );
+                    if (params) {
+                        DdRum.startView(key, screenName, { params });
+                    } else {
+                        DdRum.startView(key, screenName);
+                    }
+                }
             }
         }