TellDone

Servidor MCP de TellDone

Conecta tus notas de voz, tareas, eventos e informes de TellDone a Claude (Desktop, claude.ai y Code), Cursor, Windsurf, Codex y cualquier cliente compatible con MCP — con OAuth de un clic (inicio de sesión en el navegador, sin token que copiar) o con un token de portador.

TellDone es una aplicación de planificación por voz. Dicta tus pensamientos y la IA crea automáticamente notas estructuradas, tareas, eventos e informes diarios de productividad.

La grabación de voz está disponible en iOS y Apple Watch. Android próximamente. También puedes enviar texto a través de MCP usando process_note para el mismo pipeline de análisis de IA.

Usa el código promocional MCPBETA26 después de registrarte para obtener acceso MCP gratuito (lectura y escritura durante 30 días, luego solo lectura durante un año).

Inicio rápido

Conéctate de una de dos maneras: OAuth de un clic (recomendado — inicio de sesión en el navegador, nada que copiar) o un token de portador (funciona con todos los clientes MCP).

Opción A — OAuth de un clic · Claude Desktop, claude.ai, Claude Code

Añade TellDone como conector, inicia sesión en tu cuenta en el navegador y aprueba. Los tokens de acceso son de corta duración, con alcance limitado y revocables en cualquier momento en Configuración — no hay nada que copiar ni almacenar.

Claude Desktop y claude.ai — en Configuración, abre Conectores, elige Añadir conector personalizado y pega:

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

Haz clic en Conectar, inicia sesión en TellDone y aprueba el acceso. No hay registro manual de la aplicación — TellDone admite Documentos de Metadatos de ID de Cliente, por lo que Claude se registra automáticamente.

Claude Code

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

Luego ejecuta /mcp y elige telldone → Autenticar para abrir la página de consentimiento de TellDone en tu navegador — inicia sesión y aprueba una vez. (CLI v2.1.186+: claude mcp login telldone hace lo mismo desde la terminal).

Cualquier cliente MCP que admita el descubrimiento OAuth 2.1 (RFC 9728 + RFC 8414) se conecta de la misma manera.

Opción B — Token de portador · Cursor, Windsurf, Codex o cualquier cliente

Primero obtén un token: regístrate en app.telldone.app, abre Configuración → Agentes de IA (MCP) y haz clic en Habilitar. Luego añade el servidor con tu 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 Configuración > Servidores MCP > Añadir > Nombre: TellDone, URL: https://api.telldone.app/mcp/user/mcp, Autenticación: Bearer YOUR_TOKEN

Comienza a usarlo

Pregunta a tu herramienta de IA cosas como:

• "¿En qué trabajé hoy?"
• "Crea una tarea: revisar el informe trimestral, prioridad alta, fecha límite el viernes"
• "Encuentra todas las notas sobre la estrategia de marketing"
• "Marca la tarea de Figma como completada"
• "Crea un evento: reunión de equipo mañana a las 10 a. m., recuérdame 15 minutos antes"
• "Procesa este resumen de reunión y extrae las tareas"
• "¿Qué eventos tengo la próxima semana?"
• "Muéstrame mi informe diario de ayer"

Formatos de datos — Lee esto antes de analizar la salida

Cada herramienta devuelve JSON. La respuesta MCP envuelve los payloads en result.content[0].text como una cadena codificada en JSON — analízala con json.loads() (o equivalente) para obtener los datos reales.

Todas las fechas-hora, fechas y UUID en el JSON decodificado son CADENAS, no tipos nativos del lenguaje. No llames a .toordinal(), .weekday() ni a ningún método de fecha-hora directamente sobre ellos — obtendrás TypeError: 'str' has no attribute 'toordinal'. Analízalos primero.

Tipos de salida escalares

Forma del campo	Formato en el cable	Ejemplo	Analizar con
UUID	cadena (hex minúsculas con guiones)	"b3f3c8a0-9a4d-4e12-9f4a-1a1b2c3d4e5f"	usar tal cual
Fecha-hora (marca de tiempo)	cadena ISO 8601 con desplazamiento de zona horaria	"2026-04-18T11:30:00+00:00"	datetime.fromisoformat(s) en Python; new Date(s) en JS
Fecha (día calendario, sin hora)	cadena YYYY-MM-DD	"2026-04-18"	date.fromisoformat(s) en Python
Booleano	true / false	true	nativo
Entero	número JSON	42	nativo
Campo anulable	JSON null	null	None / null

Tipos de salida de matriz / objeto

Campo	Formato en el cable
tags (en notas/tareas/eventos)	matriz de cadenas, O null si nunca se estableció, O [] si se borró
reminder_minutes (eventos, campo escribible)	matriz de enteros en entrada/salida
attendees (eventos, campo escribible)	matriz de cadenas (nombres/correos)
metadata (notas)	objeto JSON o null
Matrices tasks / events dentro de get_note / get_notes_full	siempre presentes, posiblemente vacías []

Valores de enumeración

• priority — "low", "medium", "high" o null
• note.type — "task", "idea", "info", "status", "meeting", "event", "reflection"
• note.status — "active", "archived" (los registros eliminados se excluyen de toda herramienta de lectura)
• task.status — "todo", "done" (el parámetro de consulta status="all" significa "todos los no eliminados")
• event.status — "confirmed", "tentative", "cancelled"
• report.type — "daily", "weekly", "monthly", "yearly"
• source (tareas), completed_by (tareas) — cadenas de formato libre: "mcp", "app", "sync", "audio", "todoist", "notion", etc.

Campos de salida por herramienta

Herramienta	Campos devueltos (todos en el nivel superior de cada elemento de matriz salvo que se indique)
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 str de fecha-hora ISO 8601, stats {notas:int, tareas:int, eventos:int}
get_notes	id UUID, title str, summary str|null, type enum, tags str[]|null, priority enum|null, status enum, recorded_at str de fecha-hora ISO 8601|null, created_at str de fecha-hora ISO 8601
get_note	campos de nota (id, title, summary, transcript str|null, type, tags, priority, status, metadata obj|null, created_at) + matrices tasks[] + events[] con campos de subconjunto
get_notes_full	matriz de notas con tasks[] y events[] incrustados (mismo subconjunto que 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 str de fecha-hora ISO 8601|null, completed_at str de fecha-hora ISO 8601|null, completed_by str|null, source str|null, created_at str de fecha-hora ISO 8601
get_events	id UUID, title str, description str|null, status enum, start_at str de fecha-hora ISO 8601 (no nulo), end_at str de fecha-hora ISO 8601 (no nulo), location str|null, is_all_day bool|null, tags str[]|null, created_at str de fecha-hora ISO 8601. Nota: attendees, reminder_minutes, recurrence_rule son escribibles mediante create_event/update_event pero NO los devuelve 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 str de fecha-hora ISO 8601
get_tags	tag str, usage_count int, is_pinned bool, is_manual bool
search	{notes: [...], tasks: [...], events: [...]} — cada elemento es {id UUID, type "note"/"task"/"event", title str, detail str|null, created_at ISO 8601 datetime str}. Las tres matrices siempre presentes, posiblemente vacías.
Herramientas de escritura	mínimas: {id UUID, title str, status enum} (más type en notas). No esperes registros completos — llama a la herramienta get_* correspondiente si necesitas más campos.
Herramientas de eliminación	{id UUID, deleted: true}
process_note	{audio_id UUID, status "processing", mode "audio+stt"/"text-only", message str} — asíncrono; el resultado final llega vía WebSocket note_ready o una llamada posterior a get_notes.
Cualquier herramienta en error	{error: "message"} — siempre verifica si la clave error es nula antes de tratar la respuesta como un registro.

Formatos de parámetros de entrada

• note_id, task_id, event_id, parent_*_id — cadenas UUID
• date_from, date_to, deadline — cadenas YYYY-MM-DD (cadena vacía significa "sin filtro")
• start_at, end_at, reminder_at — cadenas de fecha-hora ISO 8601, p. ej. "2026-04-15T09:00:00Z" o "2026-04-15T09:00:00+00:00"
• tags — cadena separada por comas en la entrada (p. ej. "work,urgent"); almacenada/devuelta como string[]
• reminder_minutes, attendees — cadenas separadas por comas en la entrada; almacenadas/devueltas como matrices
• is_all_day — booleano en create_event; cadena "true"/"false" en update_event
• recurrence_rule — cadena RRULE, p. ej. "FREQ=WEEKLY;BYDAY=MO,WE,FR"

Ejemplo de análisis (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, resumen, transcripción

Cada nota tiene tres campos de texto con roles diferentes y límites diferentes. Elegir el campo correcto importa — los clientes LLM (Claude Desktop, Cursor, etc.) deben dividir el contenido adecuadamente al usar create_note o update_note.

Campo	Rol	Límite	¿Incluido en los prompts LLM del informe?
title	Asunto de una línea mostrado en listas, vistas previas, push, asuntos de correo.	200 caracteres	✅ (como encabezado de lista)
summary	Teaser de 1 a 3 frases.	Límite máximo de 1000 caracteres — decisión de producto.	✅ Textualmente. Mantenlo conciso.
transcript	Cuerpo completo de la nota. Se muestra en la vista de detalle.	Según el plan (ver abajo)	❌ Nunca. Seguro para ser largo.

Límites de transcripción según el plan (subscription_plans.max_text_length):

Plan	Máx. caracteres de transcripción
Gratis	2 000
Básico	8 000
Pro	20 000
Ultra	50 000
Personalizado	100 000

Regla general para clientes LLM:

• Salida corta (notas, recordatorios, tareas pendientes): solo title + summary. Deja transcript vacío.
• Salida larga (notas de reunión, borradores, lluvias de ideas, volcados de investigación): pon un summary de 1 a 3 frases y el cuerpo completo en transcript. No empaques todo en el resumen — alcanzarás el error de 1000 caracteres.

Mensajes de error por desbordamiento:

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

Ejemplo de uso correcto (Claude Desktop captura una reunión):

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 qué dos límites diferentes?

• summary se incluye textualmente en los prompts LLM de informes diarios/semanales/mensuales. Si cada resumen pudiera tener 20 KB, los prompts de informes se dispararían en costo y latencia (y riesgo de desbordamiento del contexto para usuarios intensivos). Los 1000 caracteres se establecieron en abril de 2026 tras medir datos de producción (mediana 247, máximo 554).
• transcript nunca está en los prompts de informes — solo aparece en la vista de detalle de la interfaz. Las transcripciones grandes cuestan solo almacenamiento, no tokens LLM. Limitar por plan previene el abuso pero por lo demás permite ser generoso.

Compatibilidad hacia atrás: transcript es un parámetro opcional (por defecto ""). Los clientes antiguos que llaman a create_note(title, summary, tags, type) siguen funcionando sin cambios — la base de datos almacena transcript = NULL. No se necesita migración.

---

Herramientas (20)

Todas las herramientas incluyen anotaciones MCP — title, readOnlyHint, destructiveHint, idempotentHint, openWorldHint — para que los clientes MCP puedan mostrar la interfaz de confirmación adecuada. Cada herramienta se ejecuta solo contra la base de datos de Telldone (openWorldHint: false) — el servidor nunca se conecta a APIs externas.

Herramientas de lectura (9)

Herramienta	Descripción
get_profile	Devuelve el perfil del usuario autenticado, incluyendo nombre para mostrar, correo electrónico, idioma, zona horaria, plan de suscripción y estadísticas de uso (total de notas, tareas, eventos). Úsalo para verificar el estado de la cuenta o la cuota.
get_notes	Lista notas de voz con filtros opcionales: date_from/date_to (ISO 8601), tag (cadena), type (tarea/idea/info/estado/reunión/evento/reflexión), search (consulta de texto), limit (predeterminado 20, máximo 100), offset. Devuelve metadatos de la nota sin el cuerpo completo — usa get_note para los detalles.
get_note	Devuelve una sola nota por UUID note_id, incluyendo transcripción completa, resumen de IA y todas las tareas y eventos secundarios vinculados. Úsalo cuando necesites el contenido completo de la nota después de encontrarla mediante get_notes o search.
get_notes_full	Recuperación masiva de notas con elementos secundarios incrustados (tareas + eventos). Mismos filtros que get_notes. Úsalo en lugar de llamar a get_note en un bucle. Devuelve cargas más grandes — configura limit adecuadamente.
get_tasks	Lista tareas con filtros: status (pendiente/hecha/todas, predeterminado: pendiente), tag, priority (baja/media/alta), date_from/date_to para rango de fecha límite, limit, offset. Devuelve título, prioridad, fecha límite, recordatorio, etiquetas y estado de finalización.
get_events	Lista eventos de calendario con filtros de rango date_from/date_to, status (confirmado/provisional/cancelado), limit, offset. Devuelve título del evento, horas de inicio/fin, ubicación, asistentes y recordatorios.
get_reports	Devuelve informes de productividad generados por IA. Filtra por period (diario/semanal/mensual/anual) y date_from/date_to. Los informes resumen tareas completadas, patrones y perspectivas de productividad.
get_tags	Devuelve todas las etiquetas definidas por el usuario ordenadas por frecuencia de uso (las más usadas primero). Sin parámetros. Úsalo para descubrir etiquetas disponibles antes de filtrar notas o tareas.
search	Búsqueda híbrida de texto + semántica en notas, tareas y eventos. Parámetro: query (cadena). Combina coincidencia de palabras clave con similitud vectorial para obtener resultados relevantes incluso con redacción diferente. Devuelve tipos de resultados mixtos con puntuaciones de relevancia.

Herramientas de escritura (11)

Herramienta	Descripción
process_note	Ejecuta el pipeline completo de análisis de IA en entrada de texto o audio — idéntico a grabar una nota de voz en la aplicación móvil. Acepta text (cadena) o audio_base64 + audio_format (m4a/wav/mp3). La IA extrae nota estructurada + tareas + eventos + etiquetas. Devuelve inmediatamente con audio_id; los resultados llegan de forma asíncrona. Consulta con get_notes() para recuperar la salida procesada.
create_note	Crea una nota de texto plano sin análisis de IA. Parámetros: title (obligatorio, máximo 200), summary (máximo 1000 caracteres, avance conciso — incluido en los prompts de LLM de informes), transcript (límite basado en plan, cuerpo de formato largo — NO en prompts de informes), type (tarea/idea/info/estado/reunión/evento/reflexión), tags (separadas por comas, máximo 20). Consulta la sección Campos de Nota para saber dónde colocar texto largo.
create_task	Crea una tarea con title (obligatorio), description, priority (baja/media/alta, predeterminado: media), deadline (fecha ISO 8601), reminder_at (fecha y hora ISO 8601), tags (separadas por comas). La tarea se crea con estado "pendiente". Se sincroniza con la aplicación móvil en tiempo real.
create_event	Crea un evento de calendario con title (obligatorio), start_at/end_at (fecha y hora ISO 8601), location, attendees (separadas por comas), reminder_minutes (entero), recurrence (cadena rrule), status (confirmado/provisional).
update_note	Actualiza campos de nota por note_id (UUID, obligatorio). Opcional: title, summary (máximo 1000), transcript (límite basado en plan, cuerpo de formato largo), type, tags, priority, status. Solo se cambian los campos proporcionados; los campos omitidos permanecen sin cambios. Pasa " " (espacio simple) para summary o transcript para borrar el campo.
update_task	Actualiza campos de tarea por task_id (UUID, obligatorio). Opcional: title, description, priority, deadline, reminder_at, tags, status (pendiente/hecha). Usa complete_task como atajo para marcar como hecha.
update_event	Actualiza campos de evento por event_id (UUID, obligatorio). Opcional: title, start_at, end_at, location, attendees, status (confirmado/provisional/cancelado), reminder_minutes.
complete_task	Marca una tarea como hecha por task_id (UUID). Atajo para update_task con status: "done". Registra la marca de tiempo de finalización y la fuente ("mcp").
delete_note	Elimina suavemente una nota por note_id (UUID). Se propaga a todas las tareas y eventos secundarios vinculados — también se eliminan suavemente. Reversible desde la aplicación web.
delete_task	Elimina suavemente una tarea por task_id (UUID). No afecta a la nota principal. Reversible desde la aplicación web.
delete_event	Elimina suavemente un evento por event_id (UUID). No afecta a la nota principal. Reversible desde la aplicación web.

Todas las herramientas de escritura se sincronizan en tiempo real con los clientes móviles y web conectados mediante WebSocket.

Pipeline completo: process_note

La herramienta process_note ejecuta el mismo pipeline que grabar en la aplicación móvil:

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

Modo texto (omitir STT):

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

Modo audio (codificado en base64):

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

Devuelve inmediatamente con audio_id. Los resultados llegan mediante WebSocket o consulta con get_notes().

Ejemplos

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

Planes y acceso

Plan	Acceso MCP	Lectura	Escritura	Precio
Gratis	--	--	--	$0
Básico	--	--	--	$4.99/mes
Pro	Lectura y escritura	9 herramientas	11 herramientas	$11.99/mes
Ultra	Lectura y escritura	9 herramientas	11 herramientas	$24.99/mes

Pro y Ultra tienen las mismas herramientas MCP. Ultra tiene cuotas más altas (notas ilimitadas, 1500 min STT/mes, 300 subidas/día).

Autenticación

TellDone admite dos formas de conectarse — elige una.

OAuth 2.1 (recomendado)

Inicio de sesión en navegador con un clic, nada que copiar o almacenar. Cumple con estándares: OAuth 2.1 con PKCE (S256), descubrimiento de servidor de autorización + recurso protegido (RFC 8414 / RFC 9728), tokens de acceso vinculados a audiencia (RFC 8707), tokens de actualización rotativos y Documentos de Metadatos de ID de Cliente (para que Claude Desktop / claude.ai se conecten sin registro manual). El acceso está delimitado — apruebas exactamente lo que la aplicación puede hacer en la pantalla de consentimiento, y solo lectura vs lectura y escritura sigue tu plan. Revoca en cualquier momento en Configuración → Agentes de IA o deshabilitando MCP.

• URL del conector: https://api.telldone.app/mcp/user
• Descubrimiento: https://api.telldone.app/.well-known/oauth-protected-resource
• Ámbitos: 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 sin OAuth. Genera un token de larga duración en la aplicación web — Configuración → Agentes de IA (MCP) → Habilitar — y envíalo como Authorization: Bearer <token>.

• URL del endpoint: https://api.telldone.app/mcp/user/mcp
• Regenerar: Configuración → Agentes de IA → Regenerar (el token anterior se revoca instantáneamente)
• Deshabilitar: Configuración → Agentes de IA → Deshabilitar (el token se elimina)

Límite de velocidad (ambos): 5 solicitudes/segundo.

Transporte

MCP Streamable HTTP (sin estado). Cada solicitud es independiente.

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

Enlaces

• Aplicación: app.telldone.app
• Sitio web: telldone.app
• Documentación: docs.telldone.app
• Aplicación iOS: App Store