> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/minimax-speech.md).

# MiniMax Speech 2.6

Despliega MiniMax Speech 2.6: TTS para agente de voz de latencia ultrabaja en servidores GPU de Clore.ai

{% hint style="success" %}
**Publicado:** 4 de marzo de 2026 — MiniMax acaba de lanzar Speech 2.6 con latencia ultrabaja, manejo de formatos mejorado y una voz similar a la humana para escenarios de agente de voz en tiempo real.
{% endhint %}

**MiniMax Speech 2.6** es un modelo de texto a voz de última generación diseñado para aplicaciones de agentes de voz en tiempo real. Cuenta con latencia end-to-end ultrabaja, manejo mejorado de formatos de audio (MP3, PCM, WAV, FLAC) y una voz considerablemente más natural en comparación con Speech 2.x. Se usa mejor mediante API, pero puede integrarse en canalizaciones autohospedadas a través de la API de MiniMax.

### Características clave

| Función            | Detalles                                          |
| ------------------ | ------------------------------------------------- |
| Latencia           | Ultrabaja (< 300 ms TTFB)                         |
| Calidad de voz     | Prosodia natural, similar a la humana             |
| Idiomas            | Más de 20 idiomas, incluidos inglés, chino y ruso |
| Formatos de salida | MP3, PCM, WAV, FLAC                               |
| Caso de uso        | Agentes de voz, TTS en tiempo real, streaming     |
| API                | API REST compatible con OpenAI                    |

### ¿Por qué MiniMax Speech 2.6?

* **Latencia inferior a 300 ms** — adecuada para agentes de conversación en tiempo real
* **Compatibilidad con streaming** — transmisión de audio token por token para la menor latencia percibida
* **Clonación de voz** — clona a partir de muestras de audio cortas
* **Listo para producción** — impulsa los propios productos de voz comerciales de MiniMax

***

## Configuración: proxy de API autohospedado en Clore.ai

MiniMax Speech 2.6 actualmente se basa en API. Puedes ejecutar un proxy FastAPI ligero en un pequeño servidor de Clore.ai (incluso solo CPU) para integrarlo en tu canalización:

```yaml
version: "3.8"
services:
  minimax-proxy:
    image: python:3.11-slim
    ports:
      - "8080:8080"
    environment:
      - MINIMAX_API_KEY=${MINIMAX_API_KEY}
      - MINIMAX_GROUP_ID=${MINIMAX_GROUP_ID}
    volumes:
      - ./app:/app
    command: >
      sh -c "pip install fastapi uvicorn httpx python-dotenv &&
             uvicorn app.main:app --host 0.0.0.0 --port 8080"
```

### Proxy FastAPI mínimo (`app/main.py`)

```python
import os, httpx
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel

app = FastAPI()

MINIMAX_API_KEY = os.environ["MINIMAX_API_KEY"]
MINIMAX_GROUP_ID = os.environ["MINIMAX_GROUP_ID"]
BASE_URL = "https://api.minimax.io/v1"

class TTSRequest(BaseModel):
    text: str
    voice_id: str = "Calm_Woman"
    speed: float = 1.0
    output_format: str = "mp3"

@app.post("/tts")
async def text_to_speech(req: TTSRequest):
    """Proxy a MiniMax Speech 2.6"""
    async with httpx.AsyncClient(timeout=30) as client:
        response = await client.post(
            f"{BASE_URL}/t2a_v2?GroupId={MINIMAX_GROUP_ID}",
            headers={"Authorization": f"Bearer {MINIMAX_API_KEY}"},
            json={
                "model": "speech-02-hd",
                "text": req.text,
                "stream": False,
                "voice_setting": {
                    "voice_id": req.voice_id,
                    "speed": req.speed,
                    "vol": 1.0,
                    "pitch": 0
                },
                "audio_setting": {
                    "sample_rate": 32000,
                    "bitrate": 128000,
                    "format": req.output_format
                }
            }
        )
    data = response.json()
    audio_b64 = data["data"]["audio"]
    import base64
    audio_bytes = base64.b64decode(audio_b64)
    return StreamingResponse(
        iter([audio_bytes]),
        media_type=f"audio/{req.output_format}"
    )

@app.get("/health")
async def health():
    return {"status": "ok", "model": "minimax-speech-2.6"}
```

### Uso

```bash
# Probar el endpoint TTS
curl -X POST http://localhost:8080/tts \\
  -H "Content-Type: application/json" \\
  -d '{"text": "¡Hola! Esto es MiniMax Speech 2.6 ejecutándose en Clore.", "voice_id": "Calm_Woman"}' \\
  --output output.mp3

# Reproducir el resultado
ffplay output.mp3
```

***

## Uso directo de la API (sin servidor)

Si solo necesitas TTS en tus scripts:

```python
import requests, base64, os

API_KEY = os.environ["MINIMAX_API_KEY"]
GROUP_ID = os.environ["MINIMAX_GROUP_ID"]

def synthesize(text: str, voice_id: str = "Calm_Woman") -> bytes:
    resp = requests.post(
        f"https://api.minimax.io/v1/t2a_v2?GroupId={GROUP_ID}",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "speech-02-hd",
            "text": text,
            "stream": False,
            "voice_setting": {"voice_id": voice_id, "speed": 1.0, "vol": 1.0, "pitch": 0},
            "audio_setting": {"sample_rate": 32000, "bitrate": 128000, "format": "mp3"}
        }
    )
    return base64.b64decode(resp.json()["data"]["audio"])

audio = synthesize("Ejecutar cargas de trabajo de IA en Clore.ai es increíblemente asequible.")
with open("output.mp3", "wb") as f:
    f.write(audio)
```

***

## IDs de voz disponibles

| ID de voz        | Personaje              | Ideal para              |
| ---------------- | ---------------------- | ----------------------- |
| `Calm_Woman`     | Femenina calmada       | Asistentes, narración   |
| `Energetic_Man`  | Masculino enérgico     | Marketing, noticias     |
| `Gentle_Man`     | Masculino suave        | Audiolibros, tutoriales |
| `Cute_Girl`      | Femenina joven         | Entretenimiento         |
| `Deep_Voice_Man` | Masculino de voz grave | Documentales            |

***

## Requisitos de GPU en Clore.ai

{% hint style="info" %}
MiniMax Speech 2.6 es un modelo basado en API: no necesitas una GPU para usarlo. Un pequeño servidor de Clore.ai solo con CPU ($0.10–0.30/día) es suficiente para ejecutar el proxy. Combínalo con otras cargas de trabajo de GPU en el mismo servidor para obtener la máxima eficiencia.
{% endhint %}

| Tipo de servidor  | Caso de uso                     | Coste de Clore.ai |
| ----------------- | ------------------------------- | ----------------- |
| Solo CPU (2 vCPU) | Proxy + puerta de enlace de API | \~$0.10–0.20/día  |
| RTX 3060          | Proxy + tareas locales de GPU   | $0.03–0.07/h      |
| RTX 4090          | Proxy + trabajo pesado de GPU   | $0.14–0.42/h      |

***

## Reenvío de puertos de Clore.ai

| Puerto | Servicio             |
| ------ | -------------------- |
| 8080   | Proxy TTS de FastAPI |

***

## Alternativas en Clore.ai

Si necesitas **totalmente local** TTS sin llamadas a la API:

| Modelo     | VRAM | Calidad | Velocidad  | Guía                                                             |
| ---------- | ---- | ------- | ---------- | ---------------------------------------------------------------- |
| Kokoro TTS | 4GB  | ⭐⭐⭐⭐    | Rápido     | [Kokoro TTS](/guides/guides_v2-es/audio-y-voz/kokoro-tts.md)     |
| F5-TTS     | 8GB  | ⭐⭐⭐⭐⭐   | Medio      | [F5-TTS](/guides/guides_v2-es/audio-y-voz/f5-tts.md)             |
| Chatterbox | 6GB  | ⭐⭐⭐⭐    | Rápido     | [Chatterbox](/guides/guides_v2-es/audio-y-voz/chatterbox-tts.md) |
| Qwen3-TTS  | 8GB  | ⭐⭐⭐⭐⭐   | Medio      | [Qwen3-TTS](/guides/guides_v2-es/audio-y-voz/qwen3-tts.md)       |
| Kani-TTS-2 | 3GB  | ⭐⭐⭐     | Muy rápido | [Kani-TTS](/guides/guides_v2-es/audio-y-voz/kani-tts.md)         |

***

## Enlaces

* **Documentación de la API de MiniMax:** [platform.minimax.io/docs](https://platform.minimax.io/docs)
* **Publicación del blog de Speech 2.6:** [minimax.io/news/minimax-speech-26](https://www.minimax.io/news/minimax-speech-26)
* **Marketplace de Clore.ai:** [clore.ai/marketplace](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/minimax-speech.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.