Migrating from ElevenLabs to Speech Revolutions

from elevenlabs.client import ElevenLabs

client = ElevenLabs()  # ELEVENLABS_API_KEY

with open("meeting.mp3", "rb") as f:
    resp = client.speech_to_text.convert(
        model_id="scribe_v2",
        file=f,
        diarize=True,
    )

print(resp.text)
for w in resp.words:
    if w.type == "word":                       # skip spacing tokens
        print(w.speaker_id, w.text, w.start, w.end)

from speechrevolutions import SpeechRevolutions

client = SpeechRevolutions()  # SPEECHREVOLUTIONS_API_KEY
result = client.transcribe("meeting.mp3", diarize=True)  # same flag name

print(result.text)
for w in result.words:                          # already words only
    print(w.speaker, w.text, w.start, w.end)
for u in result.utterances:                     # pre-grouped speaker turns
    print(f"{u.speaker}: {u.text}")

import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";
import { createReadStream } from "node:fs";

const client = new ElevenLabsClient(); // ELEVENLABS_API_KEY

const resp = await client.speechToText.convert({
  modelId: "scribe_v2",
  file: createReadStream("meeting.mp3"),
  diarize: true,
});

console.log(resp.text);
for (const w of resp.words) {
  if (w.type === "word") {                       // skip spacing tokens
    console.log(w.speakerId, w.text, w.start, w.end);
  }
}

import { SpeechRevolutions } from "speechrevolutions";

const client = new SpeechRevolutions(); // SPEECHREVOLUTIONS_API_KEY
const result = await client.transcribe("meeting.mp3", { diarize: true }); // same flag name

console.log(result.text);
for (const w of result.words) {               // already words only
  console.log(w.speaker, w.text, w.start, w.end);
}
for (const u of result.utterances) {          // pre-grouped speaker turns
  console.log(`${u.speaker}: ${u.text}`);
}

// ElevenLabs has no official Go SDK, so this calls the REST API directly.
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	audio, err := os.ReadFile("meeting.mp3")
	if err != nil {
		log.Fatal(err)
	}

	var body bytes.Buffer
	form := multipart.NewWriter(&body)
	form.WriteField("model_id", "scribe_v2")
	form.WriteField("diarize", "true")
	part, _ := form.CreateFormFile("file", "meeting.mp3")
	part.Write(audio)
	form.Close()

	req, _ := http.NewRequest("POST", "https://api.elevenlabs.io/v1/speech-to-text", &body)
	req.Header.Set("xi-api-key", os.Getenv("ELEVENLABS_API_KEY"))
	req.Header.Set("Content-Type", form.FormDataContentType())
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		msg, _ := io.ReadAll(res.Body)
		log.Fatalf("elevenlabs: %s: %s", res.Status, msg)
	}

	var resp struct {
		Text  string `json:"text"`
		Words []struct {
			Text      string  `json:"text"`
			Start     float64 `json:"start"`
			End       float64 `json:"end"`
			Type      string  `json:"type"`
			SpeakerID string  `json:"speaker_id"`
		} `json:"words"`
	}
	if err := json.NewDecoder(res.Body).Decode(&resp); err != nil {
		log.Fatal(err)
	}

	fmt.Println(resp.Text)
	for _, w := range resp.Words {
		if w.Type == "word" { // skip spacing tokens
			fmt.Println(w.SpeakerID, w.Text, w.Start, w.End)
		}
	}
}

package main

import (
	"context"
	"fmt"
	"log"

	stt "github.com/speechrevolutions/speechrevolutions-go"
)

func main() {
	ctx := context.Background()
	client, err := stt.NewClient("") // SPEECHREVOLUTIONS_API_KEY
	if err != nil {
		log.Fatal(err)
	}

	// an official SDK: no multipart form, no response struct of your own
	result, err := client.Transcribe(ctx, "meeting.mp3", stt.TranscribeOptions{
		Diarize: stt.Bool(true), // same flag name
	}, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result.Text())
	for _, w := range result.Words { // already words only
		if w.Start != nil && w.End != nil {
			fmt.Println(w.Speaker, w.Word, *w.Start, *w.End)
		}
	}
	for _, u := range result.Utterances { // pre-grouped speaker turns
		fmt.Printf("%s: %s\n", u.Speaker, u.Text)
	}
}

// ElevenLabs has no official .NET SDK, so this calls the REST API directly.
using System.Net.Http.Headers;
using System.Text.Json;

using var http = new HttpClient();
http.DefaultRequestHeaders.Add("xi-api-key", Environment.GetEnvironmentVariable("ELEVENLABS_API_KEY"));

using var form = new MultipartFormDataContent
{
    { new StringContent("scribe_v2"), "model_id" },
    { new StringContent("true"), "diarize" },
};
var audio = new ByteArrayContent(await File.ReadAllBytesAsync("meeting.mp3"));
audio.Headers.ContentType = new MediaTypeHeaderValue("audio/mpeg");
form.Add(audio, "file", "meeting.mp3");

var res = await http.PostAsync("https://api.elevenlabs.io/v1/speech-to-text", form);
res.EnsureSuccessStatusCode();
using var json = JsonDocument.Parse(await res.Content.ReadAsStringAsync());

Console.WriteLine(json.RootElement.GetProperty("text").GetString());
foreach (var w in json.RootElement.GetProperty("words").EnumerateArray())
{
    if (w.GetProperty("type").GetString() != "word") continue; // skip spacing tokens
    Console.WriteLine($"{w.GetProperty("speaker_id")} {w.GetProperty("text")} " +
                      $"{w.GetProperty("start")} {w.GetProperty("end")}");
}

using SpeechRevolutions;

// an official SDK: no multipart form, no JSON walking
using var client = new SpeechRevolutionsClient(); // SPEECHREVOLUTIONS_API_KEY
var result = await client.TranscribeAsync(
    "meeting.mp3",
    new TranscribeOptions { Diarize = true }); // same flag name

Console.WriteLine(result.Text);
foreach (var w in result.Words)          // already words only
    Console.WriteLine($"{w.Speaker} {w.Text} {w.Start} {w.End}");
foreach (var u in result.Utterances)     // pre-grouped speaker turns
    Console.WriteLine($"{u.Speaker}: {u.Text}");