@@ -10,7 +10,7 @@ It seeks to enable:
 
 * Instrumentation of inbound and outbound HTTP transactions, following [OTel Semconv](https://opentelemetry.io/docs/specs/semconv/general/trace/).
 * Tracing data egress via OTLP/JSON. (JSON-only to avoid bringing in a gRPC dependency.)
-* Distributed tracing via W3C Traceparent.
+* Distributed tracing via W3C Traceparent, including forwarding baggage (but not modifying it).
 
 Anything else, including the following, should be considered initally out of scope:
 
@@ -127,8 +127,9 @@ and span end timing are the same as for the HTTP client spans above. Requests
 that fail before they are dispatched, such as a refused connection, produce
 no span: the undici channels only fire once the request is underway. The
 injected `traceparent` replaces any caller-supplied value rather than
-appending to it, and a stale `tracestate` is removed when the span has none
-to inherit.
+appending to it, a stale `tracestate` is removed when the span has none to
+inherit, and the inherited `baggage` replaces any caller-supplied value the
+same way.
 
 Attributes set on undici/fetch client spans:
 
@@ -153,10 +154,15 @@ requests, and child spans created during request processing inherit the trace
 ID. `traceparent` values using a version other than `00` are rejected, and a
 fresh trace is started instead. The `tracestate` header, when present, is
 attached to the span and forwarded verbatim to outgoing requests. It is never
-parsed or modified.
+parsed or modified. The `baggage` header is likewise attached and forwarded
+verbatim, never parsed or modified; per the W3C Baggage specification it
+propagates independently of `traceparent`, so it is carried forward even when
+the `traceparent` is absent or rejected.
 * **Outgoing requests**: The `traceparent` header is injected into outgoing
-HTTP and undici/fetch requests, together with the stored `tracestate` when
-one is present, enabling distributed tracing across services.
+HTTP and undici/fetch requests, together with the stored `tracestate` and
+`baggage` when present, enabling distributed tracing across services.
+Baggage is a propagated header, not a span attribute, so it never appears in
+the exported span data.
 
 ## Benchmarks
 
@@ -178,9 +184,10 @@ The tracing subsystem is independent of the OpenTelemetry JavaScript packages. I
 is not interoperable with `@opentelemetry/api`, and spans created by one are not
 visible to the other. Running both in the same process produces duplicate trace
 and span IDs. The built-in instrumentation also overwrites the `traceparent`
-(and, when present, `tracestate`) header on outgoing HTTP requests, discarding
-whatever a userland propagator may have set. Users should run either this
-package or a userland OpenTelemetry SDK, not both.
+(and, when present, `tracestate`) header on outgoing HTTP requests, and
+replaces the `baggage` header when the span carries one, discarding whatever a
+userland propagator may have set. Users should run either this package or a
+userland OpenTelemetry SDK, not both.
 
 `init()` activates tracing in the thread that calls it. Worker threads
 (`node:worker_threads`) are not traced unless they call `init()` themselves.
 
@@ -49,18 +49,22 @@ function onHttpServerRequestStart({ request, response, socket }) {
   const exportUrl = getExportUrl();
   if (
     request.url === exportUrl.pathname &&
-    request.headers?.host === getCollectorHost()
+    request.headers.host === getCollectorHost()
   ) {
     return;
   }
 
-  const traceparent = request.headers?.traceparent;
+  const traceparent = request.headers.traceparent;
   const parent =
     traceparent != null ? Span.fromTraceparent(traceparent) : undefined;
   // Per the W3C Trace Context spec, tracestate is only meaningful
   // alongside a valid traceparent. It is discarded when the traceparent
   // is absent or rejected.
-  const tracestate = parent != null ? request.headers?.tracestate : undefined;
+  const tracestate = parent != null ? request.headers.tracestate : undefined;
+  // Unlike tracestate, baggage propagates independently of traceparent
+  // per the W3C Baggage spec, so it is read unconditionally. Like
+  // tracestate it is forwarded verbatim; it is never parsed.
+  const baggage = request.headers.baggage;
 
   const method = request.method || 'GET';
   const rawUrl = request.url || '/';
@@ -71,8 +75,10 @@ function onHttpServerRequestStart({ request, response, socket }) {
   // in an attribute.
   const span = new Span(method, SPAN_KIND_SERVER, {
     parent,
-    // The tracestate is forwarded verbatim; it is never parsed.
+    // The tracestate and baggage are forwarded verbatim; neither is
+    // ever parsed.
     tracestate,
+    baggage,
   });
 
   span.setAttribute('http.request.method', method);
@@ -82,7 +88,7 @@ function onHttpServerRequestStart({ request, response, socket }) {
   span.setAttribute('url.scheme', socket?.encrypted ? 'https' : 'http');
   span.setAttribute('network.protocol.version', request.httpVersion || '1.1');
 
-  const host = request.headers?.host;
+  const host = request.headers.host;
   if (host) span.setAttribute('server.address', splitAuthority(host)[0]);
 
   // The span is stashed on the request so the response handlers do not
@@ -184,10 +190,13 @@ function onHttpClientRequestCreated({ request }) {
   if (request.headersSent) return;
 
   request.setHeader('traceparent', span.toTraceparent());
-  // A stale tracestate from an unrelated trace must not travel with the
-  // new trace context.
+  // A caller-supplied tracestate or baggage is replaced rather than
+  // appended, and a stale value is removed when the span has none to
+  // inherit, so it does not travel with the new trace context.
   if (span.tracestate) request.setHeader('tracestate', span.tracestate);
   else request.removeHeader('tracestate');
+  if (span.baggage) request.setHeader('baggage', span.baggage);
+  else request.removeHeader('baggage');
 }
 
 function onHttpClientResponseFinish({ request, response }) {
@@ -260,6 +269,8 @@ function onUndiciRequestCreate({ request }) {
     if (span.tracestate)
       setUndiciHeader(request, 'tracestate', span.tracestate);
     else removeUndiciHeader(request, 'tracestate');
+    if (span.baggage) setUndiciHeader(request, 'baggage', span.baggage);
+    else removeUndiciHeader(request, 'baggage');
   }
 }
 
 
@@ -32,6 +32,10 @@ class Span {
   // Raw W3C tracestate header value, forwarded verbatim to child
   // requests. Undefined when no tracestate was received.
   tracestate;
+  // Raw W3C baggage header value, forwarded verbatim like tracestate:
+  // never parsed, never modified, and not a span attribute, so it never
+  // appears in the OTLP payload. Undefined when no baggage was received.
+  baggage;
   // Timestamps are epoch milliseconds. The start comes from the wall
   // clock; the end is derived as start + a monotonic duration, so spans
   // survive a backward clock step while keeping human-readable absolute
@@ -86,6 +90,9 @@ class Span {
     }
     // An explicit tracestate wins; children inherit their parent's.
     this.tracestate = options?.tracestate ?? parent?.tracestate;
+    // Baggage follows the same inheritance: an explicit inbound value
+    // wins, children inherit their parent's.
+    this.baggage = options?.baggage ?? parent?.baggage;
   }
 
   get traceFlags() {
 
@@ -14,7 +14,8 @@ const {
 } = require('./common/otel');
 
 // W3C trace context propagation: child spans share the incoming trace ID,
-// and outgoing requests carry the traceparent.
+// and outgoing requests carry the traceparent. The tracestate and
+// baggage headers are forwarded verbatim.
 
 describe('otel context propagation', () => {
   let collector;
@@ -96,6 +97,112 @@ describe('otel context propagation', () => {
     assert.strictEqual(outgoingTracestate, incomingTracestate);
   });
 
+  it('forwards baggage verbatim across HTTP hops', async () => {
+    const incomingTraceId = 'abcdef0123456789abcdef0123456789';
+    const incomingTraceparent = `00-${incomingTraceId}-0123456789abcdef-01`;
+    // A value with arbitrary list members and extra spaces: baggage is
+    // forwarded verbatim, so nothing may be parsed, trimmed, or reordered.
+    const incomingBaggage = 'key1=value1,key2=value2, unpacked = value3';
+
+    let outgoingBaggage = 'sentinel';
+
+    const backend = await startHTTPServer((req, res) => {
+      outgoingBaggage = req.headers.baggage;
+      res.writeHead(200);
+      res.end('backend-ok');
+    });
+
+    // The frontend makes an outgoing call to the backend, carrying a
+    // stale baggage header that the span's inherited baggage must
+    // override.
+    const frontend = await startHTTPServer((req, res) => {
+      http.get(
+        `http://127.0.0.1:${backend.port}/backend`,
+        {
+          headers: { baggage: 'stale=will-be-overridden' },
+        },
+        (backendRes) => {
+          backendRes.resume();
+          backendRes.on('end', () => {
+            res.writeHead(200);
+            res.end('frontend-ok');
+          });
+        },
+      );
+    });
+
+    await rawRequest(frontend.port, '/frontend', {
+      traceparent: incomingTraceparent,
+      baggage: incomingBaggage,
+    });
+
+    const spans = await flushAndCollect(collector);
+
+    await closeAll(frontend, backend);
+
+    assert.strictEqual(
+      outgoingBaggage,
+      incomingBaggage,
+      'The baggage must be forwarded verbatim to child requests',
+    );
+
+    // Baggage is a propagation header, not a span attribute: it must
+    // not be emitted into the OTLP payload.
+    const serverSpan = getServerSpan(spans, '/frontend');
+    assert.ok(serverSpan, 'Expected a frontend server span');
+    const attributeKeys = (serverSpan.attributes ?? []).map((a) => a.key);
+    assert.ok(
+      !attributeKeys.includes('baggage'),
+      'baggage must not be emitted as a span attribute',
+    );
+  });
+
+  it('forwards baggage without a traceparent', async () => {
+    // Per the W3C Baggage spec, baggage propagates independently of
+    // traceparent: a request with baggage but no traceparent starts a
+    // fresh trace that still carries the baggage forward.
+    const incomingBaggage = 'vendor=state,key=value';
+
+    let outgoingTraceparent = null;
+    let outgoingBaggage = 'sentinel';
+
+    const backend = await startHTTPServer((req, res) => {
+      outgoingTraceparent = req.headers.traceparent || null;
+      outgoingBaggage = req.headers.baggage;
+      res.writeHead(200);
+      res.end('backend-ok');
+    });
+
+    const frontend = await startHTTPServer((req, res) => {
+      http.get(`http://127.0.0.1:${backend.port}/backend`, (backendRes) => {
+        backendRes.resume();
+        backendRes.on('end', () => {
+          res.writeHead(200);
+          res.end('frontend-ok');
+        });
+      });
+    });
+
+    await rawRequest(frontend.port, '/frontend', {
+      baggage: incomingBaggage,
+    });
+
+    await flushAndCollect(collector);
+
+    await closeAll(frontend, backend);
+
+    // A fresh trace was started, and the baggage still travels with it.
+    assert.ok(
+      outgoingTraceparent,
+      'Expected a traceparent on the outgoing request',
+    );
+    assert.strictEqual(
+      outgoingBaggage,
+      incomingBaggage,
+      'baggage must be forwarded even without a traceparent',
+    );
+  });
+
   it('discards tracestate when the traceparent is invalid', async () => {
     const rejectedTraceId = 'abcdef0123456789abcdef0123456789';
 
 
@@ -157,6 +157,64 @@ describe('otel undici spans', () => {
     );
   });
 
+  it('overrides a stale baggage with the inherited one', async () => {
+    const incomingTraceId = 'b'.repeat(32);
+    const incomingBaggage = 'vendor=inherited,key=value';
+
+    let seen;
+    // The fetch target records the trace context headers it receives.
+    const fetchTarget = await startHTTPServer((req, res) => {
+      seen = {
+        traceparent: req.headers.traceparent,
+        baggage: req.headers.baggage,
+      };
+      res.writeHead(200);
+      res.end('ok');
+    });
+
+    // A fetch made while handling a traced request inherits the incoming
+    // baggage and must override the caller-supplied stale one.
+    const frontend = await startHTTPServer((req, res) => {
+      fetch(`http://127.0.0.1:${fetchTarget.port}/down`, {
+        headers: { baggage: 'stale=caller-value' },
+      }).then((fr) => {
+        fr.text().then(() => {
+          res.writeHead(200);
+          res.end('ok');
+        });
+      });
+    });
+
+    await rawRequest(frontend.port, '/up', {
+      traceparent: `00-${incomingTraceId}-0123456789abcdef-01`,
+      baggage: incomingBaggage,
+    });
+
+    const spans = await flushAndCollect(collector);
+    await closeAll(fetchTarget, frontend);
+
+    assert.ok(seen?.traceparent, 'Expected a traceparent on the fetch');
+    assert.ok(
+      seen.traceparent.includes(incomingTraceId),
+      'The fetch must carry the incoming trace ID',
+    );
+    assert.strictEqual(
+      seen.baggage,
+      incomingBaggage,
+      'The inherited baggage must win over the stale one',
+    );
+
+    // Baggage is a propagation header, not a span attribute: it must
+    // not be emitted into the OTLP payload.
+    const clientSpan = getClientSpan(spans, '/down');
+    assert.ok(clientSpan, 'Expected a client span for the fetch');
+    const attributeKeys = (clientSpan.attributes ?? []).map((a) => a.key);
+    assert.ok(
+      !attributeKeys.includes('baggage'),
+      'baggage must not be emitted as a span attribute',
+    );
+  });
+
   it('removes a stale tracestate when the span has none', async () => {
     let receivedTracestate = 'sentinel';
     const target = await startHTTPServer((req, res) => {