GPT Realtime Date de sortie : 2025-08-28

import asyncio, base64, json, websockets

URL = "wss://synthorai.io/v1/realtime?model=gpt-realtime"
HEADERS = {"Authorization": "Bearer sk-syn-...", "OpenAI-Beta": "realtime=v1"}

async def main():
    async with websockets.connect(URL, additional_headers=HEADERS) as ws:
        # 1) configure the speech-to-speech session
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {"modalities": ["audio", "text"], "voice": "alloy"},
        }))
        # 2) send input audio (base64 PCM16), then request a spoken reply
        await ws.send(json.dumps({"type": "input_audio_buffer.append", "audio": pcm16_b64}))
        await ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
        await ws.send(json.dumps({"type": "response.create"}))
        # 3) stream the model's audio (and text) back
        async for raw in ws:
            ev = json.loads(raw)
            if ev["type"] == "response.audio.delta":
                play(base64.b64decode(ev["delta"]))   # audio out
            elif ev["type"] == "response.done":
                break

asyncio.run(main())

import WebSocket from "ws";

const ws = new WebSocket("wss://synthorai.io/v1/realtime?model=gpt-realtime", {
  headers: { Authorization: "Bearer sk-syn-...", "OpenAI-Beta": "realtime=v1" },
});

ws.on("open", () => {
  // configure the speech-to-speech session
  ws.send(JSON.stringify({ type: "session.update", session: { modalities: ["audio", "text"], voice: "alloy" } }));
  // send input audio (base64 PCM16), then request a spoken reply
  ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: pcm16Base64 }));
  ws.send(JSON.stringify({ type: "input_audio_buffer.commit" }));
  ws.send(JSON.stringify({ type: "response.create" }));
});

ws.on("message", (raw) => {
  const ev = JSON.parse(raw.toString());
  if (ev.type === "response.audio.delta") playAudio(Buffer.from(ev.delta, "base64")); // audio out
  else if (ev.type === "response.done") ws.close();
});

# Realtime is a WebSocket protocol — use a WS client such as websocat.
# Each line below is one OpenAI Realtime event (JSON) sent to the session.
websocat -H 'Authorization: Bearer sk-syn-...' -H 'OpenAI-Beta: realtime=v1' \
  'wss://synthorai.io/v1/realtime?model=gpt-realtime' <<'EOF'
{"type":"session.update","session":{"modalities":["audio","text"],"voice":"alloy"}}
{"type":"input_audio_buffer.append","audio":"<base64-pcm16>"}
{"type":"input_audio_buffer.commit"}
{"type":"response.create"}
EOF
# Responses stream back as response.audio.delta (base64 audio out) … response.done

package main

import (
	"net/http"

	"github.com/gorilla/websocket"
)

func main() {
	h := http.Header{}
	h.Set("Authorization", "Bearer sk-syn-...")
	h.Set("OpenAI-Beta", "realtime=v1")
	c, _, err := websocket.DefaultDialer.Dial("wss://synthorai.io/v1/realtime?model=gpt-realtime", h)
	if err != nil {
		panic(err)
	}
	defer c.Close()

	// configure the speech-to-speech session, send audio, request a spoken reply
	c.WriteJSON(map[string]any{"type": "session.update", "session": map[string]any{"modalities": []string{"audio", "text"}, "voice": "alloy"}})
	c.WriteJSON(map[string]any{"type": "input_audio_buffer.append", "audio": pcm16B64})
	c.WriteJSON(map[string]any{"type": "input_audio_buffer.commit"})
	c.WriteJSON(map[string]any{"type": "response.create"})

	for {
		var ev struct {
			Type  string `json:"type"`
			Delta string `json:"delta"`
		}
		if err := c.ReadJSON(&ev); err != nil {
			return
		}
		if ev.Type == "response.audio.delta" {
			playAudio(ev.Delta) // base64 audio out
		} else if ev.Type == "response.done" {
			return
		}
	}
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.WebSocket;
import java.util.concurrent.CompletionStage;

// JDK built-in WebSocket — no extra dependency needed.
WebSocket ws = HttpClient.newHttpClient().newWebSocketBuilder()
    .header("Authorization", "Bearer sk-syn-...")
    .header("OpenAI-Beta", "realtime=v1")
    .buildAsync(URI.create("wss://synthorai.io/v1/realtime?model=gpt-realtime"), new WebSocket.Listener() {
        public CompletionStage<?> onText(WebSocket w, CharSequence data, boolean last) {
            // handle response.audio.delta (base64 audio out) / response.done here
            w.request(1);
            return null;
        }
    }).join();

// configure the session, send input audio, then request a spoken reply
ws.sendText("{\"type\":\"session.update\",\"session\":{\"modalities\":[\"audio\",\"text\"],\"voice\":\"alloy\"}}", true);
ws.sendText("{\"type\":\"input_audio_buffer.append\",\"audio\":\"<base64-pcm16>\"}", true);
ws.sendText("{\"type\":\"input_audio_buffer.commit\"}", true);
ws.sendText("{\"type\":\"response.create\"}", true);