> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# モデル

> Learn about the models that power the ElevenLabs API.

## フラッグシップモデル

### テキスト読み上げ

#### [Eleven v4](/docs/ja/overview/models#eleven-v4)

最も感情豊かで高品質な音声合成モデル

優れたボイスクローン機能

90以上の言語に対応

文字数上限：10,000文字

自然な複数話者の対話に対応

#### [Eleven v4 Turbo](/docs/ja/overview/models#eleven-v4-turbo)

最も感情豊かでリアルタイムな音声合成モデル

超低レイテンシー（推論レイテンシーの中央値：約100ms†）

優れたボイスクローン機能

90以上の言語に対応

きめ細かな制御を可能にするオーディオタグ

#### [Eleven v3](/docs/ja/overview/models#eleven-v3)

感情豊かで表現力に優れた音声合成モデル

ドラマチックな話し方とパフォーマンス

70以上の言語に対応

文字数上限：5,000文字

自然な複数話者の対話に対応

#### [Eleven v3 Conversational](/docs/ja/overview/models#eleven-v3-conversational)

表現力に優れたリアルタイム音声合成モデル

低レイテンシー（約280ms）

ドラマチックな話し方とパフォーマンス

70以上の言語に対応

きめ細かな制御を可能にするオーディオタグ

#### [Eleven Multilingual v2](/docs/ja/overview/models#multilingual-v2)

自然で一貫した高品質の音声合成モデル

自然な音声出力

29言語に対応

文字数上限：10,000文字

長文生成で最も安定

#### [Eleven Flash v2.5](/docs/ja/overview/models#flash-v25)

高速で手頃な価格の音声合成モデル

超低レイテンシー（約75ms†）

32言語に対応

文字数上限：40,000文字

高速モデルで、API生成の1文字あたりの価格が50%低減

### スピーチtoテキスト

#### [Scribe v2](/docs/ja/overview/models#scribe-v2)

最先端の音声認識モデル

90以上の言語で高精度な文字起こし

最大1,000語のキータームプロンプティング

65種類のエンティティを検出

自然言語の指示による文字起こしの編集

高精度な単語レベルのタイムスタンプ

最大32人の話者ダイアライゼーション

動的なオーディオタグ付け

スマートな言語検出

#### [Scribe v2 Realtime](/docs/ja/overview/models#scribe-v2-realtime)

リアルタイム音声認識モデル

90以上の言語で高精度な文字起こし

リアルタイム文字起こし

低レイテンシー（約150ms†）

高精度な単語レベルのタイムスタンプ

65種類のエンティティを検出

自然言語の指示による文字起こしの編集

#### [Scribe v2 Medical](/docs/ja/overview/models#scribe-v2-medical)

臨床オーディオ向けに微調整された音声認識

Scribe v2と比べて臨床オーディオの文字起こしエラーが35%少ない

日常会話ではScribe v2と同等の精度

Scribe v2と同じ機能、対応言語、料金、API

### 音楽

#### [Elevenミュージック v2.5](/docs/ja/overview/models#eleven-music)

最も高度な音楽モデル

品質とプロンプトへの忠実性を向上

より豊かなメロディー、深みのあるアレンジ、より重層的な楽器編成。

同じワークフローとサポート：構成プラン、オーディオリファレンス、インペインティング

#### [Elevenミュージック v2](/docs/ja/overview/models#eleven-music)

あらゆるスタイルに対応した、自然言語プロンプトによるスタジオ品質の音楽

ジャンル、スタイル、構成を完全にコントロール

ボーカルあり、またはインストゥルメンタルのみ

英語、スペイン語、ドイツ語、日本語などを含む多言語対応

個別セクションまたは曲全体のサウンドと歌詞を編集

[料金](https://elevenlabs.io/pricing/api)

## モデル概要

ElevenLabs APIは、さまざまなユースケース、品質レベル、パフォーマンス要件に対応するオーディオモデルを提供しています。

| モデルID                        | 説明                                                                                  | 言語                                                                                                                                                                            |
| ---------------------------- | ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `eleven_v4`                  | 最も豊かな感情表現と表現力を備えた音声合成モデル                                                            | [90以上の言語](/docs/ja/overview/models#supported-languages)                                                                                                                       |
| `eleven_v4_turbo`            | 最も表現力豊かなリアルタイム音声合成モデル（約100ms†）                                                      | [90以上の言語](/docs/ja/overview/models#supported-languages)                                                                                                                       |
| `eleven_v3`                  | 人間らしく表現力豊かな音声生成                                                                     | [70以上の言語](/docs/ja/overview/models#supported-languages-2)                                                                                                                     |
| `eleven_v3_conversational`   | 最も表現力豊かなリアルタイム音声合成モデル（約280ms†）                                                      | [70以上の言語](/docs/ja/overview/models#supported-languages-2)                                                                                                                     |
| `eleven_ttv_v3`              | 人間らしく表現力豊かなボイスデザインモデル（テキストtoボイス）                                                    | [70以上の言語](/docs/ja/overview/models#supported-languages-2)                                                                                                                     |
| `eleven_multilingual_v2`     | 豊かな感情表現を備えた自然な音声モデル                                                                 | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_flash_v2_5`          | リアルタイム用途向けに最適化された超高速モデル（約75ms†）                                                     | すべての`eleven_multilingual_v2`対応言語に加え、`hu`、`no`、`vi`                                                                                                                            |
| `eleven_flash_v2`            | リアルタイム用途向けに最適化された超高速モデル（約75ms†）                                                     | `en`                                                                                                                                                                          |
| `eleven_multilingual_sts_v2` | 最先端の多言語ボイスチェンジャーモデル（スピーチtoスピーチ）                                                     | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_multilingual_ttv_v2` | 最先端の多言語ボイスデザイナーモデル（テキストtoボイス）                                                       | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru` |
| `eleven_english_sts_v2`      | 英語専用ボイスチェンジャーモデル（スピーチtoスピーチ）                                                        | `en`                                                                                                                                                                          |
| `scribe_v2_realtime`         | リアルタイム音声認識モデル                                                                       | [90以上の言語](/docs/ja/overview/capabilities/speech-to-text#supported-languages)                                                                                                  |
| `scribe_v2_medical`          | 臨床オーディオ向けに微調整された音声認識                                                                | [90以上の言語](/docs/ja/overview/capabilities/speech-to-text#supported-languages)                                                                                                  |
| `scribe_v2`                  | 最先端の音声認識モデル                                                                         | [90以上の言語](/docs/ja/overview/capabilities/speech-to-text#supported-languages)                                                                                                  |
| `scribe_v2_medical`          | 医療・臨床オーディオに特化した音声認識モデル                                                              | [90以上の言語](/docs/ja/overview/capabilities/speech-to-text#supported-languages)                                                                                                  |
| `eleven_text_to_sound_v2`    | テキストプロンプトからのサウンドエフェクト生成                                                             | 該当なし                                                                                                                                                                          |
| `music_v2_5`                 | 最も高度な音楽モデルです。テキストプロンプト、構成プラン、以前に生成した楽曲からスタジオ品質で生成し、`music_v2`より品質とプロンプト追従性が向上しています。 | `en`、`es`、`de`、`ja`など                                                                                                                                                         |
| `music_v2`                   | テキストプロンプト、構成プラン、以前に生成した楽曲からスタジオ品質で音楽を生成                                             | `en`、`es`、`de`、`ja`など                                                                                                                                                         |
| `music_v1`                   | テキストプロンプトからスタジオ品質で音楽を生成。`music_v2`および`music_v2_5`より性能は劣ります。                         | `en`、`es`、`de`、`ja`など                                                                                                                                                         |

† アプリケーションおよびネットワークのレイテンシーを除く

### 非推奨モデル

> **Warning**
>
> `eleven_turbo_v2_5`および`eleven_turbo_v2`モデルは、それぞれ
> `eleven_flash_v2_5`および`eleven_flash_v2`モデルと機能的には同等です。ただし、Flash
> モデルのレイテンシーは平均的に低くなります。すべてのユース
> ケースでTurboモデルではなくFlashモデルを使用することをおすすめします。

| モデルID               | 説明                                 | 言語                                                                                                                                                                                              | 代替モデルの推奨            |
| ------------------- | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- |
| `eleven_turbo_v2_5` | 第1世代の低レイテンシーモデル（Flashモデルより性能は劣ります） | `en`, `ja`, `zh`, `de`, `hi`, `fr`, `ko`, `pt`, `it`, `es`, `id`, `nl`, `tr`, `fil`, `pl`, `sv`, `bg`, `ro`, `ar`, `cs`, `el`, `fi`, `hr`, `ms`, `sk`, `da`, `ta`, `uk`, `ru`, `hu`, `no`, `vi` | `eleven_flash_v2_5` |
| `eleven_turbo_v2`   | 第1世代の低レイテンシーモデル（Flashモデルより性能は劣ります） | `en`                                                                                                                                                                                            | `eleven_flash_v2`   |
| `scribe_v1`         | 第1世代の音声認識（v2モデルより性能は劣ります）          | [90以上の言語](/docs/ja/overview/capabilities/speech-to-text#supported-languages)                                                                                                                    | `scribe_v2`         |

## Eleven v4

Eleven v4は最先端の音声合成モデルで、最高品質のオーディオ、表現力、音声の演技に対するコントロールを提供します。Eleven v4は高忠実度のボイスクローンに対応し、長文の生成でも話者の特徴を確実に維持します。

このモデルは、次のシナリオに適しています。

* **キャラクターボイスオーバー**：感情表現の幅が広く、ゲームやアニメーションに最適です。
* **感情豊かな会話**：幅広い感情表現と文脈理解を備えた、自然で生き生きとした会話を生成します。
* **オーディオブック制作**：複雑な感情表現を伴う長尺のナレーションに最適です。
* **多言語プロジェクト**：言語を切り替えても一貫した音声品質を維持します。

Eleven v4は[テキストtoダイアログAPI](/docs/ja/api-reference/text-to-dialogue/convert)で利用できます。

### 対応言語

Eleven v4モデルファミリーは、以下を含む90以上の言語に対応しています：

*アフリカーンス語（af）、アラビア語（ar）、アルメニア語（hy）、アッサム語（as）、アストゥリアス語（ast）、アゼルバイジャン語（az）、ベラルーシ語（be）、ベンガル語（bn）、ボスニア語（bs）、ブルガリア語（bg）、ビルマ語（my）、広東語（yue）、カタルーニャ語（ca）、セブアノ語（ceb）、クロアチア語（hr）、チェコ語（cs）、デンマーク語（da）、オランダ語（nl）、英語（en）、エストニア語（et）、フィリピン語（fil）、フィンランド語（fi）、フランス語（fr）、ガリシア語（gl）、ジョージア語（ka）、ドイツ語（de）、ギリシャ語（el）、グジャラート語（gu）、ハウサ語（ha）、ヘブライ語（he）、ヒンディー語（hi）、ハンガリー語（hu）、アイスランド語（is）、インドネシア語（id）、アイルランド語（ga）、イタリア語（it）、日本語（ja）、ジャワ語（jv）、カンナダ語（kn）、カザフ語（kk）、韓国語（ko）、キルギス語（ky）、ラトビア語（lv）、リンガラ語（ln）、リトアニア語（lt）、ルクセンブルク語（lb）、マケドニア語（mk）、マレー語（ms）、マラヤーラム語（ml）、マルタ語（mt）、中国語（標準語）（zh）、マオリ語（mi）、マラーティー語（mr）、モンゴル語（mn）、ネパール語（ne）、ノルウェー語（no）、オック語（oc）、オディア語（or）、パシュトー語（ps）、ペルシャ語（fa）、ポーランド語（pl）、ポルトガル語（pt）、パンジャブ語（pa）、ルーマニア語（ro）、ロシア語（ru）、セルビア語（sr）、シンド語（sd）、スロバキア語（sk）、スロベニア語（sl）、ソマリ語（so）、スペイン語（es）、スワヒリ語（sw）、スウェーデン語（sv）、タジク語（tg）、タミル語（ta）、テルグ語（te）、タイ語（th）、トルコ語（tr）、ウクライナ語（uk）、ウルドゥー語（ur）、ウズベク語（uz）、ベトナム語（vi）、ウェールズ語（cy）、ヨルバ語（yo）。*

> **Note**
>
> `language_code`パラメータは、ほとんどの言語で[ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)
> の2文字コードを受け付けます。ISO 639-1コードがない言語では、[ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)の3文字コードを使用します：アストゥリアス語（`ast`）、広東語
> （`yue`）、セブアノ語（`ceb`）、フィリピン語（`fil`）。

## Eleven v4 Turbo

Eleven v4 Turboは、リアルタイム音声合成向けの最先端モデルで、高品質なオーディオ、表現力、音声の演技に対するコントロールを提供します。Eleven v4 Turboは高忠実度のボイスクローンに対応し、推論レイテンシーの中央値約100msで結果を提供します。

このモデルは、次のシナリオに適しています。

* **サポートエージェント**：顧客からの問い合わせをリアルタイムで解決する音声エージェントを実現します。
* **AIアシスタント**：幅広い感情表現と文脈理解を備えた、自然で生き生きとした会話を生成します。
* **インタラクティブキャラクター**：表現力豊かなキャラクターを使ったオーディオ体験に最適です。

Eleven v4 Turboは[テキストtoダイアログWebSocket](/docs/ja/eleven-api/guides/how-to/websockets/realtime-tdd)で利用できます。

### 対応言語

Eleven v4モデルファミリーは、以下を含む90以上の言語に対応しています：

*アフリカーンス語（af）、アラビア語（ar）、アルメニア語（hy）、アッサム語（as）、アストゥリアス語（ast）、アゼルバイジャン語（az）、ベラルーシ語（be）、ベンガル語（bn）、ボスニア語（bs）、ブルガリア語（bg）、ビルマ語（my）、広東語（yue）、カタルーニャ語（ca）、セブアノ語（ceb）、クロアチア語（hr）、チェコ語（cs）、デンマーク語（da）、オランダ語（nl）、英語（en）、エストニア語（et）、フィリピン語（fil）、フィンランド語（fi）、フランス語（fr）、ガリシア語（gl）、ジョージア語（ka）、ドイツ語（de）、ギリシャ語（el）、グジャラート語（gu）、ハウサ語（ha）、ヘブライ語（he）、ヒンディー語（hi）、ハンガリー語（hu）、アイスランド語（is）、インドネシア語（id）、アイルランド語（ga）、イタリア語（it）、日本語（ja）、ジャワ語（jv）、カンナダ語（kn）、カザフ語（kk）、韓国語（ko）、キルギス語（ky）、ラトビア語（lv）、リンガラ語（ln）、リトアニア語（lt）、ルクセンブルク語（lb）、マケドニア語（mk）、マレー語（ms）、マラヤーラム語（ml）、マルタ語（mt）、中国語（標準語）（zh）、マオリ語（mi）、マラーティー語（mr）、モンゴル語（mn）、ネパール語（ne）、ノルウェー語（no）、オック語（oc）、オディア語（or）、パシュトー語（ps）、ペルシャ語（fa）、ポーランド語（pl）、ポルトガル語（pt）、パンジャブ語（pa）、ルーマニア語（ro）、ロシア語（ru）、セルビア語（sr）、シンド語（sd）、スロバキア語（sk）、スロベニア語（sl）、ソマリ語（so）、スペイン語（es）、スワヒリ語（sw）、スウェーデン語（sv）、タジク語（tg）、タミル語（ta）、テルグ語（te）、タイ語（th）、トルコ語（tr）、ウクライナ語（uk）、ウルドゥー語（ur）、ウズベク語（uz）、ベトナム語（vi）、ウェールズ語（cy）、ヨルバ語（yo）。*

> **Note**
>
> `language_code`パラメータは、ほとんどの言語で[ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)
> の2文字コードを受け付けます。ISO 639-1コードがない言語では、[ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)の3文字コードを使用します：アストゥリアス語（`ast`）、広東語
> （`yue`）、セブアノ語（`ceb`）、フィリピン語（`fil`）。

## Eleven v3

Eleven v3は前世代の音声合成モデルで、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

Eleven v3では、新しいテキストtoダイアログAPIを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。Eleven v3はテキスト読み上げAPIでも使用でき、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成できます。

テキストtoダイアログAPIの詳細は[こちら](/docs/ja/overview/capabilities/text-to-dialogue)をご覧ください。

### 対応言語

Eleven v3モデルは、以下を含む70以上の言語に対応しています：

*アフリカーンス語（af）、アラビア語（ar）、アルメニア語（hy）、アッサム語（as）、アストゥリアス語（ast）、アゼルバイジャン語（az）、ベラルーシ語（be）、ベンガル語（bn）、ボスニア語（bs）、ブルガリア語（bg）、ビルマ語（my）、広東語（yue）、カタルーニャ語（ca）、セブアノ語（ceb）、チチェワ語（ny）、クロアチア語（hr）、チェコ語（cs）、デンマーク語（da）、オランダ語（nl）、英語（en）、エストニア語（et）、フィリピン語（fil）、フィンランド語（fi）、フランス語（fr）、ガリシア語（gl）、ジョージア語（ka）、ドイツ語（de）、ギリシャ語（el）、グジャラート語（gu）、ハウサ語（ha）、ヘブライ語（he）、ヒンディー語（hi）、ハンガリー語（hu）、アイスランド語（is）、インドネシア語（id）、アイルランド語（ga）、イタリア語（it）、日本語（ja）、ジャワ語（jv）、カンナダ語（kn）、カザフ語（kk）、キルギス語（ky）、韓国語（ko）、ラトビア語（lv）、リンガラ語（ln）、リトアニア語（lt）、ルクセンブルク語（lb）、マケドニア語（mk）、マレー語（ms）、マラヤーラム語（ml）、マルタ語（mt）、中国語（標準語）（zh）、マオリ語（mi）、マラーティー語（mr）、モンゴル語（mn）、ネパール語（ne）、ノルウェー語（no）、オック語（oc）、オディア語（or）、パシュトー語（ps）、ペルシャ語（fa）、ポーランド語（pl）、ポルトガル語（pt）、パンジャブ語（pa）、ルーマニア語（ro）、ロシア語（ru）、セルビア語（sr）、シンド語（sd）、スロバキア語（sk）、スロベニア語（sl）、ソマリ語（so）、スペイン語（es）、スワヒリ語（sw）、スウェーデン語（sv）、タジク語（tg）、タミル語（ta）、テルグ語（te）、タイ語（th）、トルコ語（tr）、ウクライナ語（uk）、ウルドゥー語（ur）、ウズベク語（uz）、ベトナム語（vi）、ウェールズ語（cy）、ヨルバ語（yo）。*

> **Note**
>
> `language_code`パラメータは、ほとんどの言語で[ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)
> の2文字コードを受け付けます。ISO 639-1コードがない言語では、[ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)の3文字コードを使用します：アストゥリアス語（`ast`）、広東語
> （`yue`）、セブアノ語（`ceb`）、フィリピン語（`fil`）。

## Eleven v3 Conversational

Eleven v3 Conversationalは、リアルタイム音声合成向けの前世代モデルです。複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

Eleven v3 Conversationalでは、新しいテキストtoダイアログWebSocketを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。

Eleven v3 Conversationalでは、新しいテキストtoダイアログWebSocketを利用できます。これにより、複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした会話を生成できます。

テキストtoダイアログWebSocketの詳細は[こちら](/docs/ja/eleven-api/guides/how-to/websockets/realtime-tdd)をご覧ください。

### 対応言語

Eleven v3モデルは、以下を含む70以上の言語に対応しています：

*アフリカーンス語（af）、アラビア語（ar）、アルメニア語（hy）、アッサム語（as）、アストゥリアス語（ast）、アゼルバイジャン語（az）、ベラルーシ語（be）、ベンガル語（bn）、ボスニア語（bs）、ブルガリア語（bg）、ビルマ語（my）、広東語（yue）、カタルーニャ語（ca）、セブアノ語（ceb）、チチェワ語（ny）、クロアチア語（hr）、チェコ語（cs）、デンマーク語（da）、オランダ語（nl）、英語（en）、エストニア語（et）、フィリピン語（fil）、フィンランド語（fi）、フランス語（fr）、ガリシア語（gl）、ジョージア語（ka）、ドイツ語（de）、ギリシャ語（el）、グジャラート語（gu）、ハウサ語（ha）、ヘブライ語（he）、ヒンディー語（hi）、ハンガリー語（hu）、アイスランド語（is）、インドネシア語（id）、アイルランド語（ga）、イタリア語（it）、日本語（ja）、ジャワ語（jv）、カンナダ語（kn）、カザフ語（kk）、キルギス語（ky）、韓国語（ko）、ラトビア語（lv）、リンガラ語（ln）、リトアニア語（lt）、ルクセンブルク語（lb）、マケドニア語（mk）、マレー語（ms）、マラヤーラム語（ml）、マルタ語（mt）、中国語（標準語）（zh）、マオリ語（mi）、マラーティー語（mr）、モンゴル語（mn）、ネパール語（ne）、ノルウェー語（no）、オック語（oc）、オディア語（or）、パシュトー語（ps）、ペルシャ語（fa）、ポーランド語（pl）、ポルトガル語（pt）、パンジャブ語（pa）、ルーマニア語（ro）、ロシア語（ru）、セルビア語（sr）、シンド語（sd）、スロバキア語（sk）、スロベニア語（sl）、ソマリ語（so）、スペイン語（es）、スワヒリ語（sw）、スウェーデン語（sv）、タジク語（tg）、タミル語（ta）、テルグ語（te）、タイ語（th）、トルコ語（tr）、ウクライナ語（uk）、ウルドゥー語（ur）、ウズベク語（uz）、ベトナム語（vi）、ウェールズ語（cy）、ヨルバ語（yo）。*

> **Note**
>
> `language_code`パラメータは、ほとんどの言語で[ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1)
> の2文字コードを受け付けます。ISO 639-1コードがない言語では、[ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3)の3文字コードを使用します：アストゥリアス語（`ast`）、広東語
> （`yue`）、セブアノ語（`ceb`）、フィリピン語（`fil`）。

## Multilingual v2

Eleven Multilingual v2は、感情を考慮する前世代の音声合成モデルです。複数の言語にわたり、幅広い感情表現と文脈理解を備えた自然で生き生きとした音声を生成します。

このモデルは、話者固有の特徴とアクセントを維持しながら、すべての対応言語で一貫した音声品質と個性を実現します。

このモデルは、高品質で感情表現豊かな音声が必要な次のシナリオで優れています。

* **キャラクターボイスオーバー**：感情表現の幅が広く、ゲームやアニメーションに最適です。
* **プロフェッショナルコンテンツ**：企業ビデオやeラーニング教材に適しています。
* **多言語プロジェクト**：言語を切り替えても一貫した音声品質を維持します。
* **安定した品質**：一貫して高品質なオーディオ出力を生成します。

Flashモデルよりも1文字あたりのレイテンシーとコストは高くなりますが、生き生きとした音声が重要なプロジェクトでは優れた品質を提供します。

Multilingual v2モデルは、29言語に対応しています。

*英語（米国、英国、オーストラリア、カナダ）、日本語、中国語、ドイツ語、ヒンディー語、フランス語（フランス、カナダ）、韓国語、ポルトガル語（ブラジル、ポルトガル）、イタリア語、スペイン語（スペイン、メキシコ）、インドネシア語、オランダ語、トルコ語、フィリピン語、ポーランド語、スウェーデン語、ブルガリア語、ルーマニア語、アラビア語（サウジアラビア、アラブ首長国連邦）、チェコ語、ギリシャ語、フィンランド語、クロアチア語、マレー語、スロバキア語、デンマーク語、タミル語、ウクライナ語、ロシア語。*

## Flash v2.5

Eleven Flash v2.5は、リアルタイムアプリケーションとAgents Platform向けに設計された、最も高速な音声合成モデルです。32言語で、超低レイテンシー（約75ms†）の高品質な音声を提供します。

このモデルは速度と品質のバランスを取り、言語間で自然な出力と一貫した音声特性を維持しながら、インタラクティブなアプリケーションに最適です。

このモデルは、特に次の用途に適しています。

* **Agents Platform**：リアルタイム音声エージェントやチャットボットに最適です。
* **インタラクティブアプリケーション**：即時応答が必要なゲームやアプリケーションに最適です。
* **大規模処理**：大量のテキスト読み上げ変換を効率的に行えます。

API生成の低価格と75msのレイテンシーにより、Flash v2.5は複数言語で高速かつ信頼性の高い音声合成を必要とする場合に、コスト効率の高い選択肢です。

Flash v2.5は、v2モデルのすべての言語に加え、以下を含む32言語に対応しています。

*ハンガリー語、ノルウェー語、ベトナム語*

† アプリケーションおよびネットワークのレイテンシーを除く

### 考慮事項

#### 数値のテキスト正規化

Flash v2.5を使用する場合、数値は期待どおりにはデフォルトで正規化されません。たとえば、電話番号がユーザーにとって分かりにくい方法で読み上げられることがあります。日付や通貨も同様の影響を受けます。

Flash v2.5では低レイテンシーを維持するため、デフォルトで正規化が無効になっています。ただし、エンタープライズのお客様は、リクエストで`apply_text_normalization`パラメータを"on"に設定することで、v2.5モデルのテキスト正規化を有効にできるようになりました。

Multilingual v2モデルは数値の正規化をより適切に処理するため、電話番号など数値の正規化が重要なケースではこのモデルの使用をおすすめします。

低レイテンシーまたはAgents Platformアプリケーションでは、TTSモデルに渡す前にLLMで[テキストを正規化](/docs/ja/overview/capabilities/text-to-speech/best-practices#text-normalization)するか、`apply_text_normalization`パラメータを使用することをおすすめします（v2.5モデルではエンタープライズプランのみ）。

## モデル選択ガイド

要件やユースケースに最適なモデルについては、[モデル選択ガイド](/docs/ja/eleven-api/choosing-the-right-model)をご覧ください。

#### 要件

#### 品質

`eleven_v4` または `eleven_multilingual_v2` を使用します

豊かな感情表現を備えた高忠実度のオーディオ出力に最適です

#### 低レイテンシー

`eleven_v4_turbo` を使用します

リアルタイムアプリケーション向けに最適化されています（レイテンシー約100ms）

#### ユースケース

#### コンテンツ制作

`eleven_v4` または `eleven_multilingual_v2` を使用します

プロフェッショナルなコンテンツ、オーディオブック、ビデオナレーションに最適です。

#### Agents Platform

`eleven_v4_turbo`、`eleven_flash_v2_5`、`eleven_flash_v2`、または `eleven_multilingual_v2` を使用します

リアルタイムの会話型アプリケーションに最適です。最も表現力豊かな話し方には `eleven_v4_turbo` を使用してください。

#### ボイスチェンジャー

`eleven_multilingual_sts_v2` を使用します

スピーチtoスピーチ変換に特化しています

## 文字数制限

1回のテキスト読み上げリクエストでサポートされる最大文字数は、モデルによって異なります。

| モデルID                    | 文字数制限  | おおよそのオーディオ時間 |
| ------------------------ | ------ | ------------ |
| `eleven_v4`              | 10,000 | 約10分         |
| `eleven_v3`              | 5,000  | 約5分          |
| `eleven_flash_v2_5`      | 40,000 | 約40分         |
| `eleven_flash_v2`        | 30,000 | 約30分         |
| `eleven_multilingual_v2` | 10,000 | 約10分         |
| `eleven_multilingual_v1` | 10,000 | 約10分         |
| `eleven_english_sts_v2`  | 10,000 | 約10分         |
| `eleven_english_sts_v1`  | 10,000 | 約10分         |

> **Note**
>
> 長いコンテンツの場合は、入力を複数のリクエストに分割することを検討してください。

## Scribe v2

Scribe v2は、90以上の言語で正確な文字起こしを行うために設計された、最先端の音声認識モデルです。正確な単語レベルのタイムスタンプに加え、話者ダイアライゼーションや動的オーディオタグ付けなどの高度な機能を提供します。

このモデルは、正確なスピーチtoテキスト変換が必要なシナリオで優れた性能を発揮します。

* **文字起こしサービス**：オーディオ／ビデオコンテンツをテキストに変換するのに最適
* **会議の記録**：会話を記録・文書化するのに最適
* **コンテンツ分析**：オーディオコンテンツの処理・分析に適しています
* **多言語認識**：90以上の言語で正確な文字起こしに対応

主な機能：

* 単語レベルのタイムスタンプを含む正確な文字起こし
* 複数話者のオーディオに対応する話者ダイアライゼーション
* 文脈を強化する動的オーディオタグ付け
* 90以上の言語をサポート
* エンティティ検出
* キータームプロンプト
* 文字起こしの編集

Scribe v2の詳細は[こちら](/docs/ja/overview/capabilities/speech-to-text)をご覧ください。

## Scribe v2 Realtime

最速かつ最も正確なライブ音声認識モデルであるScribe v2 Realtimeは、超低レイテンシーの150msで、90以上の言語において最先端の精度を実現します。

このモデルは、会話型のユースケースで優れた性能を発揮します。

* **ライブ会議の文字起こし**：リアルタイム文字起こしに最適
* **AIエージェント**：ライブ会話に最適
* **多言語認識**：自動言語認識により、90以上の言語で正確な文字起こしに対応

主な機能：

* 超低レイテンシー：約150ミリ秒で部分的な文字起こしを取得
* ストリーミング対応：オーディオをチャンクで送信しながら、リアルタイムで文字起こしを受信
* 複数のオーディオ形式：PCM（8kHz～48kHz）およびμ-lawエンコーディングに対応
* 音声アクティビティ検出（VAD）：無音検出に基づく自動音声セグメンテーション
* 手動コミット制御：文字起こしセグメントを確定するタイミングを完全に制御
* エンティティ検出
* 文字起こしの編集

Scribe v2 Realtimeの詳細は[こちら](/docs/ja/overview/capabilities/speech-to-text)をご覧ください。

## Scribe v2 Medical

Scribe v2 Medicalは、医療および臨床オーディオに特化したバッチ音声認識モデルです。Scribe v2を微調整したモデルで、日常会話におけるScribe v2の精度を維持しながら、薬剤名、解剖学、病理学、臨床ディクテーションの認識を改善します。Scribe v2と同じスピーチtoテキストAPIを使用し、料金も同一です。`model_id`として`scribe_v2_medical`を渡してください。

> **Note**
>
> ### 使用目的
>
> Scribe v2 Medicalは、開発者および組織が、臨床医と患者の会話、
> ディクテーション、問診、ケア連携の通話などの臨床オーディオを、文書化および関連する管理ワークフロー向けの
> 下書き文字起こしに変換するアプリケーションに組み込むための、バッチスピーチtoテキストAPIモデルです。生成されたテキストは、使用前に医療専門家またはその他の認可されたユーザーが
> 確認および修正することを想定しています。Scribe
> v2 Medicalは、臨床情報の解釈、診断、治療の推奨、臨床判断、その他の臨床ガイダンスの提供を目的とするものではありません。

このモデルは、以下の用途に適しています。

* **臨床文書化**：会話の途中で医療用語が出てくる環境音を含む診察や記録
* **ディクテーション**：薬剤、用量、所見が密に連続する音声
* **問診・連携通話**：多くの場合電話で、患者が自身の症状を説明する通話
* **コンプライアンスワークフロー**：PHIカテゴリには[エンティティ検出](/docs/ja/eleven-api/guides/how-to/speech-to-text/batch/entity-detection)と組み合わせて使用

主な機能：

* Scribe v2と同じリクエスト形式（`keyterms`、`entity_detection`、`no_verbatim`、ダイアライゼーション、タイムスタンプ）
* 薬剤名、解剖学用語、病理学用語の認識を改善
* Scribe v2と比べて日常会話の精度低下なし
* 90以上の言語をサポート
* 複数話者のオーディオに対応する話者ダイアライゼーション
* 動的オーディオタグ付け
* PHIカテゴリを含むエンティティ検出

Scribe v2 Medicalはバッチモデルです。ライブ文字起こしにはScribe v2 Realtimeを使用してください。

Scribe v2 MedicalはHIPAAの対象であり、エンタープライズのお客様にはBusiness Associate Agreement（BAA）およびZero Retention Mode（ZRM）をご利用いただけます。ZRMを有効にすると、オーディオ入力とテキスト出力は各リクエストの完了直後に削除されます。ElevenLabsは何も保持せず、アプリケーションは完全なAPIレスポンスを受け取り、独自の管理下で文字起こしを保持します。

> **Info**
>
> HIPAA準拠が必要な企業は、保護対象保健情報を送信する前に、Business Associate Agreement（BAA）に署名するため[ElevenLabs Sales](https://elevenlabs.io/contact-sales)へお問い合わせください。

スピーチtoテキストの詳細は[こちら](/docs/ja/overview/capabilities/speech-to-text)をご覧ください。

## Elevenミュージック

Elevenミュージックは、スタジオ品質の音楽生成モデルです。自然言語プロンプトを使って、あらゆるスタイルの音楽を生成できます。

このモデルは、次のようなシナリオに最適です。

* **ゲームサウンドトラック**：ゲーム向けの没入感あるサウンドトラックを作成
* **ポッドキャストの背景音楽**：プロフェッショナルな音楽でポッドキャストを引き立てる
* **マーケティング**：広告動画にバックグラウンド音楽を追加

主な機能：

* ジャンル、スタイル、構成を完全にコントロール
* ボーカルありまたはインストゥルメンタルのみ
* 英語、スペイン語、ドイツ語、日本語などを含む多言語対応
* 個々のセクションまたは曲全体のサウンドと歌詞を編集

Elevenミュージックの詳細は[こちら](/docs/ja/overview/capabilities/music)をご覧ください。

## 同時実行数と優先度

サブスクリプションプランによって、同時に処理できるリクエスト数と、キュー内でのリクエストの優先度が決まります。
スピーチtoテキストの同時実行数上限は引き上げられています。
同時実行数の上限に達すると、その後のリクエストは優先度の低いリクエストとともにキューで処理されます。
通常、これによって増えるレイテンシーは約50ms程度です。

| プラン      | 同時実行数上限 （Multilingual v2） | 同時実行数上限 （Flash） | STT同時実行数上限 | リアルタイムSTT同時実行数上限 | 音楽の同時実行数上限 | 優先度レベル |
| -------- | ------------------------- | --------------- | ---------- | ---------------- | ---------- | ------ |
| 無料       | 2                         | 4               | 8          | 6                | 0          | 3      |
| スターター    | 3                         | 6               | 12         | 9                | 2          | 4      |
| クリエイター   | 5                         | 10              | 20         | 15               | 2          | 5      |
| プロ       | 10                        | 20              | 40         | 30               | 2          | 5      |
| スケール     | 15                        | 30              | 60         | 45               | 5          | 5      |
| ビジネス     | 15                        | 30              | 60         | 45               | 5          | 5      |
| エンタープライズ | 引き上げ                      | 引き上げ            | 引き上げ       | 引き上げ             | 最高         | 6      |

> **Note**
>
> スタートアップ助成金の受給者には、スケールレベルの特典が提供されます。

レスポンスヘッダーには、同時実行数を監視するために使用できる `current-concurrent-requests` と `maximum-concurrent-requests` が含まれます。

### 1分あたりのAPIリクエスト数と同時実行リクエスト数

**1分あたりのAPIリクエスト数**と**同時実行リクエスト数**は、使用パターンによって異なる指標であることを理解しておくことが重要です。

1分あたりのAPIリクエスト数は、各リクエストにかかる時間やリクエストのバッチ処理方法に依存するため、同時実行リクエスト数とは異なる場合があります。

**例1：間隔を空けたリクエスト**
各リクエストの完了に1秒かかる毎分180リクエストを、0.33秒間隔で送信した場合、常に3件のリクエストが処理中となるため、同時実行リクエスト数の最大値と平均値はいずれも3になります。

**例2：バッチリクエスト**
一方、各リクエストの完了に3秒かかる毎分180リクエストをすべて一度に送信するような使用パターンでは、同時実行リクエスト数の最大値は180、平均値は9になります（1分の最初の3秒間は180リクエストが同時に存在し、残りの57秒間は0リクエストです）。

システムでは同時実行数を重視するため、1分あたりのリクエスト数よりも、各リクエストにかかる時間と送信タイミングのパターンの方が重要です。

エンドポイントへのリクエスト方法は、同時実行数上限に影響します。

* HTTPでは、各リクエストが個別に同時実行数上限へカウントされます。
* テキスト読み上げWebSocketでは、モデルがオーディオを生成している時間のみが同時実行数上限にカウントされます。つまり、ほとんどの時間では、開いているWebSocketは同時実行数上限にまったくカウントされません。
* テキストtoダイアログWebSocketの仕組みは異なります。開いている各接続は、接続が維持されている間、別のプールから1つのダイアログセッションを予約します。接続経由で生成されたオーディオは、通常の同時実行数上限にはカウントされません。1接続が1セッションとなるため理解しやすく、新しい同時実行方式に合わせてダイアログセッション上限が設定されています。詳しくは、[テキストtoダイアログの同時実行数](#text-to-dialogue-concurrency)をご覧ください。

### 同時実行数上限について

プランに紐づく同時実行数上限は、同時に処理できる会話、電話、キャラクターボイスオーバーなどの最大数として解釈すべきではありません。
実際の数は、使用するAI音声やユースケースの特性など、複数の要因によって異なります。

一般的な目安として、同時実行数上限が5の場合、通常は約100件までの同時オーディオ配信に対応できます。

これは、オーディオの生成速度がTTSリクエストの処理時間に比べて速いためです。
以下の図は、同時実行リクエスト数を2に抑えながら、異なるユーザーとの4件の同時通話を処理する例です。

![同時実行数上限](/docs/_fern-img/dcc5e3bd18993a9f862bd526f3dc1b32cfa89003a58ded6f4f6a7bda1bd5a2ea.webp)

#### AI音声エージェントの構築

TTSを対話に使用する場合、同時実行数上限が5あれば、AIエージェントと人間の参加者によるバランスの取れた会話で約100件の配信に対応できます。

カスタマーサポートのやり取りのように、AIエージェントが人間よりも発話頻度の低いユースケースでは、100件を超える同時会話に対応できる場合があります。

#### キャラクターボイスオーバー

一般に、同時実行数上限が5の場合、100件を超える同時キャラクターボイスオーバーに対応できます。

この数は、キャラクターの発話頻度、間の長さ、セリフ間のゲーム内アクションによって異なります。

#### ライブ吹き替え

同時吹き替えストリームは、通常、上記の目安に従います。

配信に会話の間がある場合（例：サウンドトラック、映像シーンなどによるもの）、推奨数を超える同時吹き替えストリームが可能になることがあります。

エンタープライズプランをご利用で、いずれかの時点でプランの同時実行数上限を超えた場合でも、利用可能な容量に応じてベストエフォートで、より低速ながらモデルリクエストが成功することがあります。

> **Note**
>
> 同時実行数上限とキューの優先度を引き上げるには、[サブスクリプション プランをアップグレードしてください](https://elevenlabs.io/pricing/api)。
>
> エンタープライズのお客様は、アカウントマネージャーに連絡して、より高い同時実行数上限をリクエストできます。

### テキストtoダイアログの同時実行数

テキストtoダイアログのリクエストは、APIの呼び出し方法に応じて2種類の方法で計測されます。

* **HTTPエンドポイント**（[ダイアログを作成](/docs/ja/api-reference/text-to-dialogue/convert)および[ダイアログをストリーミング](/docs/ja/api-reference/text-to-dialogue/stream)）は、他のテキスト読み上げリクエストと同様に、オーディオ生成中はプランの通常の同時実行数上限にカウントされます。
* [テキストtoダイアログWebSocket](/docs/ja/api-reference/text-to-dialogue/ttd-websocket)などの**WebSocketエンドポイント**は、**ダイアログセッション**として計測されます。オーディオを生成中かどうかにかかわらず、開いている接続は、接続が維持されている間、ダイアログセッションを占有します。

セッションベースの計測により、容量計画がシンプルになります。1接続が1セッションとなるため、使用量は生成アクティビティによって変動しません。オーディオ生成中だけでなく接続全体でセッションが占有されるため、この新しい同時実行方式に合わせてダイアログセッション上限が設定されています。

| プラン      | WebSocketセッション |
| -------- | -------------- |
| 無料       | 14             |
| スターター    | 21             |
| クリエイター   | 35             |
| プロ       | 70             |
| スケール     | 105            |
| ビジネス     | 105            |
| エンタープライズ | 引き上げ           |

ワークスペースのダイアログセッションがすべて使用中のときに接続を開くと、新しい接続は `too_many_concurrent_requests` エラーで拒否されます。セッションを解放するには、不要になった接続を閉じてください。`keep_alive` メッセージを送信しない限り、接続は20秒間の非アクティブ状態の後に自動的に閉じられます。

ダイアログセッションを監視するには、ダッシュボードのサイドバー下部にある **Developers** を開き、**Analytics** タブを選択して、Usageビューの **Concurrent requests** 指標を確認します。ダイアログセッションは、他の同時実行リクエストとは別に、**TTD Websocket Sessions** という独自の系列としてレポートされます。

### 同時実行数上限のスケールテスト

スケールテストは、クライアント側のスケーリング問題を特定し、ユースケースに対して同時実行数上限が適切に設定されていることを確認するのに役立ちます。

実際の使用状況にできる限り近いエンドツーエンドのワークフローをテストすることを強く推奨します。対応可能なユーザー数をシミュレーションして測定することが、そのための推奨される手法です。次の点が重要です。

* 生のリクエストではなく、ユーザーをシミュレーションする
* リクエストを送信する前に、オーディオ再生、ユーザーの発話、文字起こしの完了を待つなど、一般的なユーザー行動をシミュレーションする
* 数分かけてユーザー数を徐々に増やす
* リクエストのタイミングとリクエストサイズにランダム性を加える
* レイテンシー指標とAPIから返されたエラーコードを収集する

たとえば、100件の同時会話をサポートするよう設計されたエージェントシステムをテストするには、それぞれが会話をシミュレーションする最大100人の個別「ユーザー」を作成します。会話は通常、約10秒間のユーザーの発話、約150文字に対するTTS API呼び出し、約10秒間のユーザーへのオーディオ再生というサイクルを繰り返します。したがって、各ユーザーは20秒ごとに、150文字のテキストに対するWebSocketのテキスト読み上げAPI呼び出しを行うパターンに従う必要があります。このとき、待機時間とリクエストする文字数に少量のランダム性を加えます。テストでは、100人に達するまで1秒ごとに1ユーザーを起動し、その後、全体の安定性をテストするために合計10分間実行します。

#### スケールテストスクリプトの例

この例では、ElevenLabs APIを直接呼び出すテストフレームワークとして[locust](https://locust.io/)を使用します。

上記の例に従い、各ユーザーが20秒ごとに1リクエストを送信する会話型エージェントシステムをテストします。

**`Python`**

```python title="Python" {12}
import json
import random
import time
import gevent
import locust
from locust import User, task, events, constant_throughput
import websocket

# Averages up to 10 seconds of audio when played, depends on the voice speed
DEFAULT_TEXT = (
    "Hello, this is a test message. I am testing if a long input will cause issues for the model "
    "like this sentence. "
)

TEXT_ARRAY = [
    "Hello.",
    "Hello, this is a test message.",
    DEFAULT_TEXT,
    DEFAULT_TEXT * 2,
    DEFAULT_TEXT * 3
]

# Custom command line arguments
@events.init_command_line_parser.add_listener
def on_parser_init(parser):
    parser.add_argument("--api-key", default="YOUR_API_KEY", help="API key for authentication")
    parser.add_argument("--encoding", default="mp3_22050_32", help="Encoding")
    parser.add_argument("--text", default=DEFAULT_TEXT, help="Text to use")
    parser.add_argument("--use-text-array", default="false", help="Text to use")
    parser.add_argument("--voice-id", default="aria", help="Text to use")


class WebSocketTTSUser(User):
    # Each user will send a request every 20 seconds, regardless of how long each request takes
    wait_time = constant_throughput(0.05)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.api_key = self.environment.parsed_options.api_key
        self.voice_id = self.environment.parsed_options.voice_id
        self.text = self.environment.parsed_options.text
        self.encoding = self.environment.parsed_options.encoding
        self.use_text_array = self.environment.parsed_options.use_text_array
        if self.use_text_array:
            self.text = random.choice(TEXT_ARRAY)
        self.all_recieved = False

    @task
    def tts_task(self):
        # Do jitter waiting of up to 1 second
        # Users appear to be spawned every second so this ensures requests are not aligned
        gevent.sleep(random.random())

        max_wait_time = 10

        # Connection details
        uri = f"{self.environment.host}/v1/text-to-speech/{self.voice_id}/stream-input?auto_mode=true&output_format={self.encoding}"
        headers = {"xi-api-key": self.api_key}

        ws = None
        self.all_recieved = False
        try:
            init_msg = {"text": " "}
            # Use proper header format for websocket - this is case sensitive!
            ws = websocket.create_connection(uri, header=headers)
            ws.send(json.dumps(init_msg))

            # Start measuring after websocket initiated but before any messages are sent
            send_request_time = time.perf_counter()
            ws.send(json.dumps({"text": self.text}))

            # Send to flush and receive the audio
            ws.send(json.dumps({"text": ""}))

            def _receive():
                t_first_response = None
                audio_size = 0
                try:
                    while True:
                        # Wait up to 10 seconds for a response
                        ws.settimeout(max_wait_time)
                        response = ws.recv()
                        response_data = json.loads(response)

                        if "audio" in response_data and response_data["audio"]:
                            audio_size = audio_size + len(response_data["audio"])

                        if t_first_response is None:
                            t_first_response = time.perf_counter()
                            first_byte_ms = (
                                t_first_response - send_request_time
                            ) * 1000
                            if audio_size is None:
                                # The first response should always have audio
                                locust.events.request.fire(
                                    request_type="websocket",
                                    name="Bad Response (no audio)",
                                    response_time=first_byte_ms,
                                    response_length=audio_size,
                                    exception=Exception("Response has no audio"),
                                )
                                break

                        if "isFinal" in response_data and response_data["isFinal"]:
                            # Fire this event once finished streaming, but report the important TTFB metric
                            locust.events.request.fire(
                                request_type="websocket",
                                name="TTS Stream Success (First Byte)",
                                response_time=first_byte_ms,
                                response_length=audio_size,
                                exception=None,
                            )
                            break

                except websocket.WebSocketTimeoutException:
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Timeout",
                        response_time=max_wait_time * 1000,
                        response_length=audio_size,
                        exception=Exception("Timeout waiting for response"),
                    )
                except Exception as e:
                    # Typically JSON decode error if the server returns HTTP backoff error
                    locust.events.request.fire(
                        request_type="websocket",
                        name="TTS Stream Failure",
                        response_time=0,
                        response_length=0,
                        exception=e,
                    )
                finally:
                    self.all_recieved = True

            gevent.spawn(_receive)

            # Sleep until recieved so new tasks aren't spawned
            while not self.all_recieved:
                gevent.sleep(1)

        except websocket.WebSocketTimeoutException:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Timeout",
                response_time=max_wait_time * 1000,
                response_length=0,
                exception=Exception("Timeout waiting for response"),
            )
        except Exception as e:
            locust.events.request.fire(
                request_type="websocket",
                name="TTS Stream Failure",
                response_time=0,
                response_length=0,
                exception=e,
            )
        finally:
            # Try and close the websocket gracefully
            try:
                if ws:
                    ws.close()
            except Exception:
                pass

```