Voice Cloning API vs ElevenLabs

pip install pixelapi
---
import requests, time

API_KEY = "YOUR_API_KEY"
BASE = "https://api.pixelapi.dev"

# Basic TTS
r = requests.post(f"{BASE}/v1/tts/generate",
    headers={"Authorization": f"Bearer {API_KEY}"},
    data={"text": "Hello from the TTS API.", "language": "en"})
job_id = r.json()["generation_id"]

# Voice cloning — attach a reference clip
with open("speaker.wav", "rb") as f:
    r = requests.post(f"{BASE}/v1/tts/generate",
        headers={"Authorization": f"Bearer {API_KEY}"},
        data={"text": "Cloned voice output here.", "language": "en"},
        files={"voice_ref": ("speaker.wav", f, "audio/wav")})
job_id = r.json()["generation_id"]

# Poll until completed
while True:
    r = requests.get(f"{BASE}/v1/tts/status/{job_id}",
        headers={"Authorization": f"Bearer {API_KEY}"})
    if r.json()["status"] == "completed":
        audio = requests.get(r.json()["output_url"]).content
        open("output.wav", "wb").write(audio)
        break
    time.sleep(2)

npm install pixelapi
---
import FormData from "form-data";
import fetch from "node-fetch";
import fs from "fs";

const apiKey = process.env.PIXELAPI_KEY;
const base = "https://api.pixelapi.dev";

// Basic TTS
const form = new FormData();
form.append("text", "Hello from the voice cloning API.");
form.append("language", "en");
const res = await fetch(`${base}/v1/tts/generate`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}`, ...form.getHeaders() },
  body: form,
});
let { generation_id } = await res.json();

// Voice cloning — attach reference audio
const form2 = new FormData();
form2.append("text", "This sounds like the reference speaker.");
form2.append("language", "en");
form2.append("voice_ref", fs.createReadStream("speaker.wav"), "speaker.wav");
const res2 = await fetch(`${base}/v1/tts/generate`, {
  method: "POST",
  headers: { Authorization: `Bearer ${apiKey}`, ...form2.getHeaders() },
  body: form2,
});
generation_id = (await res2.json()).generation_id;

// Poll for result
let result;
do {
  await new Promise(r => setTimeout(r, 2000));
  result = await fetch(`${base}/v1/tts/status/${generation_id}`,
    { headers: { Authorization: `Bearer ${apiKey}` } }).then(r => r.json());
} while (result.status !== "completed");
fs.writeFileSync("output.wav",
  Buffer.from(await fetch(result.output_url).then(r => r.arrayBuffer())));

composer require pixelapi/pixelapi
---
<?php
$apiKey = getenv("PIXELAPI_KEY");
$base   = "https://api.pixelapi.dev";

// Basic TTS
$ch = curl_init("$base/v1/tts/generate");
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"],
  CURLOPT_POSTFIELDS => ["text" => "Hello from TTS.", "language" => "en"],
]);
$resp  = json_decode(curl_exec($ch), true);
$jobId = $resp["generation_id"];
curl_close($ch);

// Poll until done
do {
    sleep(2);
    $ch2 = curl_init("$base/v1/tts/status/$jobId");
    curl_setopt_array($ch2, [
      CURLOPT_RETURNTRANSFER => true,
      CURLOPT_HTTPHEADER => ["Authorization: Bearer $apiKey"],
    ]);
    $result = json_decode(curl_exec($ch2), true);
    curl_close($ch2);
} while ($result["status"] !== "completed");
file_put_contents("output.wav", file_get_contents($result["output_url"]));

gem install pixelapi
---
require "net/http"
require "json"

api_key = ENV["PIXELAPI_KEY"]
base    = "https://api.pixelapi.dev"

# Basic TTS
uri = URI("#{base}/v1/tts/generate")
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{api_key}"
req.set_form([["text", "Hello from TTS."], ["language", "en"]], "multipart/form-data")
res    = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |h| h.request(req) }
job_id = JSON.parse(res.body)["generation_id"]

# Poll until completed
loop do
  sleep 2
  uri2 = URI("#{base}/v1/tts/status/#{job_id}")
  req2 = Net::HTTP::Get.new(uri2, "Authorization" => "Bearer #{api_key}")
  result = JSON.parse(Net::HTTP.start(uri2.hostname, uri2.port, use_ssl: true) { |h| h.request(req2) }.body)
  if result["status"] == "completed"
    File.binwrite("output.wav", URI.open(result["output_url"]).read)
    break
  end
end

go get github.com/pixelapi/pixelapi-go
---
package main

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

func main() {
    apiKey := os.Getenv("PIXELAPI_KEY")
    base   := "https://api.pixelapi.dev"

    var buf bytes.Buffer
    w := multipart.NewWriter(&buf)
    w.WriteField("text", "Hello from the TTS API.")
    w.WriteField("language", "en")
    w.Close()

    req, _ := http.NewRequest("POST", base+"/v1/tts/generate", &buf)
    req.Header.Set("Authorization", "Bearer "+apiKey)
    req.Header.Set("Content-Type", w.FormDataContentType())
    resp, _ := http.DefaultClient.Do(req)
    var job struct{ GenerationID string `json:"generation_id"` }
    json.NewDecoder(resp.Body).Decode(&job)
    resp.Body.Close()

    for {
        time.Sleep(2 * time.Second)
        req2, _ := http.NewRequest("GET", base+"/v1/tts/status/"+job.GenerationID, nil)
        req2.Header.Set("Authorization", "Bearer "+apiKey)
        r2, _ := http.DefaultClient.Do(req2)
        var result struct {
            Status    string `json:"status"`
            OutputURL string `json:"output_url"`
        }
        json.NewDecoder(r2.Body).Decode(&result)
        r2.Body.Close()
        if result.Status == "completed" {
            resp3, _ := http.Get(result.OutputURL)
            data, _ := io.ReadAll(resp3.Body)
            os.WriteFile("output.wav", data, 0644)
            fmt.Println("Saved output.wav")
            break
        }
    }
}