diff --git a/README.md b/README.md
index 1bb7564..ee08a25 100644
--- a/README.md
+++ b/README.md
@@ -130,6 +130,7 @@ Commands with JSON output support:
 - **Deploy**: `deploy` (JSONL streaming), `history`
 - **Invoke**: `invoke` (JSONL streaming), `history`
 - **Browser Sub-commands**: `replays list/start`, `process exec/spawn`, `fs file-info/list-files`
+- **Browser NDJSON streaming**: `telemetry stream`
 
 ### Authentication
 
@@ -212,6 +213,9 @@ Commands with JSON output support:
   - `--start-url <url>` - Initial page to open on launch
   - `--pool-id <id>` - Acquire a browser from the specified pool (mutually exclusive with --pool-name; ignores other session flags)
   - `--pool-name <name>` - Acquire a browser from the pool name (mutually exclusive with --pool-id; ignores other session flags)
+  - `--telemetry=all` - Enable telemetry for all categories
+  - `--telemetry=off` - Disable telemetry
+  - `--telemetry=<list>` - Per-category config, e.g. `--telemetry=network=on,page=off`
   - `--output json`, `-o json` - Output raw JSON object
   - _Note: When a pool is specified, omit other session configuration flags—pool settings determine profile, proxy, viewport, etc._
 - `kernel browsers delete <id>` - Delete a browser
@@ -219,6 +223,11 @@ Commands with JSON output support:
   - `--output json`, `-o json` - Output JSON with liveViewUrl
 - `kernel browsers get <id>` - Get detailed browser session info
   - `--output json`, `-o json` - Output raw JSON object
+- `kernel browsers update <id>` - Update a running browser session
+  - `--telemetry=all` - Enable telemetry for all categories
+  - `--telemetry=off` - Disable telemetry
+  - `--telemetry=<list>` - Per-category config, e.g. `--telemetry=network=on,page=off`
+  - `--output json`, `-o json` - Output raw JSON object
 - `kernel browsers curl <id> <url>` - Make HTTP requests through a browser session's Chrome network stack
   - `-X, --request <method>` - HTTP method (default: GET; defaults to POST when `--data` is set)
   - `-H, --header <header>` - HTTP header, repeatable (`"Key: Value"` format)
@@ -281,6 +290,23 @@ Commands with JSON output support:
 - `kernel browsers replays download <id> <replay-id>` - Download a replay video
   - `-f, --output-file <path>` - Output file path for the replay video
 
+### Browser Telemetry
+
+Telemetry config is a sub-field of the browser session. Use `browsers create` or `browsers update` to enable, disable, or configure it, and `browsers get` to inspect the current state.
+
+- Enable all categories: `kernel browsers update <id> --telemetry=all`
+- Disable: `kernel browsers update <id> --telemetry=off`
+- Per-category: `kernel browsers update <id> --telemetry=network=on,page=off` (valid: `console`, `interaction`, `network`, `page`; `system` always emits and cannot be toggled)
+
+Per-category updates are partial — only categories you name are changed; others retain their current state. `--telemetry=all` and `--telemetry=off` reset the entire config.
+
+- `kernel browsers telemetry stream <id>` - Stream live telemetry events (NDJSON with `-o json`)
+  - `--categories <list>` - Filter by event category (`console`, `network`, `page`, `interaction`, `system`); `system` matches `monitor_*` event types
+  - `--types <list>` - Filter by event type (e.g. `network_response`, `console_error`)
+  - `--seq <n>` - Resume from sequence number (Last-Event-ID); `--seq=0` replays from the beginning. Omit to stream from now.
+  - `-o, --output json` - Output newline-delimited JSON envelopes
+  - Default output: tab-separated `<time>\t[<category>]\t<type>`, e.g. `15:04:05  [network]  network_response`
+
 ### Browser Process Control
 
 - `kernel browsers process exec <id> [--] [command...]` - Execute a command synchronously
diff --git a/cmd/browsers.go b/cmd/browsers.go
index d73e115..bc2b79f 100644
--- a/cmd/browsers.go
+++ b/cmd/browsers.go
@@ -175,6 +175,7 @@ type BrowsersCreateInput struct {
 	StartURL           string
 	Extensions         []string
 	Viewport           string
+	Telemetry          string
 	Output             string
 }
 
@@ -202,6 +203,7 @@ type BrowsersUpdateInput struct {
 	ProfileSaveChanges BoolFlag
 	Viewport           string
 	Force              bool
+	Telemetry          string
 	Output             string
 }
 
@@ -215,6 +217,7 @@ type BrowsersCmd struct {
 	logs       BrowserLogService
 	computer   BrowserComputerService
 	playwright BrowserPlaywrightService
+	telemetry  BrowserTelemetryService
 }
 
 type BrowsersListInput struct {
@@ -410,6 +413,14 @@ func (b BrowsersCmd) Create(ctx context.Context, in BrowsersCreateInput) error {
 		}
 	}
 
+	if in.Telemetry != "" {
+		t, err := buildNewTelemetryParam(in.Telemetry)
+		if err != nil {
+			return err
+		}
+		params.Telemetry = t
+	}
+
 	browser, err := b.browsers.New(ctx, params)
 	if err != nil {
 		return util.CleanedUpSdkError{Err: err}
@@ -576,8 +587,8 @@ func (b BrowsersCmd) Update(ctx context.Context, in BrowsersUpdateInput) error {
 	}
 
 	// Validate that at least one update option is provided
-	if !hasProxyChange && !hasProfileChange && !hasViewportChange {
-		return fmt.Errorf("must specify at least one of: --proxy-id, --clear-proxy, --profile-id, --profile-name, or --viewport")
+	if !hasProxyChange && !hasProfileChange && !hasViewportChange && in.Telemetry == "" {
+		return fmt.Errorf("must specify at least one of: --proxy-id, --clear-proxy, --profile-id, --profile-name, --viewport, or --telemetry")
 	}
 
 	params := kernel.BrowserUpdateParams{}
@@ -602,6 +613,15 @@ func (b BrowsersCmd) Update(ctx context.Context, in BrowsersUpdateInput) error {
 		}
 	}
 
+	// Handle telemetry changes
+	if in.Telemetry != "" {
+		t, err := buildUpdateTelemetryParam(in.Telemetry)
+		if err != nil {
+			return err
+		}
+		params.Telemetry = t
+	}
+
 	// Handle viewport changes
 	if hasViewportChange {
 		width, height, refreshRate, err := parseViewport(in.Viewport)
@@ -2229,6 +2249,7 @@ func init() {
 	browsersUpdateCmd.Flags().Bool("save-changes", false, "If set, save changes back to the profile when the session ends")
 	browsersUpdateCmd.Flags().String("viewport", "", "Browser viewport size (e.g., 1920x1080@25). Supported: 2560x1440@10, 1920x1080@25, 1920x1200@25, 1440x900@25, 1024x768@60, 1200x800@60, 1280x800@60")
 	browsersUpdateCmd.Flags().Bool("force", false, "Force viewport resize even when a live view or recording/replay is active")
+	browsersUpdateCmd.Flags().String("telemetry", "", "Update telemetry: --telemetry=all to enable, --telemetry=off to disable, --telemetry=network=on,page=off for per-category")
 
 	browsersCmd.AddCommand(browsersListCmd)
 	browsersCmd.AddCommand(browsersCreateCmd)
@@ -2494,6 +2515,7 @@ func init() {
 	browsersCreateCmd.Flags().Bool("viewport-interactive", false, "Interactively select viewport size from list")
 	browsersCreateCmd.Flags().String("pool-id", "", "Browser pool ID to acquire from (mutually exclusive with --pool-name)")
 	browsersCreateCmd.Flags().String("pool-name", "", "Browser pool name to acquire from (mutually exclusive with --pool-id)")
+	browsersCreateCmd.Flags().String("telemetry", "", "Configure telemetry: --telemetry=all to enable, --telemetry=off to disable, --telemetry=network=on,page=off for per-category")
 
 	// curl
 	curlCmd := &cobra.Command{
@@ -2563,6 +2585,7 @@ func runBrowsersCreate(cmd *cobra.Command, args []string) error {
 	viewportInteractive, _ := cmd.Flags().GetBool("viewport-interactive")
 	poolID, _ := cmd.Flags().GetString("pool-id")
 	poolName, _ := cmd.Flags().GetString("pool-name")
+	telemetry, _ := cmd.Flags().GetString("telemetry")
 	output, _ := cmd.Flags().GetString("output")
 
 	if poolID != "" && poolName != "" {
@@ -2672,6 +2695,7 @@ func runBrowsersCreate(cmd *cobra.Command, args []string) error {
 		StartURL:           startURL,
 		Extensions:         extensions,
 		Viewport:           viewport,
+		Telemetry:          telemetry,
 		Output:             output,
 	}
 
@@ -2730,6 +2754,7 @@ func runBrowsersUpdate(cmd *cobra.Command, args []string) error {
 	saveChanges, _ := cmd.Flags().GetBool("save-changes")
 	viewport, _ := cmd.Flags().GetString("viewport")
 	force, _ := cmd.Flags().GetBool("force")
+	telemetry, _ := cmd.Flags().GetString("telemetry")
 
 	svc := client.Browsers
 	b := BrowsersCmd{browsers: &svc}
@@ -2742,6 +2767,7 @@ func runBrowsersUpdate(cmd *cobra.Command, args []string) error {
 		ProfileSaveChanges: BoolFlag{Set: cmd.Flags().Changed("save-changes"), Value: saveChanges},
 		Viewport:           viewport,
 		Force:              force,
+		Telemetry:          telemetry,
 		Output:             out,
 	})
 }
diff --git a/cmd/browsers_telemetry.go b/cmd/browsers_telemetry.go
new file mode 100644
index 0000000..008e148
--- /dev/null
+++ b/cmd/browsers_telemetry.go
@@ -0,0 +1,207 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/kernel/cli/pkg/util"
+	kernel "github.com/kernel/kernel-go-sdk"
+	"github.com/kernel/kernel-go-sdk/option"
+	"github.com/kernel/kernel-go-sdk/packages/ssestream"
+	"github.com/pterm/pterm"
+	"github.com/spf13/cobra"
+)
+
+// BrowserTelemetryService defines the subset we use for browser telemetry streaming.
+type BrowserTelemetryService interface {
+	StreamStreaming(ctx context.Context, id string, query kernel.BrowserTelemetryStreamParams, opts ...option.RequestOption) (stream *ssestream.Stream[kernel.BrowserTelemetryStreamResponse])
+}
+
+type BrowsersTelemetryStreamInput struct {
+	Identifier string
+	Categories []string
+	Types      []string
+	Seq        int64
+	Output     string
+}
+
+// parseTelemetryCategories parses a comma-separated "name=on|off" string into
+// a BrowserTelemetryCategoriesConfigParam. Unmentioned categories are omitted.
+func parseTelemetryCategories(s string) (kernel.BrowserTelemetryCategoriesConfigParam, error) {
+	p := kernel.BrowserTelemetryCategoriesConfigParam{}
+	for _, part := range strings.Split(s, ",") {
+		name, val, ok := strings.Cut(strings.TrimSpace(part), "=")
+		if !ok {
+			return p, fmt.Errorf("invalid category assignment %q: expected name=on or name=off", part)
+		}
+		name, val = strings.TrimSpace(name), strings.TrimSpace(val)
+		var enabled bool
+		switch val {
+		case "on":
+			enabled = true
+		case "off":
+			enabled = false
+		default:
+			return p, fmt.Errorf("invalid value %q for category %q: must be 'on' or 'off'", val, name)
+		}
+		switch name {
+		case "console":
+			p.Console = kernel.BrowserTelemetryCategoryConfigParam{Enabled: kernel.Opt(enabled)}
+		case "interaction":
+			p.Interaction = kernel.BrowserTelemetryCategoryConfigParam{Enabled: kernel.Opt(enabled)}
+		case "network":
+			p.Network = kernel.BrowserTelemetryCategoryConfigParam{Enabled: kernel.Opt(enabled)}
+		case "page":
+			p.Page = kernel.BrowserTelemetryCategoryConfigParam{Enabled: kernel.Opt(enabled)}
+		default:
+			return p, fmt.Errorf("unknown category %q: must be one of %s", name, strings.Join(settableCategories, ", "))
+		}
+	}
+	return p, nil
+}
+
+// buildNewTelemetryParam converts a --telemetry flag value to the create API param.
+func buildNewTelemetryParam(s string) (kernel.BrowserNewParamsTelemetry, error) {
+	switch s {
+	case "all":
+		return kernel.BrowserNewParamsTelemetry{Enabled: kernel.Opt(true)}, nil
+	case "off":
+		return kernel.BrowserNewParamsTelemetry{Enabled: kernel.Opt(false)}, nil
+	default:
+		p, err := parseTelemetryCategories(s)
+		if err != nil {
+			return kernel.BrowserNewParamsTelemetry{}, err
+		}
+		return kernel.BrowserNewParamsTelemetry{Browser: p}, nil
+	}
+}
+
+// buildUpdateTelemetryParam converts a --telemetry flag value to the update API param.
+func buildUpdateTelemetryParam(s string) (kernel.BrowserUpdateParamsTelemetry, error) {
+	switch s {
+	case "all":
+		return kernel.BrowserUpdateParamsTelemetry{Enabled: kernel.Opt(true)}, nil
+	case "off":
+		return kernel.BrowserUpdateParamsTelemetry{Enabled: kernel.Opt(false)}, nil
+	default:
+		p, err := parseTelemetryCategories(s)
+		if err != nil {
+			return kernel.BrowserUpdateParamsTelemetry{}, err
+		}
+		return kernel.BrowserUpdateParamsTelemetry{Browser: p}, nil
+	}
+}
+
+// settableCategories are the categories accepted by --telemetry=<categories>.
+// "system" is always-on and cannot be toggled, but is valid as a --categories stream filter.
+var settableCategories = []string{"console", "interaction", "network", "page"}
+
+// streamFilterCategories are the categories accepted by `telemetry stream --categories`.
+var streamFilterCategories = []string{"console", "interaction", "network", "page", "system"}
+
+// eventCategory derives the category from the event type prefix.
+// "monitor_*" maps to "system"; all others use the prefix before the first "_".
+// TODO(sdk): kernel-go-sdk should surface Category directly on BrowserTelemetryEventUnion.
+func eventCategory(ev kernel.BrowserTelemetryEventUnion) string {
+	prefix, _, ok := strings.Cut(ev.Type, "_")
+	if !ok {
+		return ev.Type
+	}
+	if prefix == "monitor" {
+		return "system"
+	}
+	return prefix
+}
+
+// shouldEmit applies client-side category/type filters to a telemetry event.
+func shouldEmit(ev kernel.BrowserTelemetryEventUnion, categories, types []string) bool {
+	if len(categories) > 0 && !slices.Contains(categories, eventCategory(ev)) {
+		return false
+	}
+	if len(types) > 0 && !slices.Contains(types, ev.Type) {
+		return false
+	}
+	return true
+}
+
+func (b BrowsersCmd) TelemetryStream(ctx context.Context, in BrowsersTelemetryStreamInput) error {
+	if b.telemetry == nil {
+		return fmt.Errorf("telemetry service not available")
+	}
+	if in.Output != "" && in.Output != "json" {
+		return fmt.Errorf("unsupported --output value: use 'json'")
+	}
+	if in.Seq < -1 {
+		return fmt.Errorf("--seq must be >= 0 (use --seq=0 to resume from the beginning, or omit to stream from now)")
+	}
+	for _, c := range in.Categories {
+		if !slices.Contains(streamFilterCategories, c) {
+			return fmt.Errorf("unknown --categories value %q: must be one of %s", c, strings.Join(streamFilterCategories, ", "))
+		}
+	}
+	br, err := b.browsers.Get(ctx, in.Identifier, kernel.BrowserGetParams{})
+	if err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	params := kernel.BrowserTelemetryStreamParams{}
+	if in.Seq >= 0 {
+		params.LastEventID = kernel.Opt(strconv.FormatInt(in.Seq, 10))
+	}
+	stream := b.telemetry.StreamStreaming(ctx, br.SessionID, params)
+	defer stream.Close()
+	for stream.Next() {
+		ev := stream.Current()
+		cat := eventCategory(ev.Event)
+		if len(in.Categories) > 0 && !slices.Contains(in.Categories, cat) {
+			continue
+		}
+		if len(in.Types) > 0 && !slices.Contains(in.Types, ev.Event.Type) {
+			continue
+		}
+		if in.Output == "json" {
+			if err := util.PrintCompactJSONLine(ev); err != nil {
+				return err
+			}
+			continue
+		}
+		ts := time.UnixMicro(ev.Event.Ts).Local().Format("15:04:05")
+		pterm.Printf("%s\t[%s]\t%s\n", ts, cat, ev.Event.Type)
+	}
+	if err := stream.Err(); err != nil {
+		return util.CleanedUpSdkError{Err: err}
+	}
+	return nil
+}
+
+func init() {
+	// browsersCmd is a package-level var (browsers.go), initialized before init() runs.
+	telemetryRoot := &cobra.Command{Use: "telemetry", Short: "Browser telemetry operations"}
+	telemetryStream := &cobra.Command{Use: "stream <id>", Short: "Stream live telemetry events", Args: cobra.ExactArgs(1), RunE: runBrowsersTelemetryStream}
+	telemetryStream.Flags().StringSlice("categories", []string{}, "Filter by API event category (console,network,page,interaction,system); system covers all monitor_* events")
+	telemetryStream.Flags().StringSlice("types", []string{}, "Filter by event type (e.g. network_response,console_error)")
+	telemetryStream.Flags().Int64("seq", -1, "Resume stream from sequence number (Last-Event-ID); 0 means from the beginning")
+	telemetryStream.Flags().StringP("output", "o", "", "Output format: json for newline-delimited JSON envelopes")
+	telemetryRoot.AddCommand(telemetryStream)
+	browsersCmd.AddCommand(telemetryRoot)
+}
+
+func runBrowsersTelemetryStream(cmd *cobra.Command, args []string) error {
+	client := getKernelClient(cmd)
+	svc := client.Browsers
+	out, _ := cmd.Flags().GetString("output")
+	categories, _ := cmd.Flags().GetStringSlice("categories")
+	types, _ := cmd.Flags().GetStringSlice("types")
+	seq, _ := cmd.Flags().GetInt64("seq")
+	b := BrowsersCmd{browsers: &svc, telemetry: &svc.Telemetry}
+	return b.TelemetryStream(cmd.Context(), BrowsersTelemetryStreamInput{
+		Identifier: args[0],
+		Categories: categories,
+		Types:      types,
+		Seq:        seq,
+		Output:     out,
+	})
+}
diff --git a/cmd/browsers_telemetry_test.go b/cmd/browsers_telemetry_test.go
new file mode 100644
index 0000000..f46c369
--- /dev/null
+++ b/cmd/browsers_telemetry_test.go
@@ -0,0 +1,277 @@
+package cmd
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"os"
+	"testing"
+
+	kernel "github.com/kernel/kernel-go-sdk"
+	"github.com/kernel/kernel-go-sdk/option"
+	"github.com/kernel/kernel-go-sdk/packages/ssestream"
+	"github.com/stretchr/testify/assert"
+)
+
+// captureStdout redirects os.Stdout for the duration of the test and returns
+// the captured output. Needed for paths that use fmt.Println rather than pterm.
+func captureStdout(t *testing.T, fn func()) string {
+	t.Helper()
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatalf("os.Pipe: %v", err)
+	}
+	old := os.Stdout
+	os.Stdout = w
+	fn()
+	w.Close()
+	os.Stdout = old
+	var buf bytes.Buffer
+	io.Copy(&buf, r)
+	return buf.String()
+}
+
+type FakeBrowserTelemetryService struct {
+	StreamFunc func() *ssestream.Stream[kernel.BrowserTelemetryStreamResponse]
+}
+
+func (f *FakeBrowserTelemetryService) StreamStreaming(ctx context.Context, id string, query kernel.BrowserTelemetryStreamParams, opts ...option.RequestOption) *ssestream.Stream[kernel.BrowserTelemetryStreamResponse] {
+	if f.StreamFunc != nil {
+		return f.StreamFunc()
+	}
+	return makeStream([]kernel.BrowserTelemetryStreamResponse{})
+}
+
+func TestTelemetryStream_NilTelemetryErrors(t *testing.T) {
+	b := BrowsersCmd{browsers: &FakeBrowsersService{}}
+
+	err := b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+		Identifier: "session123",
+	})
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "telemetry service not available")
+}
+
+func TestTelemetryStream_UnknownCategoryErrors(t *testing.T) {
+	b := BrowsersCmd{browsers: &FakeBrowsersService{}, telemetry: &FakeBrowserTelemetryService{}}
+
+	err := b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+		Identifier: "session123",
+		Categories: []string{"netowrk"},
+		Seq:        -1,
+	})
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unknown --categories value")
+}
+
+func TestTelemetryStream_SystemCategoryAccepted(t *testing.T) {
+	setupStdoutCapture(t)
+	fake := &FakeBrowsersService{GetFunc: func(ctx context.Context, id string, query kernel.BrowserGetParams, opts ...option.RequestOption) (*kernel.BrowserGetResponse, error) {
+		return &kernel.BrowserGetResponse{SessionID: id}, nil
+	}}
+	b := BrowsersCmd{browsers: fake, telemetry: &FakeBrowserTelemetryService{}}
+
+	err := b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+		Identifier: "session123",
+		Categories: []string{"system"},
+		Seq:        -1,
+	})
+
+	assert.NoError(t, err)
+}
+
+func TestTelemetryStream_EventsFlow(t *testing.T) {
+	setupStdoutCapture(t)
+	event := kernel.BrowserTelemetryStreamResponse{}
+	if err := json.Unmarshal([]byte(`{"event":{"type":"network_response","ts":1000000}}`), &event); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	fakeBrowsers := &FakeBrowsersService{GetFunc: func(ctx context.Context, id string, query kernel.BrowserGetParams, opts ...option.RequestOption) (*kernel.BrowserGetResponse, error) {
+		return &kernel.BrowserGetResponse{SessionID: id}, nil
+	}}
+	fakeTelemetry := &FakeBrowserTelemetryService{StreamFunc: func() *ssestream.Stream[kernel.BrowserTelemetryStreamResponse] {
+		return makeStream([]kernel.BrowserTelemetryStreamResponse{event})
+	}}
+	b := BrowsersCmd{browsers: fakeBrowsers, telemetry: fakeTelemetry}
+
+	err := b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+		Identifier: "session123",
+		Seq:        -1,
+	})
+
+	assert.NoError(t, err)
+	assert.Contains(t, outBuf.String(), "network_response")
+}
+
+func TestTelemetryStream_EventsFlow_JSON(t *testing.T) {
+	event := kernel.BrowserTelemetryStreamResponse{}
+	if err := json.Unmarshal([]byte(`{"event":{"type":"network_response","ts":1000000}}`), &event); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	fakeBrowsers := &FakeBrowsersService{GetFunc: func(ctx context.Context, id string, query kernel.BrowserGetParams, opts ...option.RequestOption) (*kernel.BrowserGetResponse, error) {
+		return &kernel.BrowserGetResponse{SessionID: id}, nil
+	}}
+	fakeTelemetry := &FakeBrowserTelemetryService{StreamFunc: func() *ssestream.Stream[kernel.BrowserTelemetryStreamResponse] {
+		return makeStream([]kernel.BrowserTelemetryStreamResponse{event})
+	}}
+	b := BrowsersCmd{browsers: fakeBrowsers, telemetry: fakeTelemetry}
+
+	var err error
+	out := captureStdout(t, func() {
+		err = b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+			Identifier: "session123",
+			Output:     "json",
+			Seq:        -1,
+		})
+	})
+
+	assert.NoError(t, err)
+	assert.Contains(t, out, "network_response")
+}
+
+type capturingTelemetryService struct {
+	captured kernel.BrowserTelemetryStreamParams
+}
+
+func (c *capturingTelemetryService) StreamStreaming(ctx context.Context, id string, query kernel.BrowserTelemetryStreamParams, opts ...option.RequestOption) *ssestream.Stream[kernel.BrowserTelemetryStreamResponse] {
+	c.captured = query
+	return makeStream([]kernel.BrowserTelemetryStreamResponse{})
+}
+
+func TestTelemetryStream_SeqZeroSetsLastEventID(t *testing.T) {
+	fakeBrowsers := &FakeBrowsersService{GetFunc: func(ctx context.Context, id string, query kernel.BrowserGetParams, opts ...option.RequestOption) (*kernel.BrowserGetResponse, error) {
+		return &kernel.BrowserGetResponse{SessionID: id}, nil
+	}}
+	capSvc := &capturingTelemetryService{}
+	b := BrowsersCmd{browsers: fakeBrowsers, telemetry: capSvc}
+
+	err := b.TelemetryStream(context.Background(), BrowsersTelemetryStreamInput{
+		Identifier: "session123",
+		Seq:        0,
+	})
+
+	assert.NoError(t, err)
+	assert.True(t, capSvc.captured.LastEventID.Valid())
+	assert.Equal(t, "0", capSvc.captured.LastEventID.Value)
+}
+
+func makeEvent(t *testing.T, raw string) kernel.BrowserTelemetryEventUnion {
+	t.Helper()
+	var ev kernel.BrowserTelemetryEventUnion
+	if err := json.Unmarshal([]byte(raw), &ev); err != nil {
+		t.Fatalf("makeEvent: %v", err)
+	}
+	return ev
+}
+
+func TestEventCategory(t *testing.T) {
+	cases := []struct {
+		raw  string
+		want string
+	}{
+		{`{"type":"monitor_screenshot","ts":0}`, "system"},
+		{`{"type":"monitor_disconnected","ts":0}`, "system"},
+		{`{"type":"network_response","ts":0}`, "network"},
+		{`{"type":"console_log","ts":0}`, "console"},
+		{`{"type":"page_navigation","ts":0}`, "page"},
+		{`{"type":"interaction_click","ts":0}`, "interaction"},
+		{`{"type":"nounderscore","ts":0}`, "nounderscore"},
+	}
+	for _, tc := range cases {
+		ev := makeEvent(t, tc.raw)
+		assert.Equal(t, tc.want, eventCategory(ev), "type=%s", ev.Type)
+	}
+}
+
+func TestShouldEmit(t *testing.T) {
+	cases := []struct {
+		name       string
+		raw        string
+		categories []string
+		types      []string
+		want       bool
+	}{
+		{"no filters passes", `{"type":"network_response","category":"network","ts":0}`, nil, nil, true},
+		{"matching category passes", `{"type":"network_response","category":"network","ts":0}`, []string{"network"}, nil, true},
+		{"non-matching category drops", `{"type":"console_log","category":"console","ts":0}`, []string{"network"}, nil, false},
+		{"system category matches monitor_screenshot", `{"type":"monitor_screenshot","category":"system","ts":0}`, []string{"system"}, nil, true},
+		{"matching type passes", `{"type":"console_log","category":"console","ts":0}`, nil, []string{"console_log"}, true},
+		{"non-matching type drops", `{"type":"network_response","category":"network","ts":0}`, nil, []string{"console_log"}, false},
+		{"both filters pass when both match", `{"type":"network_response","category":"network","ts":0}`, []string{"network"}, []string{"network_response"}, true},
+		{"both filters drop when type misses", `{"type":"network_response","category":"network","ts":0}`, []string{"network"}, []string{"console_log"}, false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			ev := makeEvent(t, tc.raw)
+			assert.Equal(t, tc.want, shouldEmit(ev, tc.categories, tc.types))
+		})
+	}
+}
+
+func TestParseTelemetryCategories_PartialCategories(t *testing.T) {
+	p, err := parseTelemetryCategories("network=on,page=off")
+
+	assert.NoError(t, err)
+	assert.True(t, p.Network.Enabled.Valid())
+	assert.True(t, p.Network.Enabled.Value)
+	assert.True(t, p.Page.Enabled.Valid())
+	assert.False(t, p.Page.Enabled.Value)
+	// Unspecified categories omitted — server retains their state
+	assert.False(t, p.Console.Enabled.Valid())
+	assert.False(t, p.Interaction.Enabled.Valid())
+}
+
+func TestParseTelemetryCategories_InvalidCategory(t *testing.T) {
+	_, err := parseTelemetryCategories("foo=on")
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "unknown category")
+}
+
+func TestParseTelemetryCategories_InvalidValue(t *testing.T) {
+	_, err := parseTelemetryCategories("network=yes")
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "must be 'on' or 'off'")
+}
+
+func TestParseTelemetryCategories_WhitespaceTolerance(t *testing.T) {
+	p, err := parseTelemetryCategories(" network = on , page = off ")
+
+	assert.NoError(t, err)
+	assert.True(t, p.Network.Enabled.Valid())
+	assert.True(t, p.Network.Enabled.Value)
+	assert.True(t, p.Page.Enabled.Valid())
+	assert.False(t, p.Page.Enabled.Value)
+}
+
+// TestBuildTelemetryParam_WireEncoding locks in the three distinct wire shapes
+// the API expects: enable-all sets Enabled=true without Browser, disable-all
+// sets Enabled=false without Browser, and per-category sets only Browser so the
+// API treats it as a merge rather than a replace.
+func TestBuildTelemetryParam_WireEncoding(t *testing.T) {
+	t.Run("all", func(t *testing.T) {
+		p, err := buildNewTelemetryParam("all")
+		assert.NoError(t, err)
+		assert.True(t, p.Enabled.Valid())
+		assert.True(t, p.Enabled.Value)
+		assert.False(t, p.Browser.Network.Enabled.Valid())
+	})
+	t.Run("off", func(t *testing.T) {
+		p, err := buildNewTelemetryParam("off")
+		assert.NoError(t, err)
+		assert.True(t, p.Enabled.Valid())
+		assert.False(t, p.Enabled.Value)
+		assert.False(t, p.Browser.Network.Enabled.Valid())
+	})
+	t.Run("per-category omits Enabled so API merges", func(t *testing.T) {
+		p, err := buildNewTelemetryParam("network=off")
+		assert.NoError(t, err)
+		assert.False(t, p.Enabled.Valid(), "Enabled must be unset so API takes the merge path")
+		assert.True(t, p.Browser.Network.Enabled.Valid())
+		assert.False(t, p.Browser.Network.Enabled.Value)
+	})
+}
diff --git a/cmd/browsers_test.go b/cmd/browsers_test.go
index 36190f4..6cf892d 100644
--- a/cmd/browsers_test.go
+++ b/cmd/browsers_test.go
@@ -1643,6 +1643,74 @@ func TestBrowsersCreate_RejectsStartURLFlagToken(t *testing.T) {
 	assert.False(t, called)
 }
 
+func TestBrowsersCreate_WithTelemetry(t *testing.T) {
+	setupStdoutCapture(t)
+	var captured kernel.BrowserNewParams
+	fake := &FakeBrowsersService{NewFunc: func(ctx context.Context, body kernel.BrowserNewParams, opts ...option.RequestOption) (*kernel.BrowserNewResponse, error) {
+		captured = body
+		return &kernel.BrowserNewResponse{SessionID: "session123", CdpWsURL: "ws://example"}, nil
+	}}
+	b := BrowsersCmd{browsers: fake}
+
+	err := b.Create(context.Background(), BrowsersCreateInput{Telemetry: "all"})
+
+	assert.NoError(t, err)
+	assert.True(t, captured.Telemetry.Enabled.Valid())
+	assert.True(t, captured.Telemetry.Enabled.Value)
+}
+
+func TestBrowsersCreate_WithTelemetryCategories(t *testing.T) {
+	setupStdoutCapture(t)
+	var captured kernel.BrowserNewParams
+	fake := &FakeBrowsersService{NewFunc: func(ctx context.Context, body kernel.BrowserNewParams, opts ...option.RequestOption) (*kernel.BrowserNewResponse, error) {
+		captured = body
+		return &kernel.BrowserNewResponse{SessionID: "session123", CdpWsURL: "ws://example"}, nil
+	}}
+	b := BrowsersCmd{browsers: fake}
+
+	err := b.Create(context.Background(), BrowsersCreateInput{Telemetry: "network=on,page=off"})
+
+	assert.NoError(t, err)
+	assert.False(t, captured.Telemetry.Enabled.Valid(), "per-category must omit Enabled so the API merges")
+	assert.True(t, captured.Telemetry.Browser.Network.Enabled.Valid())
+	assert.True(t, captured.Telemetry.Browser.Network.Enabled.Value)
+	assert.True(t, captured.Telemetry.Browser.Page.Enabled.Valid())
+	assert.False(t, captured.Telemetry.Browser.Page.Enabled.Value)
+	assert.False(t, captured.Telemetry.Browser.Console.Enabled.Valid())
+	assert.False(t, captured.Telemetry.Browser.Interaction.Enabled.Valid())
+}
+
+func TestBrowsersCreate_WithTelemetryOff(t *testing.T) {
+	setupStdoutCapture(t)
+	var captured kernel.BrowserNewParams
+	fake := &FakeBrowsersService{NewFunc: func(ctx context.Context, body kernel.BrowserNewParams, opts ...option.RequestOption) (*kernel.BrowserNewResponse, error) {
+		captured = body
+		return &kernel.BrowserNewResponse{SessionID: "session123", CdpWsURL: "ws://example"}, nil
+	}}
+	b := BrowsersCmd{browsers: fake}
+
+	err := b.Create(context.Background(), BrowsersCreateInput{Telemetry: "off"})
+
+	assert.NoError(t, err)
+	assert.True(t, captured.Telemetry.Enabled.Valid())
+	assert.False(t, captured.Telemetry.Enabled.Value)
+}
+
+func TestBrowsersCreate_WithoutTelemetry(t *testing.T) {
+	setupStdoutCapture(t)
+	var captured kernel.BrowserNewParams
+	fake := &FakeBrowsersService{NewFunc: func(ctx context.Context, body kernel.BrowserNewParams, opts ...option.RequestOption) (*kernel.BrowserNewResponse, error) {
+		captured = body
+		return &kernel.BrowserNewResponse{SessionID: "session123", CdpWsURL: "ws://example"}, nil
+	}}
+	b := BrowsersCmd{browsers: fake}
+
+	err := b.Create(context.Background(), BrowsersCreateInput{})
+
+	assert.NoError(t, err)
+	assert.False(t, captured.Telemetry.Enabled.Valid())
+}
+
 func TestBrowsersCreate_WithInvalidViewport(t *testing.T) {
 	setupStdoutCapture(t)
 	fake := &FakeBrowsersService{}
diff --git a/pkg/util/json.go b/pkg/util/json.go
index aa20d3b..6a8fccd 100644
--- a/pkg/util/json.go
+++ b/pkg/util/json.go
@@ -29,6 +29,22 @@ func PrintPrettyJSON(v RawJSONProvider) error {
 	return nil
 }
 
+// PrintCompactJSONLine prints v as a single compact JSON line followed by a
+// newline. Use inside SSE loops where downstream tooling (jq -c, log shippers)
+// expects newline-delimited JSON.
+func PrintCompactJSONLine(v RawJSONProvider) error {
+	raw := v.RawJSON()
+	if raw == "" {
+		return nil
+	}
+	var buf bytes.Buffer
+	if err := json.Compact(&buf, []byte(raw)); err != nil {
+		return err
+	}
+	fmt.Println(buf.String())
+	return nil
+}
+
 // PrintPrettyJSONSlice prints a slice of SDK response types as a JSON array.
 // Each element must implement RawJSONProvider.
 func PrintPrettyJSONSlice[T RawJSONProvider](items []T) error {