diff --git a/DuckDuckGo/DBP/DataBrokerProtectionPixelsHandler.swift b/DuckDuckGo/DBP/DataBrokerProtectionPixelsHandler.swift
index 31983f62aa..7051c22287 100644
--- a/DuckDuckGo/DBP/DataBrokerProtectionPixelsHandler.swift
+++ b/DuckDuckGo/DBP/DataBrokerProtectionPixelsHandler.swift
@@ -110,7 +110,8 @@ public class DataBrokerProtectionPixelsHandler: EventMapping<DataBrokerProtectio
                     .invalidPayload,
                     .pixelTest,
                     .customDataBrokerStatsOptoutSubmit,
-                    .customGlobalStatsOptoutSubmit:
+                    .customGlobalStatsOptoutSubmit,
+                    .weeklyChildBrokerOrphanedOptOuts:
 
                 PixelKit.fire(event)
 
diff --git a/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionEventPixels.swift b/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionEventPixels.swift
index 7f82c0513d..7d7e65b465 100644
--- a/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionEventPixels.swift
+++ b/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionEventPixels.swift
@@ -130,6 +130,8 @@ final class DataBrokerProtectionEventPixels {
 
         handler.fire(.weeklyReportScanning(hadNewMatch: newMatchesFoundInTheLastWeek > 0, hadReAppereance: reAppereancesInTheLastWeek > 0, scanCoverage: percentageOfBrokersScanned.toString))
         handler.fire(.weeklyReportRemovals(removals: removalsInTheLastWeek))
+
+        fireWeeklyChildBrokerOrphanedOptOutsPixels(for: data)
     }
 
     private func hadScanThisWeek(_ brokerProfileQuery: BrokerProfileQueryData) -> Bool {
@@ -149,6 +151,77 @@ final class DataBrokerProtectionEventPixels {
     }
 }
 
+// MARK: - Orphaned profiles stuff
+
+extension DataBrokerProtectionEventPixels {
+
+    func weeklyOptOuts(for brokerProfileQueries: [BrokerProfileQueryData]) -> [OptOutJobData] {
+        let optOuts = brokerProfileQueries.flatMap { $0.optOutJobData }
+        let weeklyOptOuts = optOuts.filter { !didWeekPassedBetweenDates(start: $0.createdDate, end: Date()) }
+        return weeklyOptOuts
+    }
+
+    func fireWeeklyChildBrokerOrphanedOptOutsPixels(for data: [BrokerProfileQueryData]) {
+        let brokerURLsToQueryData = Dictionary(grouping: data, by: { $0.dataBroker.url })
+        let childBrokerURLsToOrphanedProfilesCount = childBrokerURLsToOrphanedProfilesWeeklyCount(for: data)
+        for (key, value) in childBrokerURLsToOrphanedProfilesCount {
+            guard let childQueryData = brokerURLsToQueryData[key],
+                  let childBrokerName = childQueryData.first?.dataBroker.name,
+                  let parentURL = childQueryData.first?.dataBroker.parent,
+                  let parentQueryData = brokerURLsToQueryData[parentURL] else {
+                continue
+            }
+            let childRecordsCount = weeklyOptOuts(for: childQueryData).count
+            let parentRecordsCount = weeklyOptOuts(for: parentQueryData).count
+            let recordsCountDifference = childRecordsCount - parentRecordsCount
+
+            // If both values are zero there's no point sending the pixel
+            if recordsCountDifference <= 0 && value == 0 {
+                continue
+            }
+            handler.fire(.weeklyChildBrokerOrphanedOptOuts(dataBrokerName: childBrokerName,
+                                                           childParentRecordDifference: recordsCountDifference,
+                                                           calculatedOrphanedRecords: value))
+        }
+    }
+
+    func childBrokerURLsToOrphanedProfilesWeeklyCount(for data: [BrokerProfileQueryData]) -> [String: Int] {
+
+        let brokerURLsToQueryData = Dictionary(grouping: data, by: { $0.dataBroker.url })
+        let childBrokerURLsToQueryData = brokerURLsToQueryData.filter { (_, value: Array<BrokerProfileQueryData>) in
+            guard let first = value.first,
+                  first.dataBroker.parent != nil else {
+                return false
+            }
+            return true
+        }
+
+        let childBrokerURLsToOrphanedProfilesCount = childBrokerURLsToQueryData.mapValues { value in
+            guard let parent = value.first?.dataBroker.parent,
+                let parentsQueryData = brokerURLsToQueryData[parent] else {
+                return 0
+            }
+
+            let optOuts = weeklyOptOuts(for: value)
+            let parentBrokerOptOuts = weeklyOptOuts(for: parentsQueryData)
+
+            return orphanedProfilesCount(with: optOuts, parentOptOuts: parentBrokerOptOuts)
+        }
+
+        return childBrokerURLsToOrphanedProfilesCount
+    }
+
+    func orphanedProfilesCount(with childOptOuts: [OptOutJobData], parentOptOuts: [OptOutJobData]) -> Int {
+        let matchingCount = childOptOuts.reduce(0) { (partialResult: Int, optOut: OptOutJobData) in
+            let hasFoundParentMatch = parentOptOuts.contains { parentOptOut in
+                optOut.extractedProfile.doesMatchExtractedProfile(parentOptOut.extractedProfile)
+            }
+            return partialResult + (hasFoundParentMatch ? 1 : 0)
+        }
+        return childOptOuts.count - matchingCount
+    }
+}
+
 private extension Int {
     var toString: String {
         if self < 25 {
diff --git a/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionPixels.swift b/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionPixels.swift
index d7b4cbd67c..b9fec0cadc 100644
--- a/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionPixels.swift
+++ b/LocalPackages/DataBrokerProtection/Sources/DataBrokerProtection/Pixels/DataBrokerProtectionPixels.swift
@@ -81,6 +81,8 @@ public enum DataBrokerProtectionPixels {
         static let numberOfNewRecordsFound = "num_new_found"
         static let numberOfReappereances = "num_reappeared"
         static let optOutSubmitSuccessRate = "optout_submit_success_rate"
+        static let childParentRecordDifference = "child-parent-record-difference"
+        static let calculatedOrphanedRecords = "calculated-orphaned-records"
     }
 
     case error(error: DataBrokerProtectionError, dataBroker: String)
@@ -211,6 +213,7 @@ public enum DataBrokerProtectionPixels {
     // Custom stats
     case customDataBrokerStatsOptoutSubmit(dataBrokerName: String, optOutSubmitSuccessRate: Double)
     case customGlobalStatsOptoutSubmit(optOutSubmitSuccessRate: Double)
+    case weeklyChildBrokerOrphanedOptOuts(dataBrokerName: String, childParentRecordDifference: Int, calculatedOrphanedRecords: Int)
 }
 
 extension DataBrokerProtectionPixels: PixelKitEvent {
@@ -345,8 +348,10 @@ extension DataBrokerProtectionPixels: PixelKitEvent {
         case .pixelTest: return "m_mac_dbp_configuration_pixel_test"
         case .failedToParsePrivacyConfig: return "m_mac_dbp_configuration_failed_to_parse"
 
+            // Various monitoring pixels
         case .customDataBrokerStatsOptoutSubmit: return "m_mac_dbp_databroker_custom_stats_optoutsubmit"
         case .customGlobalStatsOptoutSubmit: return "m_mac_dbp_custom_stats_optoutsubmit"
+        case .weeklyChildBrokerOrphanedOptOuts: return "m_mac_dbp_weekly_child-broker_orphaned-optouts"
         }
     }
 
@@ -522,6 +527,10 @@ extension DataBrokerProtectionPixels: PixelKitEvent {
                     Consts.optOutSubmitSuccessRate: String(optOutSubmitSuccessRate)]
         case .customGlobalStatsOptoutSubmit(let optOutSubmitSuccessRate):
             return [Consts.optOutSubmitSuccessRate: String(optOutSubmitSuccessRate)]
+        case .weeklyChildBrokerOrphanedOptOuts(let dataBrokerName, let childParentRecordDifference, let calculatedOrphanedRecords):
+            return [Consts.dataBrokerParamKey: dataBrokerName,
+                    Consts.childParentRecordDifference: String(childParentRecordDifference),
+                    Consts.calculatedOrphanedRecords: String(calculatedOrphanedRecords)]
         }
     }
 }
@@ -619,7 +628,8 @@ public class DataBrokerProtectionPixelsHandler: EventMapping<DataBrokerProtectio
                     .invalidPayload,
                     .pixelTest,
                     .customDataBrokerStatsOptoutSubmit,
-                    .customGlobalStatsOptoutSubmit:
+                    .customGlobalStatsOptoutSubmit,
+                    .weeklyChildBrokerOrphanedOptOuts:
 
                 PixelKit.fire(event)
 
diff --git a/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/DataBrokerProtectionEventPixelsTests.swift b/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/DataBrokerProtectionEventPixelsTests.swift
index b825cad871..768cac3df2 100644
--- a/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/DataBrokerProtectionEventPixelsTests.swift
+++ b/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/DataBrokerProtectionEventPixelsTests.swift
@@ -26,6 +26,7 @@ final class DataBrokerProtectionEventPixelsTests: XCTestCase {
     let repository = MockDataBrokerProtectionEventPixelsRepository()
     let handler = MockDataBrokerProtectionPixelsHandler()
     let calendar = Calendar.current
+    let eightDaysSinceToday = Calendar.current.date(byAdding: .day, value: -8, to: Date())!
 
     override func tearDown() {
         handler.clear()
@@ -374,6 +375,310 @@ final class DataBrokerProtectionEventPixelsTests: XCTestCase {
 
         XCTAssertEqual("75-100", scanCoverage)
     }
+
+    func testWeeklyOptOuts_whenBrokerProfileQueriesHasMixedCreatedDates_thenFilteredCorrectly() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+        let extractedProfile = ExtractedProfile.mockWithoutRemovedDate
+
+        let optOutShouldNotInclude1 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -14, to: Date.now)!)
+        let optOutShouldNotInclude2 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -21, to: Date.now)!)
+        let optOutShouldNotInclude3 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -8, to: Date.now)!)
+        let optOutShouldNotInclude4 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -17, to: Date.now)!)
+        let optOutShouldNotInclude5 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -10, to: Date.now)!)
+        let optOutShouldInclude1 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -6, to: Date.now)!)
+        let optOutShouldInclude2 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -3, to: Date.now)!)
+        let optOutShouldInclude3 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -1, to: Date.now)!)
+        let optOutShouldInclude4 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -5, to: Date.now)!)
+        let optOutShouldInclude5 = OptOutJobData.mock(with: Calendar.current.date(byAdding: .day, value: -2, to: Date.now)!)
+        let brokerProfileQueryData = [BrokerProfileQueryData.mock(extractedProfile: extractedProfile,
+                                                                 optOutJobData: [optOutShouldNotInclude1,
+                                                                                 optOutShouldNotInclude2,
+                                                                                 optOutShouldInclude1,
+                                                                                 optOutShouldInclude2]),
+                                      BrokerProfileQueryData.mock(extractedProfile: extractedProfile,
+                                                                  optOutJobData: []),
+                                      BrokerProfileQueryData.mock(extractedProfile: extractedProfile,
+                                                                  optOutJobData: [optOutShouldNotInclude3,
+                                                                                  optOutShouldNotInclude4]),
+                                      BrokerProfileQueryData.mock(extractedProfile: extractedProfile,
+                                                                  optOutJobData: [optOutShouldInclude3]),
+                                      BrokerProfileQueryData.mock(extractedProfile: extractedProfile,
+                                                                  optOutJobData: [optOutShouldInclude4,
+                                                                                  optOutShouldNotInclude5,
+                                                                                  optOutShouldInclude5])]
+
+        // When
+        let weeklyOptOuts = sut.weeklyOptOuts(for: brokerProfileQueryData)
+
+        // Then
+        XCTAssertEqual(weeklyOptOuts.count, 5)
+        XCTAssertTrue(weeklyOptOuts.contains { $0.createdDate == optOutShouldInclude1.createdDate })
+        XCTAssertTrue(weeklyOptOuts.contains { $0.createdDate == optOutShouldInclude2.createdDate })
+        XCTAssertTrue(weeklyOptOuts.contains { $0.createdDate == optOutShouldInclude3.createdDate })
+        XCTAssertTrue(weeklyOptOuts.contains { $0.createdDate == optOutShouldInclude4.createdDate })
+        XCTAssertTrue(weeklyOptOuts.contains { $0.createdDate == optOutShouldInclude5.createdDate })
+    }
+
+    let extractedProfile1 = ExtractedProfile.mockWithName("Steve Jones", age: "20", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let extractedProfile2 = ExtractedProfile.mockWithName("The Crock Jock", age: "24", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let extractedProfile3 = ExtractedProfile.mockWithName("Wolfy Wolfgang", age: "40", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let extractedProfile4 = ExtractedProfile.mockWithName("Pigeon Boy", age: "73", addresses: [AddressCityState(city: "Miami", state: "FL")])
+    let extractedProfile5 = ExtractedProfile.mockWithName("Definitely Not 20 Birds in a Trenchcoat", age: "7", addresses: [AddressCityState(city: "New York", state: "NY")])
+
+    let parentProfileMatching1 = ExtractedProfile.mockWithName("Steve Jones", age: "20", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let parentProfileMatching2 = ExtractedProfile.mockWithName("The Crock Jock", age: "24", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let parentProfileMatching3 = ExtractedProfile.mockWithName("Wolfy Wolfgang", age: "40", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let parentProfileMatching4 = ExtractedProfile.mockWithName("Pigeon Boy", age: "73", addresses: [AddressCityState(city: "Miami", state: "FL")])
+    let parentProfileMatching5 = ExtractedProfile.mockWithName("Definitely Not 20 Birds in a Trenchcoat", age: "7", addresses: [AddressCityState(city: "New York", state: "NY")])
+
+    let parentProfileNotMatching1 = ExtractedProfile.mockWithName("The Phantom Oinker", age: "12", addresses: [AddressCityState(city: "New York", state: "NY")])
+    let parentProfileNotMatching2 = ExtractedProfile.mockWithName("Husky Sausage Dog", age: "4", addresses: [AddressCityState(city: "Miami", state: "FL")])
+    let parentProfileNotMatching3 = ExtractedProfile.mockWithName("Actually definitely 20 Birds in a Trenchcoat", age: "7", addresses: [AddressCityState(city: "New York", state: "NY")])
+
+    func testOrphanedProfilesCount_whenChildAndParentHaveSameProfiles_thenCountIsZero() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let optOuts = [OptOutJobData.mock(with: extractedProfile1),
+                       OptOutJobData.mock(with: extractedProfile2),
+                       OptOutJobData.mock(with: extractedProfile3),
+                       OptOutJobData.mock(with: extractedProfile4),
+                       OptOutJobData.mock(with: extractedProfile5)]
+        let parentOptOuts = [OptOutJobData.mock(with: parentProfileMatching4),
+                             OptOutJobData.mock(with: parentProfileMatching2),
+                             OptOutJobData.mock(with: parentProfileMatching1),
+                             OptOutJobData.mock(with: parentProfileMatching3),
+                             OptOutJobData.mock(with: parentProfileMatching5)]
+
+        // When
+        let count = sut.orphanedProfilesCount(with: optOuts, parentOptOuts: parentOptOuts)
+
+        // Then
+        XCTAssertEqual(count, 0)
+    }
+
+    func testOrphanedProfilesCount_whenChildAndParentHaveDifferentProfiles_thenCountIsCorrect() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let optOuts = [OptOutJobData.mock(with: extractedProfile1),
+                       OptOutJobData.mock(with: extractedProfile2),
+                       OptOutJobData.mock(with: extractedProfile3),
+                       OptOutJobData.mock(with: extractedProfile4),
+                       OptOutJobData.mock(with: extractedProfile5)]
+        let parentOptOuts = [OptOutJobData.mock(with: parentProfileNotMatching1),
+                             OptOutJobData.mock(with: parentProfileMatching2),
+                             OptOutJobData.mock(with: parentProfileMatching1),
+                             OptOutJobData.mock(with: parentProfileNotMatching2),
+                             OptOutJobData.mock(with: parentProfileNotMatching3)]
+
+        // When
+        let count = sut.orphanedProfilesCount(with: optOuts, parentOptOuts: parentOptOuts)
+
+        // Then
+        XCTAssertEqual(count, 3)
+    }
+
+    func testOrphanedProfilesCount_whenChildHasMoreProfiles_thenCountIsCorrect() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let optOuts = [OptOutJobData.mock(with: extractedProfile1),
+                       OptOutJobData.mock(with: extractedProfile2),
+                       OptOutJobData.mock(with: extractedProfile3),
+                       OptOutJobData.mock(with: extractedProfile4),
+                       OptOutJobData.mock(with: extractedProfile5)]
+        let parentOptOuts = [OptOutJobData.mock(with: parentProfileMatching2),
+                             OptOutJobData.mock(with: parentProfileMatching1)]
+
+        // When
+        let count = sut.orphanedProfilesCount(with: optOuts, parentOptOuts: parentOptOuts)
+
+        // Then
+        XCTAssertEqual(count, 3)
+    }
+
+    func testChildBrokerURLsToOrphanedProfilesCount_whenChildAndParentHaveDifferentProfiles_thenCountIsCorrect() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let childURL = "child.com"
+        let parentURL = "parent.com"
+
+        let brokerProfileQueryData = [BrokerProfileQueryData.mock(url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile1),
+                                                                                  OptOutJobData.mock(with: extractedProfile2),
+                                                                                  OptOutJobData.mock(with: extractedProfile3)]),
+                                      BrokerProfileQueryData.mock(url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile4),
+                                                                                  OptOutJobData.mock(with: extractedProfile5)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching1),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching1)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching2),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching2),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching3)])]
+
+        // When
+        let brokerURLsToCounts = sut.childBrokerURLsToOrphanedProfilesWeeklyCount(for: brokerProfileQueryData)
+
+        // Then
+        XCTAssertEqual(brokerURLsToCounts, ["child.com": 3])
+    }
+
+    /*
+     fireWeeklyChildBrokerOrphanedOptOutsPixels
+     Test cases:
+     - Does fire for every child broker once (and _only_ child brokers)
+     */
+
+    let pixelName = DataBrokerProtectionPixels.weeklyChildBrokerOrphanedOptOuts(dataBrokerName: "",
+                                                                                childParentRecordDifference: 0,
+                                                                                calculatedOrphanedRecords: 0).name
+
+    func testFireWeeklyChildBrokerOrphanedOptOutsPixels_whenChildAndParentHaveSameProfiles_thenDoesNotFire() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let childURL = "child.com"
+        let parentURL = "parent.com"
+
+        let brokerProfileQueryData = [BrokerProfileQueryData.mock(url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile1),
+                                                                                  OptOutJobData.mock(with: extractedProfile2),
+                                                                                  OptOutJobData.mock(with: extractedProfile3)]),
+                                      BrokerProfileQueryData.mock(url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile4),
+                                                                                  OptOutJobData.mock(with: extractedProfile5)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching1),
+                                                                                  OptOutJobData.mock(with: parentProfileMatching4)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching2),
+                                                                                  OptOutJobData.mock(with: parentProfileMatching3),
+                                                                                  OptOutJobData.mock(with: parentProfileMatching5)])]
+
+        database.brokerProfileQueryDataToReturn = brokerProfileQueryData
+        repository.customGetLatestWeeklyPixel = nil
+
+        // When
+        sut.tryToFireWeeklyPixels()
+
+        // Then
+        let pixels = MockDataBrokerProtectionPixelsHandler.lastPixelsFired
+        XCTAssertFalse(pixels.contains { $0.name == pixelName })
+    }
+
+    func testFireWeeklyChildBrokerOrphanedOptOutsPixels_whenChildAndParentHaveDifferentProfiles_thenFiresCorrectly() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let childName = "child"
+        let childURL = "child.com"
+        let parentURL = "parent.com"
+
+        let brokerProfileQueryData = [BrokerProfileQueryData.mock(dataBrokerName: childName,
+                                                                  url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile1),
+                                                                                  OptOutJobData.mock(with: extractedProfile2),
+                                                                                  OptOutJobData.mock(with: extractedProfile3)]),
+                                      BrokerProfileQueryData.mock(dataBrokerName: childName,
+                                                                  url: childURL,
+                                                                  parentURL: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile4),
+                                                                                  OptOutJobData.mock(with: extractedProfile5)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching1),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching1)]),
+                                      BrokerProfileQueryData.mock(url: parentURL,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching2),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching2),
+                                                                                  OptOutJobData.mock(with: parentProfileNotMatching3)])]
+
+        database.brokerProfileQueryDataToReturn = brokerProfileQueryData
+        repository.customGetLatestWeeklyPixel = nil
+
+        // When
+        sut.tryToFireWeeklyPixels()
+
+        // Then
+        let pixels = MockDataBrokerProtectionPixelsHandler.lastPixelsFired
+        let firedPixel = pixels.first { $0.name == pixelName }!
+        let parameters = firedPixel.params
+        XCTAssertEqual(parameters, [DataBrokerProtectionPixels.Consts.dataBrokerParamKey: childName,
+                                    DataBrokerProtectionPixels.Consts.calculatedOrphanedRecords: "3",
+                                    DataBrokerProtectionPixels.Consts.childParentRecordDifference: "0"])
+    }
+
+    func testFireWeeklyChildBrokerOrphanedOptOutsPixels_whenThereAreMultipleChildBrokers_thenFiresOnceForEach() {
+        // Given
+        let sut = DataBrokerProtectionEventPixels(database: database, repository: repository, handler: handler)
+
+        let childName1 = "child1"
+        let childURL1 = "child1.com"
+        let parentURL1 = "parent1.com"
+
+        let childName2 = "child2"
+        let childURL2 = "child2.com"
+
+        let childName3 = "child3"
+        let childURL3 = "child3.com"
+        let parentURL3 = "parent3.com"
+
+        let brokerProfileQueryData = [BrokerProfileQueryData.mock(dataBrokerName: childName1,
+                                                                  url: childURL1,
+                                                                  parentURL: parentURL1,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile1),
+                                                                                  OptOutJobData.mock(with: extractedProfile2)]),
+                                      BrokerProfileQueryData.mock(url: parentURL1,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileMatching1)]),
+                                      BrokerProfileQueryData.mock(dataBrokerName: childName2,
+                                                                  url: childURL2,
+                                                                  parentURL: parentURL1,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile5),
+                                                                                  OptOutJobData.mock(with: extractedProfile3)]),
+                                      BrokerProfileQueryData.mock(dataBrokerName: childName3,
+                                                                  url: childURL3,
+                                                                  parentURL: parentURL3,
+                                                                  optOutJobData: [OptOutJobData.mock(with: extractedProfile4)]),
+                                      BrokerProfileQueryData.mock(url: parentURL3,
+                                                                  optOutJobData: [OptOutJobData.mock(with: parentProfileNotMatching3),
+                                                                                  OptOutJobData.mock(with: parentProfileMatching5)])]
+
+        database.brokerProfileQueryDataToReturn = brokerProfileQueryData
+        repository.customGetLatestWeeklyPixel = nil
+
+        // When
+        sut.tryToFireWeeklyPixels()
+
+        // Then
+        let pixels = MockDataBrokerProtectionPixelsHandler.lastPixelsFired
+        let firedPixels = pixels.filter { $0.name == pixelName }
+
+        XCTAssertEqual(firedPixels.count, 3)
+
+        let child1Pixel = firedPixels.filter { $0.params![DataBrokerProtectionPixels.Consts.dataBrokerParamKey] == childName1 }.first!
+        XCTAssertEqual(child1Pixel.params, [DataBrokerProtectionPixels.Consts.dataBrokerParamKey: childName1,
+                                            DataBrokerProtectionPixels.Consts.calculatedOrphanedRecords: "1",
+                                            DataBrokerProtectionPixels.Consts.childParentRecordDifference: "1"])
+
+        let child2Pixel = firedPixels.filter { $0.params![DataBrokerProtectionPixels.Consts.dataBrokerParamKey] == childName2 }.first!
+        XCTAssertEqual(child2Pixel.params, [DataBrokerProtectionPixels.Consts.dataBrokerParamKey: childName2,
+                                            DataBrokerProtectionPixels.Consts.calculatedOrphanedRecords: "2",
+                                            DataBrokerProtectionPixels.Consts.childParentRecordDifference: "1"])
+
+        let child3Pixel = firedPixels.filter { $0.params![DataBrokerProtectionPixels.Consts.dataBrokerParamKey] == childName3 }.first!
+        XCTAssertEqual(child3Pixel.params, [DataBrokerProtectionPixels.Consts.dataBrokerParamKey: childName3,
+                                            DataBrokerProtectionPixels.Consts.calculatedOrphanedRecords: "1",
+                                            DataBrokerProtectionPixels.Consts.childParentRecordDifference: "-1"])
+    }
 }
 
 final class MockDataBrokerProtectionEventPixelsRepository: DataBrokerProtectionEventPixelsRepository {
diff --git a/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/Mocks.swift b/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/Mocks.swift
index 91341e087b..023a1c9f55 100644
--- a/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/Mocks.swift
+++ b/LocalPackages/DataBrokerProtection/Tests/DataBrokerProtectionTests/Mocks.swift
@@ -31,6 +31,7 @@ extension BrokerProfileQueryData {
     static func mock(with steps: [Step] = [Step](),
                      dataBrokerName: String = "test",
                      url: String = "test.com",
+                     parentURL: String? = nil,
                      lastRunDate: Date? = nil,
                      preferredRunDate: Date? = nil,
                      extractedProfile: ExtractedProfile? = nil,
@@ -45,6 +46,7 @@ extension BrokerProfileQueryData {
                 steps: steps,
                 version: "1.0.0",
                 schedulingConfig: DataBrokerScheduleConfig.mock,
+                parent: parentURL,
                 mirrorSites: mirrorSites
             ),
             profileQuery: ProfileQuery(firstName: "John", lastName: "Doe", city: "Miami", state: "FL", birthYear: 50, deprecated: deprecated),
@@ -53,7 +55,7 @@ extension BrokerProfileQueryData {
                                      preferredRunDate: preferredRunDate,
                                      historyEvents: scanHistoryEvents,
                                      lastRunDate: lastRunDate),
-            optOutJobData: extractedProfile != nil ? [.mock(with: extractedProfile!)] : [OptOutJobData]()
+            optOutJobData: optOutJobData ?? (extractedProfile != nil ? [.mock(with: extractedProfile!)] : [OptOutJobData]())
         )
     }
 
@@ -1147,6 +1149,10 @@ extension OptOutJobData {
         .init(brokerId: 1, profileQueryId: 1, createdDate: Date(), historyEvents: historyEvents, extractedProfile: extractedProfile)
     }
 
+    static func mock(with createdDate: Date) -> OptOutJobData {
+        .init(brokerId: 1, profileQueryId: 1, createdDate: createdDate, historyEvents: [], submittedSuccessfullyDate: nil, extractedProfile: .mockWithoutRemovedDate)
+    }
+
     static func mock(with extractedProfile: ExtractedProfile,
                      historyEvents: [HistoryEvent] = [HistoryEvent](),
                      createdDate: Date,