diff --git a/README.md b/README.md
index 308a15657..d62ffa300 100644
--- a/README.md
+++ b/README.md
@@ -105,6 +105,47 @@ The `say(message: string, endCallAfterSpoken?: boolean)` can be used to invoke s
 vapi.say("Our time's up, goodbye!", true)
 ```
 
+The `setVolume(volume: number)` controls how loudly the assistant plays, from
+`0` to `1`. This is playback only: it does not change what the assistant hears,
+and it does not affect the levels reported by the `volume-level` event.
+
+```javascript
+vapi.setVolume(0.5);
+```
+
+The setting is remembered, so you can call it before a call has started and it
+will be applied as soon as the assistant's audio arrives. It also persists
+across calls, so a volume your user picked once is not reset by hanging up.
+Values outside `0` to `1` are clamped, and non-finite values are ignored.
+
+The `getAudioPlayer()` returns the `<audio>` element the SDK uses to play the
+assistant, or `null` before its track has arrived. Use it for anything the
+setter doesn't cover, such as driving a waveform visualizer.
+
+```javascript
+const player = vapi.getAudioPlayer();
+```
+
+Pair it with the `audio` event when you need the element the moment it exists:
+
+```javascript
+vapi.on('audio', (player) => {
+  // e.g. new AudioContext().createMediaElementSource(player)
+});
+```
+
+If the browser blocks playback, usually its autoplay policy when the call was
+not started from a user gesture, no player is attached and an `error` is
+emitted instead. Listen for it to prompt the user:
+
+```javascript
+vapi.on('error', (e) => {
+  if (e.type === 'audio-start-failed') {
+    // show a "tap to enable audio" affordance
+  }
+});
+```
+
 ## Events
 
 You can listen to the following events:
@@ -130,6 +171,11 @@ vapi.on('volume-level', (volume) => {
   console.log(`Assistant volume level: ${volume}`);
 });
 
+// The <audio> element playing the assistant, as soon as it exists
+vapi.on('audio', (player) => {
+  console.log(`Assistant audio attached at volume ${player.volume}`);
+});
+
 // Function calls and transcripts will be sent via messages
 vapi.on('message', (message) => {
   console.log(message);
diff --git a/__tests__/audioPlayer.test.ts b/__tests__/audioPlayer.test.ts
new file mode 100644
index 000000000..acf2b60a0
--- /dev/null
+++ b/__tests__/audioPlayer.test.ts
@@ -0,0 +1,424 @@
+import Vapi from "../vapi";
+
+/**
+ * Covers the track-started path that feeds getAudioPlayer/setVolume, which is
+ * where the lifecycle bugs live. The two functions that actually touch the DOM
+ * are substituted, so this runs in the repo's existing node environment with no
+ * extra dependency. What is deliberately not covered here: the DOM calls
+ * themselves, and the fact that volume is applied before play() is invoked.
+ */
+
+type FakePlayer = HTMLAudioElement & { removed: boolean };
+
+const fakePlayer = (participantId: string): FakePlayer => {
+  const player = {
+    volume: 1,
+    dataset: { participantId },
+    removed: false,
+    remove() {
+      this.removed = true;
+    },
+  };
+  return player as unknown as FakePlayer;
+};
+
+const trackStartedEvent = (
+  kind: "audio" | "video" = "audio",
+  sessionId = "bot-1",
+) =>
+  ({
+    action: "track-started",
+    type: kind,
+    callClientId: "test-client",
+    participant: {
+      local: false,
+      user_name: "Vapi Speaker",
+      session_id: sessionId,
+    },
+    track: { kind },
+  }) as unknown as Parameters<Vapi["handleTrackStarted"]>[0];
+
+describe("assistant audio player", () => {
+  let vapi: Vapi;
+  let mockCall: any;
+  let built: FakePlayer[];
+  let destroyed: string[];
+  /** Resolvers for in-flight builds, so tests can settle them out of order. */
+  let releases: Array<(player: FakePlayer) => void>;
+  let autoRelease: boolean;
+  /** Volume argument each build was handed, so the normalizing is observable. */
+  let builtWithVolume: Array<number | null | undefined>;
+
+  beforeEach(() => {
+    built = [];
+    destroyed = [];
+    releases = [];
+    builtWithVolume = [];
+    autoRelease = true;
+
+    mockCall = {
+      setLocalAudio: jest.fn(),
+      localAudio: jest.fn(),
+      sendAppMessage: jest.fn(),
+      destroy: jest.fn().mockResolvedValue(undefined),
+    };
+    vapi = new Vapi("dummy_token");
+    vapi["call"] = mockCall;
+
+    vapi["audioPlayerBuild"] = ((
+      _track: MediaStreamTrack,
+      participantId: string,
+      volume?: number | null,
+    ) => {
+      const player = fakePlayer(participantId);
+      built.push(player);
+      builtWithVolume.push(volume);
+      if (typeof volume === "number") player.volume = volume;
+      if (autoRelease) return Promise.resolve(player);
+      return new Promise<FakePlayer>((resolve) => {
+        releases.push(resolve);
+      });
+    }) as typeof vapi["audioPlayerBuild"];
+
+    vapi["audioPlayerDestroy"] = ((participantId: string) => {
+      destroyed.push(participantId);
+    }) as typeof vapi["audioPlayerDestroy"];
+  });
+
+  it("attaches the player when the assistant's track starts", async () => {
+    await vapi["handleTrackStarted"](trackStartedEvent());
+
+    expect(vapi.getAudioPlayer()).toBe(built[0]);
+    expect(mockCall.sendAppMessage).toHaveBeenCalledWith("playable");
+  });
+
+  it("ignores the local participant's own track", async () => {
+    const event = trackStartedEvent();
+    (event as any).participant.local = true;
+
+    await vapi["handleTrackStarted"](event);
+
+    expect(vapi.getAudioPlayer()).toBeNull();
+    expect(built).toHaveLength(0);
+  });
+
+  it("ignores tracks from participants that are not the assistant", async () => {
+    const event = trackStartedEvent();
+    (event as any).participant.user_name = "Someone Else";
+
+    await vapi["handleTrackStarted"](event);
+
+    expect(vapi.getAudioPlayer()).toBeNull();
+  });
+
+  describe("a consumer listener that throws", () => {
+    // playable is signalled on the same path, one statement after the emit.
+    it("does not stop playable being signalled from the audio emit", async () => {
+      const reported = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      vapi.on("audio", () => {
+        throw new Error("consumer bug");
+      });
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(mockCall.sendAppMessage).toHaveBeenCalledWith("playable");
+      expect(reported).toHaveBeenCalled();
+      reported.mockRestore();
+    });
+
+    it("does not stop playable being signalled from the video emit", async () => {
+      const reported = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      vapi.on("video", () => {
+        throw new Error("consumer bug");
+      });
+
+      await vapi["handleTrackStarted"](trackStartedEvent("video"));
+
+      expect(mockCall.sendAppMessage).toHaveBeenCalledWith("playable");
+      expect(reported).toHaveBeenCalled();
+      reported.mockRestore();
+    });
+  });
+
+  describe("builds that outlive what they were built for", () => {
+    beforeEach(() => {
+      autoRelease = false;
+    });
+
+    it("discards a player built for a call that has ended", async () => {
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+      await vapi.stop();
+      releases[0](built[0]);
+      await inFlight;
+
+      expect(vapi.getAudioPlayer()).toBeNull();
+      expect(built[0].removed).toBe(true);
+    });
+
+    // Isolates the call-identity check: the call object is swapped without
+    // going through stop(), so the pending-build bookkeeping is untouched and
+    // only the identity comparison can catch this.
+    it("discards a player built for a call that was replaced", async () => {
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+      vapi["call"] = { ...mockCall, sendAppMessage: jest.fn() };
+      releases[0](built[0]);
+      await inFlight;
+
+      expect(vapi.getAudioPlayer()).toBeNull();
+      expect(built[0].removed).toBe(true);
+    });
+
+    it("discards a player whose participant left while it was building", async () => {
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+      vapi["detachAudioPlayer"]("bot-1");
+      releases[0](built[0]);
+      await inFlight;
+
+      expect(vapi.getAudioPlayer()).toBeNull();
+      expect(built[0].removed).toBe(true);
+    });
+
+    // Scoped to the departing participant: anyone else leaving must not cost
+    // us the assistant's audio.
+    it("keeps a player when an unrelated participant leaves", async () => {
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+      vapi["detachAudioPlayer"]("some-other-participant");
+      releases[0](built[0]);
+      await inFlight;
+
+      expect(vapi.getAudioPlayer()).toBe(built[0]);
+      expect(mockCall.sendAppMessage).toHaveBeenCalledWith("playable");
+    });
+
+    // Two builds settle independently, so the second can finish first.
+    it("does not let an earlier build overwrite a later one", async () => {
+      const first = vapi["handleTrackStarted"](trackStartedEvent());
+      const second = vapi["handleTrackStarted"](trackStartedEvent());
+      releases[1](built[1]);
+      releases[0](built[0]);
+      await Promise.all([first, second]);
+
+      expect(vapi.getAudioPlayer()).toBe(built[1]);
+      expect(built[0].removed).toBe(true);
+      expect(built[1].removed).toBe(false);
+    });
+
+    it("forgets builds still in flight when the call is stopped", async () => {
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+      expect(vapi["pendingAudioBuilds"].size).toBe(1);
+
+      await vapi.stop();
+
+      expect(vapi["pendingAudioBuilds"].size).toBe(0);
+      releases[0](built[0]);
+      await inFlight;
+    });
+  });
+
+  it("removes the element it supersedes when the track is renegotiated", async () => {
+    await vapi["handleTrackStarted"](trackStartedEvent());
+    await vapi["handleTrackStarted"](trackStartedEvent());
+
+    expect(vapi.getAudioPlayer()).toBe(built[1]);
+    expect(built[0].removed).toBe(true);
+    expect(built[1].removed).toBe(false);
+  });
+
+  describe("when playback fails to start", () => {
+    // Not a real DOMException: jest's node environment supplies it from the
+    // parent realm, so `instanceof Error` is false and serializeError would
+    // take a branch it never takes in a browser. An in-realm Error with the
+    // same `name` is the faithful stand-in.
+    const autoplayBlocked = () => {
+      const error = new Error(
+        "play() failed because the user didn't interact with the document first.",
+      );
+      error.name = "NotAllowedError";
+      return error;
+    };
+
+    beforeEach(() => {
+      vapi["audioPlayerBuild"] = (() =>
+        Promise.reject(autoplayBlocked())) as typeof vapi["audioPlayerBuild"];
+    });
+
+    it("reports rather than leaving an unhandled rejection", async () => {
+      const reported = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      await expect(
+        vapi["handleTrackStarted"](trackStartedEvent()),
+      ).resolves.toBeUndefined();
+
+      expect(reported).toHaveBeenCalled();
+      expect(vapi.getAudioPlayer()).toBeNull();
+      reported.mockRestore();
+    });
+
+    it("emits a serialized error consumers can act on", async () => {
+      jest.spyOn(console, "error").mockImplementation(() => {});
+      const errors: any[] = [];
+      vapi.on("error", (e) => errors.push(e));
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].type).toBe("audio-start-failed");
+      expect(errors[0].error.name).toBe("NotAllowedError");
+      // Serialized, not the raw exception: consumers forward this to loggers
+      // and workers, and Error properties are not enumerable.
+      expect(errors[0].error).not.toBeInstanceOf(Error);
+      expect(JSON.parse(JSON.stringify(errors[0].error)).name).toBe(
+        "NotAllowedError",
+      );
+      jest.restoreAllMocks();
+    });
+
+    it("does not throw with no error listener attached", async () => {
+      const reported = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+
+      await expect(
+        vapi["handleTrackStarted"](trackStartedEvent()),
+      ).resolves.toBeUndefined();
+
+      expect(reported).toHaveBeenCalled();
+      reported.mockRestore();
+    });
+
+    it("forgets the failed build", async () => {
+      jest.spyOn(console, "error").mockImplementation(() => {});
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(vapi["pendingAudioBuilds"].size).toBe(0);
+      jest.restoreAllMocks();
+    });
+  });
+
+  describe("teardown", () => {
+    it("drops the reference and destroys the element when the assistant leaves", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      vapi["detachAudioPlayer"]("bot-1");
+
+      expect(vapi.getAudioPlayer()).toBeNull();
+      expect(destroyed).toContain("bot-1");
+    });
+
+    it("keeps the reference when a different participant leaves", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      vapi["detachAudioPlayer"]("someone-else");
+
+      expect(vapi.getAudioPlayer()).toBe(built[0]);
+    });
+
+    it("clears the reference on cleanup, not just on stop", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      await vapi["cleanup"]();
+
+      expect(vapi.getAudioPlayer()).toBeNull();
+    });
+  });
+
+  describe("volume", () => {
+    it("applies a volume chosen before the track arrived", async () => {
+      vapi.setVolume(0.2);
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(0.2);
+    });
+
+    it("keeps the chosen volume across calls", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+      vapi.setVolume(0.1);
+      await vapi.stop();
+
+      vapi["call"] = mockCall;
+      await vapi["handleTrackStarted"](trackStartedEvent("audio", "bot-2"));
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(0.1);
+    });
+
+    it("keeps the chosen volume when the track is replaced mid-call", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+      vapi.setVolume(0.3);
+
+      await vapi["handleTrackStarted"](trackStartedEvent("audio", "bot-2"));
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(0.3);
+    });
+
+    it("defaults to full volume when the caller never set one", async () => {
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(1);
+    });
+
+    it("hands the build an already-clamped volume", async () => {
+      vapi["desiredVolume"] = 5;
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(builtWithVolume).toEqual([1]);
+    });
+
+    it("hands the build nothing when the remembered volume is non-finite", async () => {
+      vapi["desiredVolume"] = NaN;
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(builtWithVolume).toEqual([null]);
+    });
+
+    // The build is handed the volume as it was when the build started. If the
+    // caller changes it while play() is still pending, only the reapply at
+    // attach time catches that.
+    it("applies a volume changed while the player was still building", async () => {
+      autoRelease = false;
+      vapi.setVolume(0.2);
+      const inFlight = vapi["handleTrackStarted"](trackStartedEvent());
+
+      vapi.setVolume(0.7);
+      releases[0](built[0]);
+      await inFlight;
+
+      expect(builtWithVolume).toEqual([0.2]);
+      expect(vapi.getAudioPlayer()?.volume).toBe(0.7);
+    });
+
+    it("hands the build the chosen volume", async () => {
+      vapi.setVolume(0.35);
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(builtWithVolume).toEqual([0.35]);
+    });
+
+    // setVolume validates, so these guard the field being written directly.
+    it("ignores a non-finite remembered volume", async () => {
+      vapi["desiredVolume"] = NaN;
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(1);
+    });
+
+    it("clamps an out-of-range remembered volume", async () => {
+      vapi["desiredVolume"] = 5;
+
+      await vapi["handleTrackStarted"](trackStartedEvent());
+
+      expect(vapi.getAudioPlayer()?.volume).toBe(1);
+    });
+  });
+});
diff --git a/__tests__/vapi.test.ts b/__tests__/vapi.test.ts
index 5385e2360..fd44ffd3f 100644
--- a/__tests__/vapi.test.ts
+++ b/__tests__/vapi.test.ts
@@ -104,6 +104,7 @@ describe("Vapi", () => {
     mockCall = {
       setLocalAudio: jest.fn(),
       localAudio: jest.fn(),
+      destroy: jest.fn().mockResolvedValue(undefined),
     };
     // Initialize Vapi instance and inject the mock
     vapi = new Vapi("dummy_token");
@@ -148,6 +149,111 @@ describe("Vapi", () => {
       expect(res).toBe(false);
     });
   });
+
+  describe("audio player access", () => {
+    // The real element is built by buildAudioPlayer, which needs a DOM. These
+    // tests cover everything downstream of that, which is where the reference
+    // is kept, handed out, and dropped.
+    const fakePlayer = () => ({ volume: 1 }) as HTMLAudioElement;
+
+    it("should return null before any audio track has arrived", () => {
+      expect(vapi.getAudioPlayer()).toBeNull();
+    });
+
+    it("should return the player once an audio track has arrived", () => {
+      const player = fakePlayer();
+      vapi["attachAudioPlayer"](player);
+      expect(vapi.getAudioPlayer()).toBe(player);
+    });
+
+    it("should emit the player on the audio event", () => {
+      const player = fakePlayer();
+      const listener = jest.fn();
+      vapi.on("audio", listener);
+
+      vapi["attachAudioPlayer"](player);
+
+      expect(listener).toHaveBeenCalledWith(player);
+    });
+
+    it("should store the player before emitting, so listeners can use it", () => {
+      const player = fakePlayer();
+      let seenDuringEvent: HTMLAudioElement | null = null;
+      vapi.on("audio", () => {
+        seenDuringEvent = vapi.getAudioPlayer();
+      });
+
+      vapi["attachAudioPlayer"](player);
+
+      expect(seenDuringEvent).toBe(player);
+    });
+  });
+
+  describe("setVolume", () => {
+    it("should set the volume on the attached player", () => {
+      const player = { volume: 1 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      vapi.setVolume(0.25);
+
+      expect(player.volume).toBe(0.25);
+    });
+
+    it("should do nothing when no audio track has arrived", () => {
+      expect(() => vapi.setVolume(0.5)).not.toThrow();
+    });
+
+    // The DOM throws IndexSizeError outside 0-1, so clamp rather than hand
+    // callers a browser exception from a setter.
+    it("should clamp values above 1", () => {
+      const player = { volume: 0.5 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      vapi.setVolume(1.5);
+
+      expect(player.volume).toBe(1);
+    });
+
+    it("should clamp values below 0", () => {
+      const player = { volume: 0.5 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      vapi.setVolume(-2);
+
+      expect(player.volume).toBe(0);
+    });
+
+    // Clamping alone lets NaN through, and the DOM rejects a non-finite volume
+    // with a TypeError. Untyped callers reach this via parseFloat("") and friends.
+    it("should ignore NaN rather than writing it to the player", () => {
+      const player = { volume: 0.5 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      vapi.setVolume(NaN);
+
+      expect(player.volume).toBe(0.5);
+    });
+
+    it("should ignore undefined from untyped callers", () => {
+      const player = { volume: 0.5 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      vapi.setVolume(undefined as unknown as number);
+
+      expect(player.volume).toBe(0.5);
+    });
+
+    it("should not write to the player from a previous call after stop", async () => {
+      const player = { volume: 1 } as HTMLAudioElement;
+      vapi["attachAudioPlayer"](player);
+
+      await vapi.stop();
+      vapi.setVolume(0.25);
+
+      expect(player.volume).toBe(1);
+      expect(vapi.getAudioPlayer()).toBeNull();
+    });
+  });
 });
 
 // Daily applies input settings through its remotely loaded call machine, so a
diff --git a/vapi.ts b/vapi.ts
index aba01b8ab..1576fbf1e 100644
--- a/vapi.ts
+++ b/vapi.ts
@@ -8,6 +8,7 @@ import DailyIframe, {
   DailyEventObjectLocalAudioLevel,
   DailyEventObjectNoPayload,
   DailyEventObjectParticipant,
+  DailyEventObjectTrack,
   DailyEventObjectRecordingError,
   DailyEventObjectRecordingStarted,
   DailyEventObjectRecordingStopped,
@@ -73,6 +74,7 @@ type VapiEventNames =
   | 'speech-end'
   | 'message'
   | 'video'
+  | 'audio'
   | 'error'
   | 'camera-error'
   | 'network-quality-change'
@@ -186,6 +188,7 @@ type VapiEventListeners = {
   'speech-start': () => void;
   'speech-end': () => void;
   video: (track: MediaStreamTrack) => void;
+  audio: (player: HTMLAudioElement) => void;
   message: (message: any) => void;
   error: (error: any) => void;
   'camera-error': (error: any) => void;
@@ -254,11 +257,22 @@ async function startAudioPlayer(
 async function buildAudioPlayer(
   track: MediaStreamTrack,
   participantId: string,
+  volume?: number | null,
 ) {
   const player = document.createElement('audio');
   player.dataset.participantId = participantId;
+  // Before play(), so an already-flowing track never plays at full volume first.
+  if (typeof volume === 'number') {
+    player.volume = volume;
+  }
   document.body.appendChild(player);
-  await startAudioPlayer(player, track);
+  try {
+    await startAudioPlayer(player, track);
+  } catch (error) {
+    // Appended before playback was attempted, so a failure would strand it.
+    player.remove();
+    throw error;
+  }
   return player;
 }
 
@@ -322,6 +336,15 @@ class VapiEventEmitter extends EventEmitter {
 export default class Vapi extends VapiEventEmitter {
   private started: boolean = false;
   private call: DailyCall | null = null;
+  private audioPlayer: HTMLAudioElement | null = null;
+  // Survives teardown so the caller's choice persists across calls.
+  private desiredVolume: number | null = null;
+  // Builds are tracked individually, not by one counter: several can be in
+  // flight, they finish out of order, and a teardown must invalidate only the
+  // builds belonging to the participant that left.
+  private audioBuildSequence = 0;
+  private pendingAudioBuilds = new Map<number, string>();
+  private attachedAudioBuild = 0;
   private speakingTimeout: NodeJS.Timeout | null = null;
   private dailyCallConfig: DailyAdvancedConfig = {};
   private dailyCallObject: DailyFactoryOptions = {};
@@ -351,6 +374,8 @@ export default class Vapi extends VapiEventEmitter {
       await this.call.destroy();
       this.call = null;
     }
+    this.audioPlayer = null;
+    this.pendingAudioBuilds.clear();
     this.speakingTimeout = null;
   }
 
@@ -600,24 +625,7 @@ export default class Vapi extends VapiEventEmitter {
         if (event) this.emit('recording-upload-completed', event);
       });
 
-      this.call.on('track-started', async (e) => {
-        if (!e || !e.participant) {
-          return;
-        }
-        if (e.participant?.local) {
-          return;
-        }
-        if (e.participant?.user_name !== 'Vapi Speaker') {
-          return;
-        }
-        if (e.track.kind === 'video') {
-          this.emit('video', e.track);
-        }
-        if (e.track.kind === 'audio') {
-          await buildAudioPlayer(e.track, e.participant.session_id);
-        }
-        this.call?.sendAppMessage('playable');
-      });
+      this.call.on('track-started', (e) => this.handleTrackStarted(e));
 
       this.call.on('participant-joined', (e) => {
         if (!e || !this.call) return;
@@ -640,7 +648,7 @@ export default class Vapi extends VapiEventEmitter {
         if (!e) {
           return;
         }
-        destroyAudioPlayer(e.participant.session_id);
+        this.detachAudioPlayer(e.participant.session_id);
       });
 
       // Stage 3: Mobile device handling and permissions
@@ -1019,6 +1027,8 @@ export default class Vapi extends VapiEventEmitter {
       await this.call.destroy();
       this.call = null;
     }
+    this.audioPlayer = null;
+    this.pendingAudioBuilds.clear();
     this.speakingTimeout = null;
   }
 
@@ -1031,6 +1041,177 @@ export default class Vapi extends VapiEventEmitter {
     this.call?.sendAppMessage(JSON.stringify(message));
   }
 
+  /**
+   * The two places this class touches the DOM, behind indirections so the
+   * lifecycle logic around them is testable without a browser.
+   */
+  private audioPlayerBuild(
+    track: MediaStreamTrack,
+    participantId: string,
+    volume?: number | null,
+  ): Promise<HTMLAudioElement> {
+    return buildAudioPlayer(track, participantId, volume);
+  }
+
+  private audioPlayerDestroy(participantId: string): void {
+    destroyAudioPlayer(participantId);
+  }
+
+  /**
+   * The remembered volume, bounded, or null if there is nothing to apply.
+   * Shared by both callers so they cannot disagree: the DOM throws on a
+   * non-finite or out-of-range volume, and that throw would stall the call.
+   */
+  private desiredVolumeResolve(): number | null {
+    if (this.desiredVolume === null || !Number.isFinite(this.desiredVolume)) {
+      return null;
+    }
+    return Math.min(1, Math.max(0, this.desiredVolume));
+  }
+
+  /** Shared by the initial and reconnect paths so the two cannot drift. */
+  private async handleTrackStarted(e?: DailyEventObjectTrack) {
+    if (!e || !e.participant) {
+      return;
+    }
+    if (e.participant?.local) {
+      return;
+    }
+    if (e.participant?.user_name !== 'Vapi Speaker') {
+      return;
+    }
+    if (e.track.kind === 'video') {
+      this.emitToConsumer('video', e.track);
+    }
+    if (e.track.kind === 'audio') {
+      // play() pends for the whole of media startup, so the call can end or
+      // the participant can leave while the player is still being built.
+      const call = this.call;
+      const build = ++this.audioBuildSequence;
+      this.pendingAudioBuilds.set(build, e.participant.session_id);
+
+      let player: HTMLAudioElement;
+      try {
+        player = await this.audioPlayerBuild(
+          e.track,
+          e.participant.session_id,
+          this.desiredVolumeResolve(),
+        );
+      } catch (error) {
+        // Usually autoplay policy, which is recoverable, so consumers get a
+        // signal to prompt for a gesture. Safe with no 'error' listener:
+        // emitToConsumer catches EventEmitter's unlistened-'error' throw.
+        this.pendingAudioBuilds.delete(build);
+        console.error('[vapi] could not start assistant audio', error);
+        this.emitToConsumer('error', {
+          type: 'audio-start-failed',
+          error: serializeError(error),
+        });
+        return;
+      }
+
+      const stillPending = this.pendingAudioBuilds.delete(build);
+      if (
+        !call ||
+        this.call !== call ||
+        !stillPending ||
+        build < this.attachedAudioBuild
+      ) {
+        player.remove();
+        return;
+      }
+      this.attachedAudioBuild = build;
+      this.attachAudioPlayer(player);
+    }
+    this.call?.sendAppMessage('playable');
+  }
+
+  /**
+   * Assigns before emitting, since emit is synchronous and a listener may call
+   * getAudioPlayer or setVolume during the event.
+   */
+  private attachAudioPlayer(player: HTMLAudioElement) {
+    // Renegotiation reuses the participant id, so a superseded element would
+    // still match the selector teardown uses and be removed in its place.
+    if (this.audioPlayer && this.audioPlayer !== player) {
+      this.audioPlayer.remove();
+    }
+    // Reapplied in case the volume changed while the player was building.
+    const volume = this.desiredVolumeResolve();
+    if (volume !== null) {
+      player.volume = volume;
+    }
+    this.audioPlayer = player;
+    this.emitToConsumer('audio', player);
+  }
+
+  /**
+   * A listener that throws must not take down the caller: track-started still
+   * has to signal that playback is ready. Not routed to the `error` event,
+   * which EventEmitter throws on when nothing is listening.
+   */
+  private emitToConsumer<E extends VapiEventNames>(
+    event: E,
+    ...args: Parameters<VapiEventListeners[E]>
+  ) {
+    try {
+      this.emit(event, ...args);
+    } catch (error) {
+      console.error(`[vapi] ${event} event listener threw`, error);
+    }
+  }
+
+  /** Drops the reference before removing, so nothing hands out a detached element. */
+  private detachAudioPlayer(participantId: string) {
+    if (this.audioPlayer?.dataset.participantId === participantId) {
+      this.audioPlayer = null;
+    }
+    // Scoped to this participant: the call check cannot catch these, since the
+    // call itself has not changed, and an unrelated leave must not invalidate
+    // the assistant's build.
+    for (const [build, id] of this.pendingAudioBuilds) {
+      if (id === participantId) {
+        this.pendingAudioBuilds.delete(build);
+      }
+    }
+    this.audioPlayerDestroy(participantId);
+  }
+
+  /**
+   * The <audio> element playing the assistant, or null before its track has
+   * arrived. Pair with the `audio` event when you need it the moment it exists.
+   */
+  public getAudioPlayer(): HTMLAudioElement | null {
+    return this.audioPlayer;
+  }
+
+  /**
+   * Sets assistant playback volume, 0 to 1.
+   *
+   * The setting is remembered, so it can be applied before the assistant's
+   * audio track has arrived and it survives across calls and mid-call track
+   * replacement. Callers do not have to race the start of the call.
+   *
+   * Values outside 0 to 1 are clamped and non-finite values are ignored, since
+   * the DOM rejects both rather than saturating.
+   *
+   * Only volume set through this method is remembered. Writing `volume`
+   * directly on the element from getAudioPlayer() or the `audio` event applies
+   * to that element alone, and is overwritten the next time one is attached.
+   *
+   * This is playback only. It does not change what the assistant hears, and it
+   * does not affect the levels reported by the `volume-level` event.
+   */
+  public setVolume(volume: number) {
+    if (!Number.isFinite(volume)) {
+      return;
+    }
+    this.desiredVolume = Math.min(1, Math.max(0, volume));
+    if (this.audioPlayer) {
+      this.audioPlayer.volume = this.desiredVolume;
+    }
+  }
+
   public setMuted(mute: boolean) {
     safeSetLocalAudio(this.call, !mute);
   }
@@ -1312,24 +1493,7 @@ export default class Vapi extends VapiEventEmitter {
         if (event) this.emit('recording-upload-completed', event);
       });
 
-      this.call.on('track-started', async (e) => {
-        if (!e || !e.participant) {
-          return;
-        }
-        if (e.participant?.local) {
-          return;
-        }
-        if (e.participant?.user_name !== 'Vapi Speaker') {
-          return;
-        }
-        if (e.track.kind === 'video') {
-          this.emit('video', e.track);
-        }
-        if (e.track.kind === 'audio') {
-          await buildAudioPlayer(e.track, e.participant.session_id);
-        }
-        this.call?.sendAppMessage('playable');
-      });
+      this.call.on('track-started', (e) => this.handleTrackStarted(e));
 
       this.call.on('participant-joined', (e) => {
         if (!e || !this.call) return;
@@ -1352,7 +1516,7 @@ export default class Vapi extends VapiEventEmitter {
         if (!e) {
           return;
         }
-        destroyAudioPlayer(e.participant.session_id);
+        this.detachAudioPlayer(e.participant.session_id);
       });
 
       this.call.on('remote-participants-audio-level', (e) => {