> 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. # Modelos > Learn about the models that power the ElevenLabs API. ## Modelos insignia ### Texto a Voz #### [Eleven v4](/docs/es/overview/models#eleven-v4) Nuestro modelo de síntesis de voz más expresivo y de mayor calidad Capacidades excepcionales de clonación de voz Compatible con más de 90 idiomas Límite de 10.000 caracteres Compatible con diálogos naturales entre varios hablantes #### [Eleven v4 Turbo](/docs/es/overview/models#eleven-v4-turbo) Nuestro modelo de síntesis de voz en tiempo real más expresivo Latencia ultrabaja (latencia de inferencia mediana de \~100 ms†) Capacidades excepcionales de clonación de voz Compatible con más de 90 idiomas Etiquetas de audio para un control preciso #### [Eleven v3](/docs/es/overview/models#eleven-v3) Nuestro modelo de síntesis de voz expresivo y con gran riqueza emocional Entonación e interpretación dramáticas Compatible con más de 70 idiomas Límite de 5.000 caracteres Compatible con diálogos naturales entre varios hablantes #### [Eleven v3 Conversational](/docs/es/overview/models#eleven-v3-conversational) Nuestro modelo de síntesis de voz expresivo y en tiempo real Baja latencia (\~280 ms) Entonación e interpretación dramáticas Compatible con más de 70 idiomas Etiquetas de audio para un control preciso #### [Eleven Multilingual v2](/docs/es/overview/models#multilingual-v2) Modelo de síntesis de voz realista y de calidad constante Resultado con sonido natural Compatible con 29 idiomas Límite de 10.000 caracteres El más estable para generaciones largas #### [Eleven Flash v2.5](/docs/es/overview/models#flash-v25) Nuestro modelo de síntesis de voz rápido y asequible Latencia ultrabaja (\~75 ms†) Compatible con 32 idiomas Límite de 40.000 caracteres Modelo más rápido, con un precio por carácter un 50 % menor para generaciones mediante la API ### Voz a Texto #### [Scribe v2](/docs/es/overview/models#scribe-v2) Modelo de reconocimiento de voz de última generación Transcripción precisa en más de 90 idiomas Prompting de términos clave, hasta 1000 términos Detección de entidades, 65 tipos de entidades Edición de transcripciones con instrucciones en lenguaje natural Marcas de tiempo precisas a nivel de palabra Diarización de hablantes, hasta 32 hablantes Etiquetado de audio dinámico Detección inteligente de idioma #### [Scribe v2 Realtime](/docs/es/overview/models#scribe-v2-realtime) Modelo de reconocimiento de voz en tiempo real Transcripción precisa en más de 90 idiomas Transcripción en tiempo real Baja latencia (\~150ms†) Marcas de tiempo precisas a nivel de palabra Detección de entidades, 65 tipos de entidades Edición de transcripciones con instrucciones en lenguaje natural #### [Scribe v2 Medical](/docs/es/overview/models#scribe-v2-medical) Reconocimiento de voz ajustado para audio clínico Un 35 % menos de errores de transcripción en audio clínico que Scribe v2 La misma precisión en habla cotidiana que Scribe v2 Las mismas funciones, idiomas, precios y API que Scribe v2 ### Música #### [Eleven Music v2.5](/docs/es/overview/models#eleven-music) Nuestro modelo de música más avanzado Mejor calidad y seguimiento de prompts Melodías más ricas, arreglos más profundos e instrumentos con más capas. Los mismos flujos de trabajo y compatibilidad: planes de composición, referencia de audio e inpainting #### [Eleven Music v2](/docs/es/overview/models#eleven-music) Música de calidad de estudio con prompts en lenguaje natural de cualquier estilo Control total sobre el género, el estilo y la estructura Con voz o solo instrumental Multilingüe, incluidos inglés, español, alemán, japonés y más Edita el sonido y la letra de secciones individuales o de toda la canción [Precios](https://elevenlabs.io/pricing/api) ## Resumen de modelos La API de ElevenLabs ofrece una gama de modelos de audio optimizados para distintos casos de uso, niveles de calidad y requisitos de rendimiento. | ID de modelo | Descripción | Idiomas | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `eleven_v4` | Nuestro modelo de síntesis de voz más expresivo y con mayor riqueza emocional | [más de 90 idiomas](/docs/es/overview/models#supported-languages) | | `eleven_v4_turbo` | Nuestro modelo de síntesis de voz en tiempo real más expresivo (\~100 ms†) | [más de 90 idiomas](/docs/es/overview/models#supported-languages) | | `eleven_v3` | Generación de voz humana y expresiva | [más de 70 idiomas](/docs/es/overview/models#supported-languages-2) | | `eleven_v3_conversational` | Nuestro modelo de síntesis de voz en tiempo real más expresivo (\~280 ms†) | [más de 70 idiomas](/docs/es/overview/models#supported-languages-2) | | `eleven_ttv_v3` | Modelo de diseño de voz humano y expresivo (Texto a Voz) | [más de 70 idiomas](/docs/es/overview/models#supported-languages-2) | | `eleven_multilingual_v2` | Nuestro modelo realista con una rica expresión emocional | `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` | Modelo ultrarrápido optimizado para uso en tiempo real (\~75 ms†) | Todos los idiomas de `eleven_multilingual_v2` y además: `hu`, `no`, `vi` | | `eleven_flash_v2` | Modelo ultrarrápido optimizado para uso en tiempo real (\~75 ms†) | `en` | | `eleven_multilingual_sts_v2` | Modelo multilingüe de cambiador de voz de última generación (Voz a Voz) | `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` | Modelo multilingüe de diseño de voz de última generación (Texto a Voz) | `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` | Modelo de cambiador de voz solo en inglés (Voz a Voz) | `en` | | `scribe_v2_realtime` | Modelo de reconocimiento de voz en tiempo real | [más de 90 idiomas](/docs/es/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Reconocimiento de voz ajustado para audio clínico | [más de 90 idiomas](/docs/es/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2` | Modelo de reconocimiento de voz de última generación | [más de 90 idiomas](/docs/es/overview/capabilities/speech-to-text#supported-languages) | | `scribe_v2_medical` | Modelo de reconocimiento de voz especializado en audio médico y clínico | [más de 90 idiomas](/docs/es/overview/capabilities/speech-to-text#supported-languages) | | `eleven_text_to_sound_v2` | Generación de efectos de sonido a partir de prompts de texto | No aplicable | | `music_v2_5` | Nuestro modelo de música más avanzado. Generación con calidad de estudio a partir de prompts de texto, planes de composición y canciones generadas previamente, con mejor calidad y seguimiento de prompts que `music_v2` | `en`, `es`, `de`, `ja` y más | | `music_v2` | Generación de música con calidad de estudio a partir de prompts de texto, planes de composición y canciones generadas previamente | `en`, `es`, `de`, `ja` y más | | `music_v1` | Generación de música con calidad de estudio a partir de prompts de texto. Superado por `music_v2` y `music_v2_5` | `en`, `es`, `de`, `ja` y más | † Sin incluir la latencia de la aplicación y la red ### Modelos obsoletos > **Warning** > > Los modelos `eleven_turbo_v2_5` y `eleven_turbo_v2` son funcionalmente equivalentes a los > modelos `eleven_flash_v2_5` y `eleven_flash_v2`, respectivamente, salvo que la latencia de los > modelos Flash es menor de media. Recomendamos usar los modelos Flash en lugar de los modelos Turbo en todos los > casos de uso. | ID de modelo | Descripción | Idiomas | Modelo de sustitución recomendado | | ------------------- | ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------- | | `eleven_turbo_v2_5` | Modelo de baja latencia de primera generación (superado por los modelos 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` | Modelo de baja latencia de primera generación (superado por los modelos Flash) | `en` | `eleven_flash_v2` | | `scribe_v1` | Reconocimiento de voz de primera generación (superado por los modelos v2) | [más de 90 idiomas](/docs/es/overview/capabilities/speech-to-text#supported-languages) | `scribe_v2` | ## Eleven v4 Eleven v4 es nuestro modelo de síntesis de voz más avanzado, que ofrece audio de la máxima calidad, expresividad y control sobre la interpretación de las voces. Eleven v4 admite la clonación de voz de alta fidelidad y conserva de forma fiable las características del hablante en generaciones de texto largas. Este modelo funciona bien en los siguientes casos: * **Locuciones de personajes**: Ideal para videojuegos y animación por su rango emocional. * **Diálogo emocional**: Genera diálogos naturales y realistas, con un amplio rango emocional y comprensión contextual. * **Producción de audiolibros**: Perfecto para narraciones largas con una interpretación emocional compleja. * **Proyectos multilingües**: Mantiene una calidad de voz uniforme al cambiar de idioma. Eleven v4 está disponible a través de la [API de Texto a Diálogo](/docs/es/api-reference/text-to-dialogue/convert). ### Idiomas compatibles La familia de modelos Eleven v4 admite más de 90 idiomas, entre ellos: *Afrikáans (af), árabe (ar), armenio (hy), asamés (as), asturiano (ast), azerbaiyano (az), bielorruso (be), bengalí (bn), bosnio (bs), búlgaro (bg), birmano (my), cantonés (yue), catalán (ca), cebuano (ceb), croata (hr), checo (cs), danés (da), neerlandés (nl), inglés (en), estonio (et), filipino (fil), finés (fi), francés (fr), gallego (gl), georgiano (ka), alemán (de), griego (el), guyaratí (gu), hausa (ha), hebreo (he), hindi (hi), húngaro (hu), islandés (is), indonesio (id), irlandés (ga), italiano (it), japonés (ja), javanés (jv), canarés (kn), kazajo (kk), coreano (ko), kirguís (ky), letón (lv), lingala (ln), lituano (lt), luxemburgués (lb), macedonio (mk), malayo (ms), malayalam (ml), maltés (mt), chino mandarín (zh), maorí (mi), maratí (mr), mongol (mn), nepalí (ne), noruego (no), occitano (oc), odia (or), pastún (ps), persa (fa), polaco (pl), portugués (pt), punyabí (pa), rumano (ro), ruso (ru), serbio (sr), sindhi (sd), eslovaco (sk), esloveno (sl), somalí (so), español (es), suajili (sw), sueco (sv), tayiko (tg), tamil (ta), telugu (te), tailandés (th), turco (tr), ucraniano (uk), urdu (ur), uzbeko (uz), vietnamita (vi), galés (cy), yoruba (yo).* > **Note** > > El parámetro `language_code` acepta códigos de dos letras [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) > para la mayoría de los idiomas. Los idiomas sin código ISO 639-1 usan códigos de tres letras [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): asturiano (`ast`), cantonés > (`yue`), cebuano (`ceb`) y filipino (`fil`). ## Eleven v4 Turbo Eleven v4 Turbo es nuestro modelo más avanzado para la síntesis de voz en tiempo real, que ofrece audio de alta calidad, expresividad y control sobre la interpretación de las voces. Eleven v4 Turbo admite la clonación de voz de alta fidelidad y ofrece resultados con una latencia de inferencia media de \~100 ms. Este modelo funciona bien en los siguientes casos: * **Agentes de soporte**: Impulsa agentes de voz que resuelven consultas de clientes en tiempo real. * **Asistentes de IA**: Genera diálogos naturales y realistas, con un amplio rango emocional y comprensión contextual. * **Personajes interactivos**: Excelente para experiencias de audio con personajes expresivos. Eleven v4 Turbo está disponible a través del [WebSocket de Texto a Diálogo](/docs/es/eleven-api/guides/how-to/websockets/realtime-tdd). ### Idiomas compatibles La familia de modelos Eleven v4 admite más de 90 idiomas, entre ellos: *Afrikáans (af), árabe (ar), armenio (hy), asamés (as), asturiano (ast), azerbaiyano (az), bielorruso (be), bengalí (bn), bosnio (bs), búlgaro (bg), birmano (my), cantonés (yue), catalán (ca), cebuano (ceb), croata (hr), checo (cs), danés (da), neerlandés (nl), inglés (en), estonio (et), filipino (fil), finés (fi), francés (fr), gallego (gl), georgiano (ka), alemán (de), griego (el), guyaratí (gu), hausa (ha), hebreo (he), hindi (hi), húngaro (hu), islandés (is), indonesio (id), irlandés (ga), italiano (it), japonés (ja), javanés (jv), canarés (kn), kazajo (kk), coreano (ko), kirguís (ky), letón (lv), lingala (ln), lituano (lt), luxemburgués (lb), macedonio (mk), malayo (ms), malayalam (ml), maltés (mt), chino mandarín (zh), maorí (mi), maratí (mr), mongol (mn), nepalí (ne), noruego (no), occitano (oc), odia (or), pastún (ps), persa (fa), polaco (pl), portugués (pt), punyabí (pa), rumano (ro), ruso (ru), serbio (sr), sindhi (sd), eslovaco (sk), esloveno (sl), somalí (so), español (es), suajili (sw), sueco (sv), tayiko (tg), tamil (ta), telugu (te), tailandés (th), turco (tr), ucraniano (uk), urdu (ur), uzbeko (uz), vietnamita (vi), galés (cy), yoruba (yo).* > **Note** > > El parámetro `language_code` acepta códigos de dos letras [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) > para la mayoría de los idiomas. Los idiomas sin código ISO 639-1 usan códigos de tres letras [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): asturiano (`ast`), cantonés > (`yue`), cebuano (`ceb`) y filipino (`fil`). ## Eleven v3 Eleven v3 es nuestro modelo de síntesis de voz de la generación anterior, que produce una voz natural y realista con un amplio rango emocional y comprensión contextual en varios idiomas. Con Eleven v3 llega una nueva API de Texto a Diálogo que te permite generar diálogos naturales y realistas, con un amplio rango emocional y comprensión contextual en varios idiomas. También puedes usar Eleven v3 con la API de Texto a Voz para generar voz natural y realista, con un amplio rango emocional y comprensión contextual en varios idiomas. Más información sobre la API de Texto a Diálogo [aquí](/docs/es/overview/capabilities/text-to-dialogue). ### Idiomas compatibles El modelo Eleven v3 admite más de 70 idiomas, entre ellos: *Afrikáans (af), árabe (ar), armenio (hy), asamés (as), asturiano (ast), azerbaiyano (az), bielorruso (be), bengalí (bn), bosnio (bs), búlgaro (bg), birmano (my), cantonés (yue), catalán (ca), cebuano (ceb), chichewa (ny), croata (hr), checo (cs), danés (da), neerlandés (nl), inglés (en), estonio (et), filipino (fil), finés (fi), francés (fr), gallego (gl), georgiano (ka), alemán (de), griego (el), guyaratí (gu), hausa (ha), hebreo (he), hindi (hi), húngaro (hu), islandés (is), indonesio (id), irlandés (ga), italiano (it), japonés (ja), javanés (jv), canarés (kn), kazajo (kk), kirguís (ky), coreano (ko), letón (lv), lingala (ln), lituano (lt), luxemburgués (lb), macedonio (mk), malayo (ms), malayalam (ml), maltés (mt), chino mandarín (zh), maorí (mi), maratí (mr), mongol (mn), nepalí (ne), noruego (no), occitano (oc), odia (or), pastún (ps), persa (fa), polaco (pl), portugués (pt), punyabí (pa), rumano (ro), ruso (ru), serbio (sr), sindhi (sd), eslovaco (sk), esloveno (sl), somalí (so), español (es), suajili (sw), sueco (sv), tayiko (tg), tamil (ta), telugu (te), tailandés (th), turco (tr), ucraniano (uk), urdu (ur), uzbeko (uz), vietnamita (vi), galés (cy), yoruba (yo).* > **Note** > > El parámetro `language_code` acepta códigos de dos letras [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) > para la mayoría de los idiomas. Los idiomas sin código ISO 639-1 usan códigos de tres letras [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): asturiano (`ast`), cantonés > (`yue`), cebuano (`ceb`) y filipino (`fil`). ## Eleven v3 Conversational Eleven v3 Conversational es nuestro modelo de generación anterior para la síntesis de voz en tiempo real. Produce una voz natural y realista con un amplio rango emocional y comprensión contextual en varios idiomas. Con Eleven v3 Conversational llega un nuevo WebSocket de Texto a Diálogo que te permite generar diálogos naturales y realistas, con un amplio rango emocional y comprensión contextual en varios idiomas. Con Eleven v3 Conversational llega un nuevo WebSocket de Texto a Diálogo que te permite generar diálogos naturales y realistas, con un amplio rango emocional y comprensión contextual en varios idiomas. Más información sobre el WebSocket de Texto a Diálogo [aquí](/docs/es/eleven-api/guides/how-to/websockets/realtime-tdd). ### Idiomas compatibles El modelo Eleven v3 admite más de 70 idiomas, entre ellos: *Afrikáans (af), árabe (ar), armenio (hy), asamés (as), asturiano (ast), azerbaiyano (az), bielorruso (be), bengalí (bn), bosnio (bs), búlgaro (bg), birmano (my), cantonés (yue), catalán (ca), cebuano (ceb), chichewa (ny), croata (hr), checo (cs), danés (da), neerlandés (nl), inglés (en), estonio (et), filipino (fil), finés (fi), francés (fr), gallego (gl), georgiano (ka), alemán (de), griego (el), guyaratí (gu), hausa (ha), hebreo (he), hindi (hi), húngaro (hu), islandés (is), indonesio (id), irlandés (ga), italiano (it), japonés (ja), javanés (jv), canarés (kn), kazajo (kk), kirguís (ky), coreano (ko), letón (lv), lingala (ln), lituano (lt), luxemburgués (lb), macedonio (mk), malayo (ms), malayalam (ml), maltés (mt), chino mandarín (zh), maorí (mi), maratí (mr), mongol (mn), nepalí (ne), noruego (no), occitano (oc), odia (or), pastún (ps), persa (fa), polaco (pl), portugués (pt), punyabí (pa), rumano (ro), ruso (ru), serbio (sr), sindhi (sd), eslovaco (sk), esloveno (sl), somalí (so), español (es), suajili (sw), sueco (sv), tayiko (tg), tamil (ta), telugu (te), tailandés (th), turco (tr), ucraniano (uk), urdu (ur), uzbeko (uz), vietnamita (vi), galés (cy), yoruba (yo).* > **Note** > > El parámetro `language_code` acepta códigos de dos letras [ISO 639-1](https://en.wikipedia.org/wiki/ISO_639-1) > para la mayoría de los idiomas. Los idiomas sin código ISO 639-1 usan códigos de tres letras [ISO 639-3](https://en.wikipedia.org/wiki/ISO_639-3): asturiano (`ast`), cantonés > (`yue`), cebuano (`ceb`) y filipino (`fil`). ## Multilingual v2 Eleven Multilingual v2 es un modelo de síntesis de voz de la generación anterior con sensibilidad emocional. Produce una voz natural y realista con un amplio rango emocional y comprensión contextual en varios idiomas. El modelo ofrece una calidad y personalidad de voz uniformes en todos los idiomas compatibles, al tiempo que conserva las características y el acento únicos del hablante. Este modelo destaca en situaciones que requieren una voz de alta calidad y con matices emocionales: * **Locuciones de personajes**: Ideal para videojuegos y animación por su rango emocional. * **Contenido profesional**: Muy adecuado para vídeos corporativos y materiales de e-learning. * **Proyectos multilingües**: Mantiene una calidad de voz uniforme al cambiar de idioma. * **Calidad estable**: Produce una salida de audio uniforme y de alta calidad. Aunque tiene una latencia y un coste por carácter mayores que los modelos Flash, ofrece una calidad superior para proyectos en los que una voz realista es importante. Nuestros modelos multilingües v2 son compatibles con 29 idiomas: *Inglés (EE. UU., Reino Unido, Australia, Canadá), japonés, chino, alemán, hindi, francés (Francia, Canadá), coreano, portugués (Brasil, Portugal), italiano, español (España, México), indonesio, neerlandés, turco, filipino, polaco, sueco, búlgaro, rumano, árabe (Arabia Saudí, EAU), checo, griego, finés, croata, malayo, eslovaco, danés, tamil, ucraniano y ruso.* ## Flash v2.5 Eleven Flash v2.5 es nuestro modelo de síntesis de voz más rápido, diseñado para aplicaciones en tiempo real y Agents Platform. Ofrece voz de alta calidad con una latencia ultrabaja (\~75 ms†) en 32 idiomas. El modelo equilibra velocidad y calidad, por lo que es ideal para aplicaciones interactivas, a la vez que mantiene un resultado con sonido natural y características de voz uniformes entre idiomas. Este modelo es especialmente adecuado para: * **Agents Platform**: Perfecto para agentes de voz y chatbots en tiempo real. * **Aplicaciones interactivas**: Ideal para juegos y aplicaciones que requieren una respuesta inmediata. * **Procesamiento a gran escala**: Eficiente para la conversión masiva de texto a voz. Con su precio más bajo para generaciones mediante API y una latencia de 75 ms, Flash v2.5 es la opción rentable para quien necesite una síntesis de voz rápida y fiable en varios idiomas. Flash v2.5 es compatible con 32 idiomas: todos los idiomas de los modelos v2, además de: *Húngaro, noruego y vietnamita* † Sin incluir la latencia de la aplicación y de la red ### Consideraciones #### Normalización de texto con números Al usar Flash v2.5, los números no se normalizan de forma predeterminada como podrías esperar. Por ejemplo, los números de teléfono podrían leerse de una forma que no resulte clara para el usuario. Las fechas y las divisas se ven afectadas de forma similar. De forma predeterminada, la normalización está desactivada para Flash v2.5 a fin de mantener la baja latencia. Sin embargo, los clientes Enterprise ya pueden activar la normalización de texto para los modelos v2.5 estableciendo el parámetro `apply_text_normalization` en "on" en su solicitud. El modelo Multilingual v2 normaliza mejor los números, por lo que recomendamos usarlo para números de teléfono y otros casos en los que la normalización numérica sea importante. Para aplicaciones de baja latencia o de Agents Platform, la práctica recomendada es que tu LLM [normalice el texto](/docs/es/overview/capabilities/text-to-speech/best-practices#text-normalization) antes de pasarlo al modelo de TTS, o usar el parámetro `apply_text_normalization` (solo en planes Enterprise para los modelos v2.5). ## Guía de selección de modelos Para saber qué modelo se ajusta mejor a tus requisitos y caso de uso, consulta la [guía de selección de modelos](/docs/es/eleven-api/choosing-the-right-model). #### Requisitos #### Calidad Usa `eleven_v4` o `eleven_multilingual_v2` Ideal para audio de alta fidelidad con una rica expresión emocional #### Baja latencia Usa `eleven_v4_turbo` Optimizado para aplicaciones en tiempo real (latencia de \~100 ms) #### Caso de uso #### Creación de contenido Usa `eleven_v4` o `eleven_multilingual_v2` Ideal para contenido profesional, audiolibros y narración de vídeos. #### Agents Platform Usa `eleven_v4_turbo`, `eleven_flash_v2_5`, `eleven_flash_v2` o `eleven_multilingual_v2` Perfecto para aplicaciones conversacionales en tiempo real. Usa `eleven_v4_turbo` para conseguir la entonación más expresiva. #### Cambiador de Voz Usa `eleven_multilingual_sts_v2` Especializado en la conversión de voz a voz ## Límites de caracteres El número máximo de caracteres admitidos en una sola solicitud de texto a voz varía según el modelo. | ID del modelo | Límite de caracteres | Duración aproximada del audio | | ------------------------ | -------------------- | ----------------------------- | | `eleven_v4` | 10.000 | \~10 minutos | | `eleven_v3` | 5.000 | \~5 minutos | | `eleven_flash_v2_5` | 40.000 | \~40 minutos | | `eleven_flash_v2` | 30.000 | \~30 minutos | | `eleven_multilingual_v2` | 10.000 | \~10 minutos | | `eleven_multilingual_v1` | 10.000 | \~10 minutos | | `eleven_english_sts_v2` | 10.000 | \~10 minutos | | `eleven_english_sts_v1` | 10.000 | \~10 minutos | > **Note** > > Para contenido más largo, considera dividir la entrada en varias solicitudes. ## Scribe v2 Scribe v2 es nuestro modelo de reconocimiento de voz más avanzado, diseñado para ofrecer transcripciones precisas en más de 90 idiomas. Proporciona marcas de tiempo precisas a nivel de palabra y funciones avanzadas como la diarización de hablantes y el etiquetado dinámico de audio. Este modelo destaca en situaciones que requieren una conversión precisa de voz a texto: * **Servicios de transcripción**: Perfecto para convertir contenido de audio y vídeo en texto. * **Documentación de reuniones**: Ideal para capturar y documentar conversaciones. * **Análisis de contenido**: Muy adecuado para el procesamiento y análisis de contenido de audio. * **Reconocimiento multilingüe**: Admite transcripción precisa en más de 90 idiomas. Funciones principales: * Transcripción precisa con marcas de tiempo a nivel de palabra * Diarización de hablantes para audio con varios hablantes * Etiquetado dinámico de audio para mejorar el contexto * Compatibilidad con más de 90 idiomas * Detección de entidades * Prompting de términos clave * Edición de transcripciones Más información sobre Scribe v2 [aquí](/docs/es/overview/capabilities/speech-to-text). ## Scribe v2 Realtime Scribe v2 Realtime, nuestro modelo de reconocimiento de voz en directo más rápido y preciso, ofrece una precisión de última generación en más de 90 idiomas con una latencia ultrabaja de 150 ms. Este modelo destaca en casos de uso conversacionales: * **Transcripción de reuniones en directo**: Perfecto para transcripción en tiempo real. * **Agentes de IA**: Ideal para conversaciones en directo. * **Reconocimiento multilingüe**: Admite transcripción precisa en más de 90 idiomas con reconocimiento automático del idioma. Funciones principales: * Latencia ultrabaja: obtén transcripciones parciales en \~150 milisegundos * Compatibilidad con streaming: envía audio por fragmentos mientras recibes transcripciones en tiempo real * Varios formatos de audio: compatibilidad con PCM (de 8 kHz a 48 kHz) y codificación μ-law * Detección de actividad de voz (VAD): segmentación automática de voz basada en la detección de silencios * Control de confirmación manual: control total sobre cuándo finalizar los segmentos de transcripción * Detección de entidades * Edición de transcripciones Más información sobre Scribe v2 Realtime [aquí](/docs/es/overview/capabilities/speech-to-text). ## Scribe v2 Medical Scribe v2 Medical es un modelo de reconocimiento de voz por lotes especializado en audio médico y clínico. Es un ajuste fino de Scribe v2 que mejora el reconocimiento de nombres de medicamentos, anatomía, patología y dictado clínico, al tiempo que iguala la precisión de Scribe v2 en el habla cotidiana. Utiliza la misma API de Voz a Texto que Scribe v2 y se factura a la misma tarifa. Pasa `scribe_v2_medical` como `model_id`. > **Note** > > ### Uso previsto > > Scribe v2 Medical es un modelo de API de Voz a Texto por lotes para que desarrolladores y > organizaciones lo integren en aplicaciones que convierten audio clínico, incluidas > conversaciones entre personal sanitario y pacientes, dictados, llamadas de admisión y coordinación asistencial, en borradores de > transcripciones para documentación y flujos de trabajo administrativos relacionados. El texto resultante está destinado > a ser revisado y corregido por un profesional sanitario u otro usuario autorizado antes de utilizarse. Scribe > v2 Medical no está destinado a interpretar información clínica ni a proporcionar diagnósticos, recomendaciones de > tratamiento, decisiones clínicas u otras orientaciones clínicas. Este modelo es adecuado para: * **Documentación clínica**: Consultas ambientales y notas en las que aparecen términos médicos a mitad de la conversación. * **Dictado**: Secuencias densas de medicamentos, dosis y hallazgos. * **Llamadas de admisión y coordinación**: Pacientes que describen sus propias condiciones, a menudo por teléfono. * **Flujos de trabajo de cumplimiento normativo**: Combínalo con la [detección de entidades](/docs/es/eleven-api/guides/how-to/speech-to-text/batch/entity-detection) para categorías de PHI. Funciones principales: * Misma estructura de solicitud que Scribe v2 (`keyterms`, `entity_detection`, `no_verbatim`, diarización, marcas de tiempo) * Mejor reconocimiento de nombres de medicamentos y términos de anatomía y patología * Sin pérdida de precisión en el habla cotidiana respecto a Scribe v2 * Compatibilidad con más de 90 idiomas * Diarización de hablantes para audio con varios hablantes * Etiquetado dinámico de audio * Detección de entidades, incluidas categorías de PHI Scribe v2 Medical es un modelo por lotes. Para transcripción en directo, usa Scribe v2 Realtime. Scribe v2 Medical es apto para HIPAA, con acuerdos de asociado comercial disponibles para clientes Enterprise, así como el modo de retención cero (ZRM). Con ZRM activado, la entrada de audio y la salida de texto se eliminan inmediatamente después de completarse cada solicitud. ElevenLabs no conserva nada, y tu aplicación recibe la respuesta completa de la API y conserva las transcripciones bajo tus propios controles. > **Info** > > Las empresas que requieran cumplimiento con HIPAA deben ponerse en contacto con [Ventas de ElevenLabs ](https://elevenlabs.io/contact-sales) para firmar un acuerdo de asociado comercial (BAA) antes de > enviar información sanitaria protegida. Más información sobre Voz a Texto [aquí](/docs/es/overview/capabilities/speech-to-text). ## Eleven Music Eleven Music es nuestro modelo de generación de música con calidad de estudio. Te permite generar música de cualquier estilo mediante prompts en lenguaje natural. Este modelo es excelente para los siguientes casos: * **Bandas sonoras para juegos**: Crea bandas sonoras envolventes para juegos. * **Fondos para podcasts**: Mejora los podcasts con música profesional. * **Marketing**: Añade música de fondo a vídeos publicitarios. Funciones principales: * Control total sobre el género, el estilo y la estructura * Con voz o solo instrumental * Multilingüe, incluidos inglés, español, alemán, japonés y más * Edita el sonido y la letra de secciones individuales o de toda la canción Más información sobre Eleven Music [aquí](/docs/es/overview/capabilities/music). ## Concurrencia y prioridad Tu plan de suscripción determina cuántas solicitudes se pueden procesar simultáneamente y el nivel de prioridad de tus solicitudes en la cola. Voz a Texto tiene un límite de concurrencia superior. Una vez alcanzado el límite de concurrencia, las solicitudes posteriores se procesan en una cola junto con solicitudes de menor prioridad. En la práctica, esto normalmente solo añade unos \~50 ms de latencia. | Plan | Límite de concurrencia (Multilingual v2) | Límite de concurrencia (Flash) | Límite de concurrencia de STT | Límite de concurrencia de STT en tiempo real | Límite de concurrencia de Música | Nivel de prioridad | | ---------- | ----------------------------------------- | ------------------------------- | ----------------------------- | -------------------------------------------- | -------------------------------- | ------------------ | | Gratis | 2 | 4 | 8 | 6 | 0 | 3 | | Starter | 3 | 6 | 12 | 9 | 2 | 4 | | Creator | 5 | 10 | 20 | 15 | 2 | 5 | | Pro | 10 | 20 | 40 | 30 | 2 | 5 | | Scale | 15 | 30 | 60 | 45 | 5 | 5 | | Business | 15 | 30 | 60 | 45 | 5 | 5 | | Enterprise | Superior | Superior | Superior | Superior | Máximo | 6 | > **Note** > > Quienes reciben ayudas para startups obtienen las ventajas del nivel Scale. Las cabeceras de respuesta incluyen `current-concurrent-requests` y `maximum-concurrent-requests`, que puedes usar para supervisar tu concurrencia. ### Solicitudes a la API por minuto frente a solicitudes simultáneas Es importante entender que las **solicitudes a la API por minuto** y las **solicitudes simultáneas** son métricas diferentes que dependen de tus patrones de uso. Las solicitudes a la API por minuto pueden ser distintas de las solicitudes simultáneas, ya que dependen de la duración de cada solicitud y de cómo se agrupan las solicitudes. **Ejemplo 1: Solicitudes espaciadas** Si tuvieras 180 solicitudes por minuto que tardaran 1 segundo cada una en completarse y las enviaras con 0,33 segundos de intervalo, el máximo de solicitudes simultáneas sería 3 y la media también sería 3, ya que siempre habría 3 en curso. **Ejemplo 2: Solicitudes por lotes** Sin embargo, si tuvieras un patrón de uso diferente, como 180 solicitudes por minuto que tardaran 3 segundos cada una en completarse, pero se lanzaran todas a la vez, el máximo de solicitudes simultáneas sería 180 y la media sería 9 (los primeros 3 segundos del minuto tendrían 180 solicitudes a la vez y los últimos 57 segundos tendrían 0 solicitudes). Como nuestro sistema tiene en cuenta la concurrencia, las solicitudes por minuto importan menos que la duración de cada solicitud y el patrón con el que se envían. La forma de realizar solicitudes a las rutas de API afecta a los límites de concurrencia: * Con HTTP, cada solicitud cuenta individualmente para tu límite de concurrencia. * Con el WebSocket de Texto a Voz, solo cuenta para tu límite de concurrencia el tiempo durante el cual nuestro modelo genera audio. Esto significa que, durante la mayor parte del tiempo, un websocket abierto no cuenta en absoluto para tu límite de concurrencia. * Los WebSockets de Texto a Diálogo funcionan de forma distinta: cada conexión abierta reserva una sesión de diálogo de un grupo independiente mientras permanezca abierta, y el audio generado a través de la conexión no cuenta para tu límite de concurrencia estándar. Esto está diseñado para que sea más fácil de entender: una conexión equivale a una sesión, y los límites de tus sesiones de diálogo están dimensionados para adaptarse a esta nueva metodología de concurrencia. Consulta la [concurrencia de Texto a Diálogo](#text-to-dialogue-concurrency). ### Comprender los límites de concurrencia El límite de concurrencia asociado a tu plan no debe interpretarse como el número máximo de conversaciones simultáneas, llamadas telefónicas, locuciones de personajes, etc. que se pueden gestionar a la vez. El número real depende de varios factores, incluidas las voces IA específicas utilizadas y las características del caso de uso. Como regla general, un límite de concurrencia de 5 suele poder admitir hasta aproximadamente 100 emisiones de audio simultáneas. Esto se debe a la velocidad con la que se genera el audio en relación con el tiempo que tarda en procesarse la solicitud de TTS. El diagrama de abajo muestra un ejemplo de cómo se pueden gestionar 4 llamadas simultáneas con distintos usuarios utilizando solo 2 solicitudes simultáneas. ![Límites de concurrencia](/docs/_fern-img/dcc5e3bd18993a9f862bd526f3dc1b32cfa89003a58ded6f4f6a7bda1bd5a2ea.webp) #### Crear agentes de voz IA Cuando se utiliza TTS para facilitar el diálogo, un límite de concurrencia de 5 puede admitir unas 100 emisiones para conversaciones equilibradas entre agentes de IA y participantes humanos. En casos de uso en los que el agente de IA habla con menos frecuencia que la persona, como en las interacciones de atención al cliente, se podrían admitir más de 100 conversaciones simultáneas. #### Locuciones de personajes Por lo general, se pueden admitir más de 100 locuciones simultáneas de personajes con un límite de concurrencia de 5. El número puede variar según la frecuencia de diálogo del personaje, la duración de las pausas y las acciones dentro del juego entre líneas. #### Doblaje en directo Las transmisiones de doblaje simultáneas suelen seguir la regla práctica indicada. Si la emisión incluye periodos de pausas conversacionales (por ejemplo, debido a una banda sonora, escenas visuales, etc.), podría ser posible tener más transmisiones de doblaje simultáneas que las sugeridas. Si superas los límites de concurrencia de tu plan en algún momento y tienes el plan Enterprise, las solicitudes al modelo aún pueden realizarse correctamente, aunque más despacio, según la capacidad disponible y haciendo todo lo posible. > **Note** > > Para aumentar tu límite de concurrencia y la prioridad en la cola, [mejora tu plan de suscripción](https://elevenlabs.io/pricing/api). > > Los clientes Enterprise pueden solicitar un límite de concurrencia mayor contactando con su gestor de cuenta. ### Concurrencia de Texto a Diálogo Las solicitudes de Texto a Diálogo se miden de dos formas distintas según cómo llames a la API: * Las **rutas HTTP** ([Crear diálogo](/docs/es/api-reference/text-to-dialogue/convert) y [Transmitir diálogo](/docs/es/api-reference/text-to-dialogue/stream)) cuentan para el límite de concurrencia estándar de tu plan mientras se genera audio, como cualquier otra solicitud de Texto a Voz. * Las **rutas WebSocket**, como el [WebSocket de Texto a Diálogo](/docs/es/api-reference/text-to-dialogue/ttd-websocket), se miden como **sesiones de diálogo**. Una conexión abierta mantiene una sesión de diálogo mientras permanece abierta, tanto si se está generando audio como si no. La medición basada en sesiones simplifica la planificación de capacidad: una conexión equivale a una sesión, por lo que tu uso no fluctúa con la actividad de generación. Como se mantiene una sesión durante toda la conexión en lugar de solo mientras se genera audio, los límites de tus sesiones de diálogo están dimensionados para adaptarse a esta nueva metodología de concurrencia. | Plan | Sesiones WebSocket | | ---------- | ------------------ | | Gratis | 14 | | Starter | 21 | | Creator | 35 | | Pro | 70 | | Scale | 105 | | Business | 105 | | Enterprise | Superior | Si abres una conexión mientras se están usando todas las sesiones de diálogo de tu espacio de trabajo, la nueva conexión se rechaza con un error `too_many_concurrent_requests`. Para liberar sesiones, cierra las conexiones que ya no necesites; una conexión también se cierra automáticamente después de 20 segundos de inactividad, a menos que envíes mensajes `keep_alive`. Para supervisar las sesiones de diálogo, abre **Developers** en la parte inferior de la barra lateral del panel, selecciona la pestaña **Analytics** y consulta la métrica **Concurrent requests** en la vista de uso. Las sesiones de diálogo se muestran como una serie independiente, **TTD Websocket Sessions**, separada de tus otras solicitudes simultáneas. ### Pruebas de carga de los límites de concurrencia Las pruebas de carga pueden ser útiles para identificar problemas de escalado en el lado del cliente y verificar que los límites de concurrencia estén configurados correctamente para tu caso de uso. Se recomienda encarecidamente probar los flujos de trabajo de principio a fin lo más cerca posible del uso real. La metodología recomendada para lograrlo es simular y medir cuántos usuarios se pueden admitir. Es importante: * Simular usuarios, no solicitudes sin procesar * Simular el comportamiento habitual de los usuarios, como esperar a que termine la reproducción del audio, que el usuario hable o que finalice la transcripción antes de realizar solicitudes * Aumentar el número de usuarios gradualmente durante varios minutos * Introducir aleatoriedad en los tiempos de las solicitudes y en el tamaño de las solicitudes * Registrar métricas de latencia y cualquier código de error devuelto por la API Por ejemplo, para probar un sistema de agentes diseñado para admitir 100 conversaciones simultáneas, crearías hasta 100 "usuarios" individuales, cada uno simulando una conversación. Las conversaciones suelen consistir en un ciclo repetitivo de unos 10 segundos en los que habla el usuario, seguidos de una llamada a la API de TTS para unos 150 caracteres y, después, unos 10 segundos de reproducción de audio para el usuario. Por tanto, cada usuario debe seguir el patrón de realizar una llamada a la API de Texto a Voz mediante websocket para 150 caracteres de texto cada 20 segundos, introduciendo una pequeña cantidad de aleatoriedad en el periodo de espera y en el número de caracteres solicitados. La prueba consistiría en generar un usuario por segundo hasta llegar a 100 y, a continuación, realizar pruebas durante 10 minutos en total para comprobar la estabilidad general. #### Ejemplo de script de prueba de carga Este ejemplo utiliza [locust](https://locust.io/) como framework de pruebas con llamadas directas a la API de ElevenLabs. Sigue el ejemplo indicado anteriormente y prueba un sistema de agente conversacional en el que cada usuario envía 1 solicitud cada 20 segundos. **`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 ```