Node.js SDK

npm install @murmr/sdk

import { MurmrClient } from '@murmr/sdk';

const client = new MurmrClient({
  apiKey: process.env.MURMR_API_KEY!,
  // baseUrl: 'https://api.murmr.dev', // default
  // timeout: 300_000,                 // 5 min default
});

const job = await client.speech.create({
  input: "Hello, world!",
  voice: "voice_abc123",            // Saved voice ID
  language: "English",              // optional, default: "English"
});

// job = { id: "job_xyz", status: "queued", created_at: "..." }

// Poll for completion
const result = await client.jobs.waitForCompletion(job.id);
writeFileSync("output.wav", Buffer.from(result.audio_base64!, "base64"));

const job = await client.speech.create({
  input: "A long piece of text...",
  voice: "voice_abc123",
  webhook_url: "https://your-app.com/webhooks/murmr",
});

// job = { id: "job_xyz", status: "queued", created_at: "..." }
// Audio will be POSTed to your webhook when ready

const result = await client.speech.createAndWait({
  input: "Hello, world!",
  voice: "voice_abc123",
  language: "English",
  response_format: "wav",
  onPoll: (status) => console.log(status.status),
});

writeFileSync("output.wav", Buffer.from(result.audio_base64!, "base64"));

const stream = await client.speech.stream({
  input: "Real-time audio streaming.",
  voice: "voice_abc123",
});

for await (const chunk of stream) {
  const audioData = chunk.audio || chunk.chunk;
  if (audioData) {
    const pcm = Buffer.from(audioData, "base64");
    // Process PCM: pipe to speaker, ffmpeg, etc.
  }
  if (chunk.done) break;
}

const result = await client.speech.createLongForm({
  input: longArticleText,          // No length limit
  voice: "voice_abc123",
  language: "English",
  chunkSize: 3500,                 // chars per chunk (default: 3500, max: 4096)
  silenceBetweenChunksMs: 400,     // silence gap (default: 400ms)
  maxRetries: 3,                   // retries per chunk (default: 3)
  onProgress: ({ current, total, percent }) => {
    console.log(`Chunk ${current}/${total} (${percent}%)`);
  },
});

writeFileSync("article.wav", Buffer.from(result.audio));
console.log(`${result.totalChunks} chunks, ${result.durationMs}ms total`);

interface LongFormResult {
  audio: Buffer;          // WAV audio with silence gaps
  totalChunks: number;    // Number of chunks processed
  durationMs: number;     // Total audio duration
  characterCount: number; // Total characters processed
}

import { MurmrChunkError } from '@murmr/sdk';

try {
  const result = await client.speech.createLongForm({ input, voice });
} catch (err) {
  if (err instanceof MurmrChunkError) {
    console.log(`Failed at chunk ${err.chunkIndex}/${err.totalChunks}`);
    console.log(`${err.completedChunks} chunks completed`);

    // Retry from the failed chunk
    const result = await client.speech.createLongForm({
      input,
      voice,
      startFromChunk: err.chunkIndex,
    });
  }
}

const audio = await client.voices.design({
  input: "Welcome to the show.",
  voice_description: "A deep, gravelly male voice, slow and deliberate",
  language: "English",
});

const stream = await client.voices.designStream({
  input: "Streaming with a designed voice.",
  voice_description: "A deep, authoritative male news anchor",
  language: "English",
});

for await (const chunk of stream) {
  const audioData = chunk.audio || chunk.chunk;
  if (audioData) {
    const pcm = Buffer.from(audioData, "base64");
  }
  if (chunk.done) break;
}

const { voices, saved_count, saved_limit } = await client.voices.list();
for (const voice of voices) {
  console.log(`${voice.name} (${voice.id})`);
}

// Save a VoiceDesign output for reuse
const wav = await client.voices.design({
  input: "Sample text",
  voice_description: "A warm narrator",
});

const saved = await client.voices.save({
  name: "My Narrator",
  audio: wav,
  description: "A warm narrator",
});
console.log(saved.id);  // voice_abc123def456

await client.voices.delete("voice_abc123def456");

const { prompt_data, prompt_size_bytes } = await client.voices.extractEmbeddings({
  audio: wavBuffer,
  ref_text: "Transcript of the reference audio.",
});

// Use the embedding in a TTS request
const stream = await client.speech.stream({
  input: "Hello from a portable voice!",
  voice: "inline",
  voice_clone_prompt: prompt_data,
});

const status = await client.jobs.get("job_xyz");
// status = { id, status: "queued"|"processing"|"completed"|"failed", ... }

const result = await client.jobs.waitForCompletion("job_xyz", {
  pollIntervalMs: 3000,    // default: 3s (min: 1s)
  timeoutMs: 900_000,      // default: 15 min
  onPoll: (status) => {
    console.log(`Job status: ${status.status}`);
  },
});

import { MurmrError, MurmrChunkError } from '@murmr/sdk';

try {
  const audio = await client.speech.create({ input, voice });
} catch (err) {
  if (err instanceof MurmrError) {
    console.error(err.message);    // "Usage limit exceeded..."
    console.error(err.status);     // 429
    console.error(err.code);       // "JOB_FAILED", "TIMEOUT", etc.
  }
}

import { splitIntoChunks } from '@murmr/sdk';

const chunks = splitIntoChunks(longText, 3500);
// Splits at .!? and CJK equivalents
// Falls back to clause boundaries, then word boundaries

import { concatenateAudio } from '@murmr/sdk';

const combined = concatenateAudio(audioBuffers, 'wav', 400);
// WAV: strips headers, concatenates PCM, adds silence, writes new header
// PCM: concatenates raw data with silence
// MP3/Opus/AAC/FLAC: binary concatenation (no silence)

import type {
  MurmrClientOptions,
  AudioFormat,          // 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm'
  SpeechCreateOptions,
  SpeechStreamOptions,
  CreateAndWaitOptions,
  VoiceDesignOptions,
  VoiceDesignStreamOptions,
  AsyncJobResponse,
  JobStatus,
  LongFormOptions,
  LongFormProgress,
  LongFormResult,
  WebhookPayload,
} from '@murmr/sdk';