Servidor MCP de transcrição para sua conta

O servidor MCP do Hushscript conecta um assistente às suas gravações e transcrições usando o Model Context Protocol. Aprove uma conexão OAuth no navegador ou informe um token de acesso pessoal. A transcrição e as ações pagas seguem as regras de financiamento da sua conta pessoal ou do espaço de trabalho elegível.

Dois servidores

O Hushscript, na verdade, executa dois servidores MCP separados, e a maioria dos leitores só precisa de um deles.

https://mcp.hushscript.com/mcp é o servidor de conta descrito no restante desta página. Ele aceita OAuth ou um token de acesso pessoal, e é onde o trabalho da conta acontece: enviar, transcrever, editar, exportar.

POST https://hushscript.com/mcp é um servidor de documentação gratuito e separado. Sem conta, sem token, sem login. Ele é somente leitura e anônimo: não pode abrir uma conta, executar uma transcrição, nem tocar em nada que pertença a uma conta. Ele responde perguntas sobre preços, capacidades, conteúdo das páginas e como se conectar, por meio de cinco ferramentas (get_pricing, get_capabilities, how_to_connect, list_pages, get_page) e as mesmas informações como três recursos (hushscript://pricing, hushscript://capabilities, hushscript://connect).

Se você é um agente que acabou de encontrar o Hushscript, não tem nenhum token, e ainda está decidindo se ele atende às suas necessidades antes de gastar algo, comece pelo servidor de documentação. Volte ao restante desta página quando estiver pronto para conectar uma conta.

Conectar

O servidor fala Streamable HTTP em um único endpoint:

https://mcp.hushscript.com/mcp

Não há endpoint SSE, e não há nenhum software do Hushscript para instalar localmente. No Claude Code:

claude mcp add --transport http hushscript https://mcp.hushscript.com/mcp

Em um cliente que aceita configuração em JSON:

{
  "mcpServers": {
    "hushscript": {
      "type": "http",
      "url": "https://mcp.hushscript.com/mcp"
    }
  }
}

Um cliente compatível com OAuth lê /.well-known/oauth-authorization-server para descobrir os endpoints. Ele pode se registrar por /oauth/register ou usar um documento de metadados de ID de cliente, e então abre uma janela do navegador para você fazer login.

O que você aprova

A autorização é OAuth 2.1 com PKCE. A janela do navegador é uma tela de consentimento do Hushscript, não uma caixa de senha do cliente: ela nomeia o aplicativo que está pedindo, lista em linguagem simples o que ele quer fazer, e espera por você. Nada é concedido até você aprovar ali.

Os tokens de acesso duram uma hora, e os tokens de renovação duram trinta dias. Com OAuth, seu cliente cuida dessas credenciais por você; você nunca cola um token de acesso pessoal na configuração.

Sem navegador

Uma conexão OAuth exige aprovação no navegador. O mesmo servidor também aceita um token de acesso pessoal diretamente, sem nenhuma etapa de navegador na hora de conectar. Uma pessoa cria um em Tokens, na página MCP da conta, escolhe os escopos dele e decide se ele pode comprar minutos. O token é exibido uma única vez, tem o formato hsr1:<region>:pat.<id>.<secret>, e vai em Authorization: Bearer <token> em cada requisição: sem ida e volta OAuth, sem tela de consentimento, sem registro de cliente. O mesmo token funciona na API REST.

Um token também pode pertencer a uma conta de máquina, sem nenhuma pessoa como titular. Um agente inicia um cadastro pago com POST /v1/agent/accounts, completa um Stripe Checkout hospedado em um navegador que ele pode conduzir, e reivindica a conta com um segredo de uso único em POST /v1/agent/accounts/{signup_id}/claim para obter seu primeiro token. Esse token se conecta aqui exatamente como qualquer outro. Veja Uso automatizado para o fluxo completo, do início ao fim.

Um token não pode criar, listar nem revogar outros tokens. Uma conta mantém no máximo 25 tokens ativos. O primeiro token da conta de máquina pode rotacionar a si mesmo pela API REST; o fluxo está em Uso automatizado.

Permissões

Uma conexão mantém um conjunto de escopos. Um pedido OAuth que não nomeia nenhum usa por padrão dez dos onze escopos selecionáveis por quem chama, todos exceto billing. Uma pessoa escolhe os escopos em um token criado no aplicativo. O primeiro token de uma conta de máquina tem apenas transcripts:read, transcripts:write, transcribe, account:read, export, billing e o escopo separado pat:rotate para a autorrotação. A reivindicação dela habilita as duas chaves de faturamento; um token criado por uma pessoa precisa que elas sejam habilitadas de propósito. Quando os escopos são conhecidos, o servidor anuncia as ferramentas correspondentes; o backend os aplica em cada chamada.

billing é a exceção em todos os sentidos. Nunca é concedido implicitamente, a tela de consentimento avisa você antes de aprovar, e uma ferramenta de compra precisa que a chave de faturamento do token e a chave de faturamento de toda a conta estejam habilitadas. pat:rotate não pode ser selecionado em um pedido OAuth nem no formulário de token do aplicativo.

O que as ferramentas cobrem

56 ferramentas, agrupadas pelo que elas tocam:

export_transcript retorna TXT, SRT, VTT, Markdown ou JSON. O conjunto completo de 21 formatos de exportação está no aplicativo.

Além das ferramentas, o servidor publica três recursos e uma string de instructions na conexão: os pacotes de minutos, o modelo de crédito e escopo, e o catálogo completo de códigos de erro, para que um cliente possa ler as regras antes de chamar qualquer coisa. As ferramentas de listagem paginadas recebem um limit e um cursor opaco, tirado do next_cursor da página anterior; list_packs e list_payment_methods retornam suas listas sem cursor.

Os envios pelo MCP mandam áudio já preparado. Para um vídeo local, prepare o áudio dele no seu dispositivo antes; transcribe_from_url busca links de áudio compatíveis no servidor e não importa links de vídeo. Os jobs iniciados pelo MCP usam o modo padrão: as transcrições ficam armazenadas conforme a configuração de retenção da conta. O modo privado de uso único está disponível no aplicativo, não por tokens do MCP.

Exemplos

Um cliente que faz o fluxo OAuth recebe uma sessão MCP normal e nunca vê nada disso diretamente: seu SDK monta o JSON-RPC por baixo dos panos. Esse é o mesmo protocolo que um cliente com token envia manualmente, e funciona como ferramenta de depuração dos dois jeitos.

Conecte-se com um token colocando-o direto na requisição, sem handshake além do initialize:

curl -s https://mcp.hushscript.com/mcp \
  -H "Authorization: Bearer hsr1:us:pat.4f2a1c.9e7b3d2a5c8f1e6b4a0d7c3f2e1b9a8d" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": { "name": "example-client", "version": "1.0.0" }
    }
  }'

Envie a mesma requisição de novo com um corpo diferente para ver todas as ferramentas que os escopos do token cobrem:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/list"
}

Cada item traz um nome, uma descrição e um inputSchema em JSON Schema, correspondendo aos grupos acima. Uma chamada de ferramenta é assim, create_upload reservando crédito e iniciando um envio:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "create_upload",
    "arguments": {
      "size_bytes": 52428800,
      "duration_seconds": 1800,
      "title": "Team standup 2026-09-10",
      "transcription_options": { "speaker_detection": true }
    }
  }
}

Ferramentas estruturadas como create_upload retornam um bloco content de texto com JSON transformado em string. Por exemplo:

{
  "content": [
    {
      "type": "text",
      "text": "{\n  \"job_id\": \"job_8f3a1c2b9e\",\n  \"balance_seconds\": 5400,\n  \"held_seconds\": 1800,\n  \"upload\": {\n    \"part_size_bytes\": 33554432,\n    \"total_parts\": 2,\n    \"part_urls\": [\n      { \"n\": 1, \"url\": \"https://...\" }\n    ],\n    \"next_part_number\": 2\n  }\n}"
    }
  ]
}

A resposta acima mostra os campos do envio; a resposta completa também inclui limits, funding e state. Envie os bytes para essas URLs, chame complete_upload com o ETag de cada parte, depois consulte get_job até seu estado ser done. Os exemplos estruturados abaixo mostram esse JSON interno diretamente, já interpretado, e omitem o envelope {"jsonrpc":"2.0","id":...} em volta da requisição, já que ele nunca muda: só name e arguments mudam.

export_transcript retorna o formato gerado como texto, e download_account_export_chunk retorna bytes brutos codificados como texto em base64. Interprete o text de um resultado como JSON somente quando a ferramenta retornar dados estruturados.

Listando e lendo transcrições:

{
  "name": "list_transcripts",
  "arguments": { "limit": 5 }
}

{
  "transcripts": [
    {
      "id": "t_9c2b7f10",
      "title": "Team standup 2026-09-10",
      "language_detected": "en",
      "duration_seconds": 1800,
      "tags": ["standup"],
      "insights_state": "none"
    }
  ],
  "next_cursor": null
}

Gerando Insights, grátis na primeira chamada para uma transcrição. Este exemplo mostra o saldo depois que uma nova geração começa; reused é false:

{
  "name": "generate_insights",
  "arguments": { "id": "t_9c2b7f10" }
}

{
  "ok": true,
  "reused": false,
  "balance_seconds": 5400,
  "held_seconds": 0
}

Comprando minutos, idempotency_key é obrigatório para que uma nova tentativa após uma resposta perdida não gere cobrança duplicada:

{
  "name": "purchase_pack",
  "arguments": {
    "pack": "300min",
    "payment_method_id": "pm_1PxYzABC",
    "idempotency_key": "agent-2026-09-11-refill-01"
  }
}

{
  "status": "ok",
  "balance_seconds": 23400
}

Recursos respondem sem uma chamada de ferramenta, com resources/read nomeando uma das três URIs:

{
  "jsonrpc": "2.0",
  "id": 9,
  "method": "resources/read",
  "params": { "uri": "hushscript://pricing" }
}

Resposta abreviada (a nota explicativa do recurso foi omitida):

{
  "contents": [
    {
      "uri": "hushscript://pricing",
      "mimeType": "application/json",
      "text": "{\"packs\":[{\"id\":\"45min\",\"minutes\":45},{\"id\":\"300min\",\"minutes\":300},{\"id\":\"900min\",\"minutes\":900},{\"id\":\"1800min\",\"minutes\":1800},{\"id\":\"6000min\",\"minutes\":6000}]}"
    }
  ]
}

Use list_packs para os valores e as moedas atuais dos pacotes.

Toda falha do backend traz um slug estável e um código numérico, o mesmo corpo {"error": "<slug>", "code": <number>} documentado em hushscript://error-codes. Uma chamada de ferramenta expõe esse mesmo slug e código, incorporados em uma mensagem legível em vez de um objeto de erro bruto, e sinaliza o resultado com isError em vez de lançar uma exceção:

{
  "content": [
    {
      "type": "text",
      "text": "Not enough transcription credit. This job needs 1800 seconds and the balance is 900 seconds. Top up at https://app.hushscript.com/billing (insufficient_balance, E3001)"
    }
  ],
  "isError": true
}

O que custa minutos

Ler dados da conta não gasta minutos de transcrição. As ações cobradas usam as mesmas tarifas do aplicativo. Em geral, os minutos pré-pagos pessoais as financiam; a transcrição em um espaço de trabalho pode usar o banco de horas compartilhado do Teams quando só o banco ativo cobre o job inteiro e nenhum idioma de tradução está selecionado. Um job com idiomas de tradução ou com uma URL de áudio importada usa minutos pessoais. O financiamento não muda a custódia das transcrições.

Contas pessoais elegíveis recebem 30 minutos grátis após a verificação do cartão; uma conta de máquina começa com o pacote que compra no cadastro.

• Transcrever uma gravação gasta minutos pela sua duração. O modo médico soma 100%, e cada idioma de tradução soma 25%. Com o multicanal ativado, cada canal de áudio é cobrado separadamente, então um arquivo estéreo conta em dobro.
• Insights: a primeira geração por transcrição é gratuita. Regenerar depois custa 40% da duração da gravação a partir da transcrição original, ou 30% a partir de uma versão limpa. A regeneração usa os minutos pessoais do membro, mesmo quando um banco de horas compartilhado do espaço de trabalho pagou a transcrição.
• Retraduzir uma transcrição custa 25% da sua duração por idioma, e isso sobrescreve: todo idioma que a chamada cobra perde qualquer cópia editada à mão daquela tradução, sem nenhuma forma de recuperá-la.
• purchase_pack cobra na hora um cartão salvo elegível, em caso de sucesso. Precisa do escopo billing, da chave de faturamento do próprio token e da chave de faturamento de toda a conta. Ele adiciona minutos ao saldo pessoal, não a um banco de horas compartilhado do Teams.
• add_payment_method não custa nada. Ele retorna um link do Stripe Checkout que salva um cartão na conta sem cobrá-lo; complete-o uma vez no navegador (um agente pode conduzir o próprio). Depois, o purchase_pack tenta uma cobrança fora de sessão; uma recusa, ou um desafio do emissor, volta como um código de erro distinto em vez de uma página inacabada.

Veja a página de preços para os pacotes em si.

Revisando e revogando

Para uma conta em que você consegue fazer login, as conexões OAuth aparecem em Aplicativos conectados, na página MCP de sua conta, com o cliente e os escopos delas. Os tokens também são listados ali; revogar um corta as chamadas dele. Remover a configuração de um cliente só impede que esse cliente peça de novo. Uma conta de máquina não tem caixa de e-mail de login utilizável, então o token dela é rotacionado pelo fluxo de conta de agente.

Limites

Os tokens de contas humanas permitem 1.200 requisições por minuto cada um. A cadeia de tokens de uma conta de agente compartilha esse orçamento entre as rotações. As rotas de faturamento que chamam o Stripe, acessadas por um token, compartilham 60 requisições por minuto por conta: configuração de cartão, compra, troca do cartão padrão, remoção de cartão e falhas de cache da lista de cartões. As compras de contas de agente e as compras por token de contas humanas têm teto de três tentativas a cada 24 horas móveis por conta. O cadastro pago do agente conta, assim como as falhas depois que uma tentativa é reservada; as compras em sessão de navegador humana são isentas. Uma recusa pelo teto é HTTP 429 / código 4038 agent_purchase_capped, distinta do HTTP 429 / código 5000 rate_limited comum. Ambas trazem Retry-After.

A autorização e a conclusão do OAuth compartilham uma cota de 30 por minuto por endereço. O registro tem a própria cota de 30 por minuto; /oauth/token tem uma cota separada de 600 por minuto. Cada uma usa como chave um endereço IPv4 ou um /64 de IPv6. As falhas de cache na introspecção de token bruto têm outra cota de 30 por minuto sobre a mesma chave; isso não é um limite para cada chamada de ferramenta do MCP.