Geração de imagens, PDF e áudio

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. Todos os endpoints compartilham a mesma URL base, a mesma autenticação e as mesmas funcionalidades do AI Gateway: fallbacks, cache, balanceamento de carga e novas tentativas.

Modalidade	Endpoint
Entrada de imagem	`POST /v3/router/responses`, `POST /v3/router/chat/completions`
Entrada de PDF	`POST /v3/router/responses`, `POST /v3/router/chat/completions`
Geração de imagens	`POST /v3/router/images/generations`
Edição de imagens	`POST /v3/router/images/edits`
Variações de imagens	`POST /v3/router/images/variations`
Texto para fala	`POST /v3/router/audio/speech`
Transcrição	`POST /v3/router/audio/transcriptions`
Tradução	`POST /v3/router/audio/translations`

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

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. Para ver o catálogo por endpoint, consulte Modelos compatíveis ou a página Provedores.

Entrada de imagem

Analise imagens junto com texto. Passe URLs de imagens ou arquivos codificados em base64 nas mensagens de chat/completions.

Entrada de PDF

Envie documentos PDF para extração e análise. Compatível nativamente com os modelos que oferecem suporte.

Geração de imagens

Gere, edite e crie variações de imagens com os modelos GPT Image.

Áudio

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.

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"}
        ]
      }
    ]
  }'

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"}}
        ]
      }
    ]
  }'

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);

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)

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:

{
  "type": "image_url",
  "image_url": {
    "url": "https://picsum.photos/seed/sample-photo/800/600",
    "detail": "high"
  }
}

Padrões

Várias imagens:

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);

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:

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);

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:

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.

O suporte a entrada de PDF varia por modelo. Consulte a página Modelos compatíveis 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.

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"}
        ]
      }
    ]
  }'

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"}}
        ]
      }
    ]
  }'

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);

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)

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.

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.

Para ver a lista completa e atualizada de modelos de imagem compatíveis, consulte Modelos de imagem na página Modelos compatíveis.

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));

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 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.

{
  "created": 1234567890,
  "data": [
    {
      "b64_json": "iVBORw0KGgo..."
    }
  ]
}

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.

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));

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 para saber quais modelos oferecem suporte a variações.

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));

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

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, balanceamento de carga e novas tentativas.

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`

Para ver a lista completa e atualizada de modelos de TTS, consulte Modelos de texto para fala na página Modelos compatíveis.

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);

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.

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);
}

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`

Para ver a lista completa e atualizada de modelos de transcrição, consulte Modelos de fala para texto na página Modelos compatíveis.

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);

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

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.

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);

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.

Toqan Router

Visão geral

APIs

MCP Portal

Roteamento

Segurança e privacidade

Recursos dos modelos

Ferramentas de servidor

Cenários comuns

Configuração de provedores

Entrada de imagem

Entrada de PDF

Geração de imagens

Áudio

Entrada de imagem

Formatos compatíveis

Níveis de detalhe

Padrões

Limitações

Entrada de PDF

Casos de uso

Limitações

Geração de imagens

Parâmetros

Edição de imagens

Variações de imagens

Fallbacks e confiabilidade

Áudio

Texto para fala

Transcrição

Tradução

Entrada de imagem

Entrada de PDF

Geração de imagens

Áudio

​Entrada de imagem

​Formatos compatíveis

​Níveis de detalhe

​Padrões

​Limitações

​Entrada de PDF

​Casos de uso

​Limitações

​Geração de imagens

​Parâmetros

​Edição de imagens

​Variações de imagens

​Fallbacks e confiabilidade

​Áudio

​Texto para fala

​Transcrição

​Tradução

Entrada de imagem

Formatos compatíveis

Níveis de detalhe

Padrões

Limitações

Entrada de PDF

Casos de uso

Limitações

Geração de imagens

Parâmetros

Edição de imagens

Variações de imagens

Fallbacks e confiabilidade

Áudio

Texto para fala

Transcrição

Tradução