> ## Documentation Index
> Fetch the complete documentation index at: /docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Geração de imagens, PDF e áudio

> Envie imagens, PDFs e áudio para LLMs e gere imagens e fala pelo AI Gateway. Uma única API unificada e compatível com OpenAI para todas as modalidades.

**Casos de uso**

* Analisar imagens ou PDFs enviados sem um pipeline de pré-processamento separado.
* Gerar imagens a partir de prompts de texto com a mesma API e a mesma chave.
* Transcrever gravações de áudio ou entradas de voz para processamento posterior.
* Extrair dados estruturados de documentos digitalizados, recibos ou capturas de tela.

***

O **AI Gateway** oferece suporte a todas as modalidades de entrada e saída por meio de uma única API compatível com OpenAI, incluindo a [Responses API](/docs/pt-BR/ai-gateway/features/responses-api.md). Todos os endpoints compartilham a mesma URL base, a mesma autenticação e as mesmas funcionalidades do **AI Gateway**: [fallbacks](/docs/pt-BR/ai-gateway/features/retries.md#fallbacks), [cache](/docs/pt-BR/ai-gateway/features/cache.md), [balanceamento de carga](/docs/pt-BR/ai-gateway/features/load-balancing.md) e [novas tentativas](/docs/pt-BR/ai-gateway/features/retries.md).

| Modalidade | Endpoint |
| - | - |
| [Entrada de imagem](#image-input) | `POST /v3/router/responses`, `POST /v3/router/chat/completions` |
| [Entrada de PDF](#pdf-input) | `POST /v3/router/responses`, `POST /v3/router/chat/completions` |
| [Geração de imagens](#image-generation) | `POST /v3/router/images/generations` |
| [Edição de imagens](#image-editing) | `POST /v3/router/images/edits` |
| [Variações de imagens](#image-variations) | `POST /v3/router/images/variations` |
| [Texto para fala](#text-to-speech) | `POST /v3/router/audio/speech` |
| [Transcrição](#transcription) | `POST /v3/router/audio/transcriptions` |
| [Tradução](#translation) | `POST /v3/router/audio/translations` |

Todos os endpoints usam a mesma URL base e a mesma autenticação:

```bash theme={"theme":{"light":"github-light","dark":"github-dark"}}
BASE_URL=https://router.toqan.ai/eu/v3/router
Authorization: Bearer $TOQAN_API_KEY
```

Esta página cobre o envio e a geração de cada modalidade de ponta a ponta. Quais modelos aceitam **entrada** de imagem, PDF ou áudio, o contrato das partes de conteúdo e o envio por URL versus base64 são tratados em [Enviar arquivos para modelos](/docs/pt-BR/ai-gateway/features/files.md). Para ver o catálogo por endpoint, consulte [Modelos compatíveis](/docs/pt-BR/ai-gateway/supported-models.md) ou a página [Provedores](/docs/pt-BR/ai-gateway/providers-overview.md).

> [card] [Entrada de imagem](#image-input)
>
> Analise imagens junto com texto. Passe URLs de imagens ou arquivos codificados em base64 nas mensagens de `chat/completions`.

> [card] [Entrada de PDF](#pdf-input)
>
> Envie documentos PDF para extração e análise. Compatível nativamente com os modelos que oferecem suporte.

> [card] [Geração de imagens](#image-generation)
>
> Gere, edite e crie variações de imagens com os modelos GPT Image.

> [card] [Áudio](#audio)
>
> Converta texto em fala, transcreva arquivos de áudio e traduza áudio para inglês.

## Entrada de imagem

Analise imagens junto com texto usando `POST /v3/router/responses` ou `POST /v3/router/chat/completions`. Passe as imagens como URLs públicas ou dados codificados em base64 no array de conteúdo da mensagem. Para o ciclo de vida dos arquivos, consulte a Files API.

```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl -X POST https://router.toqan.ai/eu/v3/router/responses \
  -H "Authorization: Bearer $TOQAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": [
      {
        "role": "user",
        "content": [
          {"type": "input_text", "text": "What is in this image? Describe in detail."},
          {"type": "input_image", "image_url": "https://picsum.photos/seed/sample-photo/800/600"}
        ]
      }
    ]
  }'
```

```bash cURL (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl -X POST https://router.toqan.ai/eu/v3/router/chat/completions \
  -H "Authorization: Bearer $TOQAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "What is in this image? Describe in detail."},
          {"type": "image_url", "image_url": {"url": "https://picsum.photos/seed/sample-photo/800/600"}}
        ]
      }
    ]
  }'
```

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const base64Image = fs.readFileSync("chart.png").toString("base64");

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "Analyze this chart and extract the key data points" },
        { type: "input_image", image_url: `data:image/png;base64,${base64Image}` },
      ],
    },
  ],
});

console.log(response.output_text);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from openai import OpenAI
import base64
import os

client = OpenAI(
    api_key=os.environ.get("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router",
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("chart.png")

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analyze this chart and extract the key data points"},
                {"type": "input_image", "image_url": f"data:image/png;base64,{base64_image}"},
            ],
        }
    ],
)

print(response.output_text)
```

```typescript TypeScript (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const base64Image = fs.readFileSync("chart.png").toString("base64");

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Analyze this chart and extract the key data points" },
        { type: "image_url", image_url: { url: `data:image/png;base64,${base64Image}` } },
      ],
    },
  ],
});

console.log(response.choices[0].message.content);
```

### Formatos compatíveis

| Formato | Caso de uso | Tamanho máximo |
| - | - | - |
| **JPEG/JPG** | Fotos, imagens em geral | 20MB |
| **PNG** | Capturas de tela, diagramas | 20MB |
| **GIF** | Apenas imagens estáticas | 20MB |
| **WebP** | Imagens modernas para a web | 20MB |
| **Base64** | Dados de imagem incorporados | Limite de contexto do modelo |
| **URLs** | Links públicos de imagens | Limite de contexto do modelo |

### Níveis de detalhe

| Nível | Resolução | Velocidade | Custo | Caso de uso |
| - | - | - | - | - |
| `"low"` | 512x512 | Rápida | Baixo | Visão geral rápida |
| `"high"` | Resolução completa | Lenta | Alto | Análise detalhada |
| `"auto"` | O modelo decide | Média | Médio | Equilibrado (padrão) |

Defina `detail` no objeto `image_url`:

```json theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "type": "image_url",
  "image_url": {
    "url": "https://picsum.photos/seed/sample-photo/800/600",
    "detail": "high"
  }
}
```

### Padrões

**Várias imagens:**

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "Compare these before and after photos. What changes do you notice?" },
        { type: "input_image", image_url: "https://picsum.photos/seed/before-photo/800/600" },
        { type: "input_image", image_url: "https://picsum.photos/seed/after-photo/800/600" },
      ],
    },
  ],
});

console.log(response.output_text);
```

```typescript TypeScript (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const content = [
  { type: "text", text: "Compare these before and after photos. What changes do you notice?" },
  { type: "image_url", image_url: { url: "https://picsum.photos/seed/before-photo/800/600", detail: "high" } },
  { type: "image_url", image_url: { url: "https://picsum.photos/seed/after-photo/800/600", detail: "high" } },
];

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [{ role: "user", content }],
});

console.log(response.choices[0].message.content);
```

**OCR e extração de texto:**

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const imageUrl = "https://picsum.photos/seed/sample-photo/800/600";

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "Extract all text from this image. Return as plain text, preserving formatting where possible." },
        { type: "input_image", image_url: imageUrl },
      ],
    },
  ],
});

console.log(response.output_text);
```

```typescript TypeScript (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const imageUrl = "https://picsum.photos/seed/sample-photo/800/600";

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "Extract all text from this image. Return as plain text, preserving formatting where possible.",
        },
        {
          type: "image_url",
          image_url: { url: imageUrl, detail: "high" },
        },
      ],
    },
  ],
});

console.log(response.choices[0].message.content);
```

**Saída estruturada:**

```python Python (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
from openai import OpenAI
import os
from pydantic import BaseModel
from typing import List

client = OpenAI(
    api_key=os.environ.get("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router",
)

class ImageAnalysis(BaseModel):
    objects: List[str]
    text_content: str
    dominant_colors: List[str]
    confidence: float

image_url = "https://picsum.photos/seed/sample-photo/800/600"

response = client.chat.completions.parse(
    model="openai/gpt-5.6-sol",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Analyze this image systematically"},
            {"type": "image_url", "image_url": {"url": image_url}}
        ]
    }],
    response_format=ImageAnalysis
)
```

### Limitações

| Limitação | Detalhes | Alternativa |
| - | - | - |
| **Tamanho do arquivo** | Máximo de 20MB por imagem | Comprima antes do upload |
| **Quantidade de imagens** | Varia por modelo (5-16) | Processe em lotes |
| **Vídeo** | Apenas imagens estáticas | Extraia quadros para análise |
| **Privacidade** | As imagens são enviadas ao provedor | Use modelos on-premise, se necessário |

## Entrada de PDF

Envie documentos PDF diretamente nas mensagens para análise e extração de conteúdo usando `POST /v3/router/responses` ou `POST /v3/router/chat/completions`.

> [!NOTE]
>
> O suporte a entrada de PDF varia por modelo. Consulte a página [Modelos compatíveis](/docs/pt-BR/ai-gateway/supported-models.md) e verifique na documentação do seu provedor se há suporte a PDF. Para o ciclo de vida dos arquivos e para transformar documentos enviados em fontes de dados de knowledge base, consulte a Files API.

```bash cURL theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl -X POST https://router.toqan.ai/eu/v3/router/responses \
  -H "Authorization: Bearer $TOQAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "input": [
      {
        "role": "user",
        "content": [
          {"type": "input_text", "text": "Please analyze this PDF document and provide a summary"},
          {"type": "input_file", "filename": "document.pdf", "file_data": "data:application/pdf;base64,YOUR_BASE64_ENCODED_PDF"}
        ]
      }
    ]
  }'
```

```bash cURL (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
curl -X POST https://router.toqan.ai/eu/v3/router/chat/completions \
  -H "Authorization: Bearer $TOQAN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-5.6-sol",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "Please analyze this PDF document and provide a summary"},
          {"type": "file", "file": {"file_data": "data:application/pdf;base64,YOUR_BASE64_ENCODED_PDF", "filename": "document.pdf"}}
        ]
      }
    ]
  }'
```

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const pdfBase64 = fs.readFileSync("document.pdf").toString("base64");

const response = await client.responses.create({
  model: "openai/gpt-5.6-sol",
  input: [
    {
      role: "user",
      content: [
        { type: "input_text", text: "Please analyze this PDF document and provide a summary" },
        {
          type: "input_file",
          filename: "document.pdf",
          file_data: `data:application/pdf;base64,${pdfBase64}`,
        },
      ],
    },
  ],
});

console.log(response.output_text);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from openai import OpenAI
import os
import base64

client = OpenAI(
    api_key=os.environ.get("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router",
)

with open("document.pdf", "rb") as pdf_file:
    pdf_base64 = base64.b64encode(pdf_file.read()).decode("utf-8")

response = client.responses.create(
    model="openai/gpt-5.6-sol",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Please analyze this PDF document and provide a summary"},
                {
                    "type": "input_file",
                    "filename": "document.pdf",
                    "file_data": f"data:application/pdf;base64,{pdf_base64}",
                },
            ],
        }
    ],
)

print(response.output_text)
```

```typescript TypeScript (Chat Completions) theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const pdfBase64 = fs.readFileSync("document.pdf").toString("base64");

const response = await client.chat.completions.create({
  model: "openai/gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Please analyze this PDF document and provide a summary" },
        { type: "file", file: { file_data: `data:application/pdf;base64,${pdfBase64}`, filename: "document.pdf" } },
      ],
    },
  ],
});
```

Os campos das partes de conteúdo `input_file` e `file` são especificados uma única vez, em [Enviar arquivos para modelos](/docs/pt-BR/ai-gateway/features/files.md#sending-an-image-vs-sending-a-document).

### Casos de uso

| Cenário | Exemplo de prompt |
| - | - |
| **Análise de contratos** | "Extraia os principais termos e obrigações" |
| **Processamento de faturas** | "Extraia valores, datas e informações do fornecedor" |
| **Artigos científicos** | "Resuma a metodologia e os resultados" |
| **Extração de formulários** | "Converta os dados do formulário em JSON" |

### Limitações

| Limitação | Detalhes | Alternativa |
| - | - | - |
| **Tamanho do arquivo** | Limites de contexto do modelo | Divida PDFs grandes |
| **Documentos digitalizados** | A qualidade varia por modelo | Use pré-processamento com OCR |
| **Layouts complexos** | Tabelas e gráficos podem não ser bem extraídos | Use prompts estruturados |
| **Segurança** | Documentos sensíveis são enviados ao provedor | Use modelos on-premise |

## Geração de imagens

Gere imagens a partir de um prompt de texto usando `POST /v3/router/images/generations`.

> [!NOTE]
>
> Para ver a lista completa e atualizada de modelos de imagem compatíveis, consulte [Modelos de imagem](/docs/pt-BR/ai-gateway/supported-models.md#image-models) na página Modelos compatíveis.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.images.generate({
  model: "openai/gpt-image-2",
  prompt: "A futuristic city skyline at sunset, photorealistic",
  n: 1,
  size: "1024x1024",
});

console.log(response.data[0].b64_json?.slice(0, 40));
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

response = client.images.generate(
    model="openai/gpt-image-2",
    prompt="A futuristic city skyline at sunset, photorealistic",
    n=1,
    size="1024x1024",
)

print(response.data[0].b64_json[:40])
```

### Parâmetros

| Parâmetro | Descrição |
| - | - |
| `model` | ID do modelo |
| `prompt` | Descrição em texto da imagem desejada |
| `n` | Número de imagens a gerar |
| `size` | Dimensões da imagem (consulte [Modelos compatíveis](/docs/pt-BR/ai-gateway/supported-models.md#image-models) para ver os tamanhos por modelo) |
| `response_format` | `url` ou `b64_json`. Somente DALL-E 2/3; `gpt-image-1` sempre retorna `b64_json` |
| `quality` | Nível de qualidade da imagem. Os valores variam por modelo |
| `style` | `vivid` ou `natural`. Somente DALL-E 3 |
| `background` | `transparent`, `opaque` ou `auto`. Somente `gpt-image-1` |
| `output_format` | `png`, `jpeg` ou `webp`. Somente `gpt-image-1` |
| `output_compression` | Nível de compressão de 0 a 100%. Somente `gpt-image-1` |
| `moderation` | `auto` ou `low`. Somente `gpt-image-1` |
| `stream` | Transmite imagens parciais à medida que são geradas. Somente modelos da OpenAI; consulte as restrições de streaming abaixo |

Defina `response_format` como `url` para receber um link de imagem hospedada, ou como `b64_json` para receber a imagem inline como uma string codificada em base64.

```json theme={"theme":{"light":"github-light","dark":"github-dark"}}
{
  "created": 1234567890,
  "data": [
    {
      "b64_json": "iVBORw0KGgo..."
    }
  ]
}
```

> [!NOTE]
>
> A geração de imagens com streaming (`stream: true`) tem estas restrições:
>
> * `n` deve ser `1`
> * `response_format` não é compatível
> * `size` deve ser `1024x1024`, `1024x1536`, `1536x1024` ou `auto`
>
> Requisições fora dessas restrições retornam um erro 400 antes de o stream ser aberto.

### Edição de imagens

Modifique uma imagem existente usando um prompt e uma máscara opcional com `POST /v3/router/images/edits`.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import fs from "fs";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.images.edit({
  model: "openai/gpt-image-2",
  image: fs.createReadStream("original.png"),
  prompt: "Add a sunset sky behind the buildings",
  size: "1024x1024",
});

console.log(response.data[0].b64_json?.slice(0, 40));
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

with open("original.png", "rb") as image_file:
    response = client.images.edit(
        model="openai/gpt-image-2",
        image=image_file,
        prompt="Add a sunset sky behind the buildings",
        size="1024x1024",
    )

print(response.data[0].b64_json[:40])
```

| Parâmetro | Descrição |
| - | - |
| `model` | ID do modelo |
| `image` | Arquivo PNG, WEBP ou JPEG a ser editado. Alguns modelos aceitam um array de imagens |
| `prompt` | Descrição em texto da edição desejada |
| `mask` | Máscara PNG opcional em que as áreas transparentes indicam onde editar |
| `size` | Dimensões da imagem de saída |
| `response_format` | `url` ou `b64_json`. `gpt-image-1` sempre retorna `b64_json` |
| `quality` | Nível de qualidade da imagem. Os valores variam por modelo |

### Variações de imagens

Gere variações de uma imagem existente com `POST /v3/router/images/variations`. Consulte [Modelos de imagem](/docs/pt-BR/ai-gateway/supported-models.md#image-models) para saber quais modelos oferecem suporte a variações.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import fs from "fs";
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.images.createVariation({
  model: "openai/gpt-image-2",
  image: fs.createReadStream("original.png"),
  size: "1024x1024",
  response_format: "url",
});

response.data.forEach((img) => console.log(img.url));
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

with open("original.png", "rb") as image_file:
    response = client.images.create_variation(
        model="openai/gpt-image-2",
        image=image_file,
        size="1024x1024",
        response_format="url",
    )

for img in response.data:
    print(img.url)
```

| Parâmetro | Descrição |
| - | - |
| `model` | ID do modelo |
| `image` | Imagem PNG a partir da qual criar uma variação |
| `n` | Número de variações a gerar (1-10) |
| `size` | Dimensões da imagem de saída |
| `response_format` | `url` ou `b64_json` |

### Fallbacks e confiabilidade

Os endpoints de imagem aceitam os mesmos parâmetros `fallbacks` e `retry` que as chat completions:

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.images.generate({
  model: "openai/gpt-image-2",
  prompt: "A mountain lake at dawn",
  size: "1024x1024",
  // @ts-ignore - Toqan Router extension
  fallbacks: [{ model: "openai/gpt-image-2.5-sunburst" }, { model: "openai/gpt-image-2.5-flare" }],
});
```

## Áudio

O **AI Gateway** expõe três endpoints de áudio compatíveis com OpenAI. Todos oferecem suporte a [fallbacks](/docs/pt-BR/ai-gateway/features/retries.md#fallbacks), [balanceamento de carga](/docs/pt-BR/ai-gateway/features/load-balancing.md) e [novas tentativas](/docs/pt-BR/ai-gateway/features/retries.md).

### Texto para fala

Converta texto em áudio usando `POST /v3/router/audio/speech`.

| Provedor | Modelo |
| - | - |
| OpenAI | `openai/tts-1` |
| OpenAI | `openai/tts-1-hd` |
| OpenAI | `openai/gpt-4o-mini-tts` |
| ElevenLabs | `elevenlabs/eleven_multilingual_v2` |
| ElevenLabs | `elevenlabs/eleven_turbo_v2_5` |
| ElevenLabs | `elevenlabs/eleven_flash_v2_5` |
| ElevenLabs | `elevenlabs/eleven_flash_v2` |
| Google AI | `google-ai/gemini-2.5-flash-preview-tts` |
| Google AI | `google-ai/gemini-2.5-pro-preview-tts` |
| Vertex AI | `google/gemini-2.5-flash-preview-tts` |
| Vertex AI | `google/gemini-2.5-pro-preview-tts` |

> [!NOTE]
>
> Para ver a lista completa e atualizada de modelos de TTS, consulte [Modelos de texto para fala](/docs/pt-BR/ai-gateway/supported-models.md#text-to-speech-models) na página Modelos compatíveis.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const response = await client.audio.speech.create({
  model: "openai/gpt-4o-mini-tts",
  voice: "alloy",
  input: "Hello, welcome to Acme Corp. How can I help you today?",
  response_format: "mp3",
});

const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync("output.mp3", buffer);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

with client.audio.speech.with_streaming_response.create(
    model="openai/gpt-4o-mini-tts",
    voice="alloy",
    input="Hello, welcome to Acme Corp. How can I help you today?",
    response_format="mp3",
) as response:
    response.stream_to_file("output.mp3")
```

**Streaming:** processe os chunks de áudio em tempo real à medida que chegam, o que é útil para pipelines de reprodução de baixa latência.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const processAudioChunk = (chunk: Uint8Array) => {};

const response = await client.audio.speech.create({
  model: "openai/gpt-4o-mini-tts",
  voice: "alloy",
  input: "Hello, welcome to Acme Corp. How can I help you today?",
  response_format: "pcm",
});

const reader = response.body!.getReader();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  processAudioChunk(value);
}
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ.get("TOQAN_API_KEY"),
    base_url="https://router.toqan.ai/eu/v3/router",
)

def process_audio_chunk(chunk: bytes) -> None:
    pass

with client.audio.speech.with_streaming_response.create(
    model="openai/gpt-4o-mini-tts",
    voice="alloy",
    input="Hello, welcome to Acme Corp. How can I help you today?",
    response_format="pcm",
) as response:
    for chunk in response.iter_bytes(chunk_size=1024):
        process_audio_chunk(chunk)
```

**Parâmetros:**

| Parâmetro | Descrição |
| - | - |
| `model` | ID do modelo |
| `input` | Texto a ser sintetizado. O tamanho máximo varia por provedor |
| `voice` | ID da voz. Consulte a tabela de vozes abaixo |
| `response_format` | Formato de saída: `mp3`, `opus`, `aac`, `flac`, `wav`, `pcm`. Os valores aceitos variam por provedor |
| `speed` | Velocidade de reprodução do áudio gerado |

**Vozes:**

| Provedor | Vozes |
| - | - |
| OpenAI | `alloy`, `echo`, `fable`, `onyx`, `nova`, `shimmer` |
| ElevenLabs | `aria`, `roger`, `sarah`, `laura`, `charlie`, `george`, `callum`, `river`, `liam`, `charlotte`, `alice`, `matilda`, `will`, `jessica`, `eric`, `chris` |

### Transcrição

Transcreva um arquivo de áudio para texto usando `POST /v3/router/audio/transcriptions`.

| Provedor | Modelo |
| - | - |
| OpenAI | `openai/whisper-1` |
| OpenAI | `openai/gpt-4o-transcribe` |
| OpenAI | `openai/gpt-4o-mini-transcribe` |
| OpenAI | `openai/gpt-transcribe` |
| ElevenLabs | `elevenlabs/scribe_v1` |
| Groq | `groq/whisper-large-v3` |
| Groq | `groq/whisper-large-v3-turbo` |
| Mistral | `mistral/voxtral-mini-2507` |
| Azure | `azure/whisper` |

> [!NOTE]
>
> Para ver a lista completa e atualizada de modelos de transcrição, consulte [Modelos de fala para texto](/docs/pt-BR/ai-gateway/supported-models.md#speech-to-text-models) na página Modelos compatíveis.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const transcription = await client.audio.transcriptions.create({
  model: "openai/gpt-transcribe",
  file: fs.createReadStream("meeting.mp3"),
  response_format: "json",
  language: "en",
});

console.log(transcription.text);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

with open("meeting.mp3", "rb") as audio_file:
    transcription = client.audio.transcriptions.create(
        model="openai/gpt-transcribe",
        file=audio_file,
        response_format="json",
        language="en",
    )

print(transcription.text)
```

**Parâmetros:**

| Parâmetro | Descrição |
| - | - |
| `model` | ID do modelo |
| `file` | Arquivo de áudio a ser transcrito. Formatos aceitos: `flac`, `mp3`, `mp4`, `mpeg`, `mpga`, `m4a`, `ogg`, `wav`, `webm` |
| `language` | Código de idioma ISO-639-1 do áudio de entrada (por exemplo, `en`, `fr`, `de`) |
| `prompt` | Texto opcional para orientar o estilo do modelo ou dar continuidade a um segmento anterior |
| `response_format` | `json`, `text`, `srt`, `verbose_json` ou `vtt` |
| `temperature` | Temperatura de amostragem entre 0 e 1 |
| `timestamp_granularities` | Array de granularidades: `["word"]`, `["segment"]` ou `["word", "segment"]`. Requer `verbose_json`. Não é compatível com todos os modelos |
| `diarize` | Indica qual locutor está falando no arquivo. Somente ElevenLabs |
| `num_speakers` | Número máximo de locutores a identificar. Somente ElevenLabs |
| `tag_audio_events` | Marca eventos que não são fala, como `(laughter)` ou `(applause)`. Somente ElevenLabs |
| `enable_logging` | Defina como `false` para desativar o registro em log e habilitar a retenção zero de dados |

### Tradução

> [!NOTE]
>
> O endpoint de tradução da OpenAI aceita apenas `openai/whisper-1`. `gpt-4o-transcribe` e `gpt-4o-mini-transcribe` não oferecem suporte a tradução.

Transcreva e traduza áudio para inglês usando `POST /v3/router/audio/translations`. A saída é sempre em inglês, independentemente do idioma de origem.

```typescript TypeScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
import OpenAI from "openai";
import fs from "fs";

const client = new OpenAI({
  apiKey: process.env.TOQAN_API_KEY,
  baseURL: "https://router.toqan.ai/eu/v3/router",
});

const translation = await client.audio.translations.create({
  model: "openai/whisper-1",
  file: fs.createReadStream("interview_french.mp3"),
  response_format: "json",
});

console.log(translation.text);
```

```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["TOQAN_API_KEY"],
    base_url="https://router.toqan.ai/eu/v3/router",
)

with open("interview_french.mp3", "rb") as audio_file:
    translation = client.audio.translations.create(
        model="openai/whisper-1",
        file=audio_file,
        response_format="json",
    )

print(translation.text)
```

A tradução aceita os mesmos parâmetros `response_format` e `temperature` que a transcrição.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.