Português

English

Português

English

Tema Escuro

Transcrição de Áudio Avançada (Speech-to-Text) ​

Os serviços de STT (Speech-to-Text) do SipPulse AI convertem arquivos de áudio em texto com alta precisão, permitindo enriquecer suas aplicações com dados vocais valiosos. Nossa plataforma oferece:

  • Modelos proprietários de alta performance pulse-precision (foco em máxima acurácia, resultando em um excelente Word Error Rate - WER) e pulse-speed (otimizado para baixa latência), ambos com suporte avançado a diarização (identificação de múltiplos interlocutores).
  • Recursos avançados como anonimização de dados sensíveis e Audio Intelligence para análises estruturadas e insights automáticos a partir das transcrições.

Para informações detalhadas sobre preços e especificações de cada modelo, consulte nossa página de Pricing.

Playground Interativo ​

O Playground Interativo de Transcrição de Áudio (acesse aqui) é a ferramenta ideal para experimentar e validar os modelos STT de forma intuitiva:

  1. Upload de Arquivo de Áudio

    • Realize o upload de arquivos de áudio (formatos MP3, WAV, PCM, OGG com limite de 25 MB) arrastando e soltando ou através do seletor de arquivos.

  2. Seleção do Modelo de Transcrição

    • Escolha entre os modelos disponíveis:
      • pulse-precision: Otimizado para a mais alta precisão na transcrição.
      • pulse-speed: Prioriza a velocidade de processamento, ideal para casos de uso que exigem menor latência.
      • whisper-1: Modelo da OpenAI.
      • whisper-chat: Modelo da OpenAI com alta velocidade de resposta. Ideal para aplicações que requerem respostas rápidas, mesmo que com uma leve redução na precisão em comparação ao pulse-precision.

  3. Configuração de Parâmetros

    • Formato de Saída (format): Defina o formato desejado para a transcrição (text, json, vtt, srt, verbose_json, diarization). Obs: diarization só está disponível para os modelos pulse-precision e pulse-speed.

    • Idioma (language): Especifique o idioma do áudio (e.g., pt, en, es).

    • Instruções (prompt): Forneça instruções ou contexto adicional (termos específicos, nomes próprios) para orientar e refinar o processo de transcrição.

  4. Recursos Avançados

    • Anonimização (anonymize): Habilite para ofuscar automaticamente dados sensíveis identificados na transcrição (e.g., CPF, e-mail, endereços IP). Consulte a documentação de Redação de Texto para detalhes sobre o funcionamento.
    • Audio Intelligence (insights): Ative para receber análises estruturadas juntamente com a transcrição. As opções incluem sumarização, identificação de tópicos, análise de sentimento, entre outras, processadas diretamente no endpoint.

  5. Executar Transcrição

    • Clique no botão Transcrever para que o áudio seja processado utilizando o modelo e os parâmetros selecionados. O resultado da transcrição será exibido na interface.

  6. Visualizar Código de Integração

    • A funcionalidade “Ver Código” gera automaticamente exemplos de código para integração em cURL (Bash), Python e JavaScript (Node.js). Estes exemplos são pré-configurados com os mesmos parâmetros utilizados no Playground, facilitando a implementação da funcionalidade de transcrição em suas aplicações.

Consumo via API REST ​

Utilize o endpoint nativo /v1/asr/transcribe para ter controle total sobre todos os recursos e modelos, incluindo os avançados pulse-precision e pulse-speed com diarização.

bash
# Exemplo: Transcrição com diarização, anonimização e Audio Intelligence (sumarização e tópicos)
# utilizando o modelo pulse-precision.
curl -X POST 'https://api.sippulse.ai/v1/asr/transcribe' \
  -H 'api-key: $SIPPULSE_API_KEY' \
  -F 'file=@audio.wav' \
  -F 'model=pulse-precision' \
  -F 'format=verbose_json' \
  -F 'language=pt' \
  -F 'diarization=true' \
  -F 'anonymize=true' \
  -F 'insights=["summarization","topics"]'
python
import os
import requests
import json # Adicionado para requests.utils.json.dumps, ou usar json.dumps diretamente

def transcribe_audio_advanced(
    file_path: str,
    model: str = "pulse-precision", # Padrão para nosso modelo de alta precisão
    output_format: str = "verbose_json",
    language: str = "pt",
    enable_diarization: bool = True,
    enable_anonymization: bool = True,
    audio_insights: list = None
) -> dict:
    """
    Realiza a transcrição de um arquivo de áudio utilizando o endpoint /v1/asr/transcribe
    do SipPulse AI, com suporte a recursos avançados.

    Args:
        file_path: Caminho para o arquivo de áudio.
        model: Modelo de transcrição a ser utilizado (e.g., "pulse-precision", "pulse-speed").
        output_format: Formato da saída da transcrição.
        language: Código do idioma do áudio.
        enable_diarization: Ativa/desativa a diarização (separação de interlocutores).
        enable_anonymization: Ativa/desativa a anonimização de dados sensíveis.
        audio_insights: Lista de análises de Audio Intelligence a serem aplicadas (e.g., ["summarization", "topics"]).
    """
    api_url = "https://api.sippulse.ai/v1/asr/transcribe"
    headers = {"api-key": os.getenv("SIPPULSE_API_KEY")}

    with open(file_path, "rb") as audio_file:
        files = {"file": audio_file}
        payload = {
            "model": model,
            "format": output_format,
            "language": language,
            "diarization": str(enable_diarization).lower(),
            "anonymize": str(enable_anonymization).lower(),
        }
        if audio_insights:
            # Usando json.dumps diretamente, já que requests.utils.json é um alias para o módulo json padrão
            payload["insights"] = json.dumps(audio_insights)

        response = requests.post(api_url, headers=headers, files=files, data=payload)
    response.raise_for_status()  # Levanta uma exceção para respostas de erro HTTP
    return response.json()

if __name__ == "__main__":
    # Substitua "audio.wav" pelo caminho do seu arquivo de áudio
    # É necessário ter a variável de ambiente SIPPULSE_API_KEY configurada
    try:
        transcription_result = transcribe_audio_advanced(
            "audio.wav",
            model="pulse-precision",
            audio_insights=["summarization", "topics"]
        )
        print(json.dumps(transcription_result, indent=2, ensure_ascii=False))
    except FileNotFoundError:
        print("Erro: Arquivo de áudio não encontrado. Verifique o caminho.")
    except requests.exceptions.HTTPError as e:
        print(f"Erro na API: {e.response.status_code} - {e.response.text}")
    except Exception as e:
        print(f"Ocorreu um erro inesperado: {e}")
javascript
// Node.js com node-fetch e form-data
import fs from "fs";
import FormData from "form-data";
import fetch from "node-fetch"; // Certifique-se de que node-fetch@2 está instalado ou use a API fetch nativa do Node 18+

async function transcribeAudioAdvanced(
  filePath,
  model = "pulse-precision", // Padrão para nosso modelo de alta precisão
  outputFormat = "verbose_json",
  language = "pt",
  enableDiarization = true,
  enableAnonymization = true,
  audioInsights = ["summarization", "topics"]
) {
  const apiUrl = "https://api.sippulse.ai/v1/asr/transcribe";
  const apiKey = process.env.SIPPULSE_API_KEY;

  if (!apiKey) {
    throw new Error("A variável de ambiente SIPPULSE_API_KEY não está configurada.");
  }

  const form = new FormData();
  form.append("file", fs.createReadStream(filePath));
  form.append("model", model);
  form.append("format", outputFormat);
  form.append("language", language);
  form.append("diarization", String(enableDiarization).toLowerCase());
  form.append("anonymize", String(enableAnonymization).toLowerCase());
  if (audioInsights && audioInsights.length > 0) {
    form.append("insights", JSON.stringify(audioInsights));
  }

  const response = await fetch(apiUrl, {
    method: "POST",
    headers: {
      "api-key": apiKey,
      // FormData define Content-Type automaticamente com o boundary correto
      // ...form.getHeaders() // Descomente se estiver usando uma versão mais antiga de form-data que requer isso
    },
    body: form,
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Erro na API: ${response.status} ${response.statusText} - ${errorBody}`);
  }
  return response.json();
}

// Exemplo de uso:
// (async () => {
//   try {
//     // Substitua "audio.wav" pelo caminho do seu arquivo de áudio
//     const result = await transcribeAudioAdvanced("audio.wav");
//     console.log(JSON.stringify(result, null, 2));
//   } catch (error) {
//     console.error("Falha ao transcrever áudio:", error);
//   }
// })();

Considerações sobre Custos Adicionais:

  • A utilização dos recursos de Diarization, Anonymization e Audio Intelligence pode incorrer em custos adicionais, calculados por token ou por caractere processado. Recomenda-se verificar o Dashboard da sua conta para um acompanhamento detalhado dos custos.

Listagem de Modelos ​

Para consultar os modelos STT atualmente disponíveis para sua organização, utilize o seguinte endpoint:

bash
curl -X GET 'https://api.sippulse.ai/v1/asr/models' \
  -H 'api-key: $SIPPULSE_API_KEY'
python
import os
import requests
import json

def list_available_stt_models() -> dict:
    """
    Lista os modelos de Speech-to-Text (STT) disponíveis na API SipPulse AI.
    """
    api_url = "https://api.sippulse.ai/v1/asr/models"
    headers = {"api-key": os.getenv("SIPPULSE_API_KEY")}

    response = requests.get(api_url, headers=headers)
    response.raise_for_status()
    return response.json()

if __name__ == "__main__":
    # É necessário ter a variável de ambiente SIPPULSE_API_KEY configurada
    try:
        models = list_available_stt_models()
        print("Modelos STT disponíveis:")
        print(json.dumps(models, indent=2))
    except requests.exceptions.HTTPError as e:
        print(f"Erro na API: {e.response.status_code} - {e.response.text}")
    except Exception as e:
        print(f"Ocorreu um erro inesperado: {e}")
javascript
// Node.js com node-fetch
// import fetch from "node-fetch"; // Se não estiver usando Node 18+ com fetch nativo

async function listAvailableSTTModels() {
  const apiUrl = "https://api.sippulse.ai/v1/asr/models";
  const apiKey = process.env.SIPPULSE_API_KEY;

  if (!apiKey) {
    throw new Error("A variável de ambiente SIPPULSE_API_KEY não está configurada.");
  }

  const response = await fetch(apiUrl, {
    headers: { "api-key": apiKey },
  });

  if (!response.ok) {
    const errorBody = await response.text();
    throw new Error(`Erro na API: ${response.status} ${response.statusText} - ${errorBody}`);
  }
  return response.json();
}

// Exemplo de uso:
// (async () => {
//   try {
//     const models = await listAvailableSTTModels();
//     console.log("Modelos STT disponíveis:");
//     console.log(JSON.stringify(models, null, 2));
//   } catch (error) {
//     console.error("Falha ao listar modelos STT:", error);
//   }
// })();

SDK da OpenAI ​

É possível utilizar os modelos de transcrição do SipPulse AI, incluindo os proprietários pulse-precision e pulse-speed, bem como o whisper-1, através do SDK oficial da OpenAI. Para isso, é necessário configurar o parâmetro baseURL para o endpoint do SipPulse AI, que oferece compatibilidade com a API da OpenAI para transcrições.

javascript
import OpenAI from "openai";
import fs from "fs"; // Para ler o arquivo em Node.js

const sippulseOpenAI = new OpenAI({
  apiKey: process.env.SIPPULSE_API_KEY, // Sua chave da API SipPulse
  baseURL: "https://api.sippulse.ai/v1/openai", // Endpoint de compatibilidade do SipPulse AI
});

async function transcribeWithSippulseOpenAI(audioFilePath, modelName = "pulse-precision") {
  // Em Node.js, você precisa fornecer um File-like object, como um ReadableStream.
  // No browser, você pode usar um objeto File diretamente de um <input type="file">.
  const audioFileStream = fs.createReadStream(audioFilePath);

  try {
    console.log(`Iniciando transcrição com o modelo: ${modelName}`);
    const response = await sippulseOpenAI.audio.transcriptions.create({
      file: audioFileStream, // Pode ser um Blob, ReadableStream, ou objeto File
      model: modelName,      // Ex: "pulse-precision", "pulse-speed", ou "whisper-1"
      response_format: "verbose_json", // Formato de resposta detalhado
      temperature: 0.0, // Para maior determinismo na transcrição
      // Outros parâmetros suportados pela API de transcrição da OpenAI podem ser adicionados aqui
    });
    console.log("Transcrição concluída:");
    console.log(JSON.stringify(response, null, 2));
    return response;
  } catch (error) {
    console.error("Erro durante a transcrição com SDK OpenAI:", error);
    throw error;
  }
}

// Exemplo de uso em Node.js:
// (async () => {
//   try {
//     // Substitua "caminho/para/seu/audio.wav" pelo caminho real do arquivo
//     await transcribeWithSippulseOpenAI("audio.wav", "pulse-precision");
//     // await transcribeWithSippulseOpenAI("audio.wav", "whisper-1");
//   } catch (e) {
//     // Erro já tratado dentro da função
//   }
// })();
python
from openai import OpenAI
import os

# Configuração do cliente OpenAI para usar o endpoint SipPulse AI
client = OpenAI(
  api_key=os.getenv("SIPPULSE_API_KEY"),    # Sua chave da API SipPulse
  base_url="https://api.sippulse.ai/v1/openai" # Endpoint de compatibilidade do SipPulse AI
)

def transcribe_with_sippulse_openai(file_path: str, model_name: str = "pulse-precision"):
    """
    Transcreve um arquivo de áudio usando um modelo do SipPulse AI
    através da interface compatível com OpenAI.
    """
    try:
        with open(file_path, "rb") as audio_file:
            print(f"Iniciando transcrição com o modelo: {model_name}")
            result = client.audio.transcriptions.create(
                file=audio_file,
                model=model_name,  # Ex: "pulse-precision", "pulse-speed", ou "whisper-1"
                response_format="verbose_json",
                temperature=0.0
                # Outros parâmetros suportados pela API de transcrição da OpenAI podem ser adicionados aqui
            )
        print("Transcrição concluída.")
        return result
    except Exception as e:
        print(f"Erro durante a transcrição com SDK OpenAI: {e}")
        raise

if __name__ == "__main__":
    # É necessário ter a variável de ambiente SIPPULSE_API_KEY configurada
    # Substitua "audio.wav" pelo caminho do seu arquivo de áudio
    try:
        # Exemplo com pulse-precision
        transcription_result = transcribe_with_sippulse_openai("audio.wav", model_name="pulse-precision")
        # Exemplo com whisper-1 (se disponível e desejado)
        # transcription_result = transcribe_with_sippulse_openai("audio.wav", model_name="whisper-1")
        
        if transcription_result:
            # Imprime o resultado da transcrição de forma legível
            import json
            print(json.dumps(transcription_result.dict(), indent=2, ensure_ascii=False))

    except FileNotFoundError:
        print(f"Erro: Arquivo de áudio 'audio.wav' não encontrado.")
    except Exception:
        # Erro já tratado e impresso pela função
        pass

Limitação Importante:

  • Ao utilizar o SDK da OpenAI (mesmo com o baseURL apontado para o SipPulse AI), recursos avançados e proprietários do SipPulse AI, como diarization, anonymize ou insights, não são suportados. Esses parâmetros são específicos da API REST nativa do SipPulse AI (/v1/asr/transcribe). Para usufruir da totalidade dos recursos, recomenda-se o uso direto da API REST nativa.

Boas Práticas ​

Para obter os melhores resultados e otimizar o uso dos modelos STT:

  • Qualidade do Áudio: Forneça áudios com a maior clareza possível, minimizando ruídos de fundo e garantindo boa captação da voz.
  • Fragmentação de Áudios Longos: Para arquivos de áudio extensos (e.g., >60 minutos), considere dividi-los em segmentos menores antes de enviar para transcrição. Isso pode melhorar a performance e o gerenciamento do processo.
  • Uso Estratégico da Diarization: Em gravações de diálogos, reuniões ou qualquer cenário com múltiplos interlocutores, utilize o recurso de diarização (disponível nos modelos pulse-precision e pulse-speed). A correta identificação e separação dos falantes enriquece significativamente as análises e a usabilidade da transcrição.
  • Anonimização Consciente: Ative o recurso de anonimização sempre que a transcrição puder conter dados pessoais sensíveis. Esteja ciente dos custos adicionais associados a este processamento.
  • Audio Intelligence para Insights Imediatos: Combine a transcrição com as funcionalidades de Audio Intelligence (e.g., sumarização, identificação de tópicos, análise de sentimento) para extrair valor e insights de forma automatizada e imediata, diretamente na resposta da API.
  • Monitoramento de Custos: Acompanhe regularmente o consumo e os custos associados às transcrições e aos recursos avançados através do Dashboard da sua conta SipPulse AI.

Perguntas Frequentes (FAQ) ​

Qual é a principal diferença entre os modelos pulse-precision e pulse-speed?

pulse-precision: É otimizado para máxima acurácia na transcrição, sendo a escolha ideal quando a precisão do texto é o fator mais crítico. Este modelo tende a apresentar um Word Error Rate (WER) inferior, mas pode ter uma latência ligeiramente maior. pulse-speed: Prioriza a velocidade de processamento e menor latência, sendo adequado para aplicações que requerem respostas mais rápidas, mesmo que isso implique uma acurácia marginalmente inferior em comparação ao pulse-precision.

É possível utilizar o recurso de diarização com o modelo whisper-1 através do SipPulse AI?

Não. A funcionalidade de diarização é um recurso avançado e exclusivo dos modelos proprietários do SipPulse AI: pulse-precision e pulse-speed. Estes modelos foram especificamente desenvolvidos para oferecer uma análise detalhada de áudios com múltiplos interlocutores.

Como posso obter análises estruturadas, como sumarização ou tópicos, a partir da minha transcrição?

Para receber análises estruturadas, você deve utilizar o parâmetro insights ao fazer a requisição para o endpoint nativo da API REST do SipPulse AI (/v1/asr/transcribe). Especifique uma lista com as análises desejadas (e.g., ["summarization", "topics"]). Os resultados dessas análises serão incluídos no objeto audio_insights dentro da resposta JSON. A funcionalidade "Ver Código" no Playground do SipPulse AI pode gerar exemplos de como formatar corretamente este parâmetro na sua requisição.

Qual o tempo médio para processamento de uma transcrição?

O tempo de processamento pode variar, mas geralmente corresponde a alguns segundos por minuto de áudio. Fatores como o modelo selecionado (pulse-speed tende a ser mais rápido), a duração e complexidade do áudio, e a carga atual do sistema podem influenciar o tempo total.