diff --git a/DuckDuckGo/DuckPlayer/DuckPlayerNavigationHandler.swift b/DuckDuckGo/DuckPlayer/DuckPlayerNavigationHandler.swift
index f64a61f558..609b1d3af8 100644
--- a/DuckDuckGo/DuckPlayer/DuckPlayerNavigationHandler.swift
+++ b/DuckDuckGo/DuckPlayer/DuckPlayerNavigationHandler.swift
@@ -117,7 +117,7 @@ final class DuckPlayerNavigationHandler: NSObject {
          pixelFiring: PixelFiring.Type = Pixel.self,
          dailyPixelFiring: DailyPixelFiring.Type = DailyPixel.self,
          tabNavigationHandler: DuckPlayerTabNavigationHandling? = nil,
-         duckPlayerOverlayUsagePixels: DuckPlayerOverlayPixelFiring? = nil) {
+         duckPlayerOverlayUsagePixels: DuckPlayerOverlayPixelFiring? = DuckPlayerOverlayUsagePixels()) {
         self.duckPlayer = duckPlayer
         self.featureFlagger = featureFlagger
         self.appSettings = appSettings
@@ -575,8 +575,6 @@ final class DuckPlayerNavigationHandler: NSObject {
             // Watch in YT videos always open in new tab
             redirectToYouTubeVideo(url: url, webView: webView, forceNewTab: true)
         }
-    
-    
     }
     
 }
@@ -638,7 +636,9 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
                 // Before performing the simulated request
                 DispatchQueue.main.asyncAfter(deadline: .now() + 0.15) {
                     self.performRequest(request: newRequest, webView: webView)
+                    self.duckPlayerOverlayUsagePixels?.handleNavigationAndFirePixels(url: url, duckPlayerMode: self.duckPlayerMode)
                     self.fireDuckPlayerPixels(webView: webView)
+                    
                 }
             } else {
                 redirectToYouTubeVideo(url: url, webView: webView)
@@ -663,9 +663,6 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
     @MainActor
     func handleURLChange(webView: WKWebView) -> DuckPlayerNavigationHandlerURLChangeResult {
         
-        // Track overlayUsagePixels
-        duckPlayerOverlayUsagePixels?.registerNavigation(url: webView.url)
-        
         // We want to prevent multiple simultaneous redirects
         // This can be caused by Duplicate Nav events, and quick URL changes
         if let lastTimestamp = lastURLChangeHandling,
@@ -683,6 +680,12 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
             return .notHandled(.duplicateNavigation)
         }
         
+        // Overlay Usage Pixel handling
+        if let url = webView.url {
+            duckPlayerOverlayUsagePixels?.handleNavigationAndFirePixels(url: url, duckPlayerMode: duckPlayerMode)
+            lastURLChangeHandling = Date()
+        }
+        
         // Check if DuckPlayer feature is enabled
         guard isDuckPlayerFeatureEnabled else {
             return .notHandled(.featureOff)
@@ -735,7 +738,7 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
     @MainActor
     func handleGoBack(webView: WKWebView) {
                 
-        guard isDuckPlayerFeatureEnabled else {
+        guard let url = webView.url, url.isDuckPlayer, isDuckPlayerFeatureEnabled else {
             webView.goBack()
             return
         }
@@ -783,7 +786,7 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
         guard let url = webView.url else {
             return
         }
-            
+                    
         if url.isDuckPlayer, duckPlayerMode != .disabled {
             redirectToDuckPlayerVideo(url: url, webView: webView, disableNewTab: true)
             return
@@ -833,6 +836,17 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
         // Reset allowFirstVideo
         duckPlayer.settings.allowFirstVideo = false
         
+        // Overlay Usage Pixel handling for Direct Navigation
+        if let url = webView.url, !url.isYoutube {
+            duckPlayerOverlayUsagePixels?.handleNavigationAndFirePixels(url: url, duckPlayerMode: duckPlayerMode)
+        }
+        // Reset Overlay Last Fired pixel after the page is loaded
+        // A delay is required as Youtube sometimes performs an extra redirect on load
+        DispatchQueue.main.asyncAfter(deadline: .now() + 3) {
+            self.duckPlayerOverlayUsagePixels?.lastFiredPixel = nil
+        }
+        
+        
     }
     
     /// Resets settings when the web view starts loading a new page.
@@ -890,7 +904,7 @@ extension DuckPlayerNavigationHandler: DuckPlayerNavigationHandling {
         guard isDuckPlayerFeatureEnabled else {
             return false
         }
-                
+        
         // Only account for in 'Always' mode
         if duckPlayerMode == .disabled {
             return false
diff --git a/DuckDuckGo/DuckPlayer/DuckPlayerOverlayUsagePixels.swift b/DuckDuckGo/DuckPlayer/DuckPlayerOverlayUsagePixels.swift
index 459b762f40..6f3339dd72 100644
--- a/DuckDuckGo/DuckPlayer/DuckPlayerOverlayUsagePixels.swift
+++ b/DuckDuckGo/DuckPlayer/DuckPlayerOverlayUsagePixels.swift
@@ -23,21 +23,16 @@ protocol DuckPlayerOverlayPixelFiring {
     
     var pixelFiring: PixelFiring.Type { get set }
     var navigationHistory: [URL] { get set }
+    var lastFiredPixel: Pixel.Event? { get set }
     
-    func registerNavigation(url: URL?)
-    func navigationBack(duckPlayerMode: DuckPlayerMode)
-    func navigationReload(duckPlayerMode: DuckPlayerMode)
-    func navigationWithinYoutube(duckPlayerMode: DuckPlayerMode)
-    func navigationOutsideYoutube(duckPlayerMode: DuckPlayerMode)
-    func navigationClosed(duckPlayerMode: DuckPlayerMode)
-    func overlayIdle(duckPlayerMode: DuckPlayerMode)
-    
+    func handleNavigationAndFirePixels(url: URL?, duckPlayerMode: DuckPlayerMode)
 }
 
 final class DuckPlayerOverlayUsagePixels: DuckPlayerOverlayPixelFiring {
 
     var pixelFiring: PixelFiring.Type
     var navigationHistory: [URL] = []
+    var lastFiredPixel: Pixel.Event?
 
     private var idleTimer: Timer?
     private var idleTimeInterval: TimeInterval
@@ -49,75 +44,64 @@ final class DuckPlayerOverlayUsagePixels: DuckPlayerOverlayPixelFiring {
         self.idleTimeInterval = timeoutInterval
     }
 
-    // Method to reset the idle timer
-    private func resetIdleTimer() {
-        idleTimer?.invalidate()
-        idleTimer = nil
-    }
-
-    func registerNavigation(url: URL?) {
+    func handleNavigationAndFirePixels(url: URL?, duckPlayerMode: DuckPlayerMode) {
         guard let url = url else { return }
-        navigationHistory.append(url)
-        
-        // Cancel and reset the idle timer whenever a new navigation occurs
-        resetIdleTimer()
-    }
-
-    func navigationBack(duckPlayerMode: DuckPlayerMode) {
-        guard duckPlayerMode == .alwaysAsk,
-              let lastURL = navigationHistory.last,
-              lastURL.isYoutubeWatch else { return }
-
-        pixelFiring.fire(.duckPlayerYouTubeOverlayNavigationBack, withAdditionalParameters: [:])
-    }
-
-    func navigationReload(duckPlayerMode: DuckPlayerMode) {
-        guard duckPlayerMode == .alwaysAsk,
-              let lastURL = navigationHistory.last,
-              lastURL.isYoutubeWatch else { return }
+        let comparisonURL = url.forComparison()
 
-        pixelFiring.fire(.duckPlayerYouTubeOverlayNavigationRefresh, withAdditionalParameters: [:])
-    }
+        // Only append the URL if it's different from the last entry in normalized form
+        navigationHistory.append(comparisonURL)
 
-    func navigationWithinYoutube(duckPlayerMode: DuckPlayerMode) {
+        // DuckPlayer is in Ask Mode, there's navigation history, and last URL is a YouTube Watch Video
         guard duckPlayerMode == .alwaysAsk,
               navigationHistory.count > 1,
               let currentURL = navigationHistory.last,
               let previousURL = navigationHistory.dropLast().last,
-              previousURL.isYoutubeWatch,
-              currentURL.isYoutube else { return }
-
-        pixelFiring.fire(.duckPlayerYouTubeNavigationWithinYouTube, withAdditionalParameters: [:])
-    }
+              previousURL.isYoutubeWatch else { return }
+
+        var isReload = false
+        // Check for a reload condition: when current videoID is the same as Previous
+        if let currentVideoID = currentURL.youtubeVideoParams?.videoID,
+           let previousVideoID = previousURL.youtubeVideoParams?.videoID,
+           !previousURL.isDuckPlayer, !currentURL.isDuckPlayer {
+            isReload = currentVideoID == previousVideoID
+        }
 
-    func navigationOutsideYoutube(duckPlayerMode: DuckPlayerMode) {
-        guard duckPlayerMode == .alwaysAsk,
-              navigationHistory.count > 1,
-              let currentURL = navigationHistory.last,
-              let previousURL = navigationHistory.dropLast().last,
-              previousURL.isYoutubeWatch,
-              !currentURL.isYoutube else { return }
+        // Fire the reload pixel if this is a reload navigation
+        if isReload {
+            firePixel(.duckPlayerYouTubeOverlayNavigationRefresh)
+        } else {
+            // Determine if it’s a back navigation by looking further back in history
+            let isBackNavigation = navigationHistory.count > 2 &&
+                                   navigationHistory[navigationHistory.count - 3].forComparison() == currentURL.forComparison()
+
+            // Fire the appropriate pixel based on navigation type
+            if isBackNavigation {
+                firePixel(.duckPlayerYouTubeOverlayNavigationBack)
+            } else if previousURL.isYoutubeWatch && currentURL.isYoutube {
+                // Forward navigation within YouTube (including non-video URLs)
+                firePixel(.duckPlayerYouTubeNavigationWithinYouTube)
+            } else if previousURL.isYoutubeWatch && !currentURL.isYoutube && !currentURL.isDuckPlayer {
+                // Navigation outside YouTube
+                firePixel(.duckPlayerYouTubeOverlayNavigationOutsideYoutube)
+                navigationHistory.removeAll()
+            }
+        }
 
-        pixelFiring.fire(.duckPlayerYouTubeOverlayNavigationOutsideYoutube, withAdditionalParameters: [:])
+        // Truncation logic: Remove all URLs up to the last occurrence of the current URL in normalized form
+        if navigationHistory.count > 0 {
+            if let lastOccurrenceIndex = (0..<navigationHistory.count - 1).last(where: { navigationHistory[$0].forComparison() == comparisonURL }) {
+                navigationHistory = Array(navigationHistory.prefix(upTo: lastOccurrenceIndex + 1))
+            }
+        }
     }
-
-    func navigationClosed(duckPlayerMode: DuckPlayerMode) {
-        
-        guard duckPlayerMode == .alwaysAsk,
-              let lastURL = navigationHistory.last,
-              lastURL.isYoutubeWatch else { return }
-        
-        pixelFiring.fire(.duckPlayerYouTubeOverlayNavigationClosed, withAdditionalParameters: [:])
-        
+    
+    private func firePixel(_ pixel: Pixel.Event) {
+        if lastFiredPixel == .duckPlayerYouTubeOverlayNavigationRefresh && pixel == .duckPlayerYouTubeOverlayNavigationRefresh {
+            return
+        }
+        lastFiredPixel = pixel
+        pixelFiring.fire(pixel, withAdditionalParameters: [:])
     }
 
-    func overlayIdle(duckPlayerMode: DuckPlayerMode) {
-        guard duckPlayerMode == .alwaysAsk,
-              let lastURL = navigationHistory.last,
-              lastURL.isYoutubeWatch else { return }
 
-        idleTimer = Timer.scheduledTimer(withTimeInterval: idleTimeInterval, repeats: false) { [weak self] _ in
-            self?.pixelFiring.fire(.duckPlayerYouTubeNavigationIdle30, withAdditionalParameters: [:])
-        }
-    }
 }
diff --git a/DuckDuckGoTests/DuckPlayerOverlayUsagePixelsTests.swift b/DuckDuckGoTests/DuckPlayerOverlayUsagePixelsTests.swift
index dc5be8e048..7f966f334f 100644
--- a/DuckDuckGoTests/DuckPlayerOverlayUsagePixelsTests.swift
+++ b/DuckDuckGoTests/DuckPlayerOverlayUsagePixelsTests.swift
@@ -27,201 +27,104 @@ class DuckPlayerOverlayUsagePixelsTests: XCTestCase {
 
     override func setUp() {
         super.setUp()
-        // Initialize DuckPlayerOverlayUsagePixels with a shorter timeoutInterval for testing
         PixelFiringMock.tearDown()
         duckPlayerOverlayPixels = DuckPlayerOverlayUsagePixels(pixelFiring: PixelFiringMock.self, timeoutInterval: 3.0)
     }
 
     override func tearDown() {
-        // Clean up after each test
         PixelFiringMock.tearDown()
         duckPlayerOverlayPixels = nil
         super.tearDown()
     }
-
-    func testRegisterNavigationAddsURLToHistory() {
-        // Arrange
-        let testURL = URL(string: "https://www.example.com")!
-
-        // Act
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Assert
-        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory.count, 1)
-        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory.first, testURL)
-    }
-
-    func testRegisterNavigationWithNilURLDoesNotAddToHistory() {
-        // Act
-        duckPlayerOverlayPixels.registerNavigation(url: nil)
-
-        // Assert
-        XCTAssertTrue(duckPlayerOverlayPixels.navigationHistory.isEmpty, "Navigation history should remain empty when registering a nil URL.")
-    }
-
-    func testNavigationBackFiresPixelWhenConditionsMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationBack(duckPlayerMode: .alwaysAsk)
-
-        // Assert
+    
+    // Test: Registering navigation appends URL to history
+    func testRegisterNavigationAppendsURLToHistory() {
+        let testURL1 = URL(string: "https://www.youtube.com/watch?v=example1")!
+        let testURL2 = URL(string: "https://www.youtube.com/playlist?list=PL-gbSnmxoBbmDnoFdZY5OsSuU6kqs_07a")!
+        let testURL3 = URL(string: "https://www.example.com")!
+        
+        // Simulate navigation actions
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL1, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL2, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL3, duckPlayerMode: .alwaysAsk)
+        
+        // Verify the URLs are appended in order
+        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory.count, 3)
+        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory[0], testURL1.forComparison())
+        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory[1], testURL2.forComparison())
+        XCTAssertEqual(duckPlayerOverlayPixels.navigationHistory[2], testURL3.forComparison())
+    }
+
+    // Test: Back navigation triggers duckPlayerYouTubeOverlayNavigationBack pixel
+    func testBackNavigationTriggersBackPixel() {
+        let firstURL = URL(string: "https://www.youtube.com/watch?v=example1")!
+        let secondURL = URL(string: "https://www.youtube.com/watch?v=example2")!
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: firstURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: secondURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: firstURL, duckPlayerMode: .alwaysAsk) // Simulates back navigation
+        
         XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationBack.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when conditions are met for navigationBack.")
+        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired on back navigation.")
     }
 
-    func testNavigationBackDoesNotFirePixelWhenConditionsNotMet() {
-        // Act
-        duckPlayerOverlayPixels.navigationBack(duckPlayerMode: .enabled)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired when conditions are not met for navigationBack.")
-    }
-
-    func testNavigationReloadFiresPixelWhenConditionsMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationReload(duckPlayerMode: .alwaysAsk)
-
-        // Assert
+    // Test: Reload navigation triggers duckPlayerYouTubeOverlayNavigationRefresh pixel
+    func testReloadNavigationTriggersRefreshPixel() {
+        let testURL = URL(string: "https://www.youtube.com/watch?v=XTWWSS")!
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL, duckPlayerMode: .alwaysAsk) // Simulates reload navigation
+        
         XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationRefresh.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when conditions are met for navigationReload.")
-    }
-
-    func testNavigationReloadDoesNotFirePixelWhenConditionsNotMet() {
-        // Act
-        duckPlayerOverlayPixels.navigationReload(duckPlayerMode: .enabled)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired when conditions are not met for navigationReload.")
+        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired on reload navigation.")
     }
 
-    func testNavigationWithinYoutubeFiresPixelWhenConditionsMet() {
-        // Arrange
-        let previousURL = URL(string: "https://www.youtube.com/watch?v=example1")!
-        let currentURL = URL(string: "https://www.youtube.com/watch?v=example2")!
-        duckPlayerOverlayPixels.registerNavigation(url: previousURL)
-        duckPlayerOverlayPixels.registerNavigation(url: currentURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationWithinYoutube(duckPlayerMode: .alwaysAsk)
-
-        // Assert
+    // Test: Forward navigation to various YouTube URLs triggers duckPlayerYouTubeNavigationWithinYouTube pixel
+    func testNavigateWithinYoutubeTriggersWithinYouTubePixel() {
+        let videoURL = URL(string: "https://www.youtube.com/watch?v=example1")!
+        let playlistURL = URL(string: "https://www.youtube.com/playlist?list=PL-gbSnmxoBbmDnoFdZY5OsSuU6kqs_07a")!
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: videoURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: playlistURL, duckPlayerMode: .alwaysAsk)
+        
         XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeNavigationWithinYouTube.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when conditions are met for navigationWithinYoutube.")
-    }
-
-    func testNavigationWithinYoutubeDoesNotFirePixelWhenConditionsNotMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.example.com")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationWithinYoutube(duckPlayerMode: .alwaysAsk)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired when conditions are not met for navigationWithinYoutube.")
+        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when navigating within YouTube to a non-video URL.")
     }
 
-    func testNavigationOutsideYoutubeFiresPixelWhenConditionsMet() {
-        // Arrange
-        let previousURL = URL(string: "https://www.youtube.com/watch?v=example1")!
-        let currentURL = URL(string: "https://www.example.com")!
-        duckPlayerOverlayPixels.registerNavigation(url: previousURL)
-        duckPlayerOverlayPixels.registerNavigation(url: currentURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationOutsideYoutube(duckPlayerMode: .alwaysAsk)
-
-        // Assert
+    // Test: Navigating outside YouTube triggers duckPlayerYouTubeOverlayNavigationOutsideYoutube pixel
+    func testNavigateOutsideYoutubeTriggersOutsideYouTubePixel() {
+        let youtubeURL = URL(string: "https://www.youtube.com/watch?v=example1")!
+        let outsideURL = URL(string: "https://www.example.com")!
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: youtubeURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: outsideURL, duckPlayerMode: .alwaysAsk)
+        
         XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationOutsideYoutube.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when conditions are met for navigationOutsideYoutube.")
+        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when navigating outside YouTube.")
     }
 
-    func testNavigationOutsideYoutubeDoesNotFirePixelWhenConditionsNotMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationOutsideYoutube(duckPlayerMode: .alwaysAsk)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired when conditions are not met for navigationOutsideYoutube.")
+    // Negative Test: Back navigation does not trigger within YouTube or outside YouTube pixel
+    func testBackNavigationDoesNotTriggerWithinOrOutsideYouTubePixel() {
+        let firstURL = URL(string: "https://www.youtube.com/watch?v=example1")!
+        let secondURL = URL(string: "https://www.youtube.com/watch?v=example2")!
+        let backURL = URL(string: "https://www.youtube.com/watch?v=example1")!
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: firstURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: secondURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: backURL, duckPlayerMode: .alwaysAsk) // Simulates back navigation
+        
+        XCTAssertNotEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeNavigationWithinYouTube.name, "Within YouTube pixel should not fire on back navigation.")
+        XCTAssertNotEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationOutsideYoutube.name, "Outside YouTube pixel should not fire on back navigation.")
     }
 
-    func testOverlayIdleStartsTimerAndFiresPixelAfter3Seconds() {
-        // Arrange
+    // Negative Test: Reload navigation does not trigger within YouTube or outside YouTube pixel
+    func testReloadNavigationDoesNotTriggerWithinOrOutsideYouTubePixel() {
         let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.overlayIdle(duckPlayerMode: .alwaysAsk)
-
-        // Simulate waiting for 3 seconds
-        let expectation = XCTestExpectation(description: "Wait for the pixel to be fired after 3 seconds.")
-        DispatchQueue.main.asyncAfter(deadline: .now() + 3.1) {
-            expectation.fulfill()
-        }
-
-        wait(for: [expectation], timeout: 5)
-
-        // Assert
-        XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeNavigationIdle30.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired after 3 seconds of inactivity.")
-    }
-
-    func testOverlayIdleDoesNotFirePixelWhenNavigationHistoryIsNotYouTubeWatch() {
-        // Arrange
-        let testURL = URL(string: "https://www.example.com")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.overlayIdle(duckPlayerMode: .alwaysAsk)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired if the last URL is not a YouTube watch URL.")
-    }
-
-    func testOverlayIdleDoesNotStartTimerIfModeIsNotAlwaysAsk() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.overlayIdle(duckPlayerMode: .enabled)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired if the mode is not .alwaysAsk.")
-    }
-    
-    func testNavigationClosedFiresPixelWhenConditionsMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com/watch?v=example")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationClosed(duckPlayerMode: .alwaysAsk)
-
-        // Assert
-        XCTAssertEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationClosed.name)
-        XCTAssertNotNil(PixelFiringMock.lastPixelInfo, "Pixel should be fired when conditions are met for navigationReload.")
-    }
-    
-    func testNavigationClosedDoesNotFirePixelWhenConditionsNotMet() {
-        // Arrange
-        let testURL = URL(string: "https://www.youtube.com")!
-        duckPlayerOverlayPixels.registerNavigation(url: testURL)
-
-        // Act
-        duckPlayerOverlayPixels.navigationClosed(duckPlayerMode: .enabled)
-
-        // Assert
-        XCTAssertNil(PixelFiringMock.lastPixelName, "Pixel should not be fired when conditions are not met for navigationClosed.")
+        
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL, duckPlayerMode: .alwaysAsk)
+        duckPlayerOverlayPixels.handleNavigationAndFirePixels(url: testURL, duckPlayerMode: .alwaysAsk) // Simulates reload navigation
+        
+        XCTAssertNotEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeNavigationWithinYouTube.name, "Within YouTube pixel should not fire on reload.")
+        XCTAssertNotEqual(PixelFiringMock.lastPixelName, Pixel.Event.duckPlayerYouTubeOverlayNavigationOutsideYoutube.name, "Outside YouTube pixel should not fire on reload.")
     }
 }