Speech to text

curl -s https://api.data.larsima.com/v1/audio/transcriptions \
  -H "Authorization: Bearer $DATA_API_KEY" \
  -F file=@voice.m4a \
  -F model=data-stt \
  -F language=persian \
  -F response_format=json

# {"text":"مهلت تجدیدنظرخواهی از رأی دادگاه بیست روز است.",
#  "duration":4.58,"language":"fa","usage":null,"words":null,"segments":null}

import os

from openai import OpenAI

client = OpenAI(base_url="https://api.data.larsima.com/v1",
                 api_key=os.environ["DATA_API_KEY"])

with open("voice.m4a", "rb") as f:
    resp = client.audio.transcriptions.create(
        model="data-stt",
        file=f,
        language="persian",
        response_format="json",
    )
print(resp.text)

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.data.larsima.com/v1",
  apiKey: process.env.DATA_API_KEY,
});

const resp = await client.audio.transcriptions.create({
  file: fs.createReadStream("voice.m4a"),
  model: "data-stt",
  language: "persian",
  response_format: "json",
});

console.log(resp.text);

import fs from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.data.larsima.com/v1",
  apiKey: process.env.DATA_API_KEY,
});

const resp = await client.audio.transcriptions.create({
  file: fs.createReadStream("voice.m4a"),
  model: "data-stt",
  language: "persian",
  response_format: "json",
});

console.log(resp.text);

package main

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

func main() {
	file, err := os.Open("voice.m4a")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	var buf bytes.Buffer
	w := multipart.NewWriter(&buf)
	part, _ := w.CreateFormFile("file", "voice.m4a")
	io.Copy(part, file)
	w.WriteField("model", "data-stt")
	w.WriteField("language", "persian")
	w.WriteField("response_format", "json")
	w.Close()

	req, _ := http.NewRequest("POST",
		"https://api.data.larsima.com/v1/audio/transcriptions", &buf)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("DATA_API_KEY"))
	req.Header.Set("Content-Type", w.FormDataContentType())

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	out, _ := io.ReadAll(resp.Body)
	fmt.Println(string(out))
}

// Cargo.toml: reqwest = { version = "0.12", features = ["multipart"] }
//             tokio = { version = "1", features = ["full"] }
use reqwest::multipart;
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = env::var("DATA_API_KEY")?;
    let file = tokio::fs::read("voice.m4a").await?;

    let form = multipart::Form::new()
        .part("file", multipart::Part::bytes(file).file_name("voice.m4a"))
        .text("model", "data-stt")
        .text("language", "persian")
        .text("response_format", "json");

    let resp = reqwest::Client::new()
        .post("https://api.data.larsima.com/v1/audio/transcriptions")
        .bearer_auth(key)
        .multipart(form)
        .send()
        .await?
        .text()
        .await?;

    println!("{resp}");
    Ok(())
}

import java.io.ByteArrayOutputStream;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.LinkedHashMap;
import java.util.Map;

public class Transcribe {
    public static void main(String[] args) throws Exception {
        String boundary = "----data" + System.currentTimeMillis();
        Map<String, String> fields = new LinkedHashMap<>();
        fields.put("model", "data-stt");
        fields.put("language", "persian");
        fields.put("response_format", "json");

        var out = new ByteArrayOutputStream();
        for (var e : fields.entrySet()) {
            out.write(("--" + boundary + "\r\nContent-Disposition: form-data; name=\""
                    + e.getKey() + "\"\r\n\r\n" + e.getValue() + "\r\n").getBytes());
        }
        byte[] audio = Files.readAllBytes(Path.of("voice.m4a"));
        out.write(("--" + boundary + "\r\nContent-Disposition: form-data; name=\"file\"; "
                + "filename=\"voice.m4a\"\r\nContent-Type: audio/mp4\r\n\r\n").getBytes());
        out.write(audio);
        out.write(("\r\n--" + boundary + "--\r\n").getBytes());

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.data.larsima.com/v1/audio/transcriptions"))
                .header("Authorization", "Bearer " + System.getenv("DATA_API_KEY"))
                .header("Content-Type", "multipart/form-data; boundary=" + boundary)
                .POST(HttpRequest.BodyPublishers.ofByteArray(out.toByteArray()))
                .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

using System.Net.Http.Headers;

using var client = new HttpClient();
client.DefaultRequestHeaders.Authorization =
    new AuthenticationHeaderValue("Bearer", Environment.GetEnvironmentVariable("DATA_API_KEY"));

using var form = new MultipartFormDataContent
{
    { new StringContent("data-stt"), "model" },
    { new StringContent("persian"), "language" },
    { new StringContent("json"), "response_format" },
    { new StreamContent(File.OpenRead("voice.m4a")), "file", "voice.m4a" },
};

var response = await client.PostAsync(
    "https://api.data.larsima.com/v1/audio/transcriptions", form);
Console.WriteLine(await response.Content.ReadAsStringAsync());

<?php
$payload = [
    "model" => "data-stt",
    "language" => "persian",
    "response_format" => "json",
    "file" => new CURLFile("voice.m4a"),
];

$ch = curl_init("https://api.data.larsima.com/v1/audio/transcriptions");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["Authorization: Bearer " . getenv("DATA_API_KEY")],
    CURLOPT_POSTFIELDS => $payload,
]);

echo curl_exec($ch);

require "net/http"
require "net/http/post/multipart"   # gem install multipart-post
require "uri"

uri = URI("https://api.data.larsima.com/v1/audio/transcriptions")
File.open("voice.m4a") do |file|
  request = Net::HTTP::Post::Multipart.new(uri,
    "model" => "data-stt",
    "language" => "persian",
    "response_format" => "json",
    "file" => UploadIO.new(file, "audio/mp4", "voice.m4a"))
  request["Authorization"] = "Bearer #{ENV.fetch('DATA_API_KEY')}"

  response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |http| http.request(request) }
  puts response.body
end