Text to speech

curl -s https://api.data.larsima.com/v1/audio/voices \
  -H "Authorization: Bearer $DATA_API_KEY"

# {"voices": [
#   {"id": "default", "language": "any", "gender": null, ...},
#   {"id": "male", "language": "any", "gender": "male", ...},
#   {"id": "fa-female-1", "language": "fa", "gender": "female", ...},
#   {"id": "es-male-3", "language": "es", "gender": "male", ...},
#   ... 243 total
# ]}

import os, httpx

r = httpx.get(
    "https://api.data.larsima.com/v1/audio/voices",
    headers={"Authorization": f"Bearer {os.environ['DATA_API_KEY']}"},
)
voices = r.json()["voices"]
print(len(voices), "voices")

curl -s https://api.data.larsima.com/v1/audio/speech \
  -H "Authorization: Bearer $DATA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "data-tts",
    "voice": "default",
    "input": "Se dictará sentencia en un plazo máximo de veinte días.",
    "language": "es",
    "response_format": "mp3"
  }' --output speech.mp3

import os

from openai import OpenAI

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

resp = client.audio.speech.create(
    model="data-tts",
    voice="default",   # required; the value itself has no effect -- see below
    input="Se dictará sentencia en un plazo máximo de veinte días.",
    response_format="mp3",
    extra_body={"language": "es"},
)
resp.stream_to_file("speech.mp3")

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.speech.create({
  model: "data-tts",
  voice: "default",   // required; the value itself has no effect -- see below
  input: "Se dictará sentencia en un plazo máximo de veinte días.",
  response_format: "mp3",
  language: "es",
});

fs.writeFileSync("speech.mp3", Buffer.from(await resp.arrayBuffer()));

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.speech.create({
  model: "data-tts",
  voice: "default" as any,   // required; the value itself has no effect -- see below
  input: "Se dictará sentencia en un plazo máximo de veinte días.",
  response_format: "mp3",
  // @ts-expect-error -- gateway-specific field, not in the SDK's types yet
  language: "es",
});

fs.writeFileSync("speech.mp3", Buffer.from(await resp.arrayBuffer()));

package main

import (
	"bytes"
	"encoding/json"
	"io"
	"net/http"
	"os"
)

func main() {
	body, _ := json.Marshal(map[string]any{
		"model":           "data-tts",
		"voice":           "default",
		"input":           "Se dictará sentencia en un plazo máximo de veinte días.",
		"language":        "es",
		"response_format": "mp3",
	})

	req, _ := http.NewRequest("POST",
		"https://api.data.larsima.com/v1/audio/speech", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("DATA_API_KEY"))
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	out, _ := os.Create("speech.mp3")
	defer out.Close()
	io.Copy(out, resp.Body)
}

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

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

    let bytes = reqwest::Client::new()
        .post("https://api.data.larsima.com/v1/audio/speech")
        .bearer_auth(key)
        .json(&json!({
            "model": "data-tts",
            "voice": "default",
            "input": "Se dictará sentencia en un plazo máximo de veinte días.",
            "language": "es",
            "response_format": "mp3"
        }))
        .send()
        .await?
        .bytes()
        .await?;

    fs::write("speech.mp3", bytes)?;
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;

public class TextToSpeech {
    public static void main(String[] args) throws Exception {
        String body = "{\"model\":\"data-tts\",\"voice\":\"default\","
                + "\"input\":\"Se dictar\u00e1 sentencia en un plazo m\u00e1ximo de veinte d\u00edas.\","
                + "\"language\":\"es\",\"response_format\":\"mp3\"}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.data.larsima.com/v1/audio/speech"))
                .header("Authorization", "Bearer " + System.getenv("DATA_API_KEY"))
                .header("Content-Type", "application/json; charset=utf-8")
                .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8))
                .build();

        HttpResponse<byte[]> response = HttpClient.newHttpClient()
                .send(request, HttpResponse.BodyHandlers.ofByteArray());
        Files.write(Path.of("speech.mp3"), response.body());
    }
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

var payload = new {
    model = "data-tts",
    voice = "default",
    input = "Se dictará sentencia en un plazo máximo de veinte días.",
    language = "es",
    response_format = "mp3",
};

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

var content = new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json");
var response = await client.PostAsync("https://api.data.larsima.com/v1/audio/speech", content);

await File.WriteAllBytesAsync("speech.mp3", await response.Content.ReadAsByteArrayAsync());

<?php
$payload = [
    "model" => "data-tts",
    "voice" => "default",
    "input" => "Se dictará sentencia en un plazo máximo de veinte días.",
    "language" => "es",
    "response_format" => "mp3",
];

$ch = curl_init("https://api.data.larsima.com/v1/audio/speech");
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer " . getenv("DATA_API_KEY"),
        "Content-Type: application/json",
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_UNESCAPED_UNICODE),
]);

file_put_contents("speech.mp3", curl_exec($ch));

require "net/http"
require "json"
require "uri"

uri = URI("https://api.data.larsima.com/v1/audio/speech")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer #{ENV.fetch('DATA_API_KEY')}"
request["Content-Type"] = "application/json"
request.body = {
  model: "data-tts",
  voice: "default",
  input: "Se dictará sentencia en un plazo máximo de veinte días.",
  language: "es",
  response_format: "mp3",
}.to_json

response = http.request(request)
File.binwrite("speech.mp3", response.body)