Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Gemini-TTS

אפשר לנסות את Gemini-TTS ב-Vertex AI Studio אפשר לנסות ב-Colab הצגת המחברת ב-GitHub

‫Gemini-TTS הוא השלב האחרון בהתפתחות של טכנולוגיית Cloud TTS שלנו. הוא לא רק מספק דיבור שנשמע טבעי, אלא גם מאפשר שליטה מדויקת באודיו שנוצר באמצעות הנחיות מבוססות-טקסט. בעזרת Gemini-TTS, אתם יכולים לסנתז דיבור של דובר אחד או כמה דוברים מקטעים קצרים ועד לסיפורים ארוכים, ולשלוט בדיוק בסגנון, במבטא, בקצב, בטון ואפילו בהבעה הרגשית, והכול באמצעות הנחיות בשפה טבעית.

מודלים זמינים

‫Gemini-TTS כולל את המודלים הבאים:

‫Gemini 3.1 Flash TTS (גרסת טרום-השקה)

מזהה המודל	`gemini-3.1-flash-tts-preview`
אופטימיזציה ל	יצירת אודיו ב-Cloud TTS עם זמן אחזור נמוך, שליטה, רמקול יחיד ורמקולים מרובים לאפליקציות יומיומיות חסכוניות
אמצעי קלט ופלט	קלט: טקסט פלט: אודיו
מגבלות על טוקנים	קלט: 8,192 פלט: 16,384
תמיכה במספר הרמקול	דובר יחיד, דוברים מרובים (דיאלוג)
פורמטים נתמכים של פלט אודיו	אונארי: `LINEAR16` (ברירת מחדל), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` סטרימינג: `PCM` (ברירת מחדל), `ALAW`, `MULAW`, `OGG_OPUS`
תמיכה באזור	אזורים זמינים
אפשרויות קול	אפשרויות קוליות
אפשרויות קול	אפשרויות קוליות חשוב לזכור שכל הקולות של Gemini 3.1 Flash TTS הם בגרסת טרום-השקה.
אפשרויות צריכה	מידע נוסף זמין במאמר בנושא תשלום רגיל לפי שימוש.
דוגמה	model: "gemini-3.1-flash-tts-preview" prompt: "You are having a casual conversation with a friend. Say the following in a friendly and amused way." text: "[laughs] I did NOT expect that. [sigh] Can you believe it!" speaker: "Callirrhoe"

Gemini ‎2.5 Flash TTS

מזהה המודל	`gemini-2.5-flash-tts`
אופטימיזציה ל	יצירת אודיו ב-Cloud TTS עם זמן אחזור נמוך, שליטה, רמקול יחיד ורמקולים מרובים לאפליקציות יומיומיות חסכוניות
אמצעי קלט ופלט	קלט: טקסט פלט: אודיו
מגבלות על טוקנים	קלט: 8,192 פלט: 16,384
תמיכה במספר הרמקול	רמקול יחיד, רמקולים מרובים
פורמטים נתמכים של פלט אודיו	אונארי: `LINEAR16` (ברירת מחדל), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` סטרימינג: `PCM` (ברירת מחדל), `ALAW`, `MULAW`, `OGG_OPUS`
תמיכה באזור	אזורים זמינים
אפשרויות קול	אפשרויות קוליות
השפות הזמינות	רשימת השפות הזמינות
דוגמה	model: "gemini-2.5-flash-tts" prompt: "Say the following." text: "[extremely fast] Availability and terms may vary. Check our website or your local store for complete details and restrictions." speaker: "Kore"

Gemini 2.5 Flash Lite TTS (גרסת טרום-השקה — Preview)

מזהה המודל	`gemini-2.5-flash-lite-preview-tts`
אופטימיזציה ל	יצירת אודיו ב-Cloud TTS עם זמן אחזור נמוך, שאפשר לשלוט בו, של דובר יחיד, לאפליקציות יומיומיות חסכוניות. שימו לב שהמודל הזה נמצא בגרסת טרום-השקה.
אמצעי קלט ופלט	קלט: טקסט פלט: אודיו
מגבלות על טוקנים	קלט: 8,192 פלט: 16,384
תמיכה במספר הרמקול	רווק/ה
פורמטים נתמכים של פלט אודיו	אונארי: `LINEAR16` (ברירת מחדל), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` סטרימינג: `PCM` (ברירת מחדל), `ALAW`, `MULAW`, `OGG_OPUS`
תמיכה באזור	אזורים זמינים
אפשרויות קול	אפשרויות קוליות
השפות הזמינות	רשימת השפות הזמינות
דוגמה	model: "gemini-2.5-flash-lite-preview-tts" prompt: "Say the following in an elated way." text: "Congratulations on the recent achievements!" speaker: "Aoede"

Gemini 2.5 Pro TTS

מזהה המודל	`gemini-2.5-pro-tts`
אופטימיזציה ל	שליטה גבוהה בתהליכי עבודה מובנים כמו יצירת פודקאסטים, ספרי אודיו, תמיכת לקוחות ועוד
אמצעי קלט ופלט	קלט: טקסט פלט: אודיו
מגבלות על טוקנים	קלט: 8,192 פלט: 16,384
תמיכה במספר הרמקול	רמקול יחיד, רמקולים מרובים
פורמטים נתמכים של פלט אודיו	אונארי: `LINEAR16` (ברירת מחדל), `ALAW`, `MULAW`, `MP3`, `OGG_OPUS`, `PCM` סטרימינג: `PCM` (ברירת מחדל), `ALAW`, `MULAW`, `OGG_OPUS`
תמיכה באזור	אזורים זמינים
אפשרויות קול	אפשרויות קוליות
השפות הזמינות	רשימת השפות הזמינות
דוגמה	model: "gemini-2.5-pro-tts" prompt: "You are having a casual conversation with a friend. Say the following in a friendly and amused way." text: "hahah I did NOT expect that. Can you believe it!" speaker: "Callirrhoe"

אמצעי בקרה נוספים

אמצעי בקרה ויכולות נוספים כוללים את האפשרויות הבאות:

שיחה טבעית: אינטראקציות קוליות באיכות גבוהה במיוחד, עם הבעה מתאימה יותר ודפוסי קצב, שמועברות עם זמן אחזור נמוך מאוד כדי שתוכלו לנהל שיחה בצורה שוטפת.
שליטה בסגנון: באמצעות הנחיות בשפה טבעית, אתם יכולים לשנות את אופן ההעברה של המידע בשיחה. למשל, להנחות את המודל להשתמש במבטאים ספציפיים, ליצור מגוון של טונים וביטויים, כולל לחישה.
ביצועים דינמיים: המודלים האלה יכולים להפיח חיים בטקסט וליצור קריאות אקספרסיביות של שירה, שידורי חדשות וסיפורים מרתקים. הם גם יכולים להציג רגשות ספציפיים ולבטא מבטאים שונים לפי בקשה.
שליטה משופרת בקצב ובהגייה: שליטה במהירות המסירה עוזרת להבטיח הגייה מדויקת יותר, כולל מילים ספציפיות.

במאמר בחירת ה-API המתאים מוסבר איך לבחור את ה-API המתאים לשימוש בקולות האלה באפליקציה.

אפשרויות קול

‫Gemini-TTS מציע מגוון רחב של אפשרויות קוליות, בדומה ל-Chirp 3: HD Voices הקיים שלנו, ולכל אחת מהן מאפיינים ייחודיים:

שם	מגדר	הדגמה
Achernar	נקבה
Achird	זכר
Algenib	זכר
Algieba	זכר
Alnilam	זכר
Aoede	נקבה
Autonoe	נקבה
Callirrhoe	נקבה
כארון	זכר
Despina	נקבה
אנקלאדוס	זכר
Erinome	נקבה
Fenrir	זכר
Gacrux	נקבה
יאפטוס	זכר
Kore	נקבה
Laomedeia	נקבה
Leda	נקבה
Orus	זכר
Pulcherrima	נקבה
Puck	זכר
Rasalgethi	זכר
Sadachbia	זכר
Sadaltager	זכר
Schedar	זכר
Sulafat	נקבה
Umbriel	זכר
Vindemiatrix	נקבה
Zephyr	נקבה
Zubenelgenubi	זכר

השפות הזמינות

‫Gemini-TTS תומך בשפות הבאות:

שפה	קוד BCP-47	מוכנות להשקה
ערבית (מצרים)	ar-EG	GA
בנגלית (בנגלדש)	bn-BD	GA
הולנדית (הולנד)	nl-NL	GA
אנגלית (הודו)	en-IN	GA
אנגלית (ארצות הברית)	en-US	GA
צרפתית (צרפת)	fr-FR	GA
גרמנית (גרמניה)	de-DE	GA
הינדית (הודו)	hi-IN	GA
אינדונזית (אינדונזיה)	id-ID	GA
איטלקית (איטליה)	it-IT	GA
יפנית (יפן)	ja-JP	GA
קוריאנית (דרום קוריאה)	ko-KR	GA
מראטהית (הודו)	mr-IN	GA
פולנית (פולין)	pl-PL	GA
פורטוגזית (ברזיל)	pt-BR	GA
רומנית (רומניה)	ro-RO	GA
רוסית (רוסיה)	ru-RU	GA
ספרדית (ספרד)	es-ES	GA
טמילית (הודו)	ta-IN	GA
טלוגו (הודו)	te-IN	GA
תאית (תאילנד)	th-TH	GA
טורקית (טורקיה)	tr-TR	GA
אוקראינית (אוקראינה)	uk-UA	GA
וייטנאמית (וייטנאם)	vi-VN	GA
אפריקאנס (דרום אפריקה)	af-ZA	תצוגה מקדימה
אלבנית (אלבניה)	sq-AL	תצוגה מקדימה
אמהרית (אתיופיה)	am-ET	תצוגה מקדימה
ערבית (עולם)	ar-001	תצוגה מקדימה
ארמנית (ארמניה)	hy-AM	תצוגה מקדימה
אזרית (אזרבייג'ן)	az-AZ	תצוגה מקדימה
בסקית (ספרד)	eu-ES	תצוגה מקדימה
בלארוסית (בלארוס)	be-BY	תצוגה מקדימה
בולגרית (בולגריה)	bg-BG	תצוגה מקדימה
בורמזית (מיאנמר)	my-MM	תצוגה מקדימה
קטלאנית (ספרד)	ca-ES	תצוגה מקדימה
סבואנו (הפיליפינים)	ceb-PH	תצוגה מקדימה
סינית, מנדרינית (סין)	cmn-CN	תצוגה מקדימה
סינית, מנדרינית (טייוואן)	cmn-tw	תצוגה מקדימה
קרואטית (קרואטיה)	hr-HR	תצוגה מקדימה
צ'כית (צ'כיה)	cs-CZ	תצוגה מקדימה
דנית (דנמרק)	da-DK	תצוגה מקדימה
אנגלית (אוסטרליה)	en-AU	תצוגה מקדימה
אנגלית (בריטניה)	en-GB	תצוגה מקדימה
אסטונית (אסטוניה)	et-EE	תצוגה מקדימה
פיליפינית (פיליפינים)	fil-PH	תצוגה מקדימה
פינית (פינלנד)	fi-FI	תצוגה מקדימה
צרפתית (קנדה)	fr-CA	תצוגה מקדימה
גליציאנית (ספרד)	gl-ES	תצוגה מקדימה
גאורגית (גאורגיה)	ka-GE	תצוגה מקדימה
יוונית (יוון)	el-GR	תצוגה מקדימה
גוג'ראטית (הודו)	gu-IN	תצוגה מקדימה
קריאולית האיטית (האיטי)	ht-HT	תצוגה מקדימה
עברית (ישראל)	he-IL	תצוגה מקדימה
הונגרית (הונגריה)	hu-HU	תצוגה מקדימה
איסלנדית (איסלנד)	is-IS	תצוגה מקדימה
ג'אווה (ג'אווה)	jv-JV	תצוגה מקדימה
קאנדה (הודו)	kn-IN	תצוגה מקדימה
קונקאני (הודו)	kok-IN	תצוגה מקדימה
לאו (לאוס)	lo-LA	תצוגה מקדימה
לטינית (קריית הוותיקן)	la-VA	תצוגה מקדימה
לטבית (לטביה)	lv-LV	תצוגה מקדימה
ליטאית (ליטא)	lt-LT	תצוגה מקדימה
לוקסמבורגית (לוקסמבורג)	lb-LU	תצוגה מקדימה
מקדונית (מקדוניה הצפונית)	mk-MK	תצוגה מקדימה
מאיתילי (הודו)	mai-IN	תצוגה מקדימה
מלגשית (מדגסקר)	mg-MG	תצוגה מקדימה
מלאית (מלזיה)	ms-MY	תצוגה מקדימה
מליאלאם (הודו)	ml-IN	תצוגה מקדימה
מונגולית (מונגוליה)	mn-MN	תצוגה מקדימה
נפאלית (נפאל)	ne-NP	תצוגה מקדימה
נורווגית ספרותית (בוקמול) (נורווגיה)	nb-NO	תצוגה מקדימה
נורווגית, נינורסק (נורווגיה)	nn-NO	תצוגה מקדימה
אודיה (הודו)	or-IN	תצוגה מקדימה
פאשטו (אפגניסטן)	ps-AF	תצוגה מקדימה
פרסית (איראן)	fa-IR	תצוגה מקדימה
פורטוגזית (פורטוגל)	pt-PT	תצוגה מקדימה
פנג'אבי (הודו)	pa-IN	תצוגה מקדימה
סרבית (סרביה)	sr-RS	תצוגה מקדימה
סינדהי (הודו)	sd-IN	תצוגה מקדימה
סינהלית (סרי לנקה)	si-LK	תצוגה מקדימה
סלובקית (סלובקיה)	sk-SK	תצוגה מקדימה
סלובנית (סלובניה)	sl-SI	תצוגה מקדימה
ספרדית (אמריקה הלטינית)	es-419	תצוגה מקדימה
ספרדית (מקסיקו)	es-MX	תצוגה מקדימה
סוואהילית (קניה)	sw-KE	תצוגה מקדימה
שוודית (שוודיה)	sv-SE	תצוגה מקדימה
אורדו (פקיסטן)	ur-PK	תצוגה מקדימה

אזורים שבהם השירות זמין

‫Gemini-TTS זמין בכמה אזורים, דרך Cloud Text-to-Speech API או Vertex AI API.

עיבוד ה-ML של המודלים האלה מתבצע באזור הספציפי או באזור המרובה שבו מתבצעת הבקשה. מידע נוסף מופיע במאמר בנושא מיקום הנתונים.

האזורים הבאים נתמכים ב-Cloud Text-to-Speech API:

אזור	מדינה או סמכות שיפוט	מודלים זמינים
`global`	כל העולם (חוץ מאזורי DRZ)	`gemini-3.1-flash-tts-preview` `gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`eu`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	קנדה	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`

אפשר לגשת לאזורים האלה באמצעות נקודות הקצה הבאות של API: <REGION>-texttospeech.googleapis.com. שימו לב: לאזור global אין קידומת: texttospeech.googleapis.com.

האזורים הבאים נתמכים ב-Vertex AI API:

אזור	מדינה או סמכות שיפוט	מודלים זמינים
`global`	כל העולם (חוץ מאזורי DRZ)	`gemini-3.1-flash-tts-preview` `gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-central2`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-north1`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-southwest1`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west1`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`europe-west4`	האיחוד האירופי	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`northamerica-northeast1`	קנדה	`gemini-2.5-flash-tts` `gemini-2.5-flash-lite-preview-tts`
`us-central1`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east1`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east4`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-east5`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-south1`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west1`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`
`us-west4`	ארצות הברית	`gemini-2.5-flash-tts` `gemini-2.5-pro-tts` `gemini-2.5-flash-lite-preview-tts`

אפשר לגשת לאזורים האלה באמצעות נקודות הקצה הבאות של API: <REGION>-aiplatform.googleapis.com. שימו לב: לאזור global אין קידומת: aiplatform.googleapis.com.

בחירת ה-API הנכון

במאמר הזה נסביר איך להשתמש במודלים של Gemini-TTS כדי לבצע סינתזה של דיבור של דובר יחיד ושל כמה דוברים באמצעות Cloud Text-to-Speech API או Vertex AI API.

‫Gemini-TTS זמין דרך שני ממשקי API כדי לפשט את תהליך השילוב עבור לקוחות. ‫Cloud Text-to-Speech API ו-Vertex AI API, עם נקודות קצה של REST וערכות SDK במספר שפות תכנות.

ריכזנו כאן כמה הנחיות שיעזרו לכם לבחור את ה-API המתאים.

אם התנאים הבאים מתקיימים, בוחרים באפשרות Cloud Text-to-Speech API:

אם אתם משתמשים ב-Chirp 3 HD או בקולות אחרים, אתם יכולים להמשיך להשתמש באותו Cloud Text-to-Speech API עם עדכונים מצטברים מינימליים.
אם אתם צריכים סוגים ספציפיים של קידוד פלט, אתם יכולים לציין קידוד אודיו ב-Cloud Text-to-Speech API. ב-Vertex AI API, הפלט הוא נתוני אודיו בפורמט PCM 16bit 24k, והוא לא כולל כותרות WAV. אם רוצים להמיר לפורמט אודיו אחר, ההמרה צריכה להתבצע בצד הלקוח.
אם אתם חייבים להזרים טקסט בכמה מקטעים, Cloud Text-to-Speech API תומך באינטראקציה של כמה בקשות וכמה תשובות. לעומת זאת, Vertex AI API תומך בבקשה אחת ובתשובות מרובות.
אם רוצים להחיל נורמליזציה של הטקסט כברירת מחדל. האפשרות הזו שימושית במיוחד לתמלילים שכוללים תאריכים וערכים כספיים.

אם התנאים הבאים מתקיימים, בוחרים באפשרות Vertex AI API:

אם אתם כבר משתמשים ב-Gemini-TTS מ-AI Studio, אתם יכולים לעבור ל-Vertex AI בצורה חלקה כדי ליהנות מהיתרונות של Google Cloudמבחינת יכולת ההתאמה והתאימות.
אם אתם משתמשים ב-Vertex AI API למודלים אחרים, מבנה ה-API המאוחד מקל על תחילת השימוש ב-Gemini-TTS. כדי לעשות זאת, צריך לציין את שם המודל ואת אפשרויות בחירת הקול.

שימוש ב-Cloud Text-to-Speech API

אפשר לציין פורמטים של אודיו וקצב דגימה בשדה audioConfig אם נדרשות אפשרויות שאינן ברירת המחדל.

תיאור	הגבלה	סוג
שדה לטקסט	קטן מ-4,000 בייט או שווה לו.	קלט
שדה ההנחיה	קטן מ-4,000 בייט או שווה לו.	קלט
שדות טקסט ושדות הנחיות	קטן מ-8,000 בייט או שווה לו.	קלט
משך הזמן של פלט האודיו	בערך 655 שניות. אם הטקסט שמוזן יוצר אודיו שאורכו יותר מ-655 שניות, האודיו ייחתך.	תשובה

לפני שמתחילים

כדי להתחיל להשתמש ב-Cloud Text-to-Speech, צריך להפעיל את ה-API בGoogle Cloud מסוף. כך עושים זאת:

מפעילים את Cloud Text-to-Speech בפרויקט.
מוודאים שהחיוב מופעל עבור Cloud Text-to-Speech.
מגדירים אימות לסביבת הפיתוח.
הקצאת הרשאה aiplatform.endpoints.predict למשתמש המאומת. אפשר להעניק את ההרשאה הזו באמצעות התפקיד roles/aiplatform.user.
בוחרים את נקודת הקצה הנכונה של ה-API על סמך האזורים הזמינים.

הגדרה של Google Cloud הפרויקט

כניסה למסוף Google Cloud
מעבר לדף לבחירת הפרויקט

אפשר לבחור פרויקט קיים או ליצור פרויקט חדש. מידע נוסף על יצירת פרויקט זמין במסמכי התיעוד שלGoogle Cloud .
אם יוצרים פרויקט חדש, מופיעה הודעה שמבקשת לקשר חשבון לחיוב. אם אתם משתמשים בפרויקט קיים, הקפידו להפעיל את החיוב

איך מוודאים שהחיוב מופעל בפרויקט

הערה: כדי להשתמש ב-Cloud Text-to-Speech API, צריך להפעיל את החיוב. עם זאת, לא תחויבו אלא אם תחרגו מהמכסה ללא תשלום. מידע נוסף על תמחור זמין בדף תמחור.
אחרי שבוחרים פרויקט ומקשרים אותו לחשבון לחיוב, אפשר להפעיל את Cloud Text-to-Speech API. עוברים לסרגל חיפוש מוצרים ומשאבים בחלק העליון של הדף ומקלידים speech. ברשימת התוצאות, בוחרים באפשרות Cloud Text-to-Speech API.
כדי לנסות את Cloud Text-to-Speech בלי לקשר אותו לפרויקט, בוחרים באפשרות Try this API (ניסיון השימוש ב-API הזה). כדי להפעיל את Cloud Text-to-Speech API לשימוש בפרויקט, לוחצים על Enable (הפעלה).
מגדירים אימות לסביבת הפיתוח. הוראות מפורטות זמינות במאמר בנושא הגדרת אימות ל-Cloud Text-to-Speech.

הגדרת נקודת קצה ל-API באזור מועדף

אפשר לבחור נקודת קצה על סמך אזורים זמינים.

Python

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
TTS_LOCATION = os.getenv("GOOGLE_CLOUD_REGION")

API_ENDPOINT = (
    f"{TTS_LOCATION}-texttospeech.googleapis.com"
    if TTS_LOCATION != "global"
    else "texttospeech.googleapis.com"
)
client = texttospeech.TextToSpeechClient(
    client_options=ClientOptions(api_endpoint=API_ENDPOINT)
)

CURL

GLOBAL_API_ENDPOINT=https://texttospeech.googleapis.com
REGIONAL_API_ENDPOINT=https://YOUR_REGION-texttospeech.googleapis.com

ביצוע סינתזה סינכרונית של דובר יחיד

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text: str, output_filepath: str = "output.mp3"):
    """Synthesizes speech from the input text and saves it to an MP3 file.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text: The text to synthesize.
        output_filepath: The path to save the generated audio file.
          Defaults to "output.mp3".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    # Select the voice you want to use.
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="Charon",  # Example voice, adjust as needed
        model_name="gemini-3.1-flash-tts-preview"
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Perform the text-to-speech request on the text input with the selected
    # voice parameters and audio file type.
    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    # The response's audio_content is binary.
    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "OK, so... tell me about this [uhm] AI thing."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "model_name": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

ביצוע סינתזה של דיבור של דובר יחיד בסטרימינג

סינתזה של סטרימינג מתאימה לאפליקציות בזמן אמת שבהן תגובה מהירה היא קריטית לחוויית המשתמש. בחיבור סטרימינג, ה-API מחזיר אודיו כשהוא זמין בחלקים קטנים.

בתור מי שקורא ל-API, חשוב לוודא שאתם משתמשים בחלקים של האודיו ומעבירים אותם ללקוחות שלכם כשהם מגיעים (לדוגמה, באמצעות socketio לאפליקציות אינטרנט).

‫Cloud Text-to-Speech API תומך בסטרימינג מסוג multiple request multiple response. אפשר לשלוח את נתוני הקלט ל-API באופן אסינכרוני, כמו שמוצג ב-request_generator, אבל ה-API מתחיל את הסינתזה רק כשהלקוח שולח את Half-Close כאות לכך שהוא לא ישלח יותר נתונים ל-API.

השדה prompt חייב להיות מוגדר בחלק הראשון של הקלט, כי המערכת מתעלמת ממנו בחלקים הבאים.

Python

# google-cloud-texttospeech minimum version 2.29.0 is required.

import datetime
import os
import numpy as np
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize(prompt: str, text_chunks: list[str], model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        prompt: Styling instructions on how to synthesize the content in
          the text field.
        text_chunks: Text chunks to synthesize. Note that The synthesis will 
          start when the client initiates half-close. 
        model: gemini tts model name. gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales. 
    """
    client = texttospeech.TextToSpeechClient()

    config_request = texttospeech.StreamingSynthesizeRequest(
        streaming_config=texttospeech.StreamingSynthesizeConfig(
            voice=texttospeech.VoiceSelectionParams(
                name=voice,
                language_code=locale,
                model_name=model
            )
        )
    )

    # Example request generator. A function like this can be linked to an LLM
    # text generator and the text can be passed to the TTS API asynchronously.
    def request_generator():
      yield config_request

      for i, text in enumerate(text_chunks):
        yield texttospeech.StreamingSynthesizeRequest(
            input=texttospeech.StreamingSynthesisInput(
              text=text, 
              # Prompt is only supported in the first input chunk.
              prompt=prompt if i == 0 else None,
            )
        )

    request_start_time = datetime.datetime.now()
    streaming_responses = client.streaming_synthesize(request_generator())

    is_first_chunk_received = False
    final_audio_data = np.array([])
    num_chunks_received = 0
    for response in streaming_responses:
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")

        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        # accumulating audio. In a web-server scenario, you would want to 
        # "emit" audio to the frontend as soon as it arrives.
        #
        # For example using flask socketio, you could do the following
        # from flask_socketio import SocketIO, emit
        # emit("audio", response.audio_content)
        # socketio.sleep(0)
        audio_data = np.frombuffer(response.audio_content, dtype=np.int16)
        final_audio_data = np.concatenate((final_audio_data, audio_data))

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time
    audio_duration = len(final_audio_data) / 24_000  # default sampling rate.

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")
    print(f"Audio duration: {audio_duration} seconds")

    return final_audio_data

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט חופשי

תיאור	מגבלות	סוג
שדה לטקסט	פחות מ-4,000 בייט או שווה ל-4,000 בייט	קלט
שדה ההנחיה	פחות מ-4,000 בייט או שווה ל-4,000 בייט	קלט
שדות טקסט ושדות הנחיות	פחות מ-8,000 בייט או שווה ל-8,000 בייט	קלט
כינויים של רמקולים	תווים אלפאנומריים ללא רווחים	קלט
משך הזמן של פלט האודיו	בערך 655 שניות. אם הטקסט שמוזן יוצר אודיו שאורכו יותר מ-655 שניות, האודיו ייחתך.	תשובה

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_freeform(
    prompt: str,
    text: str,
    output_filepath: str = "output_non_turn_based.wav",
):
    """Synthesizes speech from non-turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        text: The text to synthesize, containing speaker aliases to indicate
          different speakers. Example: "Sam: Hi Bob!\nBob: Hi Sam!"
        output_filepath: The path to save the generated audio file. Defaults to
          "output_non_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(text=text, prompt=prompt)

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "text": "Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?"
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט מובנה

התכונה 'ריבוי דוברים עם קלט טקסט מובנה' מאפשרת הפיכת טקסט לדיבור בצורה חכמה ודומה לדיבור אנושי. לדוגמה, סוג הקלט הזה שימושי לכתובות ולתאריכים. הזנת טקסט חופשי מקריאה את הטקסט בדיוק כמו שהוא כתוב.

תיאור	מגבלות	סוג
שדה MultiSpeakerMarkUp	פחות מ-4,000 בייט או שווה ל-4,000 בייט	קלט
שדה ההנחיה	פחות מ-4,000 בייט או שווה ל-4,000 בייט	קלט
שדות של תגי עיצוב של כמה דוברים והנחיות	פחות מ-8,000 בייט או שווה ל-8,000 בייט	קלט
כינויים של רמקולים	תווים אלפאנומריים ללא רווחים	קלט
משך הזמן של פלט האודיו	בערך 655 שניות. אם הטקסט שמוזן יוצר אודיו שאורכו יותר מ-655 שניות, האודיו ייחתך.	תשובה

Python

# google-cloud-texttospeech minimum version 2.31.0 is required.

import os
from google.cloud import texttospeech

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")

def synthesize_multispeaker_structured(
    prompt: str,
    turns: list[texttospeech.MultiSpeakerMarkup.Turn],
    output_filepath: str = "output_turn_based.wav",
):
    """Synthesizes speech from turn-based input and saves it to a WAV file.

    Args:
        prompt: Styling instructions on how to synthesize the content in the
          text field.
        turns: A list of texttospeech.MultiSpeakerMarkup.Turn objects representing
          the dialogue turns.
        output_filepath: The path to save the generated audio file. Defaults to
          "output_turn_based.wav".
    """
    client = texttospeech.TextToSpeechClient()

    synthesis_input = texttospeech.SynthesisInput(
        multi_speaker_markup=texttospeech.MultiSpeakerMarkup(turns=turns),
        prompt=prompt,
    )

    multi_speaker_voice_config = texttospeech.MultiSpeakerVoiceConfig(
        speaker_voice_configs=[
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker1",
                speaker_id="Kore",
            ),
            texttospeech.MultispeakerPrebuiltVoice(
                speaker_alias="Speaker2",
                speaker_id="Charon",
            ),
        ]
    )

    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US",
        model_name="gemini-3.1-flash-tts-preview",
        multi_speaker_voice_config=multi_speaker_voice_config,
    )

    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.LINEAR16,
        sample_rate_hertz=24000,
    )

    response = client.synthesize_speech(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    with open(output_filepath, "wb") as out:
        out.write(response.audio_content)
        print(f"Audio content written to file: {output_filepath}")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
# google-cloud-texttospeech minimum version 2.31.0 is required.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following as a conversation between friends.",
    "multiSpeakerMarkup": {
      "turns": [
        {
          "speaker": "Sam",
          "text": "Hi Bob, how are you?"
        },
        {
          "speaker": "Bob",
          "text": "I am doing well, and you?"
        }
      ]
    }
  },
  "voice": {
    "languageCode": "en-us",
    "modelName": "gemini-3.1-flash-tts-preview",
    "multiSpeakerVoiceConfig": {
      "speakerVoiceConfigs": [
        {
          "speakerAlias": "Sam",
          "speakerId": "Kore"
        },
        {
          "speakerAlias": "Bob",
          "speakerId": "Charon"
        }
      ]
    }
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16",
    "sampleRateHertz": 24000
  }
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

שימוש ב-Vertex AI API

בשיעור הזה נסביר איך להשתמש במודלים של Gemini-TTS כדי לבצע סינתזה של דיבור עם דובר אחד ועם כמה דוברים באמצעות Vertex AI API.

ב-Cloud Text-to-Speech API, המשתמש יכול לספק שדות טקסט והנחיה בנפרד. ב-Vertex AI API, זהו שדה contents יחיד, שבו מצוין הקלט בפורמט '{prompt}: {text}', למשל: "תגיד את המשפט הבא בצורה סקרנית: אוקיי, אז... ספר לי על העניין הזה של AI".

תיאור	הגבלה	סוג
שדה התוכן	קטן מ-8,000 בייט או שווה לו.	קלט
משך הזמן של פלט האודיו	בערך 655 שניות. אם הטקסט שמוזן יוצר אודיו שאורכו יותר מ-655 שניות, האודיו ייחתך.	תשובה

לפני שמתחילים

לפני שמתחילים, צריך לפעול לפי שלבי ההתקנה של Vertex AI API. כדי ליהנות מהאפשרויות של מיקום הנתונים, חשוב להגדיר את LOCATION על סמך האזורים הזמינים.

ביצוע סינתזה סינכרונית של דובר יחיד

בדוגמאות הקוד האלה אפשר לראות איך לבצע סינתזה סינכרונית של דובר יחיד.

Python

from google import genai
from google.genai import types
import wave
import os

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents="Say the following in a curious way: OK, so... tell me about this [uhm] AI thing.",
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        voice_config=types.VoiceConfig(
            prebuilt_voice_config=types.PrebuiltVoiceConfig(
              voice_name='Kore',
            )
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following in a curious way: OK, so... tell me about this [uhm] AI thing." }
  },
  "generation_config": {
    "speech_config": {
        "language_code": "en-in",
        "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "kore"
            }
        }
    }
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

ביצוע סינתזה של דיבור של דובר יחיד בסטרימינג

ב-Vertex AI API יש תמיכה בהזרמה חד-כיוונית, כלומר הלקוח שולח בקשה אחת ומקבל זרם של תשובות.

בדוגמת הקוד הזו מודגם איך לבצע סינתזה של סטרימינג של דובר יחיד.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize.
        model: gemini tts model name. Available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
          language_code=locale,
          voice_config=types.VoiceConfig(
              prebuilt_voice_config=types.PrebuiltVoiceConfig(
                voice_name=voice,
              )
          )
        ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    "Say the following in a curious way: Radio Bakery is a New York City gem, celebrated for its exceptional and creative baked goods. The pistachio croissant is often described as a delight with perfect sweetness. The rhubarb custard croissant is a lauded masterpiece of flaky pastry and tart filling. The brown butter corn cake stands out with its crisp edges and rich flavor. Despite the bustle, the staff consistently receives praise for being friendly and helpful.",
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

ביצוע סינתזה סינכרונית של כמה רמקולים

בדוגמת הקוד הזו מוצג תהליך של סינתזה סינכרונית של כמה דוברים.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad, how about you?"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

response = client.models.generate_content(
  model="gemini-3.1-flash-tts-preview",
  contents=prompt,
  config=types.GenerateContentConfig(
      speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
  )
)

data = response.candidates[0].content.parts[0].inline_data.data

file_name='output_speech.wav'
wave_file(file_name, data) # Saves the file to current directory

Audio("output_speech.wav")

CURL

# Make sure to install gcloud cli, and sign in to your project.
# Make sure to use your PROJECT_ID value.
# The available models are gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
# To parse the JSON output and use it directly see the last line of the command.
# Requires JQ and ffplay library to be installed.
PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "contents": {
    "role": "user",
    "parts": { "text": "Say the following as a conversation between friends: Sam: Hi Bob, how are you?\\nBob: I am doing well, and you?" }
  },
  "generation_config": {
    "speech_config": {
      "language_code": "en-in",
      "multi_speaker_voice_config": {
        "speaker_voice_configs": [{
          "speaker": "Sam",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Aoede"
            }
          }
        },{
          "speaker": "Bob",
          "voice_config": {
            "prebuilt_voice_config": {
              "voice_name": "Algieba"
            }
          }
        }]
      }
    },
  }
  }' \
  https://aiplatform.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/us-central1/publishers/google/models/gemini-3.1-flash-tts-preview:generateContent \
  | jq -r '.candidates[0].content.parts[0].inlineData.data' \
  | base64 -d | ffmpeg -f s16le -ar 24k -ac 1 -i - output_speech.wav

ביצוע סינתזה של כמה דוברים בסטרימינג

ב-Vertex AI API יש תמיכה בהעברת נתונים חד-כיוונית, כלומר הלקוח שולח בקשה אחת ומקבל זרם של תשובות.

בדוגמת הקוד הזו אפשר לראות איך מבצעים סינתזה של כמה דוברים בסטרימינג.

Python

from google import genai
from google.genai import types
import wave
import os
import datetime

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.environ.get("GOOGLE_CLOUD_REGION", "global")

prompt = """TTS the following conversation between Joe and Jane:
        Joe: How's it going today Jane?
        Jane: Not too bad! Honestly, I'm just blown away by this new Gemini Text-to-Speech model.
        Joe: Right?! This is a total game changer! And do you know what I just discovered?
        Jane: What?
        Joe: You can use the multi-speaker configuration to create a conversation, just like us!
        Jane: Just like us!"""

# Set up the wave file to save the output:
def wave_file(filename, pcm, channels=1, rate=24000, sample_width=2):
  with wave.open(filename, "wb") as wf:
      wf.setnchannels(channels)
      wf.setsampwidth(sample_width)
      wf.setframerate(rate)
      wf.writeframes(pcm)

def synthesize(text: str, model: str, voice: str, locale: str):
    """Synthesizes speech from the input text.

    Args:
        text: Text to synthesize. Note that The synthesis will start when the
          client initiates half-close.
        model: gemini tts model name. Available models are: gemini-3.1-flash-tts-preview, gemini-2.5-flash-tts, gemini-2.5-flash-lite-preview-tts, and gemini-2.5-pro-tts.
        voice: voice name. Example: leda, kore. Refer to available voices.
        locale: locale name. Example: en-us. Refer to available locales.
    """
    client = genai.Client(vertexai=True, project=PROJECT_ID, location=LOCATION)

    generate_content_config=types.GenerateContentConfig(
        speech_config=types.SpeechConfig(
        language_code="en-in",
        multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
            speaker_voice_configs=[
              types.SpeakerVoiceConfig(
                  speaker='Joe',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Kore',
                    )
                  )
              ),
              types.SpeakerVoiceConfig(
                  speaker='Jane',
                  voice_config=types.VoiceConfig(
                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
                        voice_name='Puck',
                    )
                  )
              ),
            ]
        )
      ),
    )

    request_start_time = datetime.datetime.now()
    is_first_chunk_received = False
    final_audio_data = bytes()
    num_chunks_received = 0

    for chunk in client.models.generate_content_stream(
        model=model,
        contents=text,
        config=generate_content_config,
    ):
        # just a simple progress indicator
        num_chunks_received += 1
        print(".", end="")
        if num_chunks_received % 40 == 0:
            print("")
        # measuring time to first audio
        if not is_first_chunk_received:
            is_first_chunk_received = True
            first_chunk_received_time = datetime.datetime.now()

        if (
            chunk.candidates is None
            or not chunk.candidates
            or chunk.candidates[0].content is None
            or not chunk.candidates[0].content.parts
        ):
            continue
        part = chunk.candidates[0].content.parts[0]
        if part.inline_data and part.inline_data.data:
          # accumulating audio. In a web-server scenario, you would want to
          # "emit" audio to the frontend as soon as it arrives.
          #
          # For example using flask socketio, you could do the following
          # from flask_socketio import SocketIO, emit
          # emit("audio", chunk.candidates[0].content.parts[0].inline_data.data)
          # socketio.sleep(0)
          final_audio_data += chunk.candidates[0].content.parts[0].inline_data.data

    time_to_first_audio = first_chunk_received_time - request_start_time
    time_to_completion = datetime.datetime.now() - request_start_time

    print("\n")
    print(f"Time to first audio: {time_to_first_audio.total_seconds()} seconds")
    print(f"Time to completion: {time_to_completion.total_seconds()} seconds")

    return final_audio_data

audio_data = synthesize(
    prompt,
    "gemini-3.1-flash-tts-preview",
    "Kore",
    "en-in")
file_name='output_speech.wav'
wave_file(file_name, audio_data)

Audio("output_speech.wav")

ביצוע סינתזת דיבור ב-Media Studio

ההרשאות שנדרשות למשימה הזו

כדי לבצע את המשימה הזו נדרשות ההרשאות הבאות:

serviceusage.services.use

אתם יכולים להשתמש ב-Media Studio במסוף Google Google Cloud כדי להתנסות במודלים של המרת טקסט לדיבור. הכלי הזה מספק ממשק משתמש שמאפשר ליצור במהירות אודיו מסונתז, להאזין לו ולהתנסות בהוראות ובפרמטרים שונים של סגנון.

במסוף Google Google Cloud , עוברים לדף Vertex AI Studio > Media Studio.

Media Studio
בתפריט הנפתח של המדיה, בוחרים באפשרות דיבור.
בשדה הטקסט, מזינים את הטקסט שרוצים ליצור ממנו קטע קול.
בחלונית הגדרות, קובעים את ההגדרות הבאות:
1. מודל: בוחרים את מודל Cloud TTS (TTS) שרוצים להשתמש בו, כמו Gemini 2.5 Pro TTS. מידע נוסף על המודלים הזמינים מופיע במאמר מודלים של Cloud TTS.
2. הוראות לגבי הסגנון: אופציונלי: מזינים הנחייה טקסטואלית שמתארת את סגנון הדיבור, הטון וההבעה הרגשית שנבחרו. כך תוכלו לשפר את ביצועי המודל מעבר לקריינות שמוגדרת כברירת מחדל. לדוגמה: "תקריין בקול רגוע ומקצועי לסרט תיעודי".
3. שפה: בוחרים את השפה והאזור של טקסט הקלט. המודל יוצר דיבור בשפה ובמבטא שנבחרו. לדוגמה, אנגלית (ארצות הברית).
4. קול: בוחרים קול מוגדר מראש לקריינות. הרשימה כוללת את הקולות שזמינים למודל ולשפה שנבחרו, כמו Acherner (Female).
אופציונלי: מרחיבים את הקטע 'אפשרויות מתקדמות' כדי להגדיר הגדרות טכניות של אודיו:
1. קידוד אודיו: בוחרים את הקידוד של קובץ האודיו שיוצא. ‫LINEAR16 הוא פורמט לא דחוס ללא איבוד נתונים שמתאים לעיבוד אודיו באיכות גבוהה. MULAW זמין גם לפלט אודיו דחוס.
2. תדירות דגימת האודיו: בוחרים את תדירות הדגימה בהרץ (Hz). ההגדרה הזו קובעת את איכות האודיו. ערכים גבוהים יותר כמו 44,100 הרץ מייצגים אודיו באיכות גבוהה יותר, ששווה לאיכות של תקליטור.
3. מהירות: כדי לשנות את מהירות הדיבור, מזיזים את פס ההזזה או מזינים ערך. ערכים קטנים מ-1 מאטים את הדיבור, וערכים גדולים מ-1 מאיצים אותו. ערך ברירת המחדל הוא 1.
4. הגברת עוצמת הקול (db): שינוי עוצמת הקול של פלט האודיו בדציבלים (dB). ערכים חיוביים מגבירים את עוצמת הקול, וערכים שליליים מנמיכים אותה. ערך ברירת המחדל הוא 0.
כדי ליצור את האודיו, לוחצים על סמל השליחה משמאל לתיבת הטקסט.
האודיו שנוצר יופיע בנגן המדיה. לוחצים על לחצן ההפעלה כדי להאזין לפלט. אתם יכולים להמשיך לשנות את ההגדרות וליצור גרסאות חדשות לפי הצורך.

טיפים לכתיבת הנחיות

כדי ליצור אודיו מעניין שנשמע טבעי מתוך טקסט, צריך להבין את הניואנסים של השפה המדוברת ולתרגם אותם לפורמט של תסריט. הטיפים הבאים יעזרו לכם ליצור תסריטים שנשמעים אותנטיים ומשקפים את הטון שבחרתם.

שלושת המנופים של שליטה בדיבור

כדי לקבל תוצאות צפויות ומדויקות ככל האפשר, חשוב לוודא שכל שלושת הרכיבים הבאים עולים בקנה אחד עם הפלט הרצוי.

הנחיית סגנון הגורם העיקרי שמשפיע על הטון הרגשי וההעברה הכוללים. ההנחיה מגדירה את ההקשר של כל קטע הדיבור.

לדוגמה: You are an AI assistant speaking in a friendly and helpful tone.
לדוגמה: Narrate this in the calm, authoritative tone of a nature documentary narrator.

תוכן טקסט המשמעות הסמנטית של המילים שאתם מסנתזים. ביטוי מעורר השראה שתואם מבחינה רגשית להנחיית הסגנון יניב תוצאות אמינות הרבה יותר מטקסט ניטרלי.

טוב: הנחיה לטון מפוחד פועלת בצורה הטובה ביותר עם טקסט כמו I think someone is in the house.
פחות יעילה: הנחיה ליצירת טון מפוחד עם טקסט כמו The meeting is at 4 PM. תניב תוצאות דו-משמעיות.

תגי עיצוב (תצוגה מקדימה) תגים עם סוגריים כמו [sigh] מתאימים בעיקר להוספת פעולה ספציפית ומקומית או לשינוי סגנון, ולא להגדרת הטון הכללי. הם פועלים בשילוב עם הנחיית הסגנון ותוכן הטקסט.

מדריך לתגי עיצוב

מהמחקר שלנו עולה שתגי עיצוב עם סוגריים פועלים באחד משלושה מצבים שונים. כדי להשתמש בתג בצורה יעילה, חשוב להבין את המצב שלו.

מצב 1: קולות שאינם דיבור

תגי העיצוב מוחלפים בהשמעה קולית שאינה דיבור (למשל אנחה או צחוק). התג עצמו לא מושמע. התכונות האלה מצוינות להוספת היסוסים ותגובות מציאותיים שדומים לאלה של בני אדם.

תג	התנהגות	אמינות	הדרכה
`[sigh]`	הוספת צליל של אנחה.	גבוהה	האיכות הרגשית של האנחה מושפעת מההנחיה.
`[laughing]`	הוספת צחוק.	גבוהה	כדי לקבל את התוצאות הטובות ביותר, כדאי להשתמש בהנחיה ספציפית. לדוגמה, הנחיה כללית עשויה ליצור צחוק של הלם, בעוד שההנחיה 'תגיב בצחוק משועשע' יוצרת צחוק של שעשוע.
`[uhm]`	הוספת צליל של היסוס.	גבוהה	האפשרות הזו שימושית ליצירת תחושה טבעית יותר של שיחה.

מצב 2: שינויים בסגנון

תגי העיצוב לא נאמרים, אבל הם משנים את אופן ההשמעה של הדיבור שבא אחריהם. ההיקף ומשך הזמן של השינוי יכולים להשתנות.

תג	התנהגות	אמינות	הדרכה
`[sarcasm]`	הוספת טון סרקסטי לביטוי הבא.	גבוהה	התג הזה הוא משנה רב עוצמה. היא מדגימה שאפשר להשתמש במושגים מופשטים כדי לכוון את המודל.
`[robotic]`	גורם לכך שהדיבור הבא יישמע רובוטי.	גבוהה	האפקט יכול לחול על ביטוי שלם. כדי לקבל את התוצאות הטובות ביותר, עדיין מומלץ להשתמש בהנחיה לסגנון (למשל, "תגיד את זה כמו רובוט").
`[shouting]`	הגברת עוצמת הקול של הדיבור הבא.	גבוהה	הכי יעיל כשמשתמשים בו עם הנחיה תואמת לסגנון (למשל, "תצעק את החלק הבא") וטקסט שמרמז על צעקה.
`[whispering]`	החלשת עוצמת הקול של הדיבור הבא.	גבוהה	כדי להשיג את התוצאות הטובות ביותר, כדאי להשתמש בהנחיה ספציפית לגבי הסגנון (לדוגמה, "עכשיו תלחש את החלק הזה הכי בשקט שאפשר").
`[extremely fast]`	הגברת המהירות של הדיבור הבא.	גבוהה	מושלם להצהרות או לדיאלוג מהיר. נדרשת תמיכה מינימלית בהנחיות.

מצב 3: תגי עיצוב עם הגייה (שמות תואר)

תג העיצוב עצמו מושמע כמילה, וגם משפיע על הטון של המשפט כולו. ההתנהגות הזו רלוונטית בדרך כלל לשמות תואר שקשורים לרגשות.

אזהרה: מכיוון שהתג עצמו נאמר, סביר להניח שהמצב הזה הוא תופעת לוואי לא רצויה ברוב תרחישי השימוש. מומלץ להשתמש בהנחיית סגנון כדי להגדיר את הטונים הרגשיים האלה.

תג	התנהגות	אמינות	הדרכה
`[scared]`	המילה "scared" (מפוחד) נאמרת, והמשפט מקבל טון מפוחד.	גבוהה	הביצועים תלויים מאוד בתוכן הטקסט. הביטוי "I just heard a window break" (שמעתי עכשיו חלון נשבר) מניב תוצאה של פחד אמיתי. ביטוי ניטרלי יניב תוצאה "מפחידה" אבל פחות אותנטית.
`[curious]`	המילה "סקרן" נאמרת, והמשפט מקבל טון סקרן.	גבוהה	כדאי להשתמש בביטוי שמעורר סקרנות כדי לתמוך בכוונה של התג.
`[bored]`	המילה bored (משועמם) נאמרת, והמשפט נאמר בטון משועמם ומונוטוני.	גבוהה	כדי להשיג את האפקט הטוב ביותר, כדאי להשתמש בהנחיה הזו עם טקסט רגיל או חוזר.

מצב 4: קצב והפסקות

התגים האלה מוסיפים שקט לאודיו שנוצר, ומאפשרים לכם לשלוט בקצב, בתזמון ובמהירות של הדיבור. סימני פיסוק רגילים (פסיקים, נקודות, נקודות ופסיקים) יוצרים גם הם הפסקות טבעיות, אבל התגים האלה מאפשרים שליטה מפורשת יותר.

תג	התנהגות	אמינות	הדרכה
`[short pause]`	מוסיף הפסקה קצרה, בדומה לפסיק (כ-250 אלפיות השנייה).	גבוהה	משתמשים בה כדי להפריד בין פסקה לפסקה או בין פריטים ברשימה, כדי לשפר את הבהירות.
`[medium pause]`	הוספת השהיה רגילה, בדומה להפסקת משפט (כ-500 אלפיות השנייה).	גבוהה	יעיל להפרדה בין משפטים או מחשבות שונות.
`[long pause]`	מוסיף הפסקה משמעותית ליצירת אפקט דרמטי (כ-1,000 אלפיות השנייה ומעלה).	גבוהה	לשימוש בתזמון דרמטי. לדוגמה: "התשובה היא... `[long pause]` ...לא." לא מומלץ להשתמש בהם יותר מדי, כי זה עלול להישמע לא טבעי.

אסטרטגיות מרכזיות להשגת תוצאות אמינות

התאמה בין שלושת המנופים: כדי להשיג את רמת החיזוי הגבוהה ביותר, חשוב לוודא שהנחיית הסגנון, תוכן הטקסט ותגי העיצוב פועלים באופן עקבי מבחינה סמנטית ומובילים לאותו יעד.
משתמשים בטקסט עשיר מבחינה רגשית: אל תסתמכו רק על הנחיות ותגים. מספקים למודל טקסט עשיר ותיאורי לעבודה. זה חשוב במיוחד כשמדובר ברגשות מורכבים כמו סרקזם, פחד או התרגשות.
כדאי לכתוב הנחיות ספציפיות ומפורטות: ככל שהנחיית הסגנון תהיה ספציפית יותר, כך התוצאה תהיה מהימנה יותר. עדיף להגיב באמוג'י של צחוק משועשע מאשר רק [laughing]. ההנחיה "תדבר כמו קריין חדשות ברדיו משנות ה-40" עדיפה על "תדבר בצורה מיושנת".
בדיקה ואימות של תגים חדשים: ההתנהגות של תג חדש או לא בדוק לא תמיד צפויה. יכול להיות שתג שאתם חושבים שהוא משנה סגנון יבוטא. תמיד כדאי לבדוק שילוב חדש של תג או הנחיה כדי לוודא שהוא פועל כמו שרוצים לפני שפורסים אותו בסביבת הייצור.

הגדרות של טיימר לדיווח על מצב מסוכן

אי אפשר להשבית חלק מבדיקות האבטחה, אבל אפשר לשנות את ערכי הסף של קטגוריות מסוימות של נזק כדי לשפר את האבטחה ולמזער את הסיכון לשימוש לרעה. אפשר להפעיל את האפשרות הזו על ידי הגדרת מסנני בטיחות בקטע AdvancedVoiceOptions.

יש 4 קטגוריות של נזק שאפשר להגדיר ברמות סף שונות. אפשר להגדיר חסימה של תוכן פוגעני בקטגוריה אחת או יותר.

השדה relax_safety_filters מדור קודם הוצא משימוש.

בהתאם למסנני הבטיחות שהגדרתם, הפלט עשוי להכיל קוד בטיחות שדומה לקוד הבא: "Cloud Text-to-Speech could not generate audio because the input text or prompt violates Vertex AI's usage guidelines. אם לדעתך מדובר בטעות, אפשר לשלוח משוב. קודי תמיכה: 62263041"

הקוד שמופיע בפלט תואם לקטגוריה ספציפית של תוכן מזיק.

בטבלה הבאה מוצג מיפוי של קודי תמיכה לקטגוריות בטיחות:

קוד תמיכה	קטגוריית בטיחות	תיאור
`54702341`	לא צוין	הקטגוריה לא צוינה.
`62263041`	תוכן מסוכן	תוכן שעלול להיות מסוכן.
`57734940`	הטרדה	תוכן שקשור להטרדה.
`90789179`	תוכן מיני בוטה	תוכן מיני או תוכן עם רמיזות מיניות.
`78610348`	דברי שטנה	תוכן שמכיל דברי שטנה.

בדוגמאות הקוד האלה מודגם איך להתאים אישית את הגדרות הבטיחות ב-Cloud Text-to-Speech API. לדוגמאות לשימוש ב-Vertex AI API, אפשר לעיין בדוגמאות ל-Vertex AI API.

Python

# google-cloud-texttospeech minimum version 2.32.0 is required.
request = texttospeech.SynthesizeSpeechRequest(
    input=synthesis_input,
    voice=voice,
    audio_config=audio_config,
    advanced_voice_options=texttospeech.AdvancedVoiceOptions(
      safety_settings=texttospeech.AdvancedVoiceOptions.SafetySettings(
          settings=[texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HARASSMENT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          ),
          texttospeech.AdvancedVoiceOptions.SafetySetting(
              category=texttospeech.AdvancedVoiceOptions.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
              threshold=texttospeech.AdvancedVoiceOptions.HarmBlockThreshold.BLOCK_LOW_AND_ABOVE
          )]
      )
    ),
)
# Perform the text-to-speech request on the text input with the selected
# voice parameters and audio file type.
response = client.synthesize_speech(request=request)

CURL

PROJECT_ID=YOUR_PROJECT_ID
curl -X POST \
  -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
  -H "x-goog-user-project: $PROJECT_ID" \
  -H "Content-Type: application/json" \
-d '{
  "input": {
    "prompt": "Say the following in a curious way.",
    "text": "I am saying something that would otherwise be blocked by Gemini TTS."
  },
  "voice": {
    "languageCode": "en-us",
    "name": "Kore",
    "modelName": "gemini-3.1-flash-tts-preview"
  },
  "audioConfig": {
    "audioEncoding": "LINEAR16"
  },
  "advancedVoiceOptions": {
    "safetySettings": {
      "settings": {
        "category": "HARM_CATEGORY_HATE_SPEECH",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_HARASSMENT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
      "settings": {
        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
        "threshold": "BLOCK_LOW_AND_ABOVE",
      },
    }
  },
}' \
  "https://texttospeech.googleapis.com/v1/text:synthesize" \
  | jq -r '.audioContent' | base64 -d | ffplay - -autoexit

Gemini-TTS קל לארגן דפים בעזרת אוספים אפשר לשמור ולסווג תוכן על סמך ההעדפות שלך.

מודלים זמינים

‫Gemini 3.1 Flash TTS (גרסת טרום-השקה)

Gemini ‎2.5 Flash TTS

Gemini 2.5 Flash Lite TTS (גרסת טרום-השקה — Preview)

Gemini 2.5 Pro TTS

אמצעי בקרה נוספים

אפשרויות קול

השפות הזמינות

אזורים שבהם השירות זמין

בחירת ה-API הנכון

שימוש ב-Cloud Text-to-Speech API

לפני שמתחילים

הגדרה של Google Cloud הפרויקט

הגדרת נקודת קצה ל-API באזור מועדף

Python

CURL

ביצוע סינתזה סינכרונית של דובר יחיד

Python

CURL

ביצוע סינתזה של דיבור של דובר יחיד בסטרימינג

Python

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט חופשי

Python

CURL

ביצוע סינתזה סינכרונית של כמה דוברים עם קלט טקסט מובנה

Python

CURL

שימוש ב-Vertex AI API

לפני שמתחילים

ביצוע סינתזה סינכרונית של דובר יחיד

Python

CURL

ביצוע סינתזה של דיבור של דובר יחיד בסטרימינג

Python

ביצוע סינתזה סינכרונית של כמה רמקולים

Python

CURL

ביצוע סינתזה של כמה דוברים בסטרימינג

Python

ביצוע סינתזת דיבור ב-Media Studio

ההרשאות שנדרשות למשימה הזו

טיפים לכתיבת הנחיות

שלושת המנופים של שליטה בדיבור

מדריך לתגי עיצוב

מצב 1: קולות שאינם דיבור

מצב 2: שינויים בסגנון

מצב 3: תגי עיצוב עם הגייה (שמות תואר)

מצב 4: קצב והפסקות

אסטרטגיות מרכזיות להשגת תוצאות אמינות

הגדרות של טיימר לדיווח על מצב מסוכן

Python

CURL

Gemini-TTS

ההרשאות שנדרשות למשימה הזו