AssemblyAI JavaScript SDK

https://github.com/assemblyai/assemblyai-node-sdk
Admin
AssemblyAI JavaScript SDK provides an easy-to-use interface for interacting with the AssemblyAI API,...
Tokens:34,122
Snippets:409
Trust Score:9.8
License:MIT
Update:1 month ago
Show doc for...
Tokens:
Raw
### Install and run the project

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-dual-channel-mic-system/README.md

Commands to install dependencies and start the development server.

```bash
npm install
npm run dev
```

--------------------------------

### Install Dependencies with npm

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-stt-from-mic/README.md

Run this command to install the necessary Node.js dependencies for the project.

```bash
npm install
```

--------------------------------

### Install AssemblyAI SDK

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Commands to install the AssemblyAI SDK using various package managers.

```bash
npm install assemblyai
```

```bash
yarn add assemblyai
```

```bash
pnpm add assemblyai
```

```bash
bun add assemblyai
```

--------------------------------

### Install AssemblyAI SDK

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/00-START-HERE.md

Use npm to install the package in your Node.js project.

```bash
npm install assemblyai
```

--------------------------------

### Run the Transcription Sample

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-stt-from-mic/README.md

Execute this command to start the real-time audio transcription sample application.

```bash
npm run start
```

--------------------------------

### Install AssemblyAI Skill for Claude Code

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Command to install the AssemblyAI skill for deep SDK context in Claude Code.

```bash
claude install-skill https://github.com/AssemblyAI/assemblyai-skill
```

--------------------------------

### Perform basic and configured transcription

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/sync-transcription.md

Examples of transcribing a local file with default settings or custom configuration options.

```typescript
// Transcribe a local file
const result = await client.sync.transcribe("./call.wav");
console.log(result.text);
console.log(result.confidence); // 0-1 score

// With optional configuration
const result = await client.sync.transcribe("./call.wav", {
  prompt: "Transcribe verbatim. Preserve disfluencies.",
  timestamps: true,
});
```

--------------------------------

### Handle Transcriber Events

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Example implementation of event listeners for session management and transcript processing.

```typescript
transcriber.on("open", (data) => console.log("Session:", data.session_id));
transcriber.on("transcript", (transcript) => {
  if (transcript.message_type === "FinalTranscript") {
    console.log("Final:", transcript.text);
  } else {
    console.log("Partial:", transcript.text);
  }
});
transcriber.on("session_information", (info) => {
  console.log("Duration:", info.session_duration);
});
```

--------------------------------

### Initialize AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Import the SDK and initialize the client with an API key.

```javascript
import { AssemblyAI } from "assemblyai";

const baseUrl = "https://api.assemblyai.com";

const client = new AssemblyAI({
  apiKey: "YOUR_API_KEY",
  baseUrl: baseUrl,
});
```

--------------------------------

### get(id)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/transcripts.md

Retrieves a transcript by its ID.

```APIDOC
## get(id)

### Description
Retrieve a transcript by its ID, regardless of status.

### Parameters
- **id** (string) - Required - The transcript ID

### Returns
- **Transcript** (Object) - A transcript object reflecting current status.
```

--------------------------------

### constructor(params: BaseServiceParams)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/client.md

Initializes a new AssemblyAI client instance with required API credentials and optional configuration for base URLs and user agent settings.

```APIDOC
## constructor(params: BaseServiceParams)

### Description
Initializes a new AssemblyAI client with API credentials and configuration.

### Parameters
- **apiKey** (string) - Required - Your AssemblyAI API key for authentication
- **baseUrl** (string) - Optional - The base URL for the API endpoints (Default: https://api.assemblyai.com)
- **streamingBaseUrl** (string) - Optional - The WebSocket base URL for streaming transcription (Default: https://streaming.assemblyai.com)
- **syncBaseUrl** (string) - Optional - The base URL for synchronous transcription (Default: https://sync.assemblyai.com)
- **userAgent** (UserAgent | boolean) - Optional - Custom user agent or false to disable (Default: true)

### Usage Example
```typescript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});
```
```

--------------------------------

### View Project File Structure

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/00-START-HERE.md

Overview of the documentation directory layout.

```text
output/
├── 00-START-HERE.md               ← You are here
├── INDEX.md                       ← Documentation index
├── README.md                      ← Overview & features
├── MANIFEST.txt                   ← What's included
│
├── client.md                      ← Main client
├── transcripts.md                 ← Async transcription
├── sync-transcription.md          ← Single-request API
├── streaming-transcription.md     ← Real-time streaming
├── realtime-transcription.md      ← Legacy API
├── files.md                       ← File uploads
│
├── types.md                       ← Type definitions
├── errors.md                      ← Error handling
├── configuration.md               ← Parameters & setup
├── utilities.md                   ← Helper functions
└── quick-reference.md             ← Common patterns
```

--------------------------------

### Get word timestamps

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Enables per-word timing information by setting the timestamps flag to true.

```typescript
const result = await client.sync.transcribe("./call.wav", {
  timestamps: true,
});
for (const word of result.words) {
  console.log(word.text, word.start, word.end); // milliseconds
}
```

--------------------------------

### redactedAudio(id: string)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/transcripts.md

Get the redacted audio URL for a transcript with PII redaction enabled.

```APIDOC
## redactedAudio(id: string)

### Description
Get the redacted audio URL for a transcript with PII redaction enabled.

### Parameters
#### Path Parameters
- **id** (string) - Required - The transcript ID

### Returns
- **RedactedAudioResponse** - Contains URL and status.
```

--------------------------------

### Basic Client Initialization

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/client.md

Standard initialization using an API key from environment variables.

```typescript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});
```

--------------------------------

### Initialize and Configure Real-time Transcriber

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Sets up the AssemblyAI client and configures the transcriber with sample rate and word boost options. Requires an API key from environment variables.

```typescript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});

const transcriber = client.realtime.transcriber({
  sampleRate: 16000,
  wordBoost: ["technical", "term"],
  disablePartialTranscripts: false,
});

transcriber.on("open", (data) => {
  console.log("Real-time session started:", data.session_id);
});

transcriber.on("transcript.partial", (transcript) => {
  process.stdout.write(`\rPartial: ${transcript.text}`);
});

transcriber.on("transcript.final", (transcript) => {
  console.log(`\nFinal: ${transcript.text} (confidence: ${transcript.confidence})`);
});

transcriber.on("session_information", (info) => {
  console.log(`Session ended. Duration: ${info.session_duration}ms`);
});

transcriber.on("error", (error) => {
  console.error("Real-time error:", error.message);
});

transcriber.on("close", (code, reason) => {
  console.log(`Connection closed (${code}): ${reason}`);
});

await transcriber.connect();

// Simulate sending audio (e.g., from microphone)
const audioSource = getAudioSource(); // Your audio source
audioSource.pipe(transcriber.stream());

// Optional: force end utterance after delay
setTimeout(() => {
  transcriber.forceEndUtterance();
}, 5000);

// Close when done
await transcriber.close();
```

--------------------------------

### connect()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Establishes the connection to the streaming API and completes the handshake process.

```APIDOC
## connect()

### Description
Establishes a connection to the streaming API and completes the handshake. Returns a promise that resolves to a `BeginEvent` containing the session ID.

### Returns
- **Promise<BeginEvent>** - Session ID and configuration echo.
```

--------------------------------

### Handling SyncTranscriptError

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/errors.md

Example of catching and handling SyncTranscriptError, including checking for retryable status codes.

```typescript
import { SyncTranscriptError } from "assemblyai";

try {
  const result = await client.sync.transcribe("./audio.wav");
} catch (error) {
  if (error instanceof SyncTranscriptError) {
    console.error(`HTTP ${error.status}: ${error.errorCode}`);
    if (error.status === 429 || error.status === 503) {
      // Implement exponential backoff
      console.log(`Retry after ${error.retryAfter} seconds`);
    }
  } else {
    console.error("Unexpected error:", error);
  }
}
```

--------------------------------

### Access word-level timestamps

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/sync-transcription.md

Iterating through the returned words to access start and end times when timestamps are enabled.

```typescript
const result = await client.sync.transcribe("./call.wav", {
  timestamps: true,
});
for (const word of result.words) {
  console.log(`${word.text}: ${word.start}ms - ${word.end}ms (confidence: ${word.confidence})`);
}
```

--------------------------------

### Initialize AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Use this configuration object to instantiate the AssemblyAI client with your API key and optional base URL overrides.

```typescript
new AssemblyAI({
  apiKey: string;              // Required
  baseUrl?: string;            // Default: https://api.assemblyai.com
  streamingBaseUrl?: string;   // Default: wss://streaming.assemblyai.com
  syncBaseUrl?: string;        // Default: https://sync.assemblyai.com
  userAgent?: UserAgent | boolean; // Default: true
})
```

--------------------------------

### Initialize AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/configuration.md

Demonstrates various ways to initialize the AssemblyAI client, including custom endpoints, disabling user agents, and providing custom user agent information.

```typescript
import { AssemblyAI } from "assemblyai";

// Minimal setup
const client = new AssemblyAI({
  apiKey: "your-api-key",
});

// With custom endpoints
const client = new AssemblyAI({
  apiKey: "your-api-key",
  baseUrl: "https://api.custom.assemblyai.com",
  streamingBaseUrl: "wss://streaming.custom.assemblyai.com",
  syncBaseUrl: "https://sync.custom.assemblyai.com",
});

// Disable user agent
const client = new AssemblyAI({
  apiKey: "your-api-key",
  userAgent: false,
});

// Custom user agent
const client = new AssemblyAI({
  apiKey: "your-api-key",
  userAgent: {
    "my-app": { name: "my-app", version: "1.0.0" },
    "custom-lib": { name: "custom-lib", version: "2.1.0" },
  },
});
```

--------------------------------

### Get redacted audio URL in TypeScript

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/transcripts.md

Retrieves the URL for redacted audio if PII redaction was enabled during transcription.

```typescript
redactedAudio(id: string): Promise<RedactedAudioResponse>
```

```typescript
const result = await client.transcripts.redactedAudio("transcript-id");
console.log(result.redacted_audio_url); // Download or stream
console.log(result.status); // "redacted_audio_ready"
```

--------------------------------

### Initialize Client with Environment Variable

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/configuration.md

Initialize the AssemblyAI client using an API key retrieved from process environment variables.

```typescript
// If ASSEMBLYAI_API_KEY is set
const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY!,
});
```

--------------------------------

### Load AssemblyAI via CDN

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

HTML script tags to load the AssemblyAI SDK from UNPKG.

```html
<!-- Unminified full SDK -->
<script src="https://www.unpkg.com/assemblyai@:version/dist/assemblyai.umd.js"></script>
<!-- Minified full SDK -->
<script src="https://www.unpkg.com/assemblyai@:version/dist/assemblyai.umd.min.js"></script>
<!-- Unminified Streaming STT only -->
<script src="https://www.unpkg.com/assemblyai@:version/dist/assemblyai.streaming.umd.js"></script>
<!-- Minified Streaming STT only -->
<script src="https://www.unpkg.com/assemblyai@:version/dist/assemblyai.streaming.umd.min.js"></script>
```

--------------------------------

### Initialize AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/client.md

Constructor signature for the AssemblyAI client.

```typescript
constructor(params: BaseServiceParams)
```

--------------------------------

### client.files.upload

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Uploads a local audio file to AssemblyAI.

```APIDOC
## client.files.upload(filePath)

### Description
Uploads a file from the local filesystem and returns the remote URL.

### Parameters
- **filePath** (string) - Required - The path to the local audio file.
```

--------------------------------

### Connect to Streaming Server

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Establish the connection to the AssemblyAI streaming server after configuring event listeners.

```typescript
await transcriber.connect();
```

--------------------------------

### Transcribe Audio with AssemblyAI

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Initialize the client and perform a transcription with speaker labels enabled.

```typescript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});

const transcript = await client.transcripts.transcribe({
  audio: "https://example.com/audio.mp3",
  speech_models: ["universal-3-5-pro", "universal-2"],
  speaker_labels: true,
});

console.log(transcript.text);
for (const utterance of transcript.utterances) {
  console.log(`Speaker ${utterance.speaker}: ${utterance.text}`);
}
```

--------------------------------

### Initialize with Custom Endpoints

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/client.md

Configure the client to use custom base URLs for API and streaming services.

```typescript
const client = new AssemblyAI({
  apiKey: "your-api-key",
  baseUrl: "https://api.custom.assemblyai.com",
  streamingBaseUrl: "wss://streaming.custom.assemblyai.com",
});
```

--------------------------------

### Authenticate AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Initialize the client using an API key from environment variables.

```typescript
const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});
```

--------------------------------

### AssemblyAI Client Initialization

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/configuration.md

Initializes the AssemblyAI client with authentication and optional custom service endpoints or user agent settings.

```APIDOC
## AssemblyAI Client Initialization

### Description
Initializes the main AssemblyAI client used to interact with transcription services.

### Parameters
- **apiKey** (string) - Required - API key for authentication
- **baseUrl** (string) - Optional - Base URL for the API (default: https://api.assemblyai.com)
- **streamingBaseUrl** (string) - Optional - Base URL for streaming (default: https://streaming.assemblyai.com)
- **syncBaseUrl** (string) - Optional - Base URL for sync (default: https://sync.assemblyai.com)
- **userAgent** (UserAgent | boolean) - Optional - User agent configuration (default: true)
```

--------------------------------

### Configure AssemblyAI MCP Server

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Command to add the AssemblyAI documentation MCP server for on-demand lookups.

```bash
claude mcp add assemblyai-docs --transport http https://mcp.assemblyai.com/docs
```

--------------------------------

### Mint a Temporary Token

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-dual-channel-mic-system/index.html

Use this curl command to mint a 60-second temporary token for streaming. Replace `<YOUR_API_KEY>` with your actual AssemblyAI API key.

```bash
curl -G https://streaming.assemblyai.com/v3/token \
  -H "Authorization: <YOUR_API_KEY>" \
  -d expires_in_seconds=60
```

--------------------------------

### Import Main SDK Modules

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Use these imports for general SDK functionality, including the main client and streaming utilities.

```typescript
import { AssemblyAI } from "assemblyai";
import {
  StreamingTranscriber,
  float32ToPcm16,
  DualChannelCapture,
} from "assemblyai";
```

--------------------------------

### Configure Real-Time Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/00-START-HERE.md

Establish a WebSocket connection for real-time audio transcription.

```typescript
const transcriber = client.streaming.transcriber({
  token: temporaryToken,
  sampleRate: 16000,
});

transcriber.on("turn", (turn) => {
  console.log(turn.text);
});

await transcriber.connect();
```

--------------------------------

### Configure custom User Agent

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/types.md

Define the structure for custom user agent components and demonstrate how to pass them to the AssemblyAI client.

```typescript
type UserAgent = {
  [component: string]: UserAgentItem | undefined | null | false;
};

type UserAgentItem = {
  name: string;
  version: string;
};
```

```typescript
const client = new AssemblyAI({
  apiKey: "...",
  userAgent: {
    myApp: { name: "my-app", version: "1.0.0" },
    customLib: { name: "custom", version: "2.1.0" },
  },
});
```

--------------------------------

### constructor(params: StreamingTranscriberParams)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Initializes a new instance of the StreamingTranscriber with the specified configuration, including authentication, audio settings, and transcription features.

```APIDOC
## constructor(params: StreamingTranscriberParams)

### Description
Creates a new streaming transcriber instance. Requires either an `apiKey` or a temporary `token` for authentication.

### Parameters
- **token** (string) - Conditional - Temporary auth token.
- **apiKey** (string) - Conditional - API key (server-side only).
- **speechModel** (StreamingSpeechModel) - Optional - Speech model (default: "universal-3-5-pro").
- **sampleRate** (number) - Required - Audio sample rate in Hz (8000-48000).
- **encoding** (AudioEncoding) - Optional - Audio encoding (default: "pcm_s16le").
- **speakerLabels** (boolean) - Optional - Enable speaker diarization.
- **maxSpeakers** (number) - Optional - Maximum speakers to detect.
- **languageCodes** (string[]) - Optional - ISO 639-1 language codes.
- **languageDetection** (boolean) - Optional - Auto-detect language.
- **prompt** (string) - Optional - Custom transcription instruction.
- **keytermsPrompt** (string[]) - Optional - Terms to bias toward.
- **filterProfanity** (boolean) - Optional - Redact profanity.
- **redactPii** (boolean) - Optional - Redact PII.
- **redactPiiPolicies** (StreamingPiiPolicy[]) - Optional - PII redaction policies.
- **voiceFocus** (VoiceFocusModel) - Optional - "near-field" or "far-field".
- **minTurnSilence** (number) - Optional - Silence threshold in ms to end turn.
- **maxTurnSilence** (number) - Optional - Maximum silence before timeout.
- **endOfTurnConfidenceThreshold** (number) - Optional - Confidence needed to end turn early.
- **interruptionDelay** (number) - Optional - Delay before interruption detection in ms.
- **formatTurns** (boolean) - Optional - Auto-format turn text.
- **channels** (Array<{ name: string }>) - Optional - Enable dual-channel mode.
- **channelAttribution** (ChannelAttributionParams) - Optional - Tuning for channel attribution.
- **connectTimeout** (number) - Optional - Handshake timeout in ms (default: 1000).
- **maxConnectionRetries** (number) - Optional - Retry attempts (default: 2).
- **connectionRetryDelay** (number) - Optional - Wait time between retries in ms (default: 500).
```

--------------------------------

### Configure AssemblyAI API Key

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-stt-from-mic/README.md

Set your AssemblyAI API key as an environment variable or in a .env file. Replace '[YOUR_ASSEMBLYAI_API_KEY]' with your actual API key.

```plaintext
ASSEMBLYAI_API_KEY=[YOUR_ASSEMBLYAI_API_KEY]
```

--------------------------------

### Implement Browser-Based Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Demonstrates streaming audio from the browser microphone using a server-provided token and Web Audio API.

```typescript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: "server-key", // Not used; token only
});

// Server provides token
const token = await getTokenFromServer();

const transcriber = client.streaming.transcriber({
  token,
  sampleRate: 16000,
  speakerLabels: true,
});

transcriber.on("turn", (turn) => {
  document.getElementById("transcript").textContent += ` ${turn.text}`;
});

transcriber.on("error", (error) => {
  console.error("Streaming error:", error);
});

// Get microphone audio
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
const context = new AudioContext({ sampleRate: 16000 });
const source = context.createMediaStreamSource(stream);
const processor = context.createScriptProcessor(4096, 1, 1);

processor.onaudioprocess = (event) => {
  const pcm16 = float32ToPcm16(event.inputBuffer.getChannelData(0));
  transcriber.sendAudio(pcm16);
};

source.connect(processor);
processor.connect(context.destination);

await transcriber.connect();
```

--------------------------------

### RealtimeTranscriber.connect()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Establishes a WebSocket connection to the real-time API.

```APIDOC
## RealtimeTranscriber.connect()

### Description
Establishes a connection to the real-time API.

### Returns
- **Promise<SessionBeginsEventData>** - A promise that resolves with session ID and configuration.
```

--------------------------------

### Configure Base URLs for AssemblyAI Client

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/configuration.md

Sets custom base URLs for the Async, Streaming, and Sync APIs during client initialization.

```typescript
const client = new AssemblyAI({
  apiKey: "key",
  baseUrl: "https://api.assemblyai.com",           // Async API
  streamingBaseUrl: "wss://streaming.assemblyai.com", // Streaming WebSocket
  syncBaseUrl: "https://sync.assemblyai.com",      // Sync API
});
```

--------------------------------

### warm()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/sync-transcription.md

Pre-establishes a connection to the sync API to reduce latency for subsequent transcription requests.

```APIDOC
## warm(params?: { model?: string })

### Description
Pre-establish the connection to the sync API. Calling `warm()` ahead of time allows the SDK to reuse a pooled connection for the next `transcribe()` call, avoiding DNS, TCP, and TLS handshake overhead on the critical path.

### Parameters
- **params** (object) - Optional - Configuration object.
- **params.model** (string) - Optional - Model to route the probe to (default: "universal-3-5-pro").

### Returns
- **Promise<boolean>** - Returns `true` if the connection was successfully opened, `false` otherwise.
```

--------------------------------

### Upload Local File Path

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/files.md

Upload a local file using its path in Node.js, Bun, or Deno environments.

```typescript
// Node.js, Bun, or Deno
const url = await client.files.upload("./audio.mp3");
console.log(url); // https://cdn.assemblyai.com/upload/...

// Then use in transcription
const transcript = await client.transcripts.transcribe({ audio_url: url });
```

--------------------------------

### Configure API Key via Environment Variable

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Set the ASSEMBLYAI_API_KEY environment variable as an alternative to passing the key directly to the SDK constructor.

```bash
# Optional; used if apiKey not provided in constructor
ASSEMBLYAI_API_KEY=your-key
```

--------------------------------

### client.streaming.transcriber

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Initializes a real-time transcriber instance for audio streaming.

```APIDOC
## client.streaming.transcriber(options)

### Description
Creates a transcriber instance to handle real-time audio streaming and event listening.

### Parameters
- **token** (string) - Required - The temporary authentication token.
- **sampleRate** (number) - Required - The sample rate of the audio stream.
- **speakerLabels** (boolean) - Optional - Enable speaker identification.
- **channels** (array) - Optional - Configuration for multi-channel audio streams.
```

--------------------------------

### Set API Key via Environment Variable

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/configuration.md

Configure the API key using a shell environment variable.

```bash
export ASSEMBLYAI_API_KEY="your-api-key"
```

--------------------------------

### Connect to Streaming API

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Establishes a connection to the streaming API and returns the session configuration.

```typescript
async connect(): Promise<BeginEvent>
```

```typescript
const begin = await transcriber.connect();
console.log(begin.id); // Session ID
```

--------------------------------

### Dual-channel streaming in browsers

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Use DualChannelCapture to stream mic and system audio simultaneously in a browser environment.

```typescript
import { AssemblyAI, DualChannelCapture } from "assemblyai";

const micStream = await navigator.mediaDevices.getUserMedia({
  audio: { echoCancellation: true, noiseSuppression: true },
});
const systemStream = await navigator.mediaDevices.getDisplayMedia({
  audio: true,
});

const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16_000,
  speakerLabels: true,
  channels: [{ name: "mic" }, { name: "system" }],
});

transcriber.on("turn", (turn) => {
  // turn.words[i].channel: "mic" | "system" | "unknown"  (physical channel)
  // turn.channel: duration-weighted rollup
  // turn.speaker_label: AAI diarization, passed through unchanged
});

const capture = new DualChannelCapture({
  micStream,
  systemStream,
  transcriber,
});

await transcriber.connect();
await capture.start();
```

--------------------------------

### Configure Streaming Connection

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Set connection timeouts and retry logic for streaming audio sessions.

```typescript
{
  connectTimeout: 1000,        // handshake timeout (ms)
  maxConnectionRetries: 2,     // retries on transient errors
  connectionRetryDelay: 500,   // wait between retries (ms)
}
```

--------------------------------

### Connect to Real-Time API

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Establishes the WebSocket connection to the transcription service.

```typescript
connect(): Promise<SessionBeginsEventData>
```

```typescript
const data = await transcriber.connect();
console.log("Session ID:", data.session_id);
```

--------------------------------

### Configure Dual-Channel Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Define multiple audio channels during transcriber initialization to process distinct audio sources simultaneously.

```typescript
const transcriber = client.streaming.transcriber({
  token,
  sampleRate: 16000,
  channels: [{ name: "mic" }, { name: "system" }],
});

transcriber.on("turn", (turn) => {
  console.log(`${turn.channel}: ${turn.text}`);
  for (const word of turn.words) {
    console.log(`  ${word.text}: ${word.channel}`);
  }
});

await transcriber.connect();
transcriber.sendAudio(micPcm, { channel: "mic" });
transcriber.sendAudio(systemPcm, { channel: "system" });
```

--------------------------------

### Import SDK Modules and Types

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Standard import patterns for the AssemblyAI SDK, including core classes, streaming utilities, and TypeScript type definitions.

```typescript
import { AssemblyAI } from "assemblyai";
import {
  StreamingTranscriber,
  float32ToPcm16,
  DualChannelCapture,
  EnergyVad,
  LinearResampler,
} from "assemblyai";

import type {
  Transcript,
  TurnEvent,
  SyncTranscriptResponse,
} from "assemblyai";

import { SyncTranscriptError, StreamingError } from "assemblyai";
```

--------------------------------

### FileService.upload()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/files.md

Uploads a local file, stream, or binary data to AssemblyAI for transcription processing.

```APIDOC
## FileService.upload(input)

### Description
Uploads a local file to AssemblyAI for transcription processing. The method accepts various input types including file paths, streams, and binary data.

### Parameters
- **input** (FileUploadParams) - Required - File source: path, stream, or binary data. Supported types include string (path/data URL), NodeJS.ReadableStream, ReadableStream, Blob, BufferSource, ArrayBufferView, ArrayBufferLike, or Uint8Array.

### Returns
- **string** - A URL pointing to the uploaded file on AssemblyAI's servers.

### Usage Example
```typescript
// Local File Path
const url = await client.files.upload("./audio.mp3");
console.log(url); // https://cdn.assemblyai.com/upload/...
```
```

--------------------------------

### Dual-channel streaming in non-browser runtimes

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Manually push tagged PCM data for dual-channel streaming in Node.js or other non-browser environments.

```typescript
const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16_000,
  channels: [{ name: "mic" }, { name: "system" }],
});

await transcriber.connect();
transcriber.sendAudio(micPcm, { channel: "mic" });
transcriber.sendAudio(systemPcm, { channel: "system" });
```

--------------------------------

### Initialize StreamingTranscriber in the browser

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/docs/compat.md

Use a temporary token to initialize the StreamingTranscriber instance in a browser environment.

```js
import { StreamingTranscriber } from "assemblyai";
// or the following if you're using UMD
// const { StreamingTranscriber } = assemblyai;

const token = getToken(); // getToken is a function for you to implement

const rt = new StreamingTranscriber({
  token: token,
});
```

--------------------------------

### Initialize RealtimeTranscriber

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Constructor for the RealtimeTranscriber class. Requires either an apiKey or a temporary token.

```typescript
constructor(params: CreateRealtimeTranscriberParams)
```

--------------------------------

### Initialize StreamingTranscriber via CDN

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Create a StreamingTranscriber object using the global assemblyai variable provided by the CDN script.

```javascript
const { StreamingTranscriber } = assemblyai;
const transcriber = new StreamingTranscriber({
  token: "[GENERATE TEMPORARY AUTH TOKEN IN YOUR API]",
  ...
});
```

--------------------------------

### Implement Browser-Side Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Securely generate a temporary token on the server and initialize the StreamingTranscriber on the client.

```typescript
// Server endpoint
app.get("/token", async (req, res) => {
  const token = await client.streaming.createTemporaryToken({
    expires_in_seconds: 60,
  });
  res.json({ token });
});

// Client code
const response = await fetch("/token");
const { token } = await response.json();

const transcriber = new StreamingTranscriber({ token, sampleRate: 16000 });
```

--------------------------------

### DualChannelCapture

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/utilities.md

A browser utility class for capturing microphone and system audio streams simultaneously for dual-channel transcription.

```APIDOC
## DualChannelCapture

### Description
Utility for capturing dual-channel audio (microphone + system audio) and feeding it to the streaming transcriber.

### Constructor
- **options** (Object) - Required
  - **micStream** (MediaStream) - Microphone audio stream.
  - **systemStream** (MediaStream) - System/screen audio stream.
  - **transcriber** (StreamingTranscriber) - The active transcriber instance.

### Methods
- **start()** (Promise<void>) - Starts the audio capture process.
```

--------------------------------

### Initialize Streaming Transcriber

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Creates a new instance of the streaming transcriber with specific speech model and audio configuration.

```typescript
const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16000,
  speakerLabels: true,
});
```

--------------------------------

### Configure Dual-Channel Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/streaming-transcription.md

Enables multi-source audio processing by defining channel names and attribution settings in the transcriber configuration.

```typescript
const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16000,
  speakerLabels: true,
  channels: [
    { name: "mic" },
    { name: "system" },
  ],
  channelAttribution: {
    dominanceRatio: 4, // Energy threshold for dominance
    resolveUnknownChannelsMethod: "window", // "window", "speaker-history", or "none"
  },
});

transcriber.on("turn", (turn) => {
  console.log(`${turn.channel || "unknown"}: ${turn.text}`);
  for (const word of turn.words) {
    console.log(`  ${word.text}: ${word.channel}`);
  }
});
```

--------------------------------

### TranscriptParams

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/types.md

Configuration parameters for creating a transcript via the async API.

```APIDOC
## TranscriptParams

### Description
Parameters for creating a transcript via the async API (lowest-level).

### Parameters
- **audio_url** (string) - Required - URL of the audio file to transcribe
- **speech_models** (string[]) - Optional - Speech models to use (with fallback order)
- **language_detection** (boolean) - Optional - Auto-detect language
- **language_code** (string) - Optional - Specific language (ISO 639-1 code)
- **speech_model** (string) - Optional - Single speech model (deprecated; use `speech_models`)
- **speaker_labels** (boolean) - Optional - Enable speaker diarization
- **speakers_expected** (number) - Optional - Expected number of speakers
- **entity_detection** (boolean) - Optional - Enable named entity extraction
- **sentiment_analysis** (boolean) - Optional - Enable sentiment analysis
- **auto_chapters** (boolean) - Optional - Enable automatic chapter detection
- **content_safety** (boolean) - Optional - Enable content safety detection
- **redact_pii** (boolean) - Optional - Redact personally identifiable information
- **redact_pii_policies** (string[]) - Optional - Which PII entities to redact
- **redact_pii_sub** (string) - Optional - Substitution strategy ("hash" or "entity_name")
- **custom_spelling** (CustomSpelling[]) - Optional - Custom vocabulary
- **filter_profanity** (boolean) - Optional - Filter profanity
```

--------------------------------

### Import SDK Types

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Import these types for static type checking when working with transcripts and streaming parameters.

```typescript
import type {
  Transcript,
  TurnEvent,
  SyncTranscriptResponse,
  StreamingTranscriberParams,
} from "assemblyai";
```

--------------------------------

### Transcribe a local file

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Transcribe an audio file from a local path.

```typescript
const transcript = await client.transcripts.transcribe({
  audio: "./recording.mp3",
});
```

--------------------------------

### Pre-warm the connection

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Initializes the connection early to avoid handshake latency during the transcription request.

```typescript
await client.sync.warm(); // fire as recording starts
const audio = await recordUntilDone();
const result = await client.sync.transcribe(audio); // reuses the hot connection
```

--------------------------------

### RealtimeTranscriber.sendAudio()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Sends a chunk of PCM audio data to the transcriber.

```APIDOC
## RealtimeTranscriber.sendAudio()

### Description
Sends PCM audio chunk to the transcriber.

### Parameters
- **audio** (AudioData) - Required - PCM audio as ArrayBuffer or typed array.
```

--------------------------------

### Authentication

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Methods for authenticating with the AssemblyAI API using either a server-side API key or a client-side temporary token.

```APIDOC
## Authentication

### Server-Side API Key
```typescript
const client = new AssemblyAI({
  apiKey: process.env.ASSEMBLYAI_API_KEY,
});
```

### Client-Side Temporary Token
```typescript
// Server generates token
const token = await client.streaming.createTemporaryToken({
  expires_in_seconds: 60,
});

// Client uses token
const transcriber = new StreamingTranscriber({
  token,
  sampleRate: 16000,
});
```
```

--------------------------------

### Enable Speech Understanding models

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Configure transcription options to enable features like speaker diarization.

```javascript
import { AssemblyAI } from "assemblyai";

const client = new AssemblyAI({
  apiKey: "<YOUR_API_KEY>",
});

const audioFile = "https://assembly.ai/wildfires.mp3";

const params = {
  audio: audioFile,
  speech_models: ["universal-3-5-pro", "universal-2"],
  language_detection: true,
  speaker_labels: true,
};

const run = async () => {
  const transcript = await client.transcripts.transcribe(params);

  for (const utterance of transcript.utterances!) {
    console.log(`Speaker ${utterance.speaker}: ${utterance.text}`);
  }
};

run();
```

--------------------------------

### Create Real-Time Transcriber Instance

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/realtime-transcription.md

Initializes a new transcriber instance using the factory method.

```typescript
transcriber(params: CreateRealtimeTranscriberParams): RealtimeTranscriber
```

--------------------------------

### Warm the Sync API Connection

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/sync-transcription.md

Pre-establishes a connection to the sync API to avoid handshake latency during transcription. Call this during audio recording to ensure a pooled connection is ready.

```typescript
async warm(params?: { model?: string }): Promise<boolean>
```

```typescript
// Fire when recording starts
await client.sync.warm();

// Simulate recording
const audio = await recordAudio(); // e.g., getUserMedia() or similar

// Next transcribe() reuses the warm connection
const result = await client.sync.transcribe(audio);
```

```typescript
await client.sync.warm({ model: "universal-3-5-pro" });
```

--------------------------------

### Process File with All Features

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Perform a full transcription with advanced features like speaker labels, entity detection, and sentiment analysis enabled.

```typescript
const transcript = await client.transcripts.transcribe({
  audio: "./interview.mp3",
  speech_models: ["universal-3-5-pro"],
  speaker_labels: true,
  entity_detection: true,
  sentiment_analysis: true,
  auto_chapters: true,
  language_detection: true,
  redact_pii: true,
});

console.log(transcript.text);
for (const utterance of transcript.utterances) {
  console.log(`Speaker ${utterance.speaker}: ${utterance.text}`);
}
for (const entity of transcript.entities) {
  console.log(`${entity.entity_type}: ${entity.text}`);
}
```

--------------------------------

### Configure transcription options

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/CLAUDE.md

Customize transcription behavior using prompts, keyterms, language codes, and conversation context.

```typescript
const result = await client.sync.transcribe("./call.wav", {
  prompt: "Transcribe verbatim. Preserve disfluencies.", // max 4096 chars, rejected over
  keyterms_prompt: ["AssemblyAI", "Lemur", "U3-Pro"], // max 2048 chars total, rejected over
  language_codes: ["es"], // or e.g. ["en", "es"] for multilingual; defaults to English; ignored when prompt is set
  conversation_context: [
    // prior turns oldest-first; capped at 100 turns / 4096 chars — trimmed, not rejected
    "I'd like to book a flight to Denver.",
    "Sure, what date were you thinking?",
  ],
});
```

--------------------------------

### float32ToPcm16(float32)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/utilities.md

Converts 32-bit floating-point audio samples to 16-bit PCM integer samples, typically for Web Audio API compatibility.

```APIDOC
## float32ToPcm16(float32)

### Description
Converts 32-bit floating-point audio samples (range [-1, 1]) to 16-bit PCM integer samples (range [-32768, 32767]).

### Parameters
- **float32** (Float32Array) - Required - Audio samples to convert.

### Returns
- **Int16Array** - The converted PCM16 audio samples.
```

--------------------------------

### Pipe File Streams to Streaming

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/utilities.md

Streams a local audio file directly to the transcriber using a web stream.

```typescript
import { ReadableStream } from "stream/web";
import fs from "fs";

const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16000,
});

const fileStream = fs.createReadStream("./audio.wav");
const webStream = ReadableStream.from(fileStream);

webStream.pipeTo(transcriber.stream());
await transcriber.connect();
```

--------------------------------

### Stream Audio with Dual Channels

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Configure a streaming transcriber to handle multiple audio channels and process turns in real-time.

```typescript
const transcriber = client.streaming.transcriber({
  token,
  sampleRate: 16000,
  channels: [{ name: "mic" }, { name: "system" }],
  speakerLabels: true,
});

transcriber.on("turn", (turn) => {
  console.log(`${turn.channel}: ${turn.text}`);
  for (const word of turn.words) {
    console.log(`  ${word.text} (channel: ${word.channel})`);
  }
});

await transcriber.connect();
```

--------------------------------

### Automatic and Manual File Upload in Transcription

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/files.md

Demonstrates automatic file upload during transcription versus manual upload to retrieve a URL for reuse.

```typescript
// Automatic upload
const transcript = await client.transcripts.transcribe({
  audio: "./recording.wav", // Local file is uploaded automatically
  speaker_labels: true,
});

// If you need the URL separately
const uploadUrl = await client.files.upload("./recording.wav");
const transcript = await client.transcripts.transcribe({
  audio_url: uploadUrl, // Reuse uploaded file
  speaker_labels: true,
});
```

--------------------------------

### Implement Real-Time Streaming Transcription

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Generate a temporary token for client-side authentication and establish a connection to the streaming transcriber.

```typescript
// Server: Create temporary token
const token = await client.streaming.createTemporaryToken({
  expires_in_seconds: 60,
});
// Send token to client...

// Client: Connect and stream audio
const transcriber = client.streaming.transcriber({
  token,
  sampleRate: 16000,
  speakerLabels: true,
});

transcriber.on("turn", (turn) => {
  console.log(turn.text);
});

transcriber.on("error", (error) => {
  console.error(error);
});

await transcriber.connect();
// Send audio: transcriber.sendAudio(pcmChunk)
await transcriber.close();
```

--------------------------------

### Import SDK Error Classes

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/quick-reference.md

Use these error classes to handle specific SDK-related exceptions.

```typescript
import { SyncTranscriptError, StreamingError } from "assemblyai";
```

--------------------------------

### Implement DNN VAD for Echo Robustness

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/samples/streaming-dual-channel-mic-system/README.md

Use a Silero VAD adapter to distinguish speech from speaker playback when platform-level echo cancellation is unavailable.

```ts
import { MicVAD } from "@ricky0123/vad-web"
import type { VadDetector, VadDetectorResult } from "assemblyai"

// Adapter: wrap a Silero session as the SDK's VadDetector interface.
class SileroVad implements VadDetector {
  constructor(private readonly speechProb: () => number) {}
  process(frame: Float32Array): VadDetectorResult {
    const p = this.speechProb()
    let sumSq = 0
    for (let i = 0; i < frame.length; i++) sumSq += frame[i] * frame[i]
    const rms = Math.sqrt(sumSq / Math.max(1, frame.length))
    return { active: p > 0.5, energy: rms }
  }
  reset(): void {}
}

// One MicVAD per channel.
const micVad = await MicVAD.new({
  /* ... */
})
const systemVad = await MicVAD.new({
  /* ... */
})

const transcriber = client.streaming.transcriber({
  speechModel: "universal-3-5-pro",
  sampleRate: 16_000,
  channels: [{ name: "mic" }, { name: "system" }],
  channelAttribution: {
    createVad: (channelName) =>
      new SileroVad(
        channelName === "mic"
          ? () => micVad.lastSpeechProb()
          : () => systemVad.lastSpeechProb(),
      ),
  },
})
```

--------------------------------

### Generate and Use Temporary Token

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Generate a temporary token on the server to securely initialize a streaming transcriber on the client side.

```typescript
// Server generates token
const token = await client.streaming.createTemporaryToken({
  expires_in_seconds: 60,
});

// Client uses token (never expose API key)
const transcriber = new StreamingTranscriber({
  token,
  sampleRate: 16000,
});
```

--------------------------------

### Async Transcription for Files

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/README.md

Use for long-form content, batches, or audio files via URL. This method handles submission and polling automatically.

```typescript
const transcript = await client.transcripts.transcribe({
  audio: "https://example.com/audio.mp3",
  speech_models: ["universal-3-5-pro"],
  speaker_labels: true,
});
```

--------------------------------

### PollingOptions

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/types.md

Configuration options for polling behavior in async transcription.

```APIDOC
## PollingOptions

### Description
Options for polling in async transcription.

### Parameters
- **pollingInterval** (number) - Default: 3000 - Time in ms between status checks
- **pollingTimeout** (number) - Default: -1 - Maximum wait time in ms (-1 = infinite)
```

--------------------------------

### client.transcripts.list(url)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Lists transcripts with support for pagination.

```APIDOC
## client.transcripts.list(url)

### Description
Returns a page of transcripts. Pass a URL to retrieve subsequent pages.
```

--------------------------------

### transcribe()

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/_autodocs/sync-transcription.md

Transcribes audio and returns the finished transcript in a single request. Input can be a local file path, raw audio bytes, a Blob/File, or a readable stream.

```APIDOC
## transcribe(audio, config?, options?)

### Description
Transcribe audio and return the finished transcript in a single request. Input can be a local file path, raw audio bytes, a Blob/File, or a readable stream.

### Parameters
- **audio** (SyncAudioInput) - Required - Audio source: local path, bytes, Blob, or stream.
- **config** (SyncTranscriptionConfig) - Optional - Transcription configuration.
- **options** (SyncTranscribeOptions) - Optional - Client-side options like request timeout.

### Config Options
- **model** (SyncSpeechModel) - Default: "universal-3-5-pro" - Speech model.
- **prompt** (string) - Custom transcription instruction (max 4096 chars).
- **keyterms_prompt** (string[]) - Terms to bias the decoder (max 2048 chars total).
- **conversation_context** (string | string[]) - Prior conversation turns (capped at 100 turns / 4096 chars).
- **language_codes** (string[]) - Default: ["en"] - ISO 639-1 language codes.
- **sample_rate** (number) - Required for raw PCM; ignored for WAV.
- **channels** (number) - Required for raw PCM; ignored for WAV.
- **timestamps** (boolean) - Default: false - Compute per-word start/end times.

### Options
- **timeout** (number) - Default: 60000 - Request timeout in milliseconds.

### Returns
- **SyncTranscriptResponse** - Complete transcript data.

### Throws
- **SyncTranscriptError** - Thrown with status, errorCode, and retryAfter on 429/503 errors.
```

--------------------------------

### client.transcripts.subtitles(id, format, charsPerCaption)

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Generates subtitles for a transcript in SRT or VTT format.

```APIDOC
## client.transcripts.subtitles(id, format, charsPerCaption)

### Description
Returns subtitle content for the specified transcript ID.

### Parameters
- **format** (string) - Required - 'srt' or 'vtt'.
- **charsPerCaption** (number) - Optional - Maximum characters per caption line.
```

--------------------------------

### List and paginate transcripts

Source: https://github.com/assemblyai/assemblyai-node-sdk/blob/main/README.md

Retrieve a list of transcripts or iterate through paginated results.

```javascript
const page = await client.transcripts.list();
```

```typescript
let previousPageUrl: string | null = null;
do {
  const page = await client.transcripts.list(previousPageUrl);
  previousPageUrl = page.page_details.prev_url;
} while (previousPageUrl !== null);
```
Tokens:
Raw