TellDone

Aplicativo de planejamento com foco em voz. Dite notas de voz no iOS/Apple Watch, a IA cria tarefas e eventos estruturados. 21 ferramentas MCP (leitura + escrita). Conecte-se a partir de Claude Code, Cursor, Windsurf. Teste gratuito com o código promocional MCPBETA26.

GitHubExperimente este MCPPatrocinado

Documentação

Servidor MCP TellDone

Conecte suas notas de voz, tarefas, eventos e relatórios do TellDone ao Claude (Desktop, claude.ai e Code), Cursor, Windsurf, Codex e qualquer cliente compatível com MCP — com OAuth em um clique (login pelo navegador, sem token para copiar) ou um bearer token.

TellDone é um aplicativo de planejamento com foco em voz. Dite seus pensamentos, e a IA cria automaticamente notas estruturadas, tarefas, eventos e relatórios diários de produtividade.

A gravação de voz está disponível no iOS e Apple Watch. Android em breve. Você também pode enviar texto via MCP usando process_note para o mesmo pipeline de análise de IA.

Use o código promocional MCPBETA26 após o cadastro para obter acesso MCP gratuito (leitura e escrita por 30 dias, depois somente leitura por um ano).

Início Rápido

Conecte-se de duas maneiras: OAuth em um clique (recomendado — login pelo navegador, nada para copiar) ou um bearer token (funciona com todos os clientes MCP).

Opção A — OAuth em um clique · Claude Desktop, claude.ai, Claude Code

Adicione TellDone como conector, faça login na sua conta no navegador e aprove. Os tokens de acesso são de curta duração, com escopo limitado e revogáveis a qualquer momento em Configurações — não há nada para copiar ou armazenar.

Claude Desktop e claude.ai — em Configurações, abra Conectores, escolha Adicionar conector personalizado e cole:

https://api.telldone.app/mcp/user

Clique em Conectar, faça login no TellDone e aprove o acesso. Sem registro manual de aplicativo — o TellDone suporta Documentos de Metadados de Client ID, então o Claude se registra automaticamente.

Claude Code

claude mcp add --transport http telldone https://api.telldone.app/mcp/user

Em seguida, execute /mcp e escolha telldone → Autenticar para abrir a página de consentimento do TellDone no seu navegador — faça login e aprove uma vez. (CLI v2.1.186+: claude mcp login telldone faz o mesmo pelo shell.)

Qualquer cliente MCP que suporte descoberta OAuth 2.1 (RFC 9728 + RFC 8414) conecta-se da mesma forma.

Opção B — Bearer token · Cursor, Windsurf, Codex ou qualquer cliente

Primeiro obtenha um token: cadastre-se em app.telldone.app, abra Configurações → Agentes de IA (MCP) e clique em Ativar. Em seguida, adicione o servidor com seu token:

Claude Code

claude mcp add telldone --transport http \
  https://api.telldone.app/mcp/user/mcp \
  --header "Authorization: Bearer YOUR_TOKEN"

Cursor .cursor/mcp.json

{
  "mcpServers": {
    "telldone": {
      "url": "https://api.telldone.app/mcp/user/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

Windsurf .codeium/windsurf/mcp_config.json

{
  "mcpServers": {
    "telldone": {
      "serverUrl": "https://api.telldone.app/mcp/user/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

Codex codex.json

{
  "mcpServers": {
    "telldone": {
      "type": "http",
      "url": "https://api.telldone.app/mcp/user/mcp",
      "headers": { "Authorization": "Bearer YOUR_TOKEN" }
    }
  }
}

OpenClaw Configurações > Servidores MCP > Adicionar > Nome: TellDone, URL: https://api.telldone.app/mcp/user/mcp, Autenticação: Bearer YOUR_TOKEN

Comece a Usar

Pergunte à sua ferramenta de IA coisas como:

"No que trabalhei hoje?"
"Crie uma tarefa: revisar relatório trimestral, prioridade alta, prazo sexta-feira"
"Encontre todas as notas sobre a estratégia de marketing"
"Marque a tarefa do Figma como concluída"
"Crie um evento: reunião de equipe amanhã às 10h, lembre-me 15 minutos antes"
"Processe este resumo de reunião e extraia tarefas"
"Quais eventos tenho na próxima semana?"
"Mostre-me meu relatório diário de ontem"

Formatos de Dados — Leia Antes de Analisar a Saída

Cada ferramenta retorna JSON. A resposta MCP na transmissão envolve os payloads em result.content[0].text como uma string codificada em JSON — analise-a com json.loads() (ou equivalente) para obter os dados reais.

Todos os datetimes, datas e UUIDs no JSON decodificado são STRINGS, não tipos nativos de linguagem. Não chame .toordinal(), .weekday() ou qualquer método de datetime diretamente neles — você receberá TypeError: 'str' has no attribute 'toordinal'. Analise-os primeiro.

Tipos de saída escalares

Formato do campo	Formato na transmissão	Exemplo	Analisar com
UUID	string (hex minúsculo com hífens)	`"b3f3c8a0-9a4d-4e12-9f4a-1a1b2c3d4e5f"`	usar como está
Datetime (timestamp)	string ISO 8601 com offset de fuso horário	`"2026-04-18T11:30:00+00:00"`	`datetime.fromisoformat(s)` em Python; `new Date(s)` em JS
Data (dia do calendário, sem hora)	string `YYYY-MM-DD`	`"2026-04-18"`	`date.fromisoformat(s)` em Python
Booleano	`true` / `false`	`true`	nativo
Inteiro	número JSON	`42`	nativo
Campo anulável	JSON `null`	`null`	`None` / `null`

Tipos de saída de array / objeto

Campo	Formato na transmissão
`tags` (em notas/tarefas/eventos)	array de strings, OU `null` se nunca definido, OU `[]` se limpo
`reminder_minutes` (eventos, campo gravável)	array de ints na entrada/saída
`attendees` (eventos, campo gravável)	array de strings (nomes/emails)
`metadata` (notas)	objeto JSON ou `null`
arrays `tasks` / `events` dentro de `get_note` / `get_notes_full`	sempre presentes, possivelmente vazios `[]`

Valores de enumeração

priority — "low", "medium", "high" ou null
note.type — "task", "idea", "info", "status", "meeting", "event", "reflection"
note.status — "active", "archived" (registros excluídos são omitidos de toda ferramenta de leitura)
task.status — "todo", "done" (parâmetro de consulta status="all" significa "todos os não excluídos")
event.status — "confirmed", "tentative", "cancelled"
report.type — "daily", "weekly", "monthly", "yearly"
source (tarefas), completed_by (tarefas) — strings de formato livre: "mcp", "app", "sync", "audio", "todoist", "notion", etc.

Campos de saída por ferramenta

Ferramenta	Campos retornados (todos no nível superior de cada item do array, salvo indicação)
`get_profile`	`id` UUID, `email` str, `display_name` str\|null, `locale` str, `transcription_locale` str\|null, `timezone` str (IANA), `subscription` str, `mcp_mode` str, `created_at` datetime ISO 8601 str, `stats` {notas:int, tarefas:int, eventos:int}
`get_notes`	`id` UUID, `title` str, `summary` str\|null, `type` enum, `tags` str[]\|null, `priority` enum\|null, `status` enum, `recorded_at` datetime ISO 8601 str\|null, `created_at` datetime ISO 8601 str
`get_note`	campos de nota (`id`, `title`, `summary`, `transcript` str\|null, `type`, `tags`, `priority`, `status`, `metadata` obj\|null, `created_at`) + arrays `tasks[]` + `events[]` com subconjunto de campos
`get_notes_full`	array de notas com `tasks[]` e `events[]` incorporados (mesmo subconjunto de `get_note`, menos `metadata`)
`get_tasks`	`id` UUID, `title` str, `description` str\|null, `status` enum, `priority` enum\|null, `tags` str[]\|null, `deadline` str AAAA-MM-DD\|null, `reminder_at` datetime ISO 8601 str\|null, `completed_at` datetime ISO 8601 str\|null, `completed_by` str\|null, `source` str\|null, `created_at` datetime ISO 8601 str
`get_events`	`id` UUID, `title` str, `description` str\|null, `status` enum, `start_at` datetime ISO 8601 str (não nulo), `end_at` datetime ISO 8601 str (não nulo), `location` str\|null, `is_all_day` bool\|null, `tags` str[]\|null, `created_at` datetime ISO 8601 str. Nota: `attendees`, `reminder_minutes`, `recurrence_rule` são graváveis via `create_event`/`update_event`, mas NÃO são retornados por `get_events`.
`get_reports`	`id` UUID, `type` enum, `period_start` str AAAA-MM-DD, `period_end` str AAAA-MM-DD, `content_md` str\|null, `created_at` datetime ISO 8601 str
`get_tags`	`tag` str, `usage_count` int, `is_pinned` bool, `is_manual` bool
`search`	`{notes: [...], tasks: [...], events: [...]}` — cada item é `{id UUID, type "note"/"task"/"event", title str, detail str\|null, created_at ISO 8601 datetime str}`. Todos os três arrays sempre presentes, possivelmente vazios.
Ferramentas de escrita	mínimo: `{id UUID, title str, status enum}` (mais `type` em notas). Não espere registros completos — chame a ferramenta `get_*` correspondente se precisar de mais campos.
Ferramentas de exclusão	`{id UUID, deleted: true}`
`process_note`	`{audio_id UUID, status "processing", mode "audio+stt"/"text-only", message str}` — assíncrono; o resultado final chega via WebSocket `note_ready` ou uma chamada posterior a `get_notes`.
Qualquer ferramenta em erro	`{error: "message"}` — sempre verifique se a chave `error` é nula antes de tratar a resposta como um registro.

Formatos de parâmetros de entrada

note_id, task_id, event_id, parent_*_id — strings UUID
date_from, date_to, deadline — strings YYYY-MM-DD (string vazia significa "sem filtro")
start_at, end_at, reminder_at — strings datetime ISO 8601, ex.: "2026-04-15T09:00:00Z" ou "2026-04-15T09:00:00+00:00"
tags — string separada por vírgulas na entrada (ex.: "work,urgent"); armazenada/retornada como string[]
reminder_minutes, attendees — strings separadas por vírgulas na entrada; armazenadas/retornadas como arrays
is_all_day — booleano em create_event; string "true"/"false" em update_event
recurrence_rule — string RRULE, ex.: "FREQ=WEEKLY;BYDAY=MO,WE,FR"

Exemplo de análise (Python)

import json
from datetime import datetime, date

# tools/call response → text → decode
payload = json.loads(response["result"]["content"][0]["text"])

# Check for error first
if "error" in payload:
    raise RuntimeError(payload["error"])

# Events: start_at is a STRING like "2026-04-18T11:30:00+00:00"
for e in payload:   # payload is list from get_events
    start = datetime.fromisoformat(e["start_at"])   # -> tz-aware datetime
    if e["end_at"]:
        end = datetime.fromisoformat(e["end_at"])

# Tasks: deadline is a STRING like "2026-04-18" (date only)
for t in tasks_payload:
    if t["deadline"]:
        d = date.fromisoformat(t["deadline"])
        days_left = (d - date.today()).days

Campos de Nota: título, resumo, transcrição

Cada nota tem três campos de texto com funções diferentes e limites diferentes. Escolher o campo certo importa — clientes LLM (Claude Desktop, Cursor, etc.) devem dividir o conteúdo adequadamente ao usar create_note ou update_note.

Campo	Função	Limite	Incluído nos prompts LLM de relatório?
`title`	Assunto de uma linha exibido em listas, prévias, push, assuntos de email.	200 caracteres	✅ (como cabeçalho de lista)
`summary`	Chamada de 1–3 frases.	Limite rígido de 1000 caracteres — decisão de produto.	✅ Literalmente. Mantenha conciso.
`transcript`	Corpo completo da nota. Exibido na visualização de detalhes.	Baseado no plano (veja abaixo)	❌ Nunca. Seguro para ser longo.

Limites de transcrição baseados no plano (subscription_plans.max_text_length):

Plano	Máx. caracteres de transcrição
Gratuito	2 000
Básico	8 000
Pro	20 000
Ultra	50 000
Personalizado	100 000

Regra prática para clientes LLM:

Saída curta (notas, lembretes, afazeres): apenas title + summary. Deixe transcript vazio.
Saída longa (atas de reunião, rascunhos, brainstormings, despejos de pesquisa): coloque um summary de 1–3 frases e o corpo completo em transcript. Não coloque tudo no resumo — você atingirá o erro de 1000 caracteres.

Mensagens de erro de estouro:

summary too long (max 1000 chars, got N). For long-form content use the 'transcript' parameter (plan-based limit).
transcript too long (max 20000 chars for pro plan, got N)

Exemplo de uso correto (Claude Desktop captura uma reunião):

create_note({
  title: "Weekly engineering sync — API versioning",
  summary: "Team agreed on semver deprecation policy with 6-month sunset window. Owner: Alex. Next sync: Thu.",
  transcript: "Full meeting transcript: Alice raised the question of how to deprecate v1...\n\n[... 5 KB of detail ...]",
  tags: "engineering,versioning,meeting"
})

Por que dois limites diferentes?

summary é incluído literalmente nos prompts LLM de relatórios diários/semanais/mensais. Se cada resumo pudesse ter 20 KB, os prompts de relatório explodiriam em custo e latência (e arriscariam estouro de janela de contexto para usuários intensos). 1000 caracteres foi definido em abril de 2026 após medir dados de produção (mediana 247, máx. 554).
transcript nunca está nos prompts de relatório — ele só aparece na visualização de detalhes da interface. Transcrições grandes custam apenas armazenamento, não tokens LLM. Limitar por plano previne abuso, mas fora isso permite generosidade.

Compatibilidade retroativa: transcript é um parâmetro opcional (padrão ""). Clientes antigos chamando create_note(title, summary, tags, type) continuam funcionando sem alterações — o banco de dados armazena transcript = NULL. Nenhuma migração necessária.

Ferramentas (20)

Todas as ferramentas incluem anotações MCP — title, readOnlyHint, destructiveHint, idempotentHint, openWorldHint — para que clientes MCP possam exibir a interface de confirmação correta. Cada ferramenta opera apenas no banco de dados Telldone (openWorldHint: false) — o servidor nunca acessa APIs externas.

Ferramentas de Leitura (9)

Ferramenta	Descrição
`get_profile`	Retorna o perfil do usuário autenticado, incluindo nome de exibição, e-mail, localidade, fuso horário, plano de assinatura e estatísticas de uso (total de notas, tarefas, eventos). Use para verificar o status da conta ou a cota.
`get_notes`	Lista notas de voz com filtros opcionais: `date_from`/`date_to` (ISO 8601), `tag` (string), `type` (task/idea/info/status/meeting/event/reflection), `search` (consulta de texto), `limit` (padrão 20, máx. 100), `offset`. Retorna metadados da nota sem o corpo completo — use `get_note` para detalhes.
`get_note`	Retorna uma única nota por UUID `note_id`, incluindo transcrição completa, resumo de IA e todas as tarefas e eventos filhos vinculados. Use quando precisar do conteúdo completo da nota após encontrá-la via `get_notes` ou `search`.
`get_notes_full`	Recuperação em massa de notas com filhos incorporados (tarefas + eventos). Mesmos filtros de `get_notes`. Use em vez de chamar `get_note` em um loop. Retorna cargas maiores — defina `limit` adequadamente.
`get_tasks`	Lista tarefas com filtros: `status` (todo/done/all, padrão: todo), `tag`, `priority` (low/medium/high), `date_from`/`date_to` para intervalo de prazo, `limit`, `offset`. Retorna título, prioridade, prazo, reminder_at, tags, status de conclusão.
`get_events`	Lista eventos de calendário com filtros de intervalo `date_from`/`date_to`, `status` (confirmed/tentative/cancelled), `limit`, `offset`. Retorna título do evento, horários de início/fim, local, participantes e lembretes.
`get_reports`	Retorna relatórios de produtividade gerados por IA. Filtre por `period` (daily/weekly/monthly/yearly) e `date_from`/`date_to`. Os relatórios resumem tarefas concluídas, padrões e insights de produtividade.
`get_tags`	Retorna todas as tags definidas pelo usuário ordenadas por frequência de uso (mais usadas primeiro). Sem parâmetros. Use para descobrir tags disponíveis antes de filtrar notas ou tarefas.
`search`	Busca híbrida de texto + semântica em notas, tarefas e eventos. Parâmetro: `query` (string). Combina correspondência de palavras-chave com similaridade vetorial para resultados relevantes mesmo com redação diferente. Retorna tipos de resultados mistos com pontuações de relevância.

Ferramentas de Escrita (11)

Ferramenta	Descrição
`process_note`	Executa o pipeline completo de análise de IA em entrada de texto ou áudio — idêntico a gravar uma nota de voz no aplicativo móvel. Aceita `text` (string) ou `audio_base64` + `audio_format` (m4a/wav/mp3). A IA extrai nota estruturada + tarefas + eventos + tags. Retorna imediatamente com `audio_id`; os resultados chegam de forma assíncrona. Consulte com `get_notes()` para recuperar a saída processada.
`create_note`	Cria uma nota de texto simples sem análise de IA. Parâmetros: `title` (obrigatório, máx. 200), `summary` (máx. 1000 caracteres, teaser conciso — incluído nos prompts de LLM de relatórios), `transcript` (limite baseado no plano, corpo longo — NÃO incluído nos prompts de relatórios), `type` (task/idea/info/status/meeting/event/reflection), `tags` (separados por vírgula, máx. 20). Consulte a seção Campos de Nota para saber onde colocar texto longo.
`create_task`	Cria uma tarefa com `title` (obrigatório), `description`, `priority` (low/medium/high, padrão: medium), `deadline` (data ISO 8601), `reminder_at` (data e hora ISO 8601), `tags` (separados por vírgula). A tarefa é criada com status "todo". Sincroniza com o aplicativo móvel em tempo real.
`create_event`	Cria um evento de calendário com `title` (obrigatório), `start_at`/`end_at` (data e hora ISO 8601), `location`, `attendees` (separados por vírgula), `reminder_minutes` (inteiro), `recurrence` (string rrule), `status` (confirmed/tentative).
`update_note`	Atualiza campos de nota por `note_id` (UUID, obrigatório). Opcionais: `title`, `summary` (máx. 1000), `transcript` (limite baseado no plano, corpo longo), `type`, `tags`, `priority`, `status`. Apenas os campos fornecidos são alterados; campos omitidos permanecem inalterados. Passe `" "` (espaço único) para `summary` ou `transcript` para limpar o campo.
`update_task`	Atualiza campos de tarefa por `task_id` (UUID, obrigatório). Opcionais: `title`, `description`, `priority`, `deadline`, `reminder_at`, `tags`, `status` (todo/done). Use `complete_task` como atalho para marcar como concluída.
`update_event`	Atualiza campos de evento por `event_id` (UUID, obrigatório). Opcionais: `title`, `start_at`, `end_at`, `location`, `attendees`, `status` (confirmed/tentative/cancelled), `reminder_minutes`.
`complete_task`	Marca uma tarefa como concluída por `task_id` (UUID). Atalho para `update_task` com `status: "done"`. Registra o carimbo de data/hora de conclusão e a origem ("mcp").
`delete_note`	Exclui suavemente uma nota por `note_id` (UUID). Propaga para todas as tarefas e eventos filhos vinculados — eles também são excluídos suavemente. Reversível pelo aplicativo web.
`delete_task`	Exclui suavemente uma tarefa por `task_id` (UUID). Não afeta a nota pai. Reversível pelo aplicativo web.
`delete_event`	Exclui suavemente um evento por `event_id` (UUID). Não afeta a nota pai. Reversível pelo aplicativo web.

Todas as ferramentas de escrita sincronizam em tempo real com clientes móveis e web conectados via WebSocket.

Pipeline Completo: `process_note`

A ferramenta process_note executa o mesmo pipeline que gravar no aplicativo móvel:

Text or Audio --> STT (if audio) --> LLM Analysis --> Note + Tasks + Events + Tags

Modo texto (pular STT):

{"name": "process_note", "arguments": {"text": "Need to buy groceries. Meeting with Katie at 3pm."}}

Modo áudio (codificado em base64):

{"name": "process_note", "arguments": {"audio_base64": "...", "audio_format": "m4a"}}

Retorna imediatamente com audio_id. Os resultados chegam via WebSocket ou consulte com get_notes().

Exemplos

`examples/test-connection.sh`

#!/bin/bash
# Test your TellDone MCP connection
TOKEN="${1:?Usage: ./test-connection.sh YOUR_TOKEN}"
URL="https://api.telldone.app/mcp/user/mcp"

echo "=== Testing connection ==="
curl -s -X POST "$URL" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_profile"}}' \
  | python3 -m json.tool

echo ""
echo "=== Listing tools ==="
curl -s -X POST "$URL" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \
  | python3 -c "import sys,json; tools=json.load(sys.stdin).get('result',{}).get('tools',[]); print(f'{len(tools)} tools available'); [print(f'  {t[\"name\"]}') for t in tools]"

`examples/daily-summary.sh`

#!/bin/bash
# Get today's tasks and notes summary
TOKEN="${1:?Usage: ./daily-summary.sh YOUR_TOKEN}"
URL="https://api.telldone.app/mcp/user/mcp"
TODAY=$(date +%Y-%m-%d)

call() {
  curl -s -X POST "$URL" \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -d "$1"
}

echo "=== Today's Notes ($TODAY) ==="
call "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"get_notes\",\"arguments\":{\"date_from\":\"$TODAY\",\"limit\":20}}}" \
  | python3 -c "
import sys, json
r = json.loads(json.load(sys.stdin)['result']['content'][0]['text'])
for n in r: print(f'  [{n[\"type\"]}] {n[\"title\"]}')" 2>/dev/null

echo ""
echo "=== Active Tasks ==="
call '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"get_tasks","arguments":{"status":"todo","limit":10}}}' \
  | python3 -c "
import sys, json
r = json.loads(json.load(sys.stdin)['result']['content'][0]['text'])
for t in r: print(f'  [{t[\"priority\"]}] {t[\"title\"]}')" 2>/dev/null

echo ""
echo "=== Upcoming Events ==="
call "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"tools/call\",\"params\":{\"name\":\"get_events\",\"arguments\":{\"date_from\":\"$TODAY\",\"limit\":5}}}" \
  | python3 -c "
import sys, json
r = json.loads(json.load(sys.stdin)['result']['content'][0]['text'])
# NOTE: start_at is a STRING like '2026-04-18T11:30:00+00:00' — parse before date math
for e in r: print(f'  {e[\"start_at\"][:16]} {e[\"title\"]}')" 2>/dev/null

`examples/create-task.sh`

#!/bin/bash
# Create a task via MCP
TOKEN="${1:?Usage: ./create-task.sh YOUR_TOKEN 'Task title'}"
TITLE="${2:?Usage: ./create-task.sh YOUR_TOKEN 'Task title'}"
PRIORITY="${3:-medium}"

curl -s -X POST "https://api.telldone.app/mcp/user/mcp" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/call\",\"params\":{\"name\":\"create_task\",\"arguments\":{\"title\":\"$TITLE\",\"priority\":\"$PRIORITY\"}}}" \
  | python3 -m json.tool

Planos e Acesso

Plano	Acesso MCP	Leitura	Escrita	Preço
Free	--	--	--	$0
Basic	--	--	--	$4.99/mo
Pro	Leitura e Escrita	9 ferramentas	11 ferramentas	$11.99/mo
Ultra	Leitura e Escrita	9 ferramentas	11 ferramentas	$24.99/mo

Pro e Ultra têm as mesmas ferramentas MCP. Ultra tem cotas maiores (notas ilimitadas, 1500 min de STT/mês, 300 uploads/dia).

Autenticação

O TellDone suporta duas formas de conexão — escolha uma.

OAuth 2.1 (recomendado)

Login no navegador com um clique, nada para copiar ou armazenar. Em conformidade com padrões: OAuth 2.1 com PKCE (S256), descoberta de servidor de autorização + recurso protegido (RFC 8414 / RFC 9728), tokens de acesso vinculados ao público (RFC 8707), refresh tokens rotativos e Documentos de Metadados de Client ID (para que Claude Desktop / claude.ai se conectem sem registro manual). O acesso é escopado — você aprova exatamente o que o aplicativo pode fazer na tela de consentimento, e somente leitura vs leitura e escrita segue seu plano. Revogue a qualquer momento em Configurações → Agentes de IA ou desabilitando o MCP.

URL do Conector: https://api.telldone.app/mcp/user
Descoberta: https://api.telldone.app/.well-known/oauth-protected-resource
Escopos: notes:read · notes:write · tasks:read · tasks:write · events:read · events:write · reports:read · tags:read · tags:write · profile:read · offline_access

Token Bearer

Para clientes sem OAuth. Gere um token de longa duração no aplicativo web — Configurações → Agentes de IA (MCP) → Ativar — e envie-o como Authorization: Bearer <token>.

URL do Endpoint: https://api.telldone.app/mcp/user/mcp
Regenerar: Configurações → Agentes de IA → Regenerar (token antigo revogado instantaneamente)
Desabilitar: Configurações → Agentes de IA → Desabilitar (token excluído)

Limite de taxa (ambos): 5 solicitações/segundo.

Transporte

MCP Streamable HTTP (sem estado). Cada solicitação é independente.

POST https://api.telldone.app/mcp/user/mcp
Authorization: Bearer <token>
Content-Type: application/json
Accept: application/json