OpenAI Audio Speech API: รหัสโปรแกรม เสียง รูปแบบ และค่าใช้จ่าย

The OpenAI API สำหรับเสียงและคำพูด แปลงข้อความเป็นเสียงพูดผ่าน โพสต์https://api.openai.com/v1/audio/speech. ส่งโมเดล ข้อความต้นทาง และเสียงของคุณ; บันทึกคำตอบเป็นไฟล์ MP3 หรือรูปแบบเสียงอื่นที่รองรับ สำหรับการผสานระบบใหม่ที่ต้องการคำแนะนำเกี่ยวกับน้ำเสียงและวิธีการพูด ให้เริ่มด้วย gpt-4o-mini-tts.

คำขอทำงานเป็นเพียงขั้นตอนแรกเท่านั้น คุณยังจำเป็นต้องมีหน่วยคิดค่าบริการที่เหมาะสม ไฟล์ผลลัพธ์ที่สามารถเล่นได้ และแผนการจัดการสำหรับสคริปต์ที่ยาว โมเดล TTS รุ่นใหม่ของ OpenAI ใช้โทเคนข้อความและโทเคนเสียงในการกำหนดราคา ส่วนโมเดล TTS รุ่นเก่าใช้ตัวอักษร ความแตกต่างนี้มีความสำคัญเมื่อคุณประมาณการค่าใช้จ่ายสำหรับการบรรยายเสียงในหนึ่งเดือน.

หากงานของคุณยังรวมถึงการเขียนบท การสร้างภาพ และการตัดต่อวิดีโอด้วย, พื้นที่ทำงานด้านเสียงของ GlobalGPT นำระบบสร้างเสียงพูดมาสู่แพลตฟอร์มสมัครสมาชิกแบบหลายโมเดลที่มีราคาไม่แพง คุณสามารถทำงานกับข้อความ เสียง ภาพ และวิดีโอได้ทั้งหมดในแดชบอร์ดเดียว จากนั้นใช้ API และ CLI ของแพลตฟอร์มนี้เพื่อทำงานผลิตซ้ำได้อย่างมีประสิทธิภาพ API TTS สาธารณะของแพลตฟอร์มนี้ใช้กระบวนการทำงานแบบแยกต่างหาก ซึ่งจะอธิบายไว้ด้านล่าง.

ลองใช้หลายแบบจำลองเสียงได้ทันที

API เสียงและคำพูด OpenAI มีหน้าที่อะไร?

Speech API เป็นจุดปลายทางสำหรับการแปลงข้อความเป็นเสียงพูด: แอปพลิเคชันของคุณจะส่งข้อความที่เขียนไว้ และรับเสียงพูดที่สร้างขึ้น การใช้งานทั่วไป ได้แก่ การแนะนำผลิตภัณฑ์ การบรรยายเพื่อความสะดวกในการเข้าถึง เนื้อหาการเรียนรู้ และเสียงบรรยายสั้นๆ คุณสามารถควบคุมข้อความก่อนที่จะถูกอ่านออกเสียง ซึ่งทำให้มีประโยชน์เมื่อข้อความต้องเป็นไปตามบทที่ได้รับการอนุมัติ.

สำหรับการแปลงเสียงเป็นข้อความ ทิศทางจะกลับกัน: เสียงที่บันทึกไว้ถูกป้อนเข้า และข้อความถูกส่งออก ผู้ช่วยเสียงแบบเรียลไทม์เพิ่มข้อกำหนดอีกข้อหนึ่ง—การฟังและตอบกลับผ่านการสนทนา OpenAI’s เอกสารเสียง แยกกระบวนการทำงานเหล่านี้ออกจากกัน ให้เลือกจุดปลายทาง Speech เมื่อคุณมีข้อความที่ต้องการให้อ่านออกเสียงแล้ว.

ระบบสร้างเสียงสนับสนุนการสตรีมมิ่ง ดังนั้นแอปพลิเคชันจึงสามารถรับเสียงเป็นชิ้นๆ ได้ การบันทึกสตรีมดังกล่าวลงในไฟล์จะไม่ทำให้เสียงนั้นเล่นอัตโนมัติในเบราว์เซอร์หรือสร้างเอเจนต์สนทนาได้ แอปพลิเคชันของคุณยังคงต้องจัดการการเล่นเสียงและตรรกะการสนทนาทั้งหมดเอง OpenAI ยังกำหนดให้ต้องแจ้งให้ผู้ฟังทราบอย่างชัดเจนว่าเสียงดังกล่าวถูกสร้างขึ้นโดย AI.

สร้างไฟล์เสียงแรกของคุณด้วย OpenAI Speech API

เรียกใช้คำขอนี้บนเซิร์ฟเวอร์หรือเครื่องพัฒนาของคุณ โดยใช้กุญแจ API OpenAI ที่เก็บไว้ใน OPENAI_API_KEY ตัวแปรสภาพแวดล้อม ให้หลีกเลี่ยงการใช้คีย์ใน JavaScript ของเบราว์เซอร์ ตัวอย่างต่อไปนี้ใช้สคริปต์สั้นๆ เดียวกันสำหรับการแนะนำผลิตภัณฑ์ และบันทึกผลลัพธ์เป็น openai-product-tour.mp3.

ตัวเลือก 1: ส่งคำขอแบบ curl

#!/bin/sh
# ตั้งค่า OPENAI_API_KEY ในสภาพแวดล้อมเซิร์ฟเวอร์ของคุณก่อน
curl --fail-with-body --show-error \
  https://api.openai.com/v1/audio/speech \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini-tts",
    "input": "ยินดีต้อนรับสู่การทัวร์ผลิตภัณฑ์ Acorn Studio ในสามขั้นตอน คุณสามารถเปลี่ยนสคริปต์สั้นๆ ให้เป็นคู่มือเสียงได้ ขั้นแรก เขียนข้อความ ขั้นต่อไป เลือกเสียง และสุดท้าย บันทึกไฟล์เสียงและทดสอบการเล่นบนโทรศัพท์ของคุณ",
    "voice": "coral",
    "instructions": "พูดอย่างชัดเจนด้วยน้ำเสียงที่อบอุ่นและเป็นกันเอง.",
    "response_format": "mp3"
  }' \
  --output openai-product-tour.mp3

คำตอบนี้มีไบต์เสียงอยู่ ดังนั้นควรบันทึกมันลงในไฟล์แทนที่จะพยายามวิเคราะห์มันเป็น JSON. The --fail-with-body ตัวเลือกนี้ทำให้ curl ส่งสถานะการออกที่ล้มเหลวเมื่อเกิดข้อผิดพลาด HTTP ตรวจสอบสถานะนั้นก่อนเปิดไฟล์: การตอบกลับที่ผิดพลาดอาจยังคงทิ้งข้อมูล JSON ไว้ในไฟล์ที่มีชื่อว่า .mp3.

ตัวเลือก 2: ใช้ Python SDK

ติดตั้งแพ็กเกจ OpenAI ด้วย python -m pip install openai. SDK จะอ่าน API key จากสภาพแวดล้อม ตัวอย่างนี้เขียนคำตอบลงทันทีที่รับมา ซึ่งช่วยหลีกเลี่ยงการโหลดคำตอบเสียงทั้งหมดเข้าสู่บัฟเฟอร์ Python ของคุณ.

"""ติดตั้ง: python -m pip install openai. ตั้งค่า OPENAI_API_KEY บนเซิร์ฟเวอร์."""
from pathlib import Path
from openai import OpenAI

client = OpenAI(max_retries=0)
script = (
    "ยินดีต้อนรับสู่การทัวร์ผลิตภัณฑ์ Acorn Studio ในสามขั้นตอน คุณสามารถเปลี่ยน "
    "บทสคริปต์สั้นๆ ให้กลายเป็นคู่มือเสียงได้ ขั้นแรก เขียนข้อความ ขั้นต่อไป "
    "เลือกเสียง และขั้นสุดท้าย บันทึกไฟล์เสียงและทดสอบการเล่นบนโทรศัพท์ของคุณ"
)

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input=script,
    instructions="พูดอย่างชัดเจนด้วยน้ำเสียงที่อบอุ่นและเป็นกันเอง.",
    response_format="mp3",
) as response:
    response.stream_to_file(Path("openai-product-tour.mp3"))

print("Saved openai-product-tour.mp3")

สามสนามหลักคือ แบบจำลอง, ข้อมูลเข้า, และ เสียง. ที่นี่, คำแนะนำ ต้องการการส่งเสียงที่อบอุ่นและเป็นธรรมชาติเหมือนการสนทนา; มันช่วยนำทางเสียงแทนที่จะเพิ่มคำเข้าไปในบทพูด ระบบนี้ทำงานร่วมกับ GPT-4o Mini TTS และไม่ได้รับการสนับสนุนจาก tts-1 และ tts-1-hd.

สำหรับเอกสารที่ยาวกว่า ให้แบ่งข้อความตามจุดแบ่งของประโยคหรือย่อหน้า กำหนดหมายเลขให้กับแต่ละส่วน และบันทึกแต่ละส่วนด้วยหมายเลขนั้น รักษาสไตล์การพูดและคำสั่งให้สอดคล้องกันในทุกส่วน ให้มีบริบทเพียงพอเพื่อให้การพูดฟังดูเป็นธรรมชาติ และตรวจสอบการเชื่อมต่อระหว่างส่วนต่าง ๆ ก่อนที่จะแจกจ่ายไฟล์บันทึกที่รวมไว้.

เลือกรุ่น เสียง และรูปแบบผลลัพธ์

The หน้าแบบ Mini TTS GPT-4o กำหนด alias ของโมเดลไปยัง gpt-4o-mini-tts-2025-12-15 snapshot. หากพฤติกรรมที่สามารถทำซ้ำได้มีความสำคัญต่อแอปพลิเคชันของคุณ ให้เลือก snapshot ที่มีเอกสารบันทึกไว้อย่างตั้งใจ และบันทึกมันไว้พร้อมกับสคริปต์ที่เก็บไว้.

เสียงที่ติดตั้งมาพร้อมเครื่องและขีดจำกัดการป้อนข้อมูล

คู่มืออ้างอิงของ Speech API ระบุว่ามีเสียงในตัว 13 เสียงสำหรับ GPT-4o Mini TTS: อัลลอย, แอช, บัลลาด, คอรัล, เอคโค่, ฟาเบิล, ออนิกซ์, โนวา, เซจ, ชิมเมอร์, เวอร์ส, มาริน, และ ซีดาร์. OpenAI แนะนำว่า มาริน หรือ ซีดาร์ เพื่อคุณภาพที่ดีที่สุด นี่คือคำแนะนำจาก OpenAI: ให้เลือกเสียงในการผลิตโดยฟังชื่อ ตัวเลข และรูปแบบประโยคของคุณเอง.

รุ่น TTS ที่ออกมาก่อนหน้านั้นรองรับชุดเสียงที่น้อยกว่า ได้แก่ alloy, ash, coral, echo, fable, onyx, nova, sage และ shimmer อย่าคิดว่าเสียงทุกเสียงจะใช้งานได้กับทุกรุ่น คู่มือ API Speech ยังรับค่าความเร็วในช่วงระหว่าง 0.25 และ 4.0, พร้อมด้วย 1.0 เป็นค่าเริ่มต้น.

มีสองขีดจำกัดการป้อนข้อมูลที่ต้องพิจารณา: ขีดจำกัดอ้างอิงของจุดสิ้นสุด ข้อมูลเข้า ถึง 4,096 ตัวอักษร, และหน้าข้อมูลรุ่น Mini TTS ระบุไว้ว่าสูงสุดคือ 2,000 โทเคนข้อมูลเข้า. ตัวอักษรและโทเคนมีหน่วยวัดที่แตกต่างกัน โปรดตรวจสอบข้อจำกัดทั้งสองของ Mini TTS โดยเฉพาะอย่างยิ่งเมื่อใช้ข้อความหลายภาษา และแบ่งสคริปต์ที่มีขนาดใหญ่ก่อนส่ง.

เลือกรูปแบบไฟล์สำหรับจุดหมายปลายทาง

เริ่มด้วย MP3 หากต้องการลิงก์ดาวน์โหลดหรือเครื่องเล่นเสียงแบบง่ายๆ ให้เลือก WAV เมื่อขั้นตอนต่อไปคือการแก้ไข ให้เลือก PCM แบบดิบเฉพาะเมื่อโปรแกรมของคุณสามารถตีความได้; การเปลี่ยนชื่อไฟล์จาก .pcm ถึง .wav ไม่สร้างส่วนหัว WAV.

ค่าบริการของ API เสียง OpenAI เป็นเท่าใด?

ตามข้อมูลที่ตรวจสอบเมื่อวันที่ 28 กันยายน 2569 OpenAI ได้ระบุ GPT-4o Mini TTS ไว้ที่ $0.60 ต่อหนึ่งล้านโทเคนข้อความที่ป้อนเข้า บวก $12 ต่อหนึ่งล้านโทเคนสัญญาณเสียง. ราคาของ TTS-1 $15 ต่อหนึ่งล้านตัวอักษร, และ TTS-1 HD มีราคา $30 ต่อหนึ่งล้านตัวอักษร. คำนวณแต่ละโมเดลด้วยหน่วยวัดของตัวเอง.

ตัวอย่างเช่น สคริปต์ 100 ฉบับ แต่ละฉบับมี 1,000 ตัวอักษร รวมเป็น 100,000 ตัวอักษร ตามอัตราที่ระบุไว้ นั่นคือ $1.50 พร้อม TTS-1 หรือ $3.00 พร้อม TTS-1 HD, ก่อนค่าใช้จ่ายอื่นๆ ของแอปพลิเคชัน จำนวนตัวอักษรเท่ากันนี้ไม่เพียงพอที่จะคำนวณ Mini TTS ได้อย่างแม่นยำ: คุณจำเป็นต้องมีจำนวนโทเคนของข้อความที่ป้อนเข้าและจำนวนโทเคนของเสียงที่ออก.

เพื่อวางแผน ให้ป้อนจำนวนการใช้งานจริงหรือสมมติฐานที่ชัดเจนลงในเครื่องคำนวณ ให้ถือว่าช่อง Mini TTS audio-token เป็นข้อมูลป้อนเข้าสำหรับงบประมาณ จนกว่าจะมีการวัดปริมาณการใช้งานแล้ว อย่าใช้ตัวเลขประมาณการต่อนาทีมาแทนที่ราคาที่รับประกันสำหรับทุกเสียง ความเร็วการพูด หรือภาษา.

แคตตาล็อกรุ่น GlobalGPT แสดงราคา TTS ในรูปเครดิต และจุดสิ้นสุดการประมาณการจะให้ราคาเสนอสำหรับคำขอที่คุณตั้งใจจะส่ง โปรดแยกการใช้เครดิต API ออกจาก việcเลือกการสมัครสมาชิกพื้นที่ทำงานแบบหลายโมเดล สำหรับงานเขียนและงานสื่อประจำวัน สิ่งนี้ช่วยให้การติดตามงบประมาณง่ายขึ้น โดยไม่ต้องสมมติว่าผลิตภัณฑ์ทั้งสองใช้โควตาการเรียกเก็บเงินร่วมกัน.

สร้างกระบวนการทำงาน TTS ด้วย API GlobalGPT

เพื่อสร้างกระบวนการทำงานที่สามารถทำซ้ำได้ตั้งแต่สคริปต์ ไปสู่เสียง และสู่วิดีโอ, สร้างข้อความใน GlobalGPT และเก็บส่วนที่เหลือของโครงการไว้ในพื้นที่ทำงานเดียวกัน ส่วน API GlobalGPT แสดงให้เห็นว่าสื่อมวลชนถูกมองเป็นเพียงงาน ในขณะที่ GlobalGPT CLI การเชื่อมต่อที่ทำงานร่วมกับเทอร์มินัลและเครื่องมือพัฒนาของคุณ.

รับ API Key ทันที

ใช้ URL ฐานข้อมูลสาธารณะ https://api2.glbgpt.com/ai-api/open/v1. ส่งคำขอ TTS ไปที่ POST /tasks, สอบถาม GET /tasks/{id}, และดาวน์โหลด output.url หลังจากที่งานเสร็จสิ้นแล้ว ช่องข้อความคือ คำสั่ง. ดำเนินการตามสัญญาการทำงานนี้โดยตรง; ซึ่งแตกต่างจากระบบตอบสนองเสียงทันทีของ OpenAI.

เลือกโมเดล TTS GlobalGPT ที่มีเอกสารประกอบ

รายการทั้งสามรายการ 330 เครดิตต่อ 1,000 ตัวอักษร. ใช้ POST /tasks/estimate พร้อมด้วยเนื้อหาคำขอที่ตั้งใจไว้สำหรับใบประมาณการที่เกี่ยวข้อง; เอกสารระบุว่าสิ่งนี้ไม่สร้างงานและไม่สำรองเครดิตไว้ การเข้าถึง API สาธารณะใช้เครดิตที่ชำระแล้ว.

สำหรับกระบวนการทำงานด้านการสร้างเนื้อหาโดยรวม โปรดดู กระบวนการแปลงข้อความเป็นเสียงใน GlobalGPT. หากท่านกำลังศึกษาตระกูลซอฟต์แวร์โอเพนซอร์ส Qwen3-TTS ที่มีชื่อแยกต่างหาก โปรดอ่าน รุ่น Qwen3-TTS และตัวเลือก API; อย่าถือว่า ID รุ่น Qwen-Audio ข้างต้นเป็นการปรับใช้ Qwen3-TTS ที่สามารถใช้แทนกันได้.

ประมาณการ ส่งครั้งเดียว แล้วตรวจสอบงานที่บันทึกไว้

ติดตั้ง คำขอ กับ python -m pip install requests และตั้งค่า GLOBALGPT_API_KEY บนเซิร์ฟเวอร์ ตัวอย่างด้านล่างนี้ใช้ Eleven v3 เลือก ID เสียงสาธารณะที่มีเอกสารประกอบ และกำหนดขีดจำกัดสูงสุดเพื่อแสดงตัวอย่างไว้ที่ 500 เครดิต โปรดปรับเปลี่ยนขีดจำกัดดังกล่าวให้สอดคล้องกับงบประมาณของคุณก่อนที่จะรันโปรแกรม.

"""ติดตั้ง requests; ตั้งค่า GLOBALGPT_API_KEY ใช้ API งานสาธารณะของ GlobalGPT."""
import json
import os
import time
import uuid
from pathlib import Path
import requests

BASE = "https://api2.glbgpt.com/ai-api/open/v1"
STATE = Path("globalgpt-tts-job.json")
OUTPUT = Path("globalgpt-product-tour.mp3")
MAX_CREDITS = 500  # ขีดจำกัดต่องานของคุณ; แก้ไขก่อนการรัน

payload = {
    "model": "eleven-v3",
    "prompt": (
 "ยินดีต้อนรับสู่การทัวร์ผลิตภัณฑ์ Acorn Studio. ในสามขั้นตอน คุณสามารถเปลี่ยน "
 "บทสคริปต์สั้นๆ ให้กลายเป็นคู่มือเสียงได้ ก่อนอื่น ให้เขียนข้อความ จากนั้น "
 "เลือกเสียง สุดท้าย ให้บันทึกไฟล์เสียงและทดสอบการเล่นบนโทรศัพท์ของคุณ"
    ),
    "metadata": {
 "voice_id": "JBFqnCBsd6RMkjVDRZzb",
 "stability": 0.5,
 "language_code": "en",
    },
}

api = requests.Session()
api.headers["Authorization"] = "Bearer " + os.environ["GLOBALGPT_API_KEY"]

if STATE.exists():
    job = json.loads(STATE.read_text())
    if job["payload"] != payload:
 raise RuntimeError("งานนี้เกี่ยวข้องกับข้อมูลเข้าที่ต่างกัน โปรดใช้ชื่อไฟล์สถานะใหม่")
else:
    estimate = api.post(BASE + "/tasks/estimate", json=payload, timeout=30)
    estimate.raise_for_status()
    quote = estimate.json()
    print("เครดิตที่ประมาณการ:", quote["credits"])
    if quote["credits"] > MAX_CREDITS:
 raise RuntimeError("การประมาณค่าเกินขีดจำกัดต่องานของคุณแล้ว")
    job = {"payload": payload, "idempotency_key": str(uuid.uuid4())}
    STATE.write_text(json.dumps(job, indent=2))

if "task_id" not in job:
    # คีย์ที่เก็บถาวรจะเก็บการลองส่งข้อมูลใหม่ (transport retry) ที่ผูกกับคำขอนี้โดยเฉพาะ
    submitted = api.post(
 BASE + "/tasks", json=payload,
 headers={"Idempotency-Key": job["idempotency_key"]}, timeout=60,
    )
    submitted.raise_for_status()
    task = submitted.json()
    job["task_id"] = task["id"]
    STATE.write_text(json.dumps(job, indent=2))
    if task.get("ignored_parameters"):
 print("พารามิเตอร์ที่ถูกเพิกเฉย:", task["ignored_parameters"])

print("งาน:", job["task_id"])
deadline = time.monotonic() + 600
while time.monotonic() < deadline:
    checked = api.get(BASE + "/tasks/" + str(job["task_id"]), timeout=30)
    checked.raise_for_status()
    task = checked.json()
    if task.get("ignored_parameters"):
 print("พารามิเตอร์ที่ถูกเพิกเฉย:", task["ignored_parameters"])
    if task["status"] == "failed":
 raise RuntimeError("Generation failed: " + json.dumps(task.get("error", {})))
    if task["status"] == "succeeded":
        # ใช้คำขอใหม่: ไม่ส่ง API key ไปยัง media host
 audio = requests.get(task["output"]["url"], timeout=60)
 audio.raise_for_status()
        OUTPUT.write_bytes(audio.content)
 print("บันทึกแล้ว:", OUTPUT)
 break
    time.sleep(10)
else:
    raise TimeoutError("งานยังอยู่ระหว่างดำเนินการ โปรดรันใหม่เพื่อตรวจสอบ ID งานที่บันทึกไว้")

ไฟล์งานจะบันทึกคำขอที่แม่นยำ คีย์ความคงที่ (idempotency key) และ ID ของงาน หากการเชื่อมต่อถูกตัดขาด ให้รันงานเดียวกันอีกครั้ง เพื่อให้โค้ดสามารถดำเนินการต่อจากงานที่มีอยู่ได้ หากต้องการสร้างเสียงที่แตกต่างกันโดยตั้งใจ ให้ใช้ชื่อไฟล์งานใหม่ และควรเก็บไฟล์งานไว้เป็นส่วนตัว หากสคริปต์ในไฟล์นั้นมีข้อมูลลับ.

ตรวจสอบ พารามิเตอร์ที่ถูกเพิกเฉย ดังนั้น การตั้งค่าที่ไม่ได้รับการสนับสนุนจะไม่ถูกกำหนดเป็นการตั้งค่าเริ่มต้นของคุณโดยอัตโนมัติ การควบคุม ElevenLabs เช่น voice_id แตกต่างจากของ Qwen เสียง และ ประเภทภาษา สนามข้อมูล ตรวจสอบทุก 5–10 วินาที จัดการกับ ล้มเหลว สถานะ และบันทึกไฟล์ที่บันทึกสำเร็จทันที: การเก็บรักษาผลลัพธ์ที่บันทึกไว้คือ 30 วัน.

ฟังตัวอย่างการนำชมผลิตภัณฑ์สองตัวอย่าง

ตัวอย่างทั้งสองนี้ที่สร้างขึ้นด้วย AI ใช้สคริปต์การแนะนำผลิตภัณฑ์เดียวกันที่มีความยาว 216 ตัวอักษร โดยใช้ Eleven v3 และ Qwen Audio 3.0 TTS Flash แต่ละตัวอย่างเป็นผลลัพธ์แรกจากการร้องขอครั้งเดียว โดยใช้การตั้งค่าเสียงตามค่าเริ่มต้น คุณจะได้รับไฟล์สั้นสองไฟล์เพื่อตรวจสอบและฟังตัวอย่าง; ตัวอย่างเหล่านี้ไม่ใช่การเปรียบเทียบที่ควบคุมอย่างละเอียดระหว่างเสียงที่ตรงกัน หรือการวัดประสิทธิภาพเสียงของ OpenAI.

Eleven v3: เสียงนำชมผลิตภัณฑ์

Qwen Audio 3.0 TTS Flash: เสียงแนะนำผลิตภัณฑ์

ตัวอย่าง Qwen มีขนาดประมาณสามเท่าของตัวอย่าง Eleven สำหรับความยาวที่คล้ายกัน ซึ่งสะท้อนถึงความแตกต่างระหว่างรูปแบบ WAV และ MP3 นอกจากนี้ ส่วนหัวของไฟล์ WAV ยังระบุข้อมูลมากกว่าปริมาณข้อมูลที่ไฟล์นั้นเก็บไว้จริง นี่เป็นปัญหาด้านการจัดแพ็กเกจไฟล์ที่ควรตรวจสอบในเครื่องเล่นเป้าหมายของคุณ; แต่ปัญหาดังกล่าวเองไม่ได้บ่งชี้อะไรเกี่ยวกับคุณภาพของเสียงพูด.

แก้ไขปัญหาทั่วไปในการสร้างเสียงพูด

สำหรับข้อผิดพลาด OpenAI ให้เริ่มจาก คู่มือเกี่ยวกับรหัสข้อผิดพลาด. สำหรับงาน GlobalGPT ให้บันทึก ID ของงานและรายละเอียดข้อผิดพลาดที่ระบบส่งกลับมาไว้ ระหว่างการพัฒนา ให้แยกข้อผิดพลาดในการส่งข้อมูล ข้อผิดพลาดในการเรียกเก็บเงิน และคุณภาพเสียงที่ไม่เป็นที่น่าพอใจออกจากกัน: เพราะแต่ละกรณีต้องการวิธีแก้ไขที่แตกต่างกัน.

ก่อนส่งบทบรรยาย ให้ฟังบันทึกเสียงทั้งหมดบนอุปกรณ์ที่ผู้ฟังจะใช้ ตรวจสอบส่วนเปิดต้นเรื่อง ชื่อและตัวเลข การเปลี่ยนผ่านระหว่างส่วนต่าง ๆ และประโยคสุดท้าย ให้ใส่คำแจ้งเตือนเกี่ยวกับเสียง AI ไว้ใกล้จุดเริ่มต้นการเล่น และเก็บสำเนาของข้อความต้นฉบับและการตั้งค่าโมเดลไว้อย่างครบถ้วน เพื่อสามารถสร้างบทบรรยายที่แก้ไขแล้วขึ้นมาใหม่ได้อย่างถูกต้อง.

คำถามที่มักถูกถาม

จุดปลายทางของ API เสียงและคำพูด OpenAI คืออะไร?

ใช้ POST https://api.openai.com/v1/audio/speech. สนามข้อมูลที่จำเป็นคือ model, input และ voice. ผลลัพธ์คือไฟล์เสียงที่สร้างขึ้น; MP3 เป็นรูปแบบมาตรฐาน.

API เสียง OpenAI เป็นบริการฟรีหรือไม่?

API Speech มีระบบการคิดค่าบริการตามการใช้งาน โปรดวางแผนงบประมาณโดยใช้อัตราค่าบริการ API ปัจจุบัน แทนที่จะสมมติว่ามีโควตาฟรี: GPT-4o Mini TTS จะถูกคิดค่าบริการตามโทเคนการป้อนข้อความและโทเคนการส่งออกเสียง ส่วน TTS-1 และ TTS-1 HD จะถูกคิดค่าบริการตามจำนวนตัวอักษร.

ผมสามารถควบคุมเสียงและสไตล์การพูดได้ไหมครับ?

เลือกเสียงที่รองรับโดยโมเดลของคุณ GPT-4o Mini TTS ยังรับคำสั่งเกี่ยวกับวิธีการพูดได้ เช่น น้ำเสียงที่อบอุ่นหรือสงบ อย่างไรก็ตาม ช่องคำสั่งนี้ไม่ทำงานกับ TTS-1 หรือ TTS-1 HD.

API ของ Speech รองรับการสตรีมหรือไม่?

ใช่ครับ มันสามารถสตรีมเสียงที่สร้างขึ้นเป็นส่วนๆ ได้ แต่แอปพลิเคชันของคุณยังต้องจัดการการเล่นเสียงด้วย เพราะการสตรีมการแปลงข้อความเป็นเสียงเพียงอย่างเดียว ยังไม่สามารถสร้างการสนทนาด้วยเสียงแบบสดที่สมบูรณ์ได้.

ผมสามารถใช้ GlobalGPT ได้หรือไม่ โดยเปลี่ยน URL หลักของ OpenAI?

ใช้ขั้นตอนการทำงานของงานสื่อ (media-task workflow) ที่ได้รับการบันทึกไว้ของ GlobalGPT สำหรับ TTS: ส่งข้อมูลไปยัง POST /tasks, ตรวจสอบสถานะด้วย GET /tasks/{id}, และดาวน์โหลด output.url หลังจากดำเนินการสำเร็จแล้ว รายชื่อโมเดล TTS ที่ได้รับการบันทึกไว้ของมันรวมถึงโมเดล ElevenLabs และ Qwen พร้อมด้วย ID และพารามิเตอร์ของโมเดลแต่ละตัว.

ควรเริ่มใช้รูปแบบไฟล์เสียงแบบไหนดี?

เริ่มด้วยไฟล์ MP3 สำหรับการดาวน์โหลดหรือเล่นผ่านเว็บแบบง่ายๆ ไฟล์ WAV มีประโยชน์เมื่อต้องการดำเนินการแก้ไขในขั้นตอนต่อไป ส่วนไฟล์ PCM แบบดิบ (Raw PCM) ต้องใช้โปรแกรมเล่นที่ตั้งค่าให้เหมาะสมกับอัตราการสุ่มตัวอย่างและความลึกของบิต เนื่องจากไฟล์นี้ไม่มีส่วนหัวไฟล์.

เริ่มด้วยสคริปต์สั้นหนึ่งบท เสียงหนึ่งชุด และไฟล์ที่บันทึกไว้หนึ่งไฟล์ เมื่อสามารถคาดการณ์การส่งข้อมูลและค่าใช้จ่ายได้แล้ว ให้เพิ่มการแบ่งเป็นชิ้น (chunking) การลองใหม่ (retries) และขั้นตอนอื่นๆ ในกระบวนการทำงานของสื่อของคุณ ให้รักษาให้รูปแบบคำขอของ API ที่เลือก หน่วยการคิดค่าบริการ และการจัดการผลลัพธ์ไว้เป็นหนึ่งเดียวในการนำไปใช้งาน.