Audio API

curl https://aiapi.services/v1/audio/speech \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-to-speech-001",
    "input": "The weather is nice today, perfect for a walk.",
    "voice": "alloy",
    "speed": 1.0
  }' \
  --output speech.mp3

import requests
 
response = requests.post(
  'https://aiapi.services/v1/audio/speech',
  headers={
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  json={
    'model': 'text-to-speech-001',
    'input': 'The weather is nice today, perfect for a walk.',
    'voice': 'alloy',
    'speed': 1.0
  }
)
 
with open('speech.mp3', 'wb') as f:
  f.write(response.content)
 
print('Speech file saved as speech.mp3')

const response = await fetch('https://aiapi.services/v1/audio/speech', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'text-to-speech-001',
    input: 'The weather is nice today, perfect for a walk.',
    voice: 'alloy',
    speed: 1.0
  })
});
 
const audioBlob = await response.blob();
const url = URL.createObjectURL(audioBlob);
 
// Play audio
const audio = new Audio(url);
audio.play();

package main
 
import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
  "os"
)
 
func main() {
  url := "https://aiapi.services/v1/audio/speech"
 
  payload := map[string]interface{}{
    "model": "text-to-speech-001",
    "input": "The weather is nice today, perfect for a walk.",
    "voice": "alloy",
    "speed": 1.0,
  }
 
  jsonData, _ := json.Marshal(payload)
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
  req.Header.Set("Content-Type", "application/json")
 
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
 
  out, _ := os.Create("speech.mp3")
  defer out.Close()
  io.Copy(out, resp.Body)
  fmt.Println("Speech file saved as speech.mp3")
}

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;
use std::fs::File;
use std::io::Write;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
 
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer YOUR_API_KEY"));
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
 
    let payload = json!({
        "model": "text-to-speech-001",
        "input": "The weather is nice today, perfect for a walk.",
        "voice": "alloy",
        "speed": 1.0
    });
 
    let response = client
        .post("https://aiapi.services/v1/audio/speech")
        .headers(headers)
        .json(&payload)
        .send()
        .await?;
 
    let audio_data = response.bytes().await?;
 
    let mut file = File::create("speech.mp3")?;
    file.write_all(&audio_data)?;
 
    println!("Speech file saved as speech.mp3");
 
    Ok(())
}

<?php
 
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://aiapi.services/v1/audio/speech");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_KEY",
    "Content-Type: application/json"
]);
 
$data = [
    "model" => "text-to-speech-001",
    "input" => "The weather is nice today, perfect for a walk.",
    "voice" => "alloy",
    "speed" => 1.0
];
 
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
$response = curl_exec($ch);
curl_close($ch);
 
file_put_contents('speech.mp3', $response);
echo "Speech file saved as speech.mp3\n";
?>

require 'net/http'
require 'json'
 
uri = URI('https://aiapi.services/v1/audio/speech')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
 
request.body = {
  model: 'text-to-speech-001',
  input: 'The weather is nice today, perfect for a walk.',
  voice: 'alloy',
  speed: 1.0
}.to_json
 
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
 
File.write('speech.mp3', response.body)
puts "Speech file saved as speech.mp3"

# Save as file
with open('output.mp3', 'wb') as f:
    f.write(response.content)

// Play in browser
const audioBlob = await response.blob();
const audioUrl = URL.createObjectURL(audioBlob);
const audio = new Audio(audioUrl);
audio.play();

# Process in memory
from io import BytesIO
import pygame
 
audio_bytes = BytesIO(response.content)
pygame.mixer.init()
pygame.mixer.music.load(audio_bytes)
pygame.mixer.music.play()