diff --git a/packages/rum/src/domain/record/index.ts b/packages/rum/src/domain/record/index.ts
index d5be936a21..7d91bd2c97 100644
--- a/packages/rum/src/domain/record/index.ts
+++ b/packages/rum/src/domain/record/index.ts
@@ -1,6 +1,6 @@
 export { record } from './record'
 export type { SerializationMetric, SerializationStats } from './serialization'
 export { createSerializationStats, aggregateSerializationStats } from './serialization'
-export { serializeNodeWithId, serializeDocument } from './serialization'
+export { serializeNode, serializeDocument } from './serialization'
 export { createElementsScrollPositions } from './elementsScrollPositions'
 export type { ShadowRootsController } from './shadowRootsController'
diff --git a/packages/rum/src/domain/record/nodeIds.ts b/packages/rum/src/domain/record/nodeIds.ts
index 2fb8b902f3..0b4361ba17 100644
--- a/packages/rum/src/domain/record/nodeIds.ts
+++ b/packages/rum/src/domain/record/nodeIds.ts
@@ -4,7 +4,7 @@ export type NodeWithSerializedNode = Node & { __brand: 'NodeWithSerializedNode'
 export type NodeId = number & { __brand: 'NodeId' }
 
 export const enum NodeIdConstants {
-  FIRST_ID = 1,
+  FIRST_ID = 0,
 }
 
 export interface NodeIds {
diff --git a/packages/rum/src/domain/record/serialization/htmlAst.specHelper.ts b/packages/rum/src/domain/record/serialization/htmlAst.specHelper.ts
index 2181031e45..1683bc4da5 100644
--- a/packages/rum/src/domain/record/serialization/htmlAst.specHelper.ts
+++ b/packages/rum/src/domain/record/serialization/htmlAst.specHelper.ts
@@ -2,7 +2,7 @@ import { NodePrivacyLevel, PRIVACY_ATTR_NAME } from '@datadog/browser-rum-core'
 import { display, objectValues } from '@datadog/browser-core'
 import type { SerializedNodeWithId } from '../../../types'
 import { createSerializationTransactionForTesting } from '../test/serialization.specHelper'
-import { serializeNodeWithId } from './serializeNode'
+import { serializeNode } from './serializeNode'
 
 export const makeHtmlDoc = (htmlContent: string, privacyTag: string) => {
   try {
@@ -30,7 +30,7 @@ export const generateLeanSerializedDoc = (htmlContent: string, privacyTag: strin
   const transaction = createSerializationTransactionForTesting()
   const newDoc = makeHtmlDoc(htmlContent, privacyTag)
   const serializedDoc = removeIdFieldsRecursivelyClone(
-    serializeNodeWithId(newDoc, NodePrivacyLevel.ALLOW, transaction) as unknown as Record<string, unknown>
+    serializeNode(newDoc, NodePrivacyLevel.ALLOW, transaction) as unknown as Record<string, unknown>
   ) as unknown as SerializedNodeWithId
   return serializedDoc
 }
diff --git a/packages/rum/src/domain/record/serialization/index.ts b/packages/rum/src/domain/record/serialization/index.ts
index 71169d1233..b4bd8a349b 100644
--- a/packages/rum/src/domain/record/serialization/index.ts
+++ b/packages/rum/src/domain/record/serialization/index.ts
@@ -1,6 +1,6 @@
 export { getElementInputValue } from './serializationUtils'
 export { serializeDocument } from './serializeDocument'
-export { serializeNodeWithId } from './serializeNode'
+export { serializeNode } from './serializeNode'
 export { serializeAttribute } from './serializeAttribute'
 export { createSerializationStats, updateSerializationStats, aggregateSerializationStats } from './serializationStats'
 export type { SerializationMetric, SerializationStats } from './serializationStats'
diff --git a/packages/rum/src/domain/record/serialization/serializationTransaction.ts b/packages/rum/src/domain/record/serialization/serializationTransaction.ts
index 4d6e500ddf..b12fff1476 100644
--- a/packages/rum/src/domain/record/serialization/serializationTransaction.ts
+++ b/packages/rum/src/domain/record/serialization/serializationTransaction.ts
@@ -29,6 +29,12 @@ export interface SerializationTransaction {
    */
   addMetric(metric: keyof SerializationStats, value: number): void
 
+  /**
+   * Assign and return an id to the given node. If the node has previously been assigned
+   * an id, the existing id will be reused.
+   */
+  assignId(node: Node): NodeId
+
   /** The kind of serialization being performed in this transaction. */
   kind: SerializationKind
 
@@ -59,12 +65,19 @@ export function serializeInTransaction(
   const stats = createSerializationStats()
 
   const transaction: SerializationTransaction = {
-    add: (record: BrowserRecord) => {
+    add(record: BrowserRecord): void {
       records.push(record)
     },
-    addMetric: (metric: keyof SerializationStats, value: number) => {
+    addMetric(metric: keyof SerializationStats, value: number): void {
       updateSerializationStats(stats, metric, value)
     },
+    assignId(node: Node): NodeId {
+      const id = scope.nodeIds.assign(node)
+      if (transaction.serializedNodeIds) {
+        transaction.serializedNodeIds.add(id)
+      }
+      return id
+    },
     kind,
     scope,
   }
diff --git a/packages/rum/src/domain/record/serialization/serializeDocument.ts b/packages/rum/src/domain/record/serialization/serializeDocument.ts
index d32ab214c5..4b8f19a81e 100644
--- a/packages/rum/src/domain/record/serialization/serializeDocument.ts
+++ b/packages/rum/src/domain/record/serialization/serializeDocument.ts
@@ -1,5 +1,5 @@
 import type { DocumentNode, SerializedNodeWithId } from '../../../types'
-import { serializeNodeWithId } from './serializeNode'
+import { serializeNode } from './serializeNode'
 import type { SerializationTransaction } from './serializationTransaction'
 
 export function serializeDocument(
@@ -7,7 +7,7 @@ export function serializeDocument(
   transaction: SerializationTransaction
 ): DocumentNode & SerializedNodeWithId {
   const defaultPrivacyLevel = transaction.scope.configuration.defaultPrivacyLevel
-  const serializedNode = serializeNodeWithId(document, defaultPrivacyLevel, transaction)
+  const serializedNode = serializeNode(document, defaultPrivacyLevel, transaction)
 
   // We are sure that Documents are never ignored, so this function never returns null
   return serializedNode as DocumentNode & SerializedNodeWithId
diff --git a/packages/rum/src/domain/record/serialization/serializeNode.spec.ts b/packages/rum/src/domain/record/serialization/serializeNode.spec.ts
index f18cf79062..d43b543704 100644
--- a/packages/rum/src/domain/record/serialization/serializeNode.spec.ts
+++ b/packages/rum/src/domain/record/serialization/serializeNode.spec.ts
@@ -27,13 +27,13 @@ import {
   AST_MASK_UNLESS_ALLOWLISTED,
   AST_ALLOW,
 } from './htmlAst.specHelper'
-import { serializeChildNodes, serializeDocumentNode, serializeNodeWithId } from './serializeNode'
+import { serializeChildNodes, serializeDocumentNode, serializeNode } from './serializeNode'
 import type { SerializationStats } from './serializationStats'
 import { createSerializationStats } from './serializationStats'
 import type { SerializationTransaction } from './serializationTransaction'
 import { serializeInTransaction, SerializationKind } from './serializationTransaction'
 
-describe('serializeNodeWithId', () => {
+describe('serializeNode', () => {
   let addShadowRootSpy: jasmine.Spy<AddShadowRootCallBack>
   let emitRecordCallback: jasmine.Spy<EmitRecordCallback>
   let emitStatsCallback: jasmine.Spy<EmitStatsCallback>
@@ -51,7 +51,7 @@ describe('serializeNodeWithId', () => {
   describe('document serialization', () => {
     it('serializes a document', () => {
       const document = new DOMParser().parseFromString('<!doctype html><html>foo</html>', 'text/html')
-      expect(serializeNodeWithId(document, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(document, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Document,
         childNodes: [
           jasmine.objectContaining({ type: NodeType.DocumentType, name: 'html', publicId: '', systemId: '' }),
@@ -65,7 +65,7 @@ describe('serializeNodeWithId', () => {
 
   describe('elements serialization', () => {
     it('serializes a div', () => {
-      expect(serializeNodeWithId(document.createElement('div'), NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(document.createElement('div'), NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Element,
         tagName: 'div',
         attributes: {},
@@ -79,7 +79,7 @@ describe('serializeNodeWithId', () => {
       const element = document.createElement('div')
       element.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN)
 
-      expect(serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(element, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Element,
         tagName: 'div',
         attributes: {
@@ -97,7 +97,7 @@ describe('serializeNodeWithId', () => {
       const element = document.createElement('div')
       element.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN)
       element.appendChild(document.createElement('hr'))
-      expect(serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)?.childNodes).toEqual([])
+      expect(serializeNode(element, NodePrivacyLevel.ALLOW, transaction)?.childNodes).toEqual([])
     })
 
     it('serializes attributes', () => {
@@ -105,7 +105,7 @@ describe('serializeNodeWithId', () => {
       element.className = 'zog'
       element.style.width = '10px'
 
-      expect(serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
+      expect(serializeNode(element, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
         foo: 'bar',
         'data-foo': 'data-bar',
         class: 'zog',
@@ -128,7 +128,7 @@ describe('serializeNodeWithId', () => {
           kind: SerializationKind.INITIAL_FULL_SNAPSHOT,
           scope,
         })
-        const node = serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)
+        const node = serializeNode(element, NodePrivacyLevel.ALLOW, transaction)
 
         expect(node?.attributes).toEqual(
           jasmine.objectContaining({
@@ -144,7 +144,7 @@ describe('serializeNodeWithId', () => {
           kind: SerializationKind.SUBSEQUENT_FULL_SNAPSHOT,
           scope,
         })
-        const node = serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)
+        const node = serializeNode(element, NodePrivacyLevel.ALLOW, transaction)
 
         expect(node?.attributes.rr_scrollLeft).toBeUndefined()
         expect(node?.attributes.rr_scrollTop).toBeUndefined()
@@ -158,7 +158,7 @@ describe('serializeNodeWithId', () => {
           kind: SerializationKind.SUBSEQUENT_FULL_SNAPSHOT,
           scope,
         })
-        const node = serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)
+        const node = serializeNode(element, NodePrivacyLevel.ALLOW, transaction)
 
         expect(node?.attributes).toEqual(
           jasmine.objectContaining({
@@ -175,7 +175,7 @@ describe('serializeNodeWithId', () => {
           kind: SerializationKind.INCREMENTAL_SNAPSHOT,
           scope,
         })
-        const node = serializeNodeWithId(element, NodePrivacyLevel.ALLOW, transaction)
+        const node = serializeNode(element, NodePrivacyLevel.ALLOW, transaction)
 
         expect(node?.attributes.rr_scrollLeft).toBeUndefined()
         expect(node?.attributes.rr_scrollTop).toBeUndefined()
@@ -186,7 +186,7 @@ describe('serializeNodeWithId', () => {
       const head = document.createElement('head')
       head.innerHTML = '  <title>  foo </title>  '
 
-      expect(serializeNodeWithId(head, NodePrivacyLevel.ALLOW, transaction)?.childNodes).toEqual([
+      expect(serializeNode(head, NodePrivacyLevel.ALLOW, transaction)?.childNodes).toEqual([
         jasmine.objectContaining({
           type: NodeType.Element,
           tagName: 'title',
@@ -199,7 +199,7 @@ describe('serializeNodeWithId', () => {
       const input = document.createElement('input')
       input.value = 'toto'
 
-      expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: { value: 'toto' },
         })
@@ -210,7 +210,7 @@ describe('serializeNodeWithId', () => {
       const textarea = document.createElement('textarea')
       textarea.value = 'toto'
 
-      expect(serializeNodeWithId(textarea, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(textarea, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: { value: 'toto' },
         })
@@ -227,7 +227,7 @@ describe('serializeNodeWithId', () => {
       select.appendChild(option2)
       select.options.selectedIndex = 1
 
-      expect(serializeNodeWithId(select, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(select, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: { value: 'bar' },
           childNodes: [
@@ -252,7 +252,7 @@ describe('serializeNodeWithId', () => {
       input.type = 'password'
       input.value = 'toto'
 
-      expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
+      expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
     })
 
     it('does not serialize <input type="password"> values set via attribute setter', () => {
@@ -260,13 +260,13 @@ describe('serializeNodeWithId', () => {
       input.type = 'password'
       input.setAttribute('value', 'toto')
 
-      expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
+      expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
     })
 
     it('serializes <input type="checkbox"> elements checked state', () => {
       const checkbox = document.createElement('input')
       checkbox.type = 'checkbox'
-      expect(serializeNodeWithId(checkbox, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(checkbox, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: {
             type: 'checkbox',
@@ -277,7 +277,7 @@ describe('serializeNodeWithId', () => {
 
       checkbox.checked = true
 
-      expect(serializeNodeWithId(checkbox, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(checkbox, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: {
             type: 'checkbox',
@@ -291,14 +291,14 @@ describe('serializeNodeWithId', () => {
     it('serializes <input type="radio"> elements checked state', () => {
       const radio = document.createElement('input')
       radio.type = 'radio'
-      expect(serializeNodeWithId(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
+      expect(serializeNode(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
         type: 'radio',
         value: 'on',
       })
 
       radio.checked = true
 
-      expect(serializeNodeWithId(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
+      expect(serializeNode(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
         type: 'radio',
         value: 'on',
         checked: '',
@@ -308,7 +308,7 @@ describe('serializeNodeWithId', () => {
     it('serializes <audio> elements paused state', () => {
       const audio = document.createElement('audio')
 
-      expect(serializeNodeWithId(audio, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(audio, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: { rr_mediaState: 'paused' },
         })
@@ -317,7 +317,7 @@ describe('serializeNodeWithId', () => {
       // Emulate a playing audio file
       Object.defineProperty(audio, 'paused', { value: false })
 
-      expect(serializeNodeWithId(audio, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+      expect(serializeNode(audio, NodePrivacyLevel.ALLOW, transaction)).toEqual(
         jasmine.objectContaining({
           attributes: { rr_mediaState: 'played' },
         })
@@ -330,7 +330,7 @@ describe('serializeNodeWithId', () => {
         input.value = 'toto'
         input.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_USER_INPUT)
 
-        expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+        expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(
           jasmine.objectContaining({
             attributes: {
               [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_MASK_USER_INPUT,
@@ -347,7 +347,7 @@ describe('serializeNodeWithId', () => {
         parent.appendChild(input)
         parent.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_USER_INPUT)
 
-        expect(serializeNodeWithId(parent, NodePrivacyLevel.ALLOW, transaction)?.childNodes[0]).toEqual(
+        expect(serializeNode(parent, NodePrivacyLevel.ALLOW, transaction)?.childNodes[0]).toEqual(
           jasmine.objectContaining({
             attributes: { value: '***' },
           })
@@ -360,7 +360,7 @@ describe('serializeNodeWithId', () => {
         button.value = 'toto'
         button.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_USER_INPUT)
 
-        expect(serializeNodeWithId(button, NodePrivacyLevel.ALLOW, transaction)?.attributes.value).toEqual('toto')
+        expect(serializeNode(button, NodePrivacyLevel.ALLOW, transaction)?.attributes.value).toEqual('toto')
       })
 
       it('does not apply mask for <input type="submit"> contained in a masked ancestor', () => {
@@ -369,7 +369,7 @@ describe('serializeNodeWithId', () => {
         button.value = 'toto'
         button.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_USER_INPUT)
 
-        expect(serializeNodeWithId(button, NodePrivacyLevel.ALLOW, transaction)?.attributes.value).toEqual('toto')
+        expect(serializeNode(button, NodePrivacyLevel.ALLOW, transaction)?.attributes.value).toEqual('toto')
       })
 
       it('serializes <input type="radio"> elements without checked property', () => {
@@ -377,7 +377,7 @@ describe('serializeNodeWithId', () => {
         radio.type = 'radio'
         radio.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_USER_INPUT)
 
-        expect(serializeNodeWithId(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
+        expect(serializeNode(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
           type: 'radio',
           value: '***',
           'data-dd-privacy': 'mask-user-input',
@@ -385,7 +385,7 @@ describe('serializeNodeWithId', () => {
 
         radio.checked = true
 
-        expect(serializeNodeWithId(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
+        expect(serializeNode(radio, NodePrivacyLevel.ALLOW, transaction)?.attributes).toEqual({
           type: 'radio',
           value: '***',
           'data-dd-privacy': 'mask-user-input',
@@ -399,7 +399,7 @@ describe('serializeNodeWithId', () => {
         input.placeholder = 'someValue'
         input.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK)
 
-        expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)?.attributes.placeholder).toEqual('***')
+        expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)?.attributes.placeholder).toEqual('***')
       })
     })
 
@@ -417,7 +417,7 @@ describe('serializeNodeWithId', () => {
         input.value = 'toto'
         input.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_MASK_UNLESS_ALLOWLISTED)
 
-        expect(serializeNodeWithId(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
+        expect(serializeNode(input, NodePrivacyLevel.ALLOW, transaction)).toEqual(jasmine.objectContaining({}))
       })
     })
 
@@ -425,7 +425,7 @@ describe('serializeNodeWithId', () => {
       it('serializes a shadow host', () => {
         const div = document.createElement('div')
         div.attachShadow({ mode: 'open' })
-        expect(serializeNodeWithId(div, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(div, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'div',
           attributes: {},
@@ -448,7 +448,7 @@ describe('serializeNodeWithId', () => {
         const shadowRoot = div.attachShadow({ mode: 'open' })
         shadowRoot.appendChild(document.createElement('hr'))
 
-        expect(serializeNodeWithId(div, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(div, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'div',
           attributes: {},
@@ -482,7 +482,7 @@ describe('serializeNodeWithId', () => {
         const shadowRoot = div.attachShadow({ mode: 'open' })
         shadowRoot.appendChild(document.createTextNode('foo'))
 
-        expect(serializeNodeWithId(div, NodePrivacyLevel.ALLOW, transaction)).toEqual(
+        expect(serializeNode(div, NodePrivacyLevel.ALLOW, transaction)).toEqual(
           jasmine.objectContaining({
             attributes: {
               [PRIVACY_ATTR_NAME]: PRIVACY_ATTR_VALUE_MASK,
@@ -514,7 +514,7 @@ describe('serializeNodeWithId', () => {
         const styleNode = appendElement('<style></style>', document.head) as HTMLStyleElement
         styleNode.sheet!.insertRule('body { width: 100%; }')
 
-        expect(serializeNodeWithId(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'style',
           id: jasmine.any(Number) as unknown as number,
@@ -531,7 +531,7 @@ describe('serializeNodeWithId', () => {
       it('serializes a node with CSS rules specified as inner text', () => {
         const styleNode = appendElement('<style>body { width: 100%; }</style>', document.head) as HTMLStyleElement
 
-        expect(serializeNodeWithId(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'style',
           id: jasmine.any(Number) as unknown as number,
@@ -549,7 +549,7 @@ describe('serializeNodeWithId', () => {
         const styleNode = appendElement('<style>body { width: 100%; }</style>', document.head) as HTMLStyleElement
         styleNode.sheet!.insertRule('body { color: red; }')
 
-        expect(serializeNodeWithId(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(styleNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'style',
           id: jasmine.any(Number) as unknown as number,
@@ -572,7 +572,7 @@ describe('serializeNodeWithId', () => {
         const cssText2 = 'body { background-color: green; }'
         appendElement(`<style>${cssText2}</style>`, containerNode) as HTMLStyleElement
 
-        expect(serializeNodeWithId(containerNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(containerNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'div',
           id: jasmine.any(Number) as unknown as number,
@@ -624,7 +624,7 @@ describe('serializeNodeWithId', () => {
           document.head
         )
 
-        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -653,7 +653,7 @@ describe('serializeNodeWithId', () => {
           configurable: true,
         })
 
-        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -689,7 +689,7 @@ describe('serializeNodeWithId', () => {
           configurable: true,
         })
 
-        expect(serializeNodeWithId(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+        expect(serializeNode(linkNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
           type: NodeType.Element,
           tagName: 'link',
           id: jasmine.any(Number) as unknown as number,
@@ -714,7 +714,7 @@ describe('serializeNodeWithId', () => {
       parentEl.setAttribute(PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW)
       const textNode = document.createTextNode('foo')
       parentEl.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(textNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Text,
         id: jasmine.any(Number) as unknown as number,
         textContent: 'foo',
@@ -725,7 +725,7 @@ describe('serializeNodeWithId', () => {
       const parentEl = document.createElement('bar')
       const textNode = document.createTextNode('')
       parentEl.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(textNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Text,
         id: jasmine.any(Number) as unknown as number,
         textContent: '',
@@ -736,7 +736,7 @@ describe('serializeNodeWithId', () => {
       const head = document.getElementsByTagName('head')[0]
       const textNode = document.createTextNode('   ')
       head.appendChild(textNode)
-      expect(serializeNodeWithId(textNode, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(textNode, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
       head.removeChild(textNode)
     })
   })
@@ -745,7 +745,7 @@ describe('serializeNodeWithId', () => {
     it('serializes a CDATA node', () => {
       const xmlDocument = new DOMParser().parseFromString('<root></root>', 'text/xml')
       const cdataNode = xmlDocument.createCDATASection('foo')
-      expect(serializeNodeWithId(cdataNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
+      expect(serializeNode(cdataNode, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.CDATA,
         id: jasmine.any(Number) as unknown as number,
         textContent: '',
@@ -761,7 +761,7 @@ describe('serializeNodeWithId', () => {
       scope,
       (transaction) => {
         transaction.serializedNodeIds = new Set()
-        const node = serializeNodeWithId(document.createElement('div'), NodePrivacyLevel.ALLOW, transaction)!
+        const node = serializeNode(document.createElement('div'), NodePrivacyLevel.ALLOW, transaction)!
         expect(transaction.serializedNodeIds).toEqual(new Set([node.id]))
         return []
       }
@@ -777,7 +777,7 @@ describe('serializeNodeWithId', () => {
         scope,
         (transaction) => {
           transaction.serializedNodeIds = new Set()
-          serializeNodeWithId(document.createElement('script'), NodePrivacyLevel.ALLOW, transaction)
+          serializeNode(document.createElement('script'), NodePrivacyLevel.ALLOW, transaction)
           expect(transaction.serializedNodeIds.size).toBe(0)
           return []
         }
@@ -786,36 +786,36 @@ describe('serializeNodeWithId', () => {
 
     it('does not serialize ignored nodes', () => {
       const scriptElement = document.createElement('script')
-      expect(serializeNodeWithId(scriptElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(scriptElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
       expect(scope.nodeIds.get(scriptElement)).toBe(undefined)
     })
 
     it('ignores script tags', () => {
       const scriptElement = document.createElement('script')
-      expect(serializeNodeWithId(scriptElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(scriptElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
     })
 
     it('ignores comments', () => {
       const commentNode = document.createComment('foo')
-      expect(serializeNodeWithId(commentNode, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(commentNode, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
     })
 
     it('ignores link favicons', () => {
       const linkElement = document.createElement('link')
       linkElement.setAttribute('rel', 'shortcut icon')
-      expect(serializeNodeWithId(linkElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(linkElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
     })
 
     it('ignores meta keywords', () => {
       const metaElement = document.createElement('meta')
       metaElement.setAttribute('name', 'keywords')
-      expect(serializeNodeWithId(metaElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(metaElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
     })
 
     it('ignores meta name attribute casing', () => {
       const metaElement = document.createElement('meta')
       metaElement.setAttribute('name', 'KeYwOrDs')
-      expect(serializeNodeWithId(metaElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
+      expect(serializeNode(metaElement, NodePrivacyLevel.ALLOW, transaction)).toBeNull()
     })
   })
 
@@ -987,6 +987,7 @@ describe('serializeDocumentNode handles', function testAllowDomTree() {
 
       expect(serializeDocumentNode(document, NodePrivacyLevel.ALLOW, transaction)).toEqual({
         type: NodeType.Document,
+        id: 0,
         childNodes: [
           jasmine.objectContaining({ type: NodeType.DocumentType }),
           jasmine.objectContaining({ type: NodeType.Element, tagName: 'html' }),
@@ -1005,6 +1006,7 @@ describe('serializeDocumentNode handles', function testAllowDomTree() {
   it('a masked DOM Document itself is still serialized ', () => {
     expect(serializeDocumentNode(document, NodePrivacyLevel.MASK, transaction)).toEqual({
       type: NodeType.Document,
+      id: 0,
       childNodes: serializeChildNodes(document, NodePrivacyLevel.MASK, transaction),
       adoptedStyleSheets: undefined,
     })
diff --git a/packages/rum/src/domain/record/serialization/serializeNode.ts b/packages/rum/src/domain/record/serialization/serializeNode.ts
index a0ca22166f..89cf1f33b0 100644
--- a/packages/rum/src/domain/record/serialization/serializeNode.ts
+++ b/packages/rum/src/domain/record/serialization/serializeNode.ts
@@ -12,7 +12,6 @@ import {
 import type {
   DocumentFragmentNode,
   DocumentNode,
-  SerializedNode,
   SerializedNodeWithId,
   CDataNode,
   DocumentTypeNode,
@@ -26,33 +25,37 @@ import { serializeStyleSheets } from './serializeStyleSheets'
 import { serializeAttributes } from './serializeAttributes'
 import type { SerializationTransaction } from './serializationTransaction'
 
-export function serializeNodeWithId(
+export function serializeNode(
   node: Element,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
 ): (SerializedNodeWithId & ElementNode) | null
-export function serializeNodeWithId(
+export function serializeNode(
   node: Node,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
 ): SerializedNodeWithId | null
-export function serializeNodeWithId(
+export function serializeNode(
   node: Node,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
 ): SerializedNodeWithId | null {
-  const serializedNode = serializeNode(node, parentNodePrivacyLevel, transaction)
-  if (!serializedNode) {
-    return null
-  }
-
-  const id = transaction.scope.nodeIds.assign(node)
-  const serializedNodeWithId = serializedNode as SerializedNodeWithId
-  serializedNodeWithId.id = id
-  if (transaction.serializedNodeIds) {
-    transaction.serializedNodeIds.add(id)
+  switch (node.nodeType) {
+    case node.DOCUMENT_NODE:
+      return serializeDocumentNode(node as Document, parentNodePrivacyLevel, transaction)
+    case node.DOCUMENT_FRAGMENT_NODE:
+      return serializeDocumentFragmentNode(node as DocumentFragment, parentNodePrivacyLevel, transaction)
+    case node.DOCUMENT_TYPE_NODE:
+      return serializeDocumentTypeNode(node as DocumentType, transaction)
+    case node.ELEMENT_NODE:
+      return serializeElementNode(node as Element, parentNodePrivacyLevel, transaction)
+    case node.TEXT_NODE:
+      return serializeTextNode(node as Text, parentNodePrivacyLevel, transaction)
+    case node.CDATA_SECTION_NODE:
+      return serializeCDataNode(node as CDATASection, transaction)
+    default:
+      return null
   }
-  return serializedNodeWithId
 }
 
 export function serializeChildNodes(
@@ -62,7 +65,7 @@ export function serializeChildNodes(
 ): SerializedNodeWithId[] {
   const result: SerializedNodeWithId[] = []
   forEachChildNodes(node, (childNode) => {
-    const serializedChildNode = serializeNodeWithId(childNode, parentNodePrivacyLevel, transaction)
+    const serializedChildNode = serializeNode(childNode, parentNodePrivacyLevel, transaction)
     if (serializedChildNode) {
       result.push(serializedChildNode)
     }
@@ -70,34 +73,14 @@ export function serializeChildNodes(
   return result
 }
 
-function serializeNode(
-  node: Node,
-  parentNodePrivacyLevel: ParentNodePrivacyLevel,
-  transaction: SerializationTransaction
-): SerializedNode | undefined {
-  switch (node.nodeType) {
-    case node.DOCUMENT_NODE:
-      return serializeDocumentNode(node as Document, parentNodePrivacyLevel, transaction)
-    case node.DOCUMENT_FRAGMENT_NODE:
-      return serializeDocumentFragmentNode(node as DocumentFragment, parentNodePrivacyLevel, transaction)
-    case node.DOCUMENT_TYPE_NODE:
-      return serializeDocumentTypeNode(node as DocumentType)
-    case node.ELEMENT_NODE:
-      return serializeElementNode(node as Element, parentNodePrivacyLevel, transaction)
-    case node.TEXT_NODE:
-      return serializeTextNode(node as Text, parentNodePrivacyLevel)
-    case node.CDATA_SECTION_NODE:
-      return serializeCDataNode()
-  }
-}
-
 export function serializeDocumentNode(
   document: Document,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
-): DocumentNode {
+): DocumentNode & SerializedNodeWithId {
   return {
     type: NodeType.Document,
+    id: transaction.assignId(document),
     childNodes: serializeChildNodes(document, parentNodePrivacyLevel, transaction),
     adoptedStyleSheets: serializeStyleSheets(document.adoptedStyleSheets),
   }
@@ -107,7 +90,7 @@ function serializeDocumentFragmentNode(
   element: DocumentFragment,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
-): DocumentFragmentNode | undefined {
+): DocumentFragmentNode & SerializedNodeWithId {
   const isShadowRoot = isNodeShadowRoot(element)
   if (isShadowRoot) {
     transaction.scope.shadowRootsController.addShadowRoot(element, transaction.scope)
@@ -115,15 +98,20 @@ function serializeDocumentFragmentNode(
 
   return {
     type: NodeType.DocumentFragment,
+    id: transaction.assignId(element),
     childNodes: serializeChildNodes(element, parentNodePrivacyLevel, transaction),
     isShadowRoot,
     adoptedStyleSheets: isShadowRoot ? serializeStyleSheets(element.adoptedStyleSheets) : undefined,
   }
 }
 
-function serializeDocumentTypeNode(documentType: DocumentType): DocumentTypeNode {
+function serializeDocumentTypeNode(
+  documentType: DocumentType,
+  transaction: SerializationTransaction
+): DocumentTypeNode & SerializedNodeWithId {
   return {
     type: NodeType.DocumentType,
+    id: transaction.assignId(documentType),
     name: documentType.name,
     publicId: documentType.publicId,
     systemId: documentType.systemId,
@@ -152,7 +140,7 @@ function serializeElementNode(
   element: Element,
   parentNodePrivacyLevel: ParentNodePrivacyLevel,
   transaction: SerializationTransaction
-): ElementNode | undefined {
+): (ElementNode & SerializedNodeWithId) | null {
   const tagName = getValidTagName(element.tagName)
   const isSVG = isSVGElement(element) || undefined
 
@@ -164,6 +152,7 @@ function serializeElementNode(
     const { width, height } = element.getBoundingClientRect()
     return {
       type: NodeType.Element,
+      id: transaction.assignId(element),
       tagName,
       attributes: {
         rr_width: `${width}px`,
@@ -177,9 +166,10 @@ function serializeElementNode(
 
   // Ignore Elements like Script and some Link, Metas
   if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {
-    return
+    return null
   }
 
+  const id = transaction.assignId(element)
   const attributes = serializeAttributes(element, nodePrivacyLevel, transaction)
 
   let childNodes: SerializedNodeWithId[] = []
@@ -193,6 +183,7 @@ function serializeElementNode(
 
   return {
     type: NodeType.Element,
+    id,
     tagName,
     attributes,
     childNodes,
@@ -210,20 +201,29 @@ function isSVGElement(el: Element): boolean {
  * for privacy level.
  */
 
-function serializeTextNode(textNode: Text, parentNodePrivacyLevel: ParentNodePrivacyLevel): TextNode | undefined {
+function serializeTextNode(
+  textNode: Text,
+  parentNodePrivacyLevel: ParentNodePrivacyLevel,
+  transaction: SerializationTransaction
+): (TextNode & SerializedNodeWithId) | null {
   const textContent = getTextContent(textNode, parentNodePrivacyLevel)
   if (textContent === undefined) {
-    return
+    return null
   }
   return {
     type: NodeType.Text,
+    id: transaction.assignId(textNode),
     textContent,
   }
 }
 
-function serializeCDataNode(): CDataNode {
+function serializeCDataNode(
+  node: CDATASection,
+  transaction: SerializationTransaction
+): CDataNode & SerializedNodeWithId {
   return {
     type: NodeType.CDATA,
+    id: transaction.assignId(node),
     textContent: '',
   }
 }
diff --git a/packages/rum/src/domain/record/test/serialization.specHelper.ts b/packages/rum/src/domain/record/test/serialization.specHelper.ts
index a729b7944e..13e53a7493 100644
--- a/packages/rum/src/domain/record/test/serialization.specHelper.ts
+++ b/packages/rum/src/domain/record/test/serialization.specHelper.ts
@@ -8,6 +8,7 @@ import {
   serializeInTransaction,
   updateSerializationStats,
 } from '../serialization'
+import type { NodeId } from '../nodeIds'
 import { createRecordingScopeForTesting } from './recordingScope.specHelper'
 
 export function createSerializationTransactionForTesting({
@@ -19,6 +20,7 @@ export function createSerializationTransactionForTesting({
   scope?: RecordingScope
   stats?: SerializationStats
 } = {}): SerializationTransaction {
+  const transactionScope = scope || createRecordingScopeForTesting()
   return {
     add(): void {
       throw new Error('Use serializeInTransaction normally to test code that generates BrowserRecords.')
@@ -28,8 +30,11 @@ export function createSerializationTransactionForTesting({
         updateSerializationStats(stats, metric, value)
       }
     },
+    assignId(node: Node): NodeId {
+      return transactionScope.nodeIds.assign(node)
+    },
     kind: kind ?? SerializationKind.INITIAL_FULL_SNAPSHOT,
-    scope: scope || createRecordingScopeForTesting(),
+    scope: transactionScope,
   }
 }
 
diff --git a/packages/rum/src/domain/record/trackers/trackMutation.spec.ts b/packages/rum/src/domain/record/trackers/trackMutation.spec.ts
index a994b47c21..ed734ac47d 100644
--- a/packages/rum/src/domain/record/trackers/trackMutation.spec.ts
+++ b/packages/rum/src/domain/record/trackers/trackMutation.spec.ts
@@ -473,16 +473,14 @@ describe('trackMutation', () => {
         expect(emitRecordCallback).toHaveBeenCalledTimes(1)
         const { validate, expectNewNode, expectInitialNode } = createMutationPayloadValidator(serializedDocument)
 
+        const expectedHost = expectNewNode({ type: NodeType.Element, tagName: 'div' })
+        const shadowRootNode = expectNewNode({ type: NodeType.DocumentFragment, isShadowRoot: true })
         const child = expectNewNode({ type: NodeType.Element, tagName: 'span' })
-        const shadowRootNode = expectNewNode({ type: NodeType.DocumentFragment, isShadowRoot: true }).withChildren(
-          child
-        )
-        const expectedHost = expectNewNode({ type: NodeType.Element, tagName: 'div' }).withChildren(shadowRootNode)
         validate(getLatestMutationPayload(), {
           adds: [
             {
               parent: expectInitialNode({ idAttribute: 'sandbox' }),
-              node: expectedHost,
+              node: expectedHost.withChildren(shadowRootNode.withChildren(child)),
             },
           ],
         })
diff --git a/packages/rum/src/domain/record/trackers/trackMutation.ts b/packages/rum/src/domain/record/trackers/trackMutation.ts
index 83e74e5815..6b93f627b6 100644
--- a/packages/rum/src/domain/record/trackers/trackMutation.ts
+++ b/packages/rum/src/domain/record/trackers/trackMutation.ts
@@ -29,7 +29,7 @@ import {
   getElementInputValue,
   serializeAttribute,
   serializeInTransaction,
-  serializeNodeWithId,
+  serializeNode,
   SerializationKind,
 } from '../serialization'
 import { createMutationBatch } from '../mutationBatch'
@@ -218,7 +218,7 @@ function processChildListMutations(
       continue
     }
 
-    const serializedNode = serializeNodeWithId(node, parentNodePrivacyLevel, transaction)
+    const serializedNode = serializeNode(node, parentNodePrivacyLevel, transaction)
     if (!serializedNode) {
       continue
     }
diff --git a/packages/rum/src/entries/internal.ts b/packages/rum/src/entries/internal.ts
index 93eb81d565..0892bb6787 100644
--- a/packages/rum/src/entries/internal.ts
+++ b/packages/rum/src/entries/internal.ts
@@ -15,4 +15,4 @@ export {
 
 export * from '../types'
 
-export { serializeNodeWithId } from '../domain/record'
+export { serializeNode, serializeNode as serializeNodeWithId } from '../domain/record'