Audio

The Audio endpoints turn speech into text. audio.transcriptions transcribes audio in its own language. audio.translations (deprecated) transcribes and translates into English. Both are OpenAI-compatible and take a multipart file upload.

Glexir sells speech-to-text only. Text-to-speech and realtime voice are not available.

Transcribe a file

import { readFile } from "node:fs/promises";
import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir({ apiKey: process.env.GLEXIR_API_KEY });

const transcript = await glexir.audio.transcriptions.create({
  file: await toFile(await readFile("meeting.m4a"), "meeting.m4a"),
  model: "gpt-transcribe",
});

console.log(transcript.text);

Response:

{
  "text": "Thanks everyone for joining. Let's start with the roadmap.",
  "usage": { "type": "duration", "seconds": 42 }
}

Supported models

The TranscriptionModel type lists these IDs. It also accepts any other string.

File uploads

The request is multipart/form-data. The SDK builds it for you when you pass file.

• The file must be 25 MB or smaller. Larger files return 413 with code file_too_large. Split long recordings into chunks.
• Supported formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav and webm.
• The format is detected from the filename, so the upload needs a name with the right extension.

file is an Uploadable: File | Blob | Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | Response. Pass a File, or wrap other data with toFile(data, "name.ext"). If you pass a Blob or bytes without a name, the SDK names the part file.bin and the format can't be detected.

import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir();

// From a URL
const audio = await fetch("https://example.com/call.mp3");
const fromUrl = await glexir.audio.transcriptions.create({
  file: await toFile(audio, "call.mp3"),
  model: "gpt-transcribe",
});

// From a browser <input type="file">: a File already has a name
declare const picked: File;
const fromInput = await glexir.audio.transcriptions.create({ file: picked, model: "gpt-transcribe" });

toFile()

import type { Uploadable } from "@glexir/sdk";

// Exported from @glexir/sdk
declare function toFile(data: Uploadable | string, name?: string, options?: { type?: string }): Promise<File>;

Wraps data in a File with a filename and an optional MIME type. It throws a GlexirError if no filename is given and data is not already a File. A File passed with no name and no type is returned as-is.

The SDK sends text fields before the file part, writes arrays as repeated key[] parts, and objects as key[sub] parts. You don't need to do anything for this.

Response formats

response_format decides what the call returns. The SDK's return type follows it.

import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir();
const file = await toFile(await (await fetch("https://example.com/talk.mp3")).arrayBuffer(), "talk.mp3");

const text: string = await glexir.audio.transcriptions.create({
  file,
  model: "gpt-transcribe",
  response_format: "text",
});

Word and segment timestamps need whisper-1 with response_format: "verbose_json" and timestamp_granularities.

Languages and keywords

With gpt-transcribe, pass candidate languages and domain keywords to improve accuracy. Don't send language and languages together.

import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir();
declare const recording: Uint8Array;

const transcript = await glexir.audio.transcriptions.create({
  file: await toFile(recording, "support-call.wav"),
  model: "gpt-transcribe",
  languages: ["en", "yo"],
  keywords: ["Glexir", "Adebayo", "refund ticket"],
});

console.log(transcript.languages); // [{ code: "en" }], or [] when detection was unreliable

Stream a transcript

Set stream: true to get transcript events as they are produced. The call returns a Stream<TranscriptionStreamEvent>.

import Glexir, { toFile } from "@glexir/sdk";

const glexir = new Glexir();
declare const recording: Uint8Array;

const stream = await glexir.audio.transcriptions.create({
  file: await toFile(recording, "memo.webm"),
  model: "gpt-transcribe",
  stream: true,
});

for await (const event of stream) {
  if (event.type === "transcript.text.delta") process.stdout.write(event.delta);
  if (event.type === "transcript.text.done") console.log("\n", event.usage);
}

whisper-1 ignores stream and returns a normal response. See Streaming for Stream methods.

Speaker diarization

gpt-4o-transcribe-diarize with response_format: "diarized_json" returns segments labelled by speaker. Name up to four speakers with known_speaker_names and matching known_speaker_references (data: URLs of 2 to 10 second samples). Unnamed speakers are labelled A, B and so on. For audio longer than 30 seconds, chunking_strategy is required.

This model is not in the price book today, so the call returns 403 model_not_priced. The types are documented below for completeness.

Translations (deprecated)

audio.translations.create() transcribes audio and translates it into English. It works with whisper-1 only, and OpenAI shuts down /audio/translations on 2027-02-26. whisper-1 is not in Glexir's price book today, so the call returns 403 model_not_priced. Use audio.transcriptions instead.

import type { APIPromise, RequestOptions, Translation, TranslationCreateParams, TranslationVerbose } from "@glexir/sdk";

// glexir.audio.translations (deprecated). Overloads narrow the result by response_format.
interface Translations {
  create(body: TranslationCreateParams & { response_format?: "json" }, options?: RequestOptions): APIPromise<Translation>;
  create(body: TranslationCreateParams & { response_format: "verbose_json" }, options?: RequestOptions): APIPromise<TranslationVerbose>;
  create(body: TranslationCreateParams & { response_format: "text" | "srt" | "vtt" }, options?: RequestOptions): APIPromise<string>;
}

response_format works as for transcriptions: json (default) returns Translation ({ text }), verbose_json returns TranslationVerbose (duration, language, text, segments?), and text, srt and vtt return a string.

Per-second billing

Transcription is billed by audio duration, per second, at the model's per-minute rate divided by 60. Each request is billed at least 1 second, and partial seconds round up. See Pricing for the rate.

Glexir finds the duration in this order:

1. usage.seconds when the response has duration usage (json, diarized_json, or the final transcript.text.done stream event).
2. duration from a verbose_json response.
3. Otherwise (text, srt, vtt, or no usage), the duration Glexir reads from the uploaded file. If the file can't be read, it estimates from the file size at about 16 kbit/s.

Before forwarding, Glexir reserves a hold sized from the file's duration (or the size estimate) and settles it when the response or stream ends. See Credits & billing.

Method reference

glexir.audio.transcriptions.create()

import type {
  APIPromise,
  RequestOptions,
  Stream,
  Transcription,
  TranscriptionCreateParamsBase,
  TranscriptionDiarized,
  TranscriptionStreamEvent,
  TranscriptionVerbose,
} from "@glexir/sdk";

type NonStreaming = { stream?: false | null };

// glexir.audio.transcriptions. Overloads narrow the result by response_format and stream.
interface Transcriptions {
  create(body: TranscriptionCreateParamsBase & NonStreaming & { response_format?: "json" }, options?: RequestOptions): APIPromise<Transcription>;
  create(body: TranscriptionCreateParamsBase & NonStreaming & { response_format: "verbose_json" }, options?: RequestOptions): APIPromise<TranscriptionVerbose>;
  create(body: TranscriptionCreateParamsBase & NonStreaming & { response_format: "diarized_json" }, options?: RequestOptions): APIPromise<TranscriptionDiarized>;
  create(body: TranscriptionCreateParamsBase & NonStreaming & { response_format: "text" | "srt" | "vtt" }, options?: RequestOptions): APIPromise<string>;
  create(body: TranscriptionCreateParamsBase & { stream: true }, options?: RequestOptions): APIPromise<Stream<TranscriptionStreamEvent>>;
}

POST /audio/transcriptions. The overloads above pick the return type from response_format and stream, as in the Response formats table. options are the per-request options described in Client configuration.

Other keys are sent as extra form fields.

Response types

Errors

See HTTP error codes for the full list.