diff --git a/.env.template b/.env.template
index ced73b36c..aa3309224 100644
--- a/.env.template
+++ b/.env.template
@@ -206,6 +206,14 @@
 # WARNING: May contain PII, API keys in prompts, or sensitive data
 # LOGGING_LOG_BODIES=false
 
+# Log audio endpoint inputs/outputs: /v1/audio/speech text input + binary audio
+# output (stored as base64 so the dashboard can play it back) and
+# /v1/audio/transcriptions upload metadata. Requires LOGGING_LOG_BODIES=true (the
+# master body-logging switch); when bodies are logged but this is off, audio
+# responses are recorded as a lightweight placeholder instead of the full bytes.
+# WARNING: stores full audio in the audit log and grows storage quickly (default: false)
+# LOGGING_LOG_AUDIO_BODIES=false
+
 # Log request/response headers (default: false)
 # Sensitive headers (Authorization, Cookie, etc.) are automatically redacted
 # LOGGING_LOG_HEADERS=false
diff --git a/CLAUDE.md b/CLAUDE.md
index fc3f69424..684329bd3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -116,7 +116,7 @@ Full reference: `.env.template` and `config/config.yaml`
   - `ENABLED_PASSTHROUGH_PROVIDERS` (openai,anthropic,openrouter,zai,vllm: Comma-separated list of enabled passthrough providers)
 - **Storage:** `STORAGE_TYPE` (sqlite), `SQLITE_PATH` (data/gomodel.db), `POSTGRES_URL`, `MONGODB_URL`
 - **Models:** `MODELS_ENABLED_BY_DEFAULT` (true), `MODEL_OVERRIDES_ENABLED` (true), `KEEP_ONLY_ALIASES_AT_MODELS_ENDPOINT` (false), `CONFIGURED_PROVIDER_MODELS_MODE` (`fallback` or `allowlist`, default `fallback`; `allowlist` skips upstream `/models` for providers with configured lists); persisted overrides restrict/allow selectors with `user_paths`. When alias-only models listing is enabled, `GET /v1/models` returns only model aliases, not full concrete model specs, to operators.
-- **Audit logging:** `LOGGING_ENABLED` (false), `LOGGING_LOG_BODIES` (false), `LOGGING_LOG_HEADERS` (false), `LOGGING_RETENTION_DAYS` (30)
+- **Audit logging:** `LOGGING_ENABLED` (false), `LOGGING_LOG_BODIES` (false), `LOGGING_LOG_AUDIO_BODIES` (false: refines `LOGGING_LOG_BODIES` for audio endpoints — base64 audio for `/v1/audio/speech` (≤8 MB, else `too_large`) + dashboard playback, upload metadata for transcriptions; no effect unless `LOGGING_LOG_BODIES` is on, in which case audio-off records a placeholder), `LOGGING_LOG_HEADERS` (false), `LOGGING_RETENTION_DAYS` (30)
 - **Usage tracking:** `USAGE_ENABLED` (true), `ENFORCE_RETURNING_USAGE_DATA` (true), `USAGE_RETENTION_DAYS` (90)
 - **Dashboard live logs:**
   - `DASHBOARD_LIVE_LOGS_ENABLED` (true): keep enabled for low-latency dashboard previews; set false only when live streams are not needed or memory/socket usage must be minimized.
diff --git a/config/logging.go b/config/logging.go
index ea110ae2b..c54350326 100644
--- a/config/logging.go
+++ b/config/logging.go
@@ -11,6 +11,16 @@ type LogConfig struct {
 	// Default: true
 	LogBodies bool `yaml:"log_bodies" env:"LOGGING_LOG_BODIES"`
 
+	// LogAudioBodies refines LogBodies for audio endpoints: when both are
+	// enabled, the /v1/audio/speech JSON input and binary audio output are
+	// stored (audio as base64 for playback) and /v1/audio/transcriptions upload
+	// metadata is recorded. Requires LogBodies (the master body-logging switch);
+	// when LogBodies is on but this is off, audio responses are recorded as a
+	// lightweight placeholder instead of the full bytes.
+	// WARNING: stores full audio in the audit log; grows storage quickly.
+	// Default: false
+	LogAudioBodies bool `yaml:"log_audio_bodies" env:"LOGGING_LOG_AUDIO_BODIES"`
+
 	// LogHeaders enables logging of request/response headers
 	// Sensitive headers (Authorization, Cookie, etc.) are auto-redacted
 	// Default: true
diff --git a/docs/advanced/audio-api.mdx b/docs/advanced/audio-api.mdx
index 883891e04..ebd9a0c72 100644
--- a/docs/advanced/audio-api.mdx
+++ b/docs/advanced/audio-api.mdx
@@ -82,3 +82,20 @@ through the full inference orchestrator**. Compared with `/v1/chat/completions`:
 For a provider whose native audio API differs from OpenAI's, use the
 [passthrough API](/features/passthrough-api) (`/p/{provider}/v1/audio/...`) to
 forward bytes verbatim to that upstream.
+
+## Audit logging
+
+Audio requests appear in the audit log like any other model interaction. Because
+audio payloads are binary and large, their bodies are gated by a dedicated
+setting, [`LOGGING_LOG_AUDIO_BODIES`](/advanced/configuration#audit-logging)
+(default `false`), which **refines** `LOGGING_LOG_BODIES` — it has no effect
+unless body logging is enabled:
+
+- **Body logging off** (`LOGGING_LOG_BODIES=false`) — no audio body is stored,
+  regardless of this setting.
+- **Body logging on, audio off** (the default) — the audio response is recorded
+  as a lightweight `{__audio__, content_type, bytes, stored: false}` placeholder; no audio bytes are stored.
+- **Body logging on, audio on** — `/v1/audio/speech` stores its text input and the
+  generated audio (base64, capped at 8 MB) so the **dashboard renders an inline
+  player**, and `/v1/audio/transcriptions` stores upload metadata (filename, model,
+  params) but never the raw uploaded audio bytes.
diff --git a/docs/advanced/configuration.mdx b/docs/advanced/configuration.mdx
index 603f5bef2..fede48bff 100644
--- a/docs/advanced/configuration.mdx
+++ b/docs/advanced/configuration.mdx
@@ -92,6 +92,7 @@ Storage is shared by audit logging, usage tracking, and future features like IAM
 | --------------------------------- | ------------------------------------------ | ------- |
 | `LOGGING_ENABLED`                 | Enable audit logging                       | `false` |
 | `LOGGING_LOG_BODIES`              | Log request/response bodies                | `true`  |
+| `LOGGING_LOG_AUDIO_BODIES`        | Log audio endpoint inputs/outputs          | `false` |
 | `LOGGING_LOG_HEADERS`             | Log headers (sensitive ones auto-redacted) | `true`  |
 | `LOGGING_ONLY_MODEL_INTERACTIONS` | Only log AI model endpoints                | `true`  |
 | `LOGGING_BUFFER_SIZE`             | In-memory buffer before flush              | `1000`  |
@@ -104,6 +105,17 @@ Storage is shared by audit logging, usage tracking, and future features like IAM
   prompts.
 </Warning>
 
+<Note>
+  `LOGGING_LOG_AUDIO_BODIES` refines `LOGGING_LOG_BODIES` for audio endpoints —
+  it has no effect unless body logging is enabled. With both on, `/v1/audio/speech`
+  stores its text input and the generated audio (base64, capped at 8 MB) so the
+  dashboard can play it back, and `/v1/audio/transcriptions` stores upload metadata
+  (never the raw audio bytes). It defaults to `false` because audio payloads are
+  large and grow the audit store quickly. When body logging is on but this is off,
+  audio responses are recorded as a lightweight `{__audio__, content_type, bytes, stored: false}` placeholder;
+  when body logging is off, no audio body is stored at all.
+</Note>
+
 #### Token Usage Tracking
 
 | Variable                       | Description                                    | Default |
diff --git a/internal/admin/dashboard/static/css/dashboard.css b/internal/admin/dashboard/static/css/dashboard.css
index 6e99a4048..b577191cd 100644
--- a/internal/admin/dashboard/static/css/dashboard.css
+++ b/internal/admin/dashboard/static/css/dashboard.css
@@ -2880,6 +2880,39 @@ textarea:focus {
   overflow-wrap: normal;
 }
 
+.audit-audio {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  white-space: normal;
+}
+
+.audit-audio-player {
+  width: 100%;
+  max-width: 420px;
+  height: 36px;
+}
+
+.audit-audio-meta {
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
+.audit-audio-empty {
+  align-items: flex-start;
+  padding: 4px 0;
+}
+
+.audit-audio-icon {
+  font-size: 20px;
+  line-height: 1;
+}
+
+.audit-audio-note {
+  font-size: 12px;
+  color: var(--text-muted);
+}
+
 .conversation-body-highlight {
   display: inline;
   border-left: 2px solid color-mix(in srgb, var(--accent) 70%, var(--border));
diff --git a/internal/admin/dashboard/static/js/modules/audit-list.js b/internal/admin/dashboard/static/js/modules/audit-list.js
index 153fa0f1f..513fe1af9 100644
--- a/internal/admin/dashboard/static/js/modules/audit-list.js
+++ b/internal/admin/dashboard/static/js/modules/audit-list.js
@@ -508,10 +508,19 @@
                 const copyBodyState = createCopyState();
                 const copyHeadersState = createCopyState();
 
+                const helpers = global.DashboardConversationHelpers;
+                const computeRenderedBody = (p) => {
+                    if (!p || !p.showBody) return '';
+                    if (helpers && typeof helpers.isAudioBody === 'function' && helpers.isAudioBody(p.body)) {
+                        return helpers.renderAudioBody(p.body);
+                    }
+                    return renderBody(p.entry, p.body, { promptCacheHighlight: p.promptCacheHighlight });
+                };
+
                 return {
                     pane,
                     formattedHeaders: pane && pane.showHeaders ? formatJSON(pane.headers) : '',
-                    renderedBody: pane && pane.showBody ? renderBody(pane.entry, pane.body, { promptCacheHighlight: pane.promptCacheHighlight }) : '',
+                    renderedBody: computeRenderedBody(pane),
                     copyBodyState,
                     copyHeadersState,
                     copyState: copyBodyState,
@@ -527,9 +536,7 @@
                     syncPane(nextPane) {
                         this.pane = nextPane;
                         this.formattedHeaders = nextPane && nextPane.showHeaders ? formatJSON(nextPane.headers) : '';
-                        this.renderedBody = nextPane && nextPane.showBody
-                            ? renderBody(nextPane.entry, nextPane.body, { promptCacheHighlight: nextPane.promptCacheHighlight })
-                            : '';
+                        this.renderedBody = computeRenderedBody(nextPane);
                     }
                 };
             }
diff --git a/internal/admin/dashboard/static/js/modules/audit-list.test.cjs b/internal/admin/dashboard/static/js/modules/audit-list.test.cjs
index e56b8c6c8..567444a62 100644
--- a/internal/admin/dashboard/static/js/modules/audit-list.test.cjs
+++ b/internal/admin/dashboard/static/js/modules/audit-list.test.cjs
@@ -599,6 +599,92 @@ test('auditPaneState syncs pane content when live detail data arrives', () => {
     assert.equal(renderCalls, 1);
 });
 
+test('isAudioBody detects the audio body marker', () => {
+    const helpers = loadConversationHelpers();
+    assert.equal(helpers.isAudioBody({ __audio__: true, content_type: 'audio/mpeg' }), true);
+    assert.equal(helpers.isAudioBody({ model: 'gpt-5' }), false);
+    assert.equal(helpers.isAudioBody(null), false);
+    assert.equal(helpers.isAudioBody('audio'), false);
+});
+
+test('renderAudioBody renders a player with a data URL when audio bytes are stored', () => {
+    const helpers = loadConversationHelpers();
+    const html = helpers.renderAudioBody({
+        __audio__: true,
+        content_type: 'audio/mpeg',
+        bytes: 2048,
+        encoding: 'base64',
+        data: 'QUJD',
+        stored: true
+    });
+    assert.match(html, /<audio[^>]+controls/);
+    assert.match(html, /src="data:audio\/mpeg;base64,QUJD"/);
+    assert.match(html, /2\.0 KB/);
+});
+
+test('renderAudioBody sanitizes content type and strips non-base64 characters', () => {
+    const helpers = loadConversationHelpers();
+    const html = helpers.renderAudioBody({
+        __audio__: true,
+        content_type: 'audio/mpeg" onerror=alert(1)',
+        bytes: 10,
+        encoding: 'base64',
+        data: 'AB"><script>CD',
+        stored: true
+    });
+    assert.ok(!html.includes('onerror'), 'content type must be sanitized');
+    assert.ok(!html.includes('<script>'), 'base64 payload must be sanitized');
+    // Dangerous characters (<, >, ") are stripped from the data URL; only the
+    // valid base64 alphabet survives (the letters of "script" are harmless).
+    assert.match(html, /src="data:audio\/mpeg;base64,ABscriptCD"/);
+});
+
+test('renderAudioBody renders a placeholder when audio is not stored', () => {
+    const helpers = loadConversationHelpers();
+    const html = helpers.renderAudioBody({
+        __audio__: true,
+        content_type: 'audio/mpeg',
+        bytes: 61056,
+        stored: false
+    });
+    assert.ok(!html.includes('<audio'), 'no player when bytes are absent');
+    assert.match(html, /LOGGING_LOG_AUDIO_BODIES/);
+    assert.match(html, /59\.6 KB/);
+});
+
+test('renderAudioBody notes when audio was too large to store', () => {
+    const helpers = loadConversationHelpers();
+    const html = helpers.renderAudioBody({
+        __audio__: true,
+        content_type: 'audio/wav',
+        bytes: 99999999,
+        stored: false,
+        too_large: true
+    });
+    assert.ok(!html.includes('<audio'));
+    assert.match(html, /too large/i);
+});
+
+test('auditPaneState renders audio bodies through the audio helper', () => {
+    const helpers = loadConversationHelpers();
+    const module = createAuditListModule({
+        window: { DashboardConversationHelpers: helpers }
+    });
+    const paneState = module.auditPaneState({
+        entry: { id: 'audit-1' },
+        showBody: true,
+        body: {
+            __audio__: true,
+            content_type: 'audio/mpeg',
+            bytes: 1024,
+            encoding: 'base64',
+            data: 'QUJD',
+            stored: true
+        }
+    });
+    assert.match(paneState.renderedBody, /<audio[^>]+src="data:audio\/mpeg;base64,QUJD"/);
+});
+
 test('auditPaneState copies the formatted body and resets success feedback', async () => {
     let resetCallback = null;
     const writes = [];
diff --git a/internal/admin/dashboard/static/js/modules/conversation-helpers.js b/internal/admin/dashboard/static/js/modules/conversation-helpers.js
index 68a81cf91..5ec42f846 100644
--- a/internal/admin/dashboard/static/js/modules/conversation-helpers.js
+++ b/internal/admin/dashboard/static/js/modules/conversation-helpers.js
@@ -343,6 +343,53 @@
             .replaceAll("'", '&#39;');
     }
 
+    // isAudioBody detects the audit value produced for audio endpoint bodies
+    // (see auditlog.AudioBodyLog): an object carrying the "__audio__" marker.
+    function isAudioBody(value) {
+        return !!(value && typeof value === 'object' && value.__audio__ === true);
+    }
+
+    function formatByteSize(bytes) {
+        const n = Number(bytes || 0);
+        if (!Number.isFinite(n) || n <= 0) return '0 B';
+        const units = ['B', 'KB', 'MB', 'GB'];
+        let i = 0;
+        let size = n;
+        while (size >= 1024 && i < units.length - 1) {
+            size /= 1024;
+            i++;
+        }
+        return (i === 0 ? String(size) : size.toFixed(1)) + ' ' + units[i];
+    }
+
+    function sanitizeAudioContentType(value) {
+        const ct = String(value || '').trim();
+        return /^audio\/[a-zA-Z0-9.+-]+$/.test(ct) ? ct : 'audio/mpeg';
+    }
+
+    // renderAudioBody renders an audio body as a player when the audio bytes
+    // were captured (base64), otherwise a labeled placeholder explaining why.
+    function renderAudioBody(value) {
+        const contentType = sanitizeAudioContentType(value.content_type);
+        const metaLabel = escapeHTML(contentType + ' · ' + formatByteSize(value.bytes));
+        if (value.stored && value.encoding === 'base64' && value.data) {
+            const b64 = String(value.data).replace(/[^A-Za-z0-9+/=]/g, '');
+            const src = 'data:' + contentType + ';base64,' + b64;
+            return '<div class="audit-audio">'
+                + '<audio class="audit-audio-player" controls preload="none" src="' + src + '"></audio>'
+                + '<div class="audit-audio-meta mono">' + metaLabel + '</div>'
+                + '</div>';
+        }
+        const reason = value.too_large
+            ? 'Audio too large to store.'
+            : 'Audio not logged. Set LOGGING_LOG_AUDIO_BODIES=true to capture playable audio.';
+        return '<div class="audit-audio audit-audio-empty">'
+            + '<div class="audit-audio-icon" aria-hidden="true">🔊</div>'
+            + '<div class="audit-audio-meta mono">' + metaLabel + '</div>'
+            + '<div class="audit-audio-note">' + escapeHTML(reason) + '</div>'
+            + '</div>';
+    }
+
     function jsonStringContent(value) {
         try {
             return JSON.stringify(String(value)).slice(1, -1);
@@ -465,6 +512,8 @@
         isConversationalPath,
         isConversationExcludedPath,
         canShowConversation,
-        renderBodyWithConversationHighlights
+        renderBodyWithConversationHighlights,
+        isAudioBody,
+        renderAudioBody
     };
 })(window);
diff --git a/internal/app/app.go b/internal/app/app.go
index 5034066f8..f743a54b0 100644
--- a/internal/app/app.go
+++ b/internal/app/app.go
@@ -883,6 +883,7 @@ func (a *App) logStartupInfo() {
 	if cfg.Logging.Enabled {
 		slog.Info("audit logging enabled",
 			"log_bodies", cfg.Logging.LogBodies,
+			"log_audio_bodies", cfg.Logging.LogAudioBodies,
 			"log_headers", cfg.Logging.LogHeaders,
 			"retention_days", cfg.Logging.RetentionDays,
 		)
diff --git a/internal/auditlog/audio_body.go b/internal/auditlog/audio_body.go
new file mode 100644
index 000000000..aa072faf6
--- /dev/null
+++ b/internal/auditlog/audio_body.go
@@ -0,0 +1,57 @@
+package auditlog
+
+import (
+	"encoding/base64"
+	"strings"
+)
+
+// audioBodyMaxBytes caps how much *raw* audio is embedded as base64 in an audit
+// log entry; larger payloads are recorded as metadata-only placeholders so the
+// audit store does not balloon on long generations. The stored base64 is ~4/3 of
+// this (≈10.7 MB at the cap), deliberately kept well under document-store
+// per-record ceilings (e.g. MongoDB's 16 MB BSON limit) so a near-cap clip plus
+// the rest of the entry (request text, headers, workflow metadata) and encoding
+// overhead cannot push the document over the limit and fail the audit insert.
+const audioBodyMaxBytes = 8 * 1024 * 1024
+
+// AudioBodyLog is the audit representation of an audio request/response body.
+// The "__audio__" marker lets the dashboard detect audio payloads and render a
+// player (when Data is present) or a labeled placeholder. When Data is set it
+// holds the base64-encoded audio, suitable for a data: URL of ContentType.
+type AudioBodyLog struct {
+	Audio       bool   `json:"__audio__" bson:"__audio__"`
+	ContentType string `json:"content_type,omitempty" bson:"content_type,omitempty"`
+	Bytes       int    `json:"bytes" bson:"bytes"`
+	Encoding    string `json:"encoding,omitempty" bson:"encoding,omitempty"`
+	Data        string `json:"data,omitempty" bson:"data,omitempty"`
+	Stored      bool   `json:"stored" bson:"stored"`
+	TooLarge    bool   `json:"too_large,omitempty" bson:"too_large,omitempty"`
+}
+
+// IsAudioContentType reports whether a Content-Type denotes an audio payload.
+func IsAudioContentType(contentType string) bool {
+	mediaType := strings.ToLower(strings.TrimSpace(strings.Split(contentType, ";")[0]))
+	return strings.HasPrefix(mediaType, "audio/")
+}
+
+// BuildAudioResponseBody builds the audit value for a binary audio response.
+// When storeBytes is true and the payload fits within audioBodyMaxBytes the
+// audio is embedded as base64 for playback; otherwise only metadata is kept.
+func BuildAudioResponseBody(contentType string, data []byte, storeBytes bool) AudioBodyLog {
+	body := AudioBodyLog{
+		Audio:       true,
+		ContentType: strings.TrimSpace(contentType),
+		Bytes:       len(data),
+	}
+	if !storeBytes || len(data) == 0 {
+		return body
+	}
+	if len(data) > audioBodyMaxBytes {
+		body.TooLarge = true
+		return body
+	}
+	body.Encoding = "base64"
+	body.Data = base64.StdEncoding.EncodeToString(data)
+	body.Stored = true
+	return body
+}
diff --git a/internal/auditlog/audio_body_test.go b/internal/auditlog/audio_body_test.go
new file mode 100644
index 000000000..493bbbd34
--- /dev/null
+++ b/internal/auditlog/audio_body_test.go
@@ -0,0 +1,97 @@
+package auditlog
+
+import (
+	"encoding/base64"
+	"testing"
+)
+
+func TestIsAudioContentType(t *testing.T) {
+	tests := []struct {
+		contentType string
+		want        bool
+	}{
+		{"audio/mpeg", true},
+		{"audio/wav", true},
+		{"audio/mpeg; charset=utf-8", true},
+		{"AUDIO/MPEG", true},
+		{"application/json", false},
+		{"", false},
+		{"text/plain", false},
+	}
+	for _, tt := range tests {
+		if got := IsAudioContentType(tt.contentType); got != tt.want {
+			t.Errorf("IsAudioContentType(%q) = %v, want %v", tt.contentType, got, tt.want)
+		}
+	}
+}
+
+func TestBuildAudioResponseBody_StoresBase64WhenEnabled(t *testing.T) {
+	data := []byte{0x00, 0x01, 0x02, 0xff, 0xfe}
+	body := BuildAudioResponseBody("audio/mpeg", data, true)
+
+	if !body.Audio {
+		t.Fatal("expected Audio marker to be true")
+	}
+	if !body.Stored || body.Encoding != "base64" {
+		t.Fatalf("expected stored base64, got stored=%v encoding=%q", body.Stored, body.Encoding)
+	}
+	if body.Bytes != len(data) {
+		t.Errorf("Bytes = %d, want %d", body.Bytes, len(data))
+	}
+	decoded, err := base64.StdEncoding.DecodeString(body.Data)
+	if err != nil {
+		t.Fatalf("stored data is not valid base64: %v", err)
+	}
+	if string(decoded) != string(data) {
+		t.Errorf("round-trip mismatch: audio bytes were not preserved losslessly")
+	}
+}
+
+func TestBuildAudioResponseBody_PlaceholderWhenDisabled(t *testing.T) {
+	data := []byte{0x00, 0x01, 0x02}
+	body := BuildAudioResponseBody("audio/mpeg", data, false)
+
+	if !body.Audio {
+		t.Fatal("expected Audio marker to be true")
+	}
+	if body.Stored || body.Data != "" || body.Encoding != "" {
+		t.Errorf("expected no bytes stored when disabled, got %+v", body)
+	}
+	if body.Bytes != len(data) {
+		t.Errorf("Bytes = %d, want %d (size metadata should still be recorded)", body.Bytes, len(data))
+	}
+}
+
+func TestBuildAudioResponseBody_TooLarge(t *testing.T) {
+	data := make([]byte, audioBodyMaxBytes+1)
+	body := BuildAudioResponseBody("audio/mpeg", data, true)
+
+	if body.Stored || body.Data != "" {
+		t.Error("expected oversized audio to not be stored")
+	}
+	if !body.TooLarge {
+		t.Error("expected TooLarge to be set for oversized audio")
+	}
+}
+
+func TestBuildAudioResponseBody_AvoidsUTF8Corruption(t *testing.T) {
+	// MP3 frame headers contain bytes that are invalid UTF-8; the old capture
+	// path coerced these to U+FFFD. base64 must preserve them exactly.
+	data := []byte{0xff, 0xfb, 0x90, 0x00}
+	body := BuildAudioResponseBody("audio/mpeg", data, true)
+	decoded, err := base64.StdEncoding.DecodeString(body.Data)
+	if err != nil {
+		t.Fatalf("invalid base64: %v", err)
+	}
+	// The bytes must survive verbatim — the old toValidUTF8String path would
+	// have rewritten 0xff/0x90 into the U+FFFD replacement character (0xEF 0xBF
+	// 0xBD), changing the byte length and content.
+	if len(decoded) != len(data) {
+		t.Fatalf("length changed: got %d bytes, want %d (UTF-8 coercion would have altered this)", len(decoded), len(data))
+	}
+	for i := range data {
+		if decoded[i] != data[i] {
+			t.Fatalf("byte %d = %#x, want %#x", i, decoded[i], data[i])
+		}
+	}
+}
diff --git a/internal/auditlog/auditlog.go b/internal/auditlog/auditlog.go
index 6f9248800..56fe5b2bc 100644
--- a/internal/auditlog/auditlog.go
+++ b/internal/auditlog/auditlog.go
@@ -233,6 +233,12 @@ type Config struct {
 	// LogBodies enables logging of full request/response bodies
 	LogBodies bool
 
+	// LogAudioBodies refines LogBodies for audio endpoints (base64 audio for
+	// /v1/audio/speech, upload metadata for transcriptions). Requires LogBodies:
+	// when LogBodies is off no audio body is captured; when LogBodies is on but
+	// this is off, audio responses are recorded as a lightweight placeholder.
+	LogAudioBodies bool
+
 	// LogHeaders enables logging of request/response headers
 	LogHeaders bool
 
@@ -255,6 +261,7 @@ func DefaultConfig() Config {
 	return Config{
 		Enabled:               false,
 		LogBodies:             false,
+		LogAudioBodies:        false,
 		LogHeaders:            false,
 		BufferSize:            1000,
 		FlushInterval:         5 * time.Second,
diff --git a/internal/auditlog/auditlog_test.go b/internal/auditlog/auditlog_test.go
index 5982b7b8a..62b1ea3bd 100644
--- a/internal/auditlog/auditlog_test.go
+++ b/internal/auditlog/auditlog_test.go
@@ -535,6 +535,47 @@ func TestMiddleware_SkipsStreamingResponseWriterCapture(t *testing.T) {
 	}
 }
 
+// TestMiddleware_AudioResponseNotMarkedTruncated verifies that an oversized audio
+// response — which trips the response writer's truncation flag — does NOT set
+// ResponseBodyTooBigToHandle on the audit entry. The audio handler captures the
+// body losslessly via its own path, so a truncation flag here would produce
+// conflicting metadata (a fully-stored body alongside a "too big" marker).
+func TestMiddleware_AudioResponseNotMarkedTruncated(t *testing.T) {
+	e := echo.New()
+	logger := &capturingLogger{cfg: Config{Enabled: true, LogBodies: true}}
+
+	req := httptest.NewRequest(http.MethodPost, "/v1/audio/speech", strings.NewReader(`{"model":"gpt-4o-mini-tts","input":"hi","voice":"alloy"}`))
+	rec := httptest.NewRecorder()
+	c := e.NewContext(req, rec)
+
+	oversized := bytes.Repeat([]byte{0xff}, int(MaxBodyCapture)+16)
+	var capture *responseBodyCapture
+	handler := Middleware(logger)(func(c *echo.Context) error {
+		capture, _ = c.Response().(*responseBodyCapture)
+		c.Response().Header().Set("Content-Type", "audio/mpeg")
+		c.Response().WriteHeader(http.StatusOK)
+		_, err := c.Response().Write(oversized)
+		return err
+	})
+
+	if err := handler(c); err != nil {
+		t.Fatalf("handler returned error: %v", err)
+	}
+	if capture == nil || !capture.truncated {
+		t.Fatal("expected the response writer to mark the oversized body as truncated")
+	}
+	if len(logger.entries) != 1 {
+		t.Fatalf("len(entries) = %d, want 1", len(logger.entries))
+	}
+	entry := logger.entries[0]
+	if entry.Data != nil && entry.Data.ResponseBodyTooBigToHandle {
+		t.Error("audio response must not set ResponseBodyTooBigToHandle; the handler owns audio body capture")
+	}
+	if entry.Data != nil && entry.Data.ResponseBody != nil {
+		t.Errorf("middleware must not store the audio response body, got %T", entry.Data.ResponseBody)
+	}
+}
+
 func TestMiddleware_PrefersWorkflowOverLegacyResolution(t *testing.T) {
 	e := echo.New()
 	logger := &capturingLogger{
@@ -918,6 +959,8 @@ func TestIsModelInteractionPath(t *testing.T) {
 		{"batches", "/v1/batches", true},
 		{"batches with subpath", "/v1/batches/123", true},
 		{"batches prefix overmatch", "/v1/batcheship", false},
+		{"audio speech", "/v1/audio/speech", true},
+		{"audio transcriptions", "/v1/audio/transcriptions", true},
 		{"models", "/v1/models", false},
 		{"models with subpath", "/v1/models/gpt-4", false},
 		{"health", "/health", false},
diff --git a/internal/auditlog/factory.go b/internal/auditlog/factory.go
index cd10edafa..fc1f12762 100644
--- a/internal/auditlog/factory.go
+++ b/internal/auditlog/factory.go
@@ -95,6 +95,7 @@ func buildLoggerConfig(logCfg config.LogConfig) Config {
 	cfg := Config{
 		Enabled:               logCfg.Enabled,
 		LogBodies:             logCfg.LogBodies,
+		LogAudioBodies:        logCfg.LogAudioBodies,
 		LogHeaders:            logCfg.LogHeaders,
 		BufferSize:            logCfg.BufferSize,
 		FlushInterval:         time.Duration(logCfg.FlushInterval) * time.Second,
diff --git a/internal/auditlog/middleware.go b/internal/auditlog/middleware.go
index 316a9a009..1044937bd 100644
--- a/internal/auditlog/middleware.go
+++ b/internal/auditlog/middleware.go
@@ -135,27 +135,35 @@ func Middleware(logger LoggerInterface) echo.MiddlewareFunc {
 
 			// Capture response body if enabled
 			if cfg.LogBodies && responseCapture != nil && shouldCaptureResponseBody(c) && responseCapture.body.Len() > 0 {
-				// Set truncation flag if response body exceeded limit
-				if responseCapture.truncated {
-					entry.Data.ResponseBodyTooBigToHandle = true
-				}
-
 				bodyBytes := responseCapture.body.Bytes()
 
-				// Decompress if Content-Encoding header is present
-				if contentEncoding := c.Response().Header().Get("Content-Encoding"); contentEncoding != "" {
-					if decompressed, ok := decompressBody(bodyBytes, contentEncoding); ok {
-						bodyBytes = decompressed
+				// Audio responses are binary; the audio handler captures them
+				// losslessly as base64 (gated by LogAudioBodies) before this
+				// runs. Skip here so we neither corrupt the bytes via UTF-8
+				// coercion nor clobber the handler-set body — and do not apply
+				// the writer's truncation flag, which would conflict with the
+				// fully-stored audio body (the handler tracks its own size cap).
+				if !IsAudioContentType(c.Response().Header().Get("Content-Type")) {
+					// Set truncation flag if response body exceeded limit
+					if responseCapture.truncated {
+						entry.Data.ResponseBodyTooBigToHandle = true
+					}
+
+					// Decompress if Content-Encoding header is present
+					if contentEncoding := c.Response().Header().Get("Content-Encoding"); contentEncoding != "" {
+						if decompressed, ok := decompressBody(bodyBytes, contentEncoding); ok {
+							bodyBytes = decompressed
+						}
 					}
-				}
 
-				// Parse JSON to any for native BSON storage in MongoDB
-				var parsed any
-				if jsonErr := json.Unmarshal(bodyBytes, &parsed); jsonErr == nil {
-					entry.Data.ResponseBody = parsed
-				} else {
-					// Fallback: store as valid UTF-8 string if not valid JSON
-					entry.Data.ResponseBody = toValidUTF8String(bodyBytes)
+					// Parse JSON to any for native BSON storage in MongoDB
+					var parsed any
+					if jsonErr := json.Unmarshal(bodyBytes, &parsed); jsonErr == nil {
+						entry.Data.ResponseBody = parsed
+					} else {
+						// Fallback: store as valid UTF-8 string if not valid JSON
+						entry.Data.ResponseBody = toValidUTF8String(bodyBytes)
+					}
 				}
 			}
 
@@ -400,6 +408,54 @@ func EnrichEntry(c *echo.Context, model, provider string) {
 	publishLiveAuditUpdate(c, entry)
 }
 
+// EnrichEntryWithRequestBody sets the audit request body from a handler that
+// captures its own request payload (e.g. audio endpoints, which are not
+// ingress-managed and so have no request snapshot to read from). A nil body or
+// missing entry is a no-op; an already-populated request body is preserved.
+func EnrichEntryWithRequestBody(c *echo.Context, body any) {
+	if body == nil {
+		return
+	}
+	entry := entryFromContext(c)
+	if entry == nil {
+		return
+	}
+	data := ensureLogData(entry)
+	if data.RequestBody != nil {
+		return
+	}
+	data.RequestBody = body
+	publishLiveAuditUpdate(c, entry)
+}
+
+// EnrichEntryWithResponseBody sets the audit response body from a handler that
+// captures its own response payload (e.g. audio output served as raw bytes).
+// A nil body or missing entry is a no-op.
+func EnrichEntryWithResponseBody(c *echo.Context, body any) {
+	if body == nil {
+		return
+	}
+	entry := entryFromContext(c)
+	if entry == nil {
+		return
+	}
+	ensureLogData(entry).ResponseBody = body
+	publishLiveAuditUpdate(c, entry)
+}
+
+// entryFromContext returns the live audit entry stored on the request context,
+// or nil when audit logging is inactive for the request.
+func entryFromContext(c *echo.Context) *LogEntry {
+	if c == nil {
+		return nil
+	}
+	entry, ok := c.Get(string(LogEntryKey)).(*LogEntry)
+	if !ok {
+		return nil
+	}
+	return entry
+}
+
 // EnrichEntryWithRequestedModel attaches early requested-model metadata to the
 // live audit entry before the final workflow policy has been resolved.
 func EnrichEntryWithRequestedModel(c *echo.Context, requestedModel string) {
diff --git a/internal/core/endpoints.go b/internal/core/endpoints.go
index a62d396ef..cd38a1787 100644
--- a/internal/core/endpoints.go
+++ b/internal/core/endpoints.go
@@ -25,6 +25,8 @@ const (
 	OperationEmbeddings          Operation = "embeddings"
 	OperationBatches             Operation = "batches"
 	OperationFiles               Operation = "files"
+	OperationAudioSpeech         Operation = "audio_speech"
+	OperationAudioTranscriptions Operation = "audio_transcriptions"
 	OperationProviderPassthrough Operation = "provider_passthrough"
 )
 
@@ -111,6 +113,23 @@ func describeEndpointPath(path string) EndpointDescriptor {
 			Dialect:          "openai_compat",
 			Operation:        OperationFiles,
 		}
+	case path == "/v1/audio/speech":
+		// Audio endpoints call a provider and incur usage, so they are model
+		// interactions and must appear in audit/request logs. They are not
+		// IngressManaged: the handlers parse the body themselves (JSON for
+		// speech, multipart for transcriptions) rather than going through the
+		// translated inference pipeline.
+		return EndpointDescriptor{
+			ModelInteraction: true,
+			Dialect:          "openai_compat",
+			Operation:        OperationAudioSpeech,
+		}
+	case path == "/v1/audio/transcriptions":
+		return EndpointDescriptor{
+			ModelInteraction: true,
+			Dialect:          "openai_compat",
+			Operation:        OperationAudioTranscriptions,
+		}
 	case strings.HasPrefix(path, "/p/"):
 		return EndpointDescriptor{
 			ModelInteraction: true,
@@ -156,6 +175,10 @@ func bodyModeForEndpoint(method, path string, operation Operation) BodyMode {
 			return BodyModeMultipart
 		}
 		return BodyModeNone
+	case OperationAudioSpeech:
+		return BodyModeJSON
+	case OperationAudioTranscriptions:
+		return BodyModeMultipart
 	case OperationProviderPassthrough:
 		return BodyModeOpaque
 	default:
diff --git a/internal/core/endpoints_test.go b/internal/core/endpoints_test.go
index a05c5cb1c..317dd4f28 100644
--- a/internal/core/endpoints_test.go
+++ b/internal/core/endpoints_test.go
@@ -23,6 +23,8 @@ func TestDescribeEndpointPath(t *testing.T) {
 		{path: "/v1/batches", managed: true, dialect: "openai_compat", operation: OperationBatches, bodyMode: BodyModeNone, interaction: true},
 		{path: "/v1/embeddings/", managed: true, dialect: "openai_compat", operation: OperationEmbeddings, bodyMode: BodyModeJSON, interaction: true},
 		{path: "/v1/files/file_1", managed: true, dialect: "openai_compat", operation: OperationFiles, bodyMode: BodyModeNone, interaction: true},
+		{path: "/v1/audio/speech", managed: false, dialect: "openai_compat", operation: OperationAudioSpeech, bodyMode: BodyModeJSON, interaction: true},
+		{path: "/v1/audio/transcriptions", managed: false, dialect: "openai_compat", operation: OperationAudioTranscriptions, bodyMode: BodyModeMultipart, interaction: true},
 		{path: "/p/openai/responses", managed: true, dialect: "provider_passthrough", operation: OperationProviderPassthrough, bodyMode: BodyModeOpaque, interaction: true},
 		{path: "/v1/models", managed: false, dialect: "", operation: "", bodyMode: BodyModeNone, interaction: false},
 	}
@@ -72,6 +74,8 @@ func TestDescribeEndpoint_UsesMethodForBodyMode(t *testing.T) {
 		{method: http.MethodPost, path: "/v1/files", bodyMode: BodyModeMultipart},
 		{method: http.MethodPost, path: "/v1/files/", bodyMode: BodyModeMultipart},
 		{method: http.MethodGet, path: "/v1/files/file_1", bodyMode: BodyModeNone},
+		{method: http.MethodPost, path: "/v1/audio/speech", bodyMode: BodyModeJSON},
+		{method: http.MethodPost, path: "/v1/audio/transcriptions", bodyMode: BodyModeMultipart},
 		{method: http.MethodPost, path: "/v1/batches/batch_1/cancel", bodyMode: BodyModeNone},
 	}
 
diff --git a/internal/server/audio_service.go b/internal/server/audio_service.go
index 986e5dc98..664c57e06 100644
--- a/internal/server/audio_service.go
+++ b/internal/server/audio_service.go
@@ -19,6 +19,14 @@ type audioService struct {
 	provider        core.RoutableProvider
 	modelAuthorizer RequestModelAuthorizer
 	budgetChecker   BudgetChecker
+	// logBodies and logAudioBodies mirror the audit logger config. Audio
+	// endpoints are not ingress-managed, so the audit middleware cannot capture
+	// their (binary/multipart) bodies; the service captures them here instead.
+	// logBodies is the master switch: audio bodies are only captured when it is
+	// on. logAudioBodies then decides whether the audio bytes are stored as
+	// base64 (playable) or as a lightweight placeholder.
+	logBodies      bool
+	logAudioBodies bool
 }
 
 func (s *audioService) router() (core.AudioProvider, error) {
@@ -47,6 +55,10 @@ func (s *audioService) CreateSpeech(c *echo.Context) error {
 		return handleError(c, core.NewInvalidRequestError("voice is required", nil))
 	}
 
+	if s.logBodies && s.logAudioBodies {
+		auditlog.EnrichEntryWithRequestBody(c, audioSpeechAuditInput(req))
+	}
+
 	ctx, err := s.prepare(c, req.Model, req.Provider)
 	if err != nil {
 		return handleError(c, err)
@@ -55,7 +67,7 @@ func (s *audioService) CreateSpeech(c *echo.Context) error {
 	if err != nil {
 		return handleError(c, err)
 	}
-	return respondAudio(c, resp)
+	return s.respondAudio(c, resp)
 }
 
 // CreateTranscription handles POST /v1/audio/transcriptions.
@@ -70,6 +82,10 @@ func (s *audioService) CreateTranscription(c *echo.Context) error {
 		return handleError(c, err)
 	}
 
+	if s.logBodies && s.logAudioBodies {
+		auditlog.EnrichEntryWithRequestBody(c, audioTranscriptionAuditInput(req))
+	}
+
 	ctx, err := s.prepare(c, req.Model, req.Provider)
 	if err != nil {
 		return handleError(c, err)
@@ -78,7 +94,7 @@ func (s *audioService) CreateTranscription(c *echo.Context) error {
 	if err != nil {
 		return handleError(c, err)
 	}
-	return respondAudio(c, resp)
+	return s.respondAudio(c, resp)
 }
 
 // selectorResolver maps a requested model selector to the concrete registry
@@ -166,7 +182,7 @@ func transcriptionRequestFromForm(c *echo.Context) (*core.AudioTranscriptionRequ
 	}, nil
 }
 
-func respondAudio(c *echo.Context, resp *core.AudioResponse) error {
+func (s *audioService) respondAudio(c *echo.Context, resp *core.AudioResponse) error {
 	if resp == nil {
 		return handleError(c, core.NewProviderError("", http.StatusBadGateway, "provider returned empty audio response", nil))
 	}
@@ -174,5 +190,62 @@ func respondAudio(c *echo.Context, resp *core.AudioResponse) error {
 	if contentType == "" {
 		contentType = "application/octet-stream"
 	}
+
+	// Audio output is binary; the audit middleware skips audio Content-Types so
+	// it never corrupts the bytes via UTF-8 coercion. Capture it here instead.
+	// Body logging is the master switch (LogBodies); LogAudioBodies only decides
+	// whether the bytes are embedded as base64 for playback or recorded as a
+	// lightweight placeholder.
+	if auditlog.IsAudioContentType(contentType) && s.logBodies {
+		auditlog.EnrichEntryWithResponseBody(c, auditlog.BuildAudioResponseBody(contentType, resp.Data, s.logAudioBodies))
+	}
+
 	return c.Blob(http.StatusOK, contentType, resp.Data)
 }
+
+// audioSpeechAuditInput builds the audit request body for a text-to-speech
+// request: the user-facing synthesis parameters, never routing metadata.
+func audioSpeechAuditInput(req *core.AudioSpeechRequest) map[string]any {
+	input := map[string]any{
+		"model": req.Model,
+		"input": req.Input,
+		"voice": req.Voice,
+	}
+	if req.ResponseFormat != "" {
+		input["response_format"] = req.ResponseFormat
+	}
+	if req.Speed != 0 {
+		input["speed"] = req.Speed
+	}
+	if req.Instructions != "" {
+		input["instructions"] = req.Instructions
+	}
+	return input
+}
+
+// audioTranscriptionAuditInput builds the audit request body for a
+// speech-to-text request: upload metadata and parameters, never the raw audio
+// bytes (which are large and binary).
+func audioTranscriptionAuditInput(req *core.AudioTranscriptionRequest) map[string]any {
+	meta := map[string]any{
+		"model":      req.Model,
+		"filename":   req.Filename,
+		"file_bytes": len(req.File),
+	}
+	if req.Language != "" {
+		meta["language"] = req.Language
+	}
+	if req.Prompt != "" {
+		meta["prompt"] = req.Prompt
+	}
+	if req.ResponseFormat != "" {
+		meta["response_format"] = req.ResponseFormat
+	}
+	if req.Temperature != "" {
+		meta["temperature"] = req.Temperature
+	}
+	if len(req.TimestampGranularities) > 0 {
+		meta["timestamp_granularities"] = req.TimestampGranularities
+	}
+	return meta
+}
diff --git a/internal/server/audio_service_test.go b/internal/server/audio_service_test.go
index 3029147e1..3962964ef 100644
--- a/internal/server/audio_service_test.go
+++ b/internal/server/audio_service_test.go
@@ -3,6 +3,7 @@ package server
 import (
 	"bytes"
 	"context"
+	"encoding/base64"
 	"mime/multipart"
 	"net/http"
 	"net/http/httptest"
@@ -11,6 +12,7 @@ import (
 
 	"github.com/labstack/echo/v5"
 
+	"gomodel/internal/auditlog"
 	"gomodel/internal/core"
 )
 
@@ -250,6 +252,106 @@ func TestAudioTranscription_MissingModel(t *testing.T) {
 	}
 }
 
+// newSpeechRequestWithAuditEntry builds a /v1/audio/speech request and seeds an
+// empty audit entry into the context (as the audit middleware would), returning
+// the context, recorder, and the entry to assert on.
+func newSpeechRequestWithAuditEntry() (*echo.Context, *httptest.ResponseRecorder, *auditlog.LogEntry) {
+	body := `{"model":"gpt-4o-mini-tts","input":"hello","voice":"alloy"}`
+	req := httptest.NewRequest(http.MethodPost, "/v1/audio/speech", strings.NewReader(body))
+	req.Header.Set("Content-Type", "application/json")
+	rec := httptest.NewRecorder()
+	c := echo.New().NewContext(req, rec)
+	entry := &auditlog.LogEntry{}
+	c.Set(string(auditlog.LogEntryKey), entry)
+	return c, rec, entry
+}
+
+func newSpeechMock() *audioMockProvider {
+	return &audioMockProvider{
+		mockProvider: &mockProvider{supportedModels: []string{"gpt-4o-mini-tts"}},
+		speechResp:   &core.AudioResponse{ContentType: "audio/mpeg", Data: []byte("synthetic-audio")},
+	}
+}
+
+// TestAudioSpeech_LogsAudioBodiesWhenEnabled: with both LogBodies and
+// LogAudioBodies on, the speech input is logged and the audio output is stored
+// losslessly as base64 for playback.
+func TestAudioSpeech_LogsAudioBodiesWhenEnabled(t *testing.T) {
+	svc := &audioService{provider: newSpeechMock(), logBodies: true, logAudioBodies: true}
+	c, rec, entry := newSpeechRequestWithAuditEntry()
+
+	if err := svc.CreateSpeech(c); err != nil {
+		t.Fatalf("CreateSpeech returned error: %v", err)
+	}
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+
+	reqBody, ok := entry.Data.RequestBody.(map[string]any)
+	if !ok {
+		t.Fatalf("request body not captured as map, got %T", entry.Data.RequestBody)
+	}
+	if reqBody["input"] != "hello" || reqBody["voice"] != "alloy" {
+		t.Errorf("request body mismatch: %+v", reqBody)
+	}
+
+	respBody, ok := entry.Data.ResponseBody.(auditlog.AudioBodyLog)
+	if !ok {
+		t.Fatalf("response body not an AudioBodyLog, got %T", entry.Data.ResponseBody)
+	}
+	if !respBody.Stored || respBody.Encoding != "base64" {
+		t.Fatalf("expected stored base64 audio, got %+v", respBody)
+	}
+	decoded, err := base64.StdEncoding.DecodeString(respBody.Data)
+	if err != nil || string(decoded) != "synthetic-audio" {
+		t.Errorf("base64 did not round-trip to the audio bytes: decoded=%q err=%v", decoded, err)
+	}
+}
+
+// TestAudioSpeech_PlaceholderWhenAudioDisabled: with LogBodies on but
+// LogAudioBodies off, the audio response is a metadata-only placeholder and the
+// input is not captured.
+func TestAudioSpeech_PlaceholderWhenAudioDisabled(t *testing.T) {
+	svc := &audioService{provider: newSpeechMock(), logBodies: true, logAudioBodies: false}
+	c, _, entry := newSpeechRequestWithAuditEntry()
+
+	if err := svc.CreateSpeech(c); err != nil {
+		t.Fatalf("CreateSpeech returned error: %v", err)
+	}
+
+	if entry.Data != nil && entry.Data.RequestBody != nil {
+		t.Errorf("input should not be captured when LogAudioBodies is off, got %+v", entry.Data.RequestBody)
+	}
+	respBody, ok := entry.Data.ResponseBody.(auditlog.AudioBodyLog)
+	if !ok {
+		t.Fatalf("response body not an AudioBodyLog, got %T", entry.Data.ResponseBody)
+	}
+	if respBody.Stored || respBody.Data != "" {
+		t.Errorf("audio bytes must not be stored when LogAudioBodies is off, got %+v", respBody)
+	}
+	if respBody.Bytes != len("synthetic-audio") {
+		t.Errorf("placeholder should still record byte size, got %d", respBody.Bytes)
+	}
+}
+
+// TestAudioSpeech_NoAudioBodyWhenBodiesDisabled: LogBodies is the master switch.
+// With it off, no audio body is captured even if LogAudioBodies is on.
+func TestAudioSpeech_NoAudioBodyWhenBodiesDisabled(t *testing.T) {
+	svc := &audioService{provider: newSpeechMock(), logBodies: false, logAudioBodies: true}
+	c, rec, entry := newSpeechRequestWithAuditEntry()
+
+	if err := svc.CreateSpeech(c); err != nil {
+		t.Fatalf("CreateSpeech returned error: %v", err)
+	}
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, want 200", rec.Code)
+	}
+	if entry.Data != nil && (entry.Data.RequestBody != nil || entry.Data.ResponseBody != nil) {
+		t.Errorf("no body should be captured when LogBodies is off, got req=%+v resp=%+v",
+			entry.Data.RequestBody, entry.Data.ResponseBody)
+	}
+}
+
 // TestAudioSpeech_NilResponseReturns502 covers the respondAudio guard: when the
 // provider returns no response and no error, the gateway must report a 502.
 func TestAudioSpeech_NilResponseReturns502(t *testing.T) {
diff --git a/internal/server/handlers.go b/internal/server/handlers.go
index 222eede22..a99505320 100644
--- a/internal/server/handlers.go
+++ b/internal/server/handlers.go
@@ -202,10 +202,18 @@ func (h *Handler) nativeFiles() *nativeFileService {
 }
 
 func (h *Handler) audio() *audioService {
+	var logBodies, logAudioBodies bool
+	if h.logger != nil {
+		cfg := h.logger.Config()
+		logBodies = cfg.LogBodies
+		logAudioBodies = cfg.LogAudioBodies
+	}
 	return &audioService{
 		provider:        h.provider,
 		modelAuthorizer: h.modelAuthorizer,
 		budgetChecker:   h.budgetChecker,
+		logBodies:       logBodies,
+		logAudioBodies:  logAudioBodies,
 	}
 }