Text-to-Speech

POST https://api.cencori.com/api/ai/audio/speech

curl https://api.cencori.com/api/ai/audio/speech \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1",
    "input": "Hello! Welcome to Cencori.",
    "voice": "alloy"
  }' \
  --output speech.mp3

curl https://api.cencori.com/api/ai/audio/speech \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1-hd",
    "input": "This is a professional announcement.",
    "voice": "onyx",
    "response_format": "opus"
  }' \
  --output speech.opus

curl https://api.cencori.com/api/ai/audio/speech \
  -H "Authorization: Bearer $CENCORI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "tts-1",
    "input": "Speeding up this narration.",
    "voice": "nova",
    "speed": 1.5
  }' \
  --output speech.mp3

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  apiKey: process.env.CENCORI_API_KEY,
  baseURL: 'https://api.cencori.com/v1'
});

const mp3 = await client.audio.speech.create({
  model: 'tts-1',
  voice: 'alloy',
  input: 'Today is a wonderful day!'
});

const buffer = Buffer.from(await mp3.arrayBuffer());
fs.writeFileSync('speech.mp3', buffer);

import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const { text } = await req.json();
  
  const response = await fetch('https://api.cencori.com/api/ai/audio/speech', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.CENCORI_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'tts-1',
      voice: 'alloy',
      input: text
    })
  });
  
  const audioBuffer = await response.arrayBuffer();
  
  return new NextResponse(audioBuffer, {
    headers: {
      'Content-Type': 'audio/mpeg',
      'Content-Disposition': 'inline; filename="speech.mp3"'
    }
  });
}

// Split long text into chunks
function chunkText(text: string, maxLength: number = 4000): string[] {
  const sentences = text.match(/[^.!?]+[.!?]+/g) || [text];
  const chunks: string[] = [];
  let currentChunk = '';
  
  for (const sentence of sentences) {
    if ((currentChunk + sentence).length > maxLength) {
      chunks.push(currentChunk.trim());
      currentChunk = sentence;
    } else {
      currentChunk += sentence;
    }
  }
  
  if (currentChunk) chunks.push(currentChunk.trim());
  return chunks;
}

// Generate speech for each chunk
const longText = "Very long text...";
const chunks = chunkText(longText);

for (let i = 0; i < chunks.length; i++) {
  const mp3 = await client.audio.speech.create({
    model: 'tts-1',
    voice: 'alloy',
    input: chunks[i]
  });
  
  const buffer = Buffer.from(await mp3.arrayBuffer());
  fs.writeFileSync(`speech_part${i + 1}.mp3`, buffer);
}

const voices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
const text = 'Hello, this is a voice comparison test.';

for (const voice of voices) {
  const mp3 = await client.audio.speech.create({
    model: 'tts-1',
    voice,
    input: text
  });
  
  const buffer = Buffer.from(await mp3.arrayBuffer());
  fs.writeFileSync(`voice_${voice}.mp3`, buffer);
}

const chapters = ['Chapter 1 text...', 'Chapter 2 text...'];

for (let i = 0; i < chapters.length; i++) {
  const mp3 = await client.audio.speech.create({
    model: 'tts-1-hd',
    voice: 'fable',
    input: chapters[i],
    speed: 0.9  // Slightly slower for audiobooks
  });
  
  const buffer = Buffer.from(await mp3.arrayBuffer());
  fs.writeFileSync(`chapter_${i + 1}.mp3`, buffer);
}

const intro = await client.audio.speech.create({
  model: 'tts-1-hd',
  voice: 'echo',
  input: 'Welcome to the Tech Insights Podcast. Your weekly dose of innovation and discovery.'
});

// Read webpage content aloud
async function textToSpeech(element: HTMLElement) {
  const text = element.innerText;
  
  const response = await fetch('/api/tts', {
    method: 'POST',
    body: JSON.stringify({ text })
  });
  
  const audioBlob = await response.blob();
  const audioUrl = URL.createObjectURL(audioBlob);
  
  const audio = new Audio(audioUrl);
  audio.play();
}

const notification = await client.audio.speech.create({
  model: 'tts-1',
  voice: 'nova',
  input: 'You have 3 new messages waiting.'
});

// Language learning pronunciation
const phrases = [
  { text: 'Hello', lang: 'en' },
  { text: 'Bonjour', lang: 'fr' },
  { text: 'Hola', lang: 'es' }
];

for (const phrase of phrases) {
  const mp3 = await client.audio.speech.create({
    model: 'tts-1-hd',
    voice: 'alloy',
    input: phrase.text
  });
  
  const buffer = Buffer.from(await mp3.arrayBuffer());
  fs.writeFileSync(`${phrase.lang}_${phrase.text}.mp3`, buffer);
}

{
  "error": "bad_request",
  "message": "Input text exceeds maximum length of 4096 characters"
}

{
  "error": "bad_request",
  "message": "Input text is required"
}

{
  "error": "provider_not_configured",
  "message": "No OpenAI API key configured"
}

curl https://api.cencori.com/api/ai/audio/speech \
  -H "Authorization: Bearer $CENCORI_API_KEY"

{
  "models": ["tts-1", "tts-1-hd"],
  "voices": [
    { "id": "alloy", "description": "Neutral and balanced" },
    { "id": "echo", "description": "Warm and conversational" },
    { "id": "fable", "description": "British accent, expressive" },
    { "id": "onyx", "description": "Deep and authoritative" },
    { "id": "nova", "description": "Friendly and upbeat" },
    { "id": "shimmer", "description": "Clear and professional" }
  ],
  "formats": ["mp3", "opus", "aac", "flac", "wav", "pcm"]
}