Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

API TTS: Generiranje govora

Lekcija 10 od 18 Ažurirano 3. studenoga 2026. Programer
Na ovoj stranici
  1. API TTS: Generiranje govora
  2. Tvoj prvi TTS poziv
  3. Dostupni modeli
  4. Izlazni formati
  5. Generiranje audija u serijama
  6. Ograničenje broja znakova i dijeljenje
  7. Nakon 6. siječnja 2027.: Kako natjerati Realtime model da govori
  8. Ključne točke

Ažuriranje 2. studenoga 2026. — Audio modeli. Nekoliko modela u ovom tečaju je zastarjelo: tts-1, tts-1-hd i gpt-4o-mini-tts bit će ugašeni 6. siječnja 2027. (nasljednik: gpt-realtime-2.1-mini, za koji OpenAI TTS vodič navodi da nije podržan od strane /v1/audio/speech: migracija sinteze govora prelazi na Realtime API); gpt-realtime, gpt-4o-realtime i stariji audio modeli 20. siječnja 2027. (gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-audio-1.5); whisper-1, gpt-4o-transcribe i /v1/audio/translations 26. veljače 2027. (gpt-transcribe, gpt-live-transcribe, v1/realtime/translations). Za full-duplex glas, GPT-Live 1 dostupan je u API-ju od 10. rujna 2026. Lekcija ispravljena 3. studenoga 2026.: response.stream_to_file() na rezultatu speech.create() je zastarjelo u SDK-u („Zbog greške, ova metoda zapravo ne strimira“) → koristi with_streaming_response, kao u službenom vodiču; modeli i glasovi ažurirani (gpt-4o-mini-tts i njegove upute za glas, 13 glasova uključujući marin i cedar); novi odjeljak o migraciji na gpt-realtime-2.1-mini prije 6. siječnja 2027., na temelju vodiča Realtime conversations. Izvori: Text to speech · Create speech · Realtime conversations · Deprecations.

API TTS: Generiranje govora

OpenAI-jev API za tekst-u-govor (TTS) pretvara tekst u visokokvalitetni audio zapis. Za razliku od Realtime API-ja koji upravlja cjelovitim glasovnim razgovorima, TTS API je usluga jednokratnog poziva: šalješ tekst i primaš audio datoteku. Idealno je rješenje za generiranje najava, glasovnih obavijesti, audioknjiga ili sadržaja prilagođenog osobama s invaliditetom.

Tvoj prvi TTS poziv

Generiranje govora iznimno je jednostavno:

from openai import OpenAI
from pathlib import Path

client = OpenAI()

speech_file = Path("welcome.mp3")

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input="Dobrodošli u Corsen Academy. "
          "Vaša obuka o glasovnim agentima počinje sada.",
    instructions="Govori toplim, odmjeranim tonom.",
) as response:
    response.stream_to_file(speech_file)

API vraća audio stream koji možeš izravno spremiti ili strimirati na player. Koristi with_streaming_response, kao što je ovdje prikazano: pozivanje stream_to_file() na rezultatu običnog speech.create() je zastarjelo u SDK-u, koji napominje da to zapravo ne strimira audio zapis.

Dostupni modeli

Tri modela Audio API-ja su zastarjela i bit će ugašena 6. siječnja 2027.: ovo je prijelazno razdoblje tijekom kojeg ih još uvijek možeš koristiti.

ModelSpecifičnostGlasovi
gpt-4o-mini-ttsPrihvaća upute: naglasak, emocija, intonacija, brzina, ton, šaputanje13 glasova, uključujući marin i cedar, preporučeni za kvalitetu
tts-1Manja latencija, niža kvaliteta9 glasova: alloy, ash, coral, echo, fable, onyx, nova, sage, shimmer
tts-1-hdViša kvaliteta od tts-1, veća latencijaIstih 9 glasova

Upute ne funkcioniraju s tts-1 i tts-1-hd. Parametar speed, od 0.25 do 4.0, prilagođava brzinu kod svih modela. Prema vodiču, glasovi su optimizirani za engleski jezik: poslušaj ih na francuskom na OpenAI.fm prije odabira. OpenAI-jeva pravila korištenja također zahtijevaju da jasno obavijestiš svoje korisnike da je glas koji čuju generiran umjetnom inteligencijom.

Izlazni formati

API proizvodi šest formata, odabranih pomoću response_format:

FormatUpotreba
mp3 (zadano)Opća upotreba
opusInternet strimanje i komunikacija, niska latencija
aacDigitalna kompresija, preferiraju YouTube, Android i iOS
flacKompresija bez gubitaka, za arhiviranje
wavNekompresirano, za izbjegavanje opterećenja dekodiranjem
pcmSirovi uzorci na 24 kHz, 16-bitni signed, bez zaglavlja
for fmt in ("mp3", "opus", "aac", "flac", "wav", "pcm"):
    with client.audio.speech.with_streaming_response.create(
        model="gpt-4o-mini-tts",
        voice="marin",
        input="Tekst za pretvorbu",
        response_format=fmt,
    ) as response:
        response.stream_to_file(f"example.{fmt}")

Za glasovnog agenta izgrađenog na Realtime API-ju, format pcm je najprikladniji: njegovi uzorci od 24 kHz, 16-bitni odgovaraju audio/pcm formatu Realtime API-ja na 24 kHz.

Generiranje audija u serijama

Za velike količine teksta, obradi segmente paralelno:

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI()

async def generate_speech_batch(segments: list[dict]) -> list[bytes]:
    """Generiraj audio za više segmenta paralelno."""
    async def generate_one(segment):
        response = await async_client.audio.speech.create(
            model="gpt-4o-mini-tts",
            voice=segment.get("voice", "alloy"),
            input=segment["text"],
            response_format="mp3"
        )
        return await response.aread()

    tasks = [generate_one(seg) for seg in segments]
    return await asyncio.gather(*tasks)

# Upotreba
segments = [
    {"text": "Poglavlje jedno. Uvod u glasovne agente.", "voice": "onyx"},
    {"text": "Glasovni agenti transformiraju interakciju čovjek-računalo.", "voice": "onyx"},
    {"text": "U ovom poglavlju istražit ćemo osnove.", "voice": "onyx"},
]

audio_chunks = asyncio.run(generate_speech_batch(segments))

# Spajanje datoteka
from pydub import AudioSegment
import io

combined = AudioSegment.empty()
for chunk in audio_chunks:
    segment = AudioSegment.from_mp3(io.BytesIO(chunk))
    combined += segment

combined.export("chapter_1.mp3", format="mp3")

Ograničenje broja znakova i dijeljenje

TTS API ima ograničenje od 4.096 znakova po zahtjevu. Za duže tekstove, pametno ih podijeli:

def split_text_for_tts(text: str, max_chars: int = 4000) -> list[str]:
    """Podijeli tekst na segmente poštujući TTS ograničenja."""
    sentences = text.replace(". ", ".\n").split("\n")
    segments = []
    current = ""

    for sentence in sentences:
        if len(current) + len(sentence) + 1 > max_chars:
            if current:
                segments.append(current.strip())
            current = sentence
        else:
            current += " " + sentence if current else sentence

    if current:
        segments.append(current.strip())

    return segments

Nakon 6. siječnja 2027.: Kako natjerati Realtime model da govori

OpenAI označava gpt-realtime-2.1-mini kao zamjenu za tri modela i upozorava: to nije model za krajnju točku /v1/audio/speech; migracija mijenja radni tijek. Prolaziš kroz Realtime sesiju. Vodič Realtime conversations pokazuje kako dobiti odgovor bez konteksta, koji ignorira razgovor i slijedi samo svoje upute: to je način da ga natjeraš da izgovori zadani tekst.

import base64
import json
import os
import wave

import websocket  # pip install websocket-client

TEXT = "Dobrodošli u Corsen Academy. Vaša obuka o glasovnim agentima počinje sada."

ws = websocket.WebSocket()
ws.connect(
    "wss://api.openai.com/v1/realtime?model=gpt-realtime-2.1-mini",
    header=[f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}"],
)

# Samo audio izlaz, 16-bitni PCM na 24 kHz, s odabranim glasom
ws.send(json.dumps({
    "type": "session.update",
    "session": {
        "type": "realtime",
        "output_modalities": ["audio"],
        "audio": {"output": {"format": {"type": "audio/pcm", "rate": 24000}, "voice": "marin"}},
    },
}))

# Odgovor bez konteksta (prazan ulaz), koji mora izgovoriti tekst točno kako jest
ws.send(json.dumps({
    "type": "response.create",
    "response": {
        "input": [],
        "output_modalities": ["audio"],
        "instructions": f"Izgovori točno sljedeći tekst, bez dodavanja bilo čega:\n{TEXT}",
    },
}))

audio, transcription = bytearray(), []
while True:
    event = json.loads(ws.recv())
    if event["type"] == "response.output_audio.delta":
        audio += base64.b64decode(event["delta"])
    elif event["type"] == "response.output_audio_transcript.delta":
        transcription.append(event["delta"])
    elif event["type"] == "error":
        raise RuntimeError(event["error"]["message"])
    elif event["type"] == "response.done":
        break
ws.close()

with wave.open("welcome.wav", "wb") as wav:
    wav.setnchannels(1)
    wav.setsampwidth(2)  # 16 bita
    wav.setframerate(24000)
    wav.writeframes(bytes(audio))
print("Izgovoreni tekst:", "".join(transcription))

Dvije razlike s Audio API-jem važne su u proizvodnji. Rezultat više nije zajamčen riječ-po-riječ: Realtime model slijedi uputu; ne čita datoteku. Stoga usporedi transkripciju onoga što je rekao, vraćenu u response.output_audio_transcript.delta, s očekivanim tekstom i ponovno generiraj ako postoji neusklađenost. Naplata se također mijenja: slijedi tarife Realtime modela, u tokenima teksta i audija, navedene u njegovom specifikacijskom listu. Konačno, odbijeni ključ ne sprječava povezivanje: on stiže tek nakon toga, u događaju error.

Ključne točke

  • gpt-4o-mini-tts, tts-1 i tts-1-hd gasi se 6. siječnja 2027.; gpt-4o-mini-tts je jedini koji prihvaća upute za glas (instructions)
  • Snimaj audio s with_streaming_response: stream_to_file() na običnom speech.create() je zastarjelo
  • Šest izlaznih formata: MP3, Opus, AAC, FLAC, WAV i sirovi PCM
  • PCM format je idealan za integraciju s Realtime API-jem
  • Ograničenje od 4.096 znakova po zahtjevu: podijeli duge tekstove na granicama rečenica
  • Obrada u serijama s async klijentom ubrzava generiranje velikog sadržaja
  • Migracija prolazi kroz Realtime sesiju s gpt-realtime-2.1-mini: odgovor bez konteksta, 24 kHz PCM audio, transkripcija za usporedbu s tekstom