diff --git a/.size-limit.js b/.size-limit.js
index eedacb4819bd..8d7ad5e8e3cd 100644
--- a/.size-limit.js
+++ b/.size-limit.js
@@ -156,7 +156,7 @@ module.exports = [
     path: 'packages/vue/build/esm/index.js',
     import: createImport('init'),
     gzip: true,
-    limit: '30 KB',
+    limit: '31 KB',
   },
   {
     name: '@sentry/vue (incl. Tracing)',
@@ -178,13 +178,13 @@ module.exports = [
     name: 'CDN Bundle',
     path: createCDNPath('bundle.min.js'),
     gzip: true,
-    limit: '28.5 KB',
+    limit: '29 KB',
   },
   {
     name: 'CDN Bundle (incl. Tracing)',
     path: createCDNPath('bundle.tracing.min.js'),
     gzip: true,
-    limit: '43.5 KB',
+    limit: '44 KB',
   },
   {
     name: 'CDN Bundle (incl. Logs, Metrics)',
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index 9968a4489c08..b89abe607f0e 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -79,11 +79,13 @@ export {
   convertSpanLinksForEnvelope,
   spanToTraceHeader,
   spanToJSON,
+  spanToStreamedSpanJSON,
   spanIsSampled,
   spanToTraceContext,
   getSpanDescendants,
   getStatusMessage,
   getRootSpan,
+  INTERNAL_getSegmentSpan,
   getActiveSpan,
   addChildSpanToSpan,
   spanTimeInputToSeconds,
diff --git a/packages/core/src/tracing/sentrySpan.ts b/packages/core/src/tracing/sentrySpan.ts
index 9bd98b9741c6..8bdae7129dba 100644
--- a/packages/core/src/tracing/sentrySpan.ts
+++ b/packages/core/src/tracing/sentrySpan.ts
@@ -1,3 +1,4 @@
+/* eslint-disable max-lines */
 import { getClient, getCurrentScope } from '../currentScopes';
 import { DEBUG_BUILD } from '../debug-build';
 import { createSpanEnvelope } from '../envelope';
@@ -21,6 +22,7 @@ import type {
   SpanJSON,
   SpanOrigin,
   SpanTimeInput,
+  StreamedSpanJSON,
 } from '../types-hoist/span';
 import type { SpanStatus } from '../types-hoist/spanStatus';
 import type { TimedEvent } from '../types-hoist/timedEvent';
@@ -29,8 +31,10 @@ import { generateSpanId, generateTraceId } from '../utils/propagationContext';
 import {
   convertSpanLinksForEnvelope,
   getRootSpan,
+  getSimpleStatusMessage,
   getSpanDescendants,
   getStatusMessage,
+  getStreamedSpanLinks,
   spanTimeInputToSeconds,
   spanToJSON,
   spanToTransactionTraceContext,
@@ -241,6 +245,30 @@ export class SentrySpan implements Span {
     };
   }
 
+  /**
+   * Get {@link StreamedSpanJSON} representation of this span.
+   *
+   * @hidden
+   * @internal This method is purely for internal purposes and should not be used outside
+   * of SDK code. If you need to get a JSON representation of a span,
+   * use `spanToStreamedSpanJSON(span)` instead.
+   */
+  public getStreamedSpanJSON(): StreamedSpanJSON {
+    return {
+      name: this._name ?? '',
+      span_id: this._spanId,
+      trace_id: this._traceId,
+      parent_span_id: this._parentSpanId,
+      start_timestamp: this._startTime,
+      // just in case _endTime is not set, we use the start time (i.e. duration 0)
+      end_timestamp: this._endTime ?? this._startTime,
+      is_segment: this._isStandaloneSpan || this === getRootSpan(this),
+      status: getSimpleStatusMessage(this._status),
+      attributes: this._attributes,
+      links: getStreamedSpanLinks(this._links),
+    };
+  }
+
   /** @inheritdoc */
   public isRecording(): boolean {
     return !this._endTime && !!this._sampled;
diff --git a/packages/core/src/utils/spanUtils.ts b/packages/core/src/utils/spanUtils.ts
index d7c261ecd73c..6e4a95b61d7b 100644
--- a/packages/core/src/utils/spanUtils.ts
+++ b/packages/core/src/utils/spanUtils.ts
@@ -1,4 +1,6 @@
 import { getAsyncContextStrategy } from '../asyncContext';
+import type { RawAttributes } from '../attributes';
+import { serializeAttributes } from '../attributes';
 import { getMainCarrier } from '../carrier';
 import { getCurrentScope } from '../currentScopes';
 import {
@@ -12,7 +14,15 @@ import { SPAN_STATUS_OK, SPAN_STATUS_UNSET } from '../tracing/spanstatus';
 import { getCapturedScopesOnSpan } from '../tracing/utils';
 import type { TraceContext } from '../types-hoist/context';
 import type { SpanLink, SpanLinkJSON } from '../types-hoist/link';
-import type { Span, SpanAttributes, SpanJSON, SpanOrigin, SpanTimeInput } from '../types-hoist/span';
+import type {
+  SerializedSpan,
+  Span,
+  SpanAttributes,
+  SpanJSON,
+  SpanOrigin,
+  SpanTimeInput,
+  StreamedSpanJSON,
+} from '../types-hoist/span';
 import type { SpanStatus } from '../types-hoist/spanStatus';
 import { addNonEnumerableProperty } from '../utils/object';
 import { generateSpanId } from '../utils/propagationContext';
@@ -105,6 +115,27 @@ export function convertSpanLinksForEnvelope(links?: SpanLink[]): SpanLinkJSON[]
   }
 }
 
+/**
+ * Converts the span links array to a flattened version with serialized attributes for V2 spans.
+ *
+ * If the links array is empty, it returns `undefined` so the empty value can be dropped before it's sent.
+ */
+export function getStreamedSpanLinks(
+  links?: SpanLink[],
+): SpanLinkJSON<RawAttributes<Record<string, unknown>>>[] | undefined {
+  if (links?.length) {
+    return links.map(({ context: { spanId, traceId, traceFlags, ...restContext }, attributes }) => ({
+      span_id: spanId,
+      trace_id: traceId,
+      sampled: traceFlags === TRACE_FLAG_SAMPLED,
+      attributes,
+      ...restContext,
+    }));
+  } else {
+    return undefined;
+  }
+}
+
 /**
  * Convert a span time input into a timestamp in seconds.
  */
@@ -150,23 +181,12 @@ export function spanToJSON(span: Span): SpanJSON {
   if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
     const { attributes, startTime, name, endTime, status, links } = span;
 
-    // In preparation for the next major of OpenTelemetry, we want to support
-    // looking up the parent span id according to the new API
-    // In OTel v1, the parent span id is accessed as `parentSpanId`
-    // In OTel v2, the parent span id is accessed as `spanId` on the `parentSpanContext`
-    const parentSpanId =
-      'parentSpanId' in span
-        ? span.parentSpanId
-        : 'parentSpanContext' in span
-          ? (span.parentSpanContext as { spanId?: string } | undefined)?.spanId
-          : undefined;
-
     return {
       span_id,
       trace_id,
       data: attributes,
       description: name,
-      parent_span_id: parentSpanId,
+      parent_span_id: getOtelParentSpanId(span),
       start_timestamp: spanTimeInputToSeconds(startTime),
       // This is [0,0] by default in OTEL, in which case we want to interpret this as no end time
       timestamp: spanTimeInputToSeconds(endTime) || undefined,
@@ -187,6 +207,77 @@ export function spanToJSON(span: Span): SpanJSON {
   };
 }
 
+/**
+ * Convert a span to the intermediate {@link StreamedSpanJSON} representation.
+ */
+export function spanToStreamedSpanJSON(span: Span): StreamedSpanJSON {
+  if (spanIsSentrySpan(span)) {
+    return span.getStreamedSpanJSON();
+  }
+
+  const { spanId: span_id, traceId: trace_id } = span.spanContext();
+
+  // Handle a span from @opentelemetry/sdk-base-trace's `Span` class
+  if (spanIsOpenTelemetrySdkTraceBaseSpan(span)) {
+    const { attributes, startTime, name, endTime, status, links } = span;
+
+    return {
+      name,
+      span_id,
+      trace_id,
+      parent_span_id: getOtelParentSpanId(span),
+      start_timestamp: spanTimeInputToSeconds(startTime),
+      end_timestamp: spanTimeInputToSeconds(endTime),
+      is_segment: span === INTERNAL_getSegmentSpan(span),
+      status: getSimpleStatusMessage(status),
+      attributes,
+      links: getStreamedSpanLinks(links),
+    };
+  }
+
+  // Finally, as a fallback, at least we have `spanContext()`....
+  // This should not actually happen in reality, but we need to handle it for type safety.
+  return {
+    span_id,
+    trace_id,
+    start_timestamp: 0,
+    name: '',
+    end_timestamp: 0,
+    status: 'ok',
+    is_segment: span === INTERNAL_getSegmentSpan(span),
+  };
+}
+
+/**
+ * In preparation for the next major of OpenTelemetry, we want to support
+ * looking up the parent span id according to the new API
+ * In OTel v1, the parent span id is accessed as `parentSpanId`
+ * In OTel v2, the parent span id is accessed as `spanId` on the `parentSpanContext`
+ */
+function getOtelParentSpanId(span: OpenTelemetrySdkTraceBaseSpan): string | undefined {
+  return 'parentSpanId' in span
+    ? span.parentSpanId
+    : 'parentSpanContext' in span
+      ? (span.parentSpanContext as { spanId?: string } | undefined)?.spanId
+      : undefined;
+}
+
+/**
+ * Converts a {@link StreamedSpanJSON} to a {@link SerializedSpan}.
+ * This is the final serialized span format that is sent to Sentry.
+ * The returned serilaized spans must not be consumed by users or SDK integrations.
+ */
+export function streamedSpanJsonToSerializedSpan(spanJson: StreamedSpanJSON): SerializedSpan {
+  return {
+    ...spanJson,
+    attributes: serializeAttributes(spanJson.attributes),
+    links: spanJson.links?.map(link => ({
+      ...link,
+      attributes: serializeAttributes(link.attributes),
+    })),
+  };
+}
+
 function spanIsOpenTelemetrySdkTraceBaseSpan(span: Span): span is OpenTelemetrySdkTraceBaseSpan {
   const castSpan = span as Partial<OpenTelemetrySdkTraceBaseSpan>;
   return !!castSpan.attributes && !!castSpan.startTime && !!castSpan.name && !!castSpan.endTime && !!castSpan.status;
@@ -237,6 +328,13 @@ export function getStatusMessage(status: SpanStatus | undefined): string | undef
   return status.message || 'internal_error';
 }
 
+/**
+ * Convert the various statuses to the simple onces expected by Sentry for steamed spans ('ok' is default).
+ */
+export function getSimpleStatusMessage(status: SpanStatus | undefined): 'ok' | 'error' {
+  return !status || status.code === SPAN_STATUS_OK || status.code === SPAN_STATUS_UNSET ? 'ok' : 'error';
+}
+
 const CHILD_SPANS_FIELD = '_sentryChildSpans';
 const ROOT_SPAN_FIELD = '_sentryRootSpan';
 
@@ -298,7 +396,12 @@ export function getSpanDescendants(span: SpanWithPotentialChildren): Span[] {
 /**
  * Returns the root span of a given span.
  */
-export function getRootSpan(span: SpanWithPotentialChildren): Span {
+export const getRootSpan = INTERNAL_getSegmentSpan;
+
+/**
+ * Returns the segment span of a given span.
+ */
+export function INTERNAL_getSegmentSpan(span: SpanWithPotentialChildren): Span {
   return span[ROOT_SPAN_FIELD] || span;
 }
 
diff --git a/packages/core/test/lib/utils/spanUtils.test.ts b/packages/core/test/lib/utils/spanUtils.test.ts
index bca9a406dd50..e4a0b31990d7 100644
--- a/packages/core/test/lib/utils/spanUtils.test.ts
+++ b/packages/core/test/lib/utils/spanUtils.test.ts
@@ -4,6 +4,7 @@ import {
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
+  SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE,
   SentrySpan,
   setCurrentClient,
   SPAN_STATUS_ERROR,
@@ -16,7 +17,7 @@ import {
   TRACEPARENT_REGEXP,
 } from '../../../src';
 import type { SpanLink } from '../../../src/types-hoist/link';
-import type { Span, SpanAttributes, SpanTimeInput } from '../../../src/types-hoist/span';
+import type { Span, SpanAttributes, SpanTimeInput, StreamedSpanJSON } from '../../../src/types-hoist/span';
 import type { SpanStatus } from '../../../src/types-hoist/spanStatus';
 import type { OpenTelemetrySdkTraceBaseSpan } from '../../../src/utils/spanUtils';
 import {
@@ -24,7 +25,9 @@ import {
   spanIsSampled,
   spanTimeInputToSeconds,
   spanToJSON,
+  spanToStreamedSpanJSON,
   spanToTraceContext,
+  streamedSpanJsonToSerializedSpan,
   TRACE_FLAG_NONE,
   TRACE_FLAG_SAMPLED,
   updateSpanName,
@@ -41,6 +44,7 @@ function createMockedOtelSpan({
   status = { code: SPAN_STATUS_UNSET },
   endTime = Date.now(),
   parentSpanId,
+  links = undefined,
 }: {
   spanId: string;
   traceId: string;
@@ -51,6 +55,7 @@ function createMockedOtelSpan({
   status?: SpanStatus;
   endTime?: SpanTimeInput;
   parentSpanId?: string;
+  links?: SpanLink[];
 }): Span {
   return {
     spanContext: () => {
@@ -66,6 +71,7 @@ function createMockedOtelSpan({
     status,
     endTime,
     parentSpanId,
+    links,
   } as OpenTelemetrySdkTraceBaseSpan;
 }
 
@@ -409,6 +415,233 @@ describe('spanToJSON', () => {
     });
   });
 
+  describe('spanToStreamedSpanJSON', () => {
+    describe('SentrySpan', () => {
+      it('converts a minimal span', () => {
+        const span = new SentrySpan();
+        expect(spanToStreamedSpanJSON(span)).toEqual({
+          span_id: expect.stringMatching(/^[0-9a-f]{16}$/),
+          trace_id: expect.stringMatching(/^[0-9a-f]{32}$/),
+          name: '',
+          start_timestamp: expect.any(Number),
+          end_timestamp: expect.any(Number),
+          status: 'ok',
+          is_segment: true,
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'manual',
+          },
+        });
+      });
+
+      it('converts a full span', () => {
+        const span = new SentrySpan({
+          op: 'test op',
+          name: 'test name',
+          parentSpanId: '1234',
+          spanId: '5678',
+          traceId: 'abcd',
+          startTimestamp: 123,
+          endTimestamp: 456,
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto',
+            attr1: 'value1',
+            attr2: 2,
+            attr3: true,
+          },
+          links: [
+            {
+              context: {
+                spanId: 'span1',
+                traceId: 'trace1',
+                traceFlags: TRACE_FLAG_SAMPLED,
+              },
+              attributes: {
+                'sentry.link.type': 'previous_trace',
+              },
+            },
+          ],
+        });
+        span.setStatus({ code: SPAN_STATUS_OK });
+        span.setAttribute('attr4', [1, 2, 3]);
+
+        expect(spanToStreamedSpanJSON(span)).toEqual({
+          name: 'test name',
+          parent_span_id: '1234',
+          span_id: '5678',
+          trace_id: 'abcd',
+          start_timestamp: 123,
+          end_timestamp: 456,
+          status: 'ok',
+          is_segment: true,
+          attributes: {
+            attr1: 'value1',
+            attr2: 2,
+            attr3: true,
+            attr4: [1, 2, 3],
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'test op',
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto',
+          },
+          links: [
+            {
+              span_id: 'span1',
+              trace_id: 'trace1',
+              sampled: true,
+              attributes: {
+                [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',
+              },
+            },
+          ],
+        });
+      });
+    });
+    describe('OpenTelemetry Span', () => {
+      it('converts a simple span', () => {
+        const span = createMockedOtelSpan({
+          spanId: 'SPAN-1',
+          traceId: 'TRACE-1',
+          name: 'test span',
+          startTime: 123,
+          endTime: [0, 0],
+          attributes: {},
+          status: { code: SPAN_STATUS_UNSET },
+        });
+
+        expect(spanToStreamedSpanJSON(span)).toEqual({
+          span_id: 'SPAN-1',
+          trace_id: 'TRACE-1',
+          parent_span_id: undefined,
+          start_timestamp: 123,
+          end_timestamp: 0,
+          name: 'test span',
+          is_segment: true,
+          status: 'ok',
+          attributes: {},
+        });
+      });
+
+      it('converts a full span', () => {
+        const span = createMockedOtelSpan({
+          spanId: 'SPAN-1',
+          traceId: 'TRACE-1',
+          parentSpanId: 'PARENT-1',
+          name: 'test span',
+          startTime: 123,
+          endTime: 456,
+          attributes: {
+            attr1: 'value1',
+            attr2: 2,
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'test op',
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto',
+          },
+          links: [
+            {
+              context: {
+                spanId: 'span1',
+                traceId: 'trace1',
+                traceFlags: TRACE_FLAG_SAMPLED,
+              },
+              attributes: {
+                [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',
+              },
+            },
+          ],
+          status: { code: SPAN_STATUS_ERROR, message: 'unknown_error' },
+        });
+
+        expect(spanToStreamedSpanJSON(span)).toEqual({
+          span_id: 'SPAN-1',
+          trace_id: 'TRACE-1',
+          parent_span_id: 'PARENT-1',
+          start_timestamp: 123,
+          end_timestamp: 456,
+          name: 'test span',
+          is_segment: true,
+          status: 'error',
+          attributes: {
+            attr1: 'value1',
+            attr2: 2,
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'test op',
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto',
+          },
+          links: [
+            {
+              span_id: 'span1',
+              trace_id: 'trace1',
+              sampled: true,
+              attributes: {
+                [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',
+              },
+            },
+          ],
+        });
+      });
+    });
+  });
+
+  describe('streamedSpanJsonToSerializedSpan', () => {
+    it('converts a streamed span JSON with links to a serialized span', () => {
+      const spanJson: StreamedSpanJSON = {
+        name: 'test name',
+        parent_span_id: '1234',
+        span_id: '5678',
+        trace_id: 'abcd',
+        start_timestamp: 123,
+        end_timestamp: 456,
+        status: 'ok',
+        is_segment: true,
+        attributes: {
+          attr1: 'value1',
+          attr2: 2,
+          attr3: true,
+          attr4: [1, 2, 3],
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: 'test op',
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: 'auto',
+        },
+        links: [
+          {
+            span_id: 'span1',
+            trace_id: 'trace1',
+            sampled: true,
+            attributes: {
+              [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: 'previous_trace',
+            },
+          },
+        ],
+      };
+
+      expect(streamedSpanJsonToSerializedSpan(spanJson)).toEqual({
+        name: 'test name',
+        parent_span_id: '1234',
+        span_id: '5678',
+        trace_id: 'abcd',
+        start_timestamp: 123,
+        end_timestamp: 456,
+        status: 'ok',
+        is_segment: true,
+        attributes: {
+          attr1: { type: 'string', value: 'value1' },
+          attr2: { type: 'integer', value: 2 },
+          attr3: { type: 'boolean', value: true },
+          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: { type: 'string', value: 'test op' },
+          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: { type: 'string', value: 'auto' },
+          // notice the absence of `attr4`!
+          // for now, we don't yet serialize array attributes. This test will fail
+          // once we allow serializing them.
+        },
+        links: [
+          {
+            span_id: 'span1',
+            trace_id: 'trace1',
+            sampled: true,
+            attributes: {
+              [SEMANTIC_LINK_ATTRIBUTE_LINK_TYPE]: { type: 'string', value: 'previous_trace' },
+            },
+          },
+        ],
+      });
+    });
+  });
+
   it('returns minimal object for unknown span implementation', () => {
     const span = {
       // This is the minimal interface we require from a span