Saltar al contenido
LinkdashLinkdash
Español
Esc
↑↓navegar↵abrir⌘Jvista previa
En esta página

MCP

MCP remoto en https://api.linkdash.dev/mcp. Inicia sesión con OAuth desde Claude, ChatGPT, Cursor y Codex, o usa una clave de API.

MCP remoto en https://api.linkdash.dev/mcp. Agrega la URL a tu cliente e inicia sesión con tu cuenta de Linkdash. Para agentes que se ejecutan sin una persona frente a un navegador, usa una clave de API. Markdown sin formato: mcp.md.

Conectar

Dale al cliente solo la URL https://api.linkdash.dev/mcp. El cliente abre el inicio de sesión de Linkdash y luego una pantalla de consentimiento con el nombre de la app y el sitio al que regresa. Si das permiso, el cliente recibe un token para tu cuenta.

  • claude.ai y Claude Desktop: abre Linkdash en el directorio de conectores (o ve a Customize → Connectors y busca Linkdash) y haz clic en Connect.
  • ChatGPT: pronto habrá una ficha en el directorio de plugins de ChatGPT. Mientras tanto, en Plugins, elige + → Add custom MCP server, ingresa la URL de arriba y elige OAuth.
  • Claude Code: claude mcp add --transport http linkdash https://api.linkdash.dev/mcp, luego claude mcp login linkdash (o /mcp en una sesión).
  • Cursor: Add to Cursor lo instala con un clic. Después, inicia sesión cuando Cursor te lo pida. También puedes agregar el servidor a mcp.json con "url" y sin headers.
  • Codex: codex mcp add linkdash --url https://api.linkdash.dev/mcp, luego codex mcp login linkdash.

La app obtiene el mismo acceso que una clave de API. Las apps conectadas aparecen en Panel → Claves de API, donde Desconectar les revoca el acceso de inmediato.

Automatización y agentes sin interfaz

Para iniciar sesión se necesita una persona frente a un navegador. Para trabajos de CI, agentes programados, servidores y código que llama a MCP directamente, envía una clave de API: Authorization: Bearer ldash_.... Son las mismas claves que usa la API HTTP.

Cursor (~/.cursor/mcp.json o .cursor/mcp.json):

{
  "mcpServers": {
    "linkdash": {
      "url": "https://api.linkdash.dev/mcp",
      "headers": { "Authorization": "Bearer ${env:LINKDASH_API_KEY}" }
    }
  }
}

Claude Code: claude mcp add --transport http linkdash https://api.linkdash.dev/mcp --header "Authorization: Bearer $LINKDASH_API_KEY" (en JSON se necesita "type": "http").

Codex: codex mcp add linkdash --url https://api.linkdash.dev/mcp --bearer-token-env-var LINKDASH_API_KEY

OpenCode: opencode mcp add linkdash --url https://api.linkdash.dev/mcp --header Authorization="Bearer $LINKDASH_API_KEY"

Local: URL .site de Convex + /mcp.

Archivos

No envíes bytes dentro del JSON de MCP. Genera una URL ({uploadUrl,storageId}), sube el archivo con PUT desde el host y luego crea el enlace:

curl https://api.linkdash.dev/v1/uploads \
  -H "Authorization: Bearer ldash_..." \
  -H "Content-Type: application/json" \
  -d '{"fileSize":12345}'

curl -X PUT -H "Content-Type: video/mp4" --data-binary @clip.mp4 "$uploadUrl"

curl https://api.linkdash.dev/v1/links \
  -H "Authorization: Bearer ldash_..." \
  -H "Content-Type: application/json" \
  -d '{"storageId":"…","fileName":"clip.mp4","fileType":"video/mp4","fileSize":12345}'

Herramientas MCP: files_upload_url devuelve {uploadUrl,storageId} → el host hace PUT a uploadUrl → links_create con ese storageId. Tarjeta de vista previa opcional: previewName, previewDescription, previewImageStorageId (con la misma subida). Con el parámetro opcional maxOpenings, el enlace se pausa después de esa cantidad de aperturas. links_update puede aumentar el límite o enviar clearMaxOpenings. No le muestres uploadUrl al usuario.

Herramientas

CLI HTTP MCP
auth whoami GET /me whoami
links list GET /links (?q=&tag=&kind=&status=&folder=&limit=&cursor=) links_list
links get <id> GET /links/:id (?domain=) links_get
links create --url/--file/--text/--folder POST /links links_create
links update <id> PATCH /links/:id links_update
links move <id> POST /links/:id/move links_move
links copy <id> POST /links/:id/copy links_copy
links delete <id> DELETE /links/:id (?contents=keep|delete) links_delete
links share <id> --email <e> POST /links/:id/shares links_share
links unshare <id> --email <e> DELETE /links/:id/shares/:email links_unshare
links shares <id> GET /links/:id/shares links_shares
links shares (sin id) GET /shares links_shares (sin id)
links shared GET /shared links_shared
links leave <_id | share URL> DELETE /shared/:id links_leave
links_share_role { id, email, role } → { id, email, role } (viewer o editor)
links_unlock { id, variant?, password?, variantPassword? } → el destino; desbloquea una variante protegida con contraseña para un editor durante 30 minutos
links_activity { id, limit?, cursor? } → { items: [{ action, detail?, actor, _creationTime }], cursor }
links role <id> --email <e> --role viewer|editor PATCH /links/:id/shares/:email links_share_role
links unlock <_id | share URL> POST /links/:id/unlock links_unlock
links activity <id> GET /links/:id/activity links_activity
links reset-link <id> POST /links/:id/reset-link links_update (resetShareLink: true)
links stats --last 24h GET /links/:id/stats?last=24h links_stats
links export GET /links/export links_export
links import POST /links/import links_import
links variants list <id> GET /links/:id/variants variants_list
links variants add <id> POST /links/:id/variants variants_add
links variants update <id> <name> PATCH /links/:id/variants/:name variants_update
links variants remove <id> <name> DELETE /links/:id/variants/:name variants_remove
(el host hace PUT después de generar la URL) POST /uploads files_upload_url
DELETE /uploads/:storageId files_discard
webhooks list/create/get/rotate/delete GET/POST /webhooks, GET/DELETE /webhooks/:id, POST /webhooks/:id/rotate webhooks_*
domains list/add/connect/verify/remove GET/POST /domains, GET /domains/:host/connect, POST /domains/:host/verify, DELETE /domains/:host domains_*

Carpetas

Una carpeta es un enlace que muestra los elementos que pones dentro. Consulta Carpetas para ver cómo funciona el modelo.

Herramienta Entrada
links_create { kind: "folder", name, … } crea una carpeta. Cualquier creación acepta folder (slug) y folderDomain? para crear el elemento dentro de una carpeta. La respuesta incluye folder
links_list Una página, { items, cursor } (limit de 1 a 100, 50 por defecto; vuelve a enviar cursor hasta que sea null). q busca coincidencias de palabras; folder: "<slug>" lista lo que está directamente dentro; folder: "root" lista el nivel superior; kind acepta también folder. Las filas incluyen folder, y las filas de carpetas incluyen items
links_move { id, domain?, folder: string | null, folderDomain? } → { id, folder }
links_copy { id, domain? } → { id, url, access, kind, folder } (mismo acceso, nueva URL para compartir, sin personas)
links_delete contents?: "keep" | "delete" para carpetas (keep por defecto)

links_export / links_import agregan las columnas folder y access, y las filas con kind folder crean carpetas.

Acceso y uso compartido

Los enlaces y carpetas nuevos son restringidos: url es https://linkdash.dev/s/<token>, que solo pueden abrir tú y las personas con quienes lo compartes. Envía access en links_create o links_update: restricted (por defecto), link (cualquiera con la URL para compartir) o public (cualquiera, en la URL corta). Pide access: "public" cuando el enlace se vaya a publicar. Consulta Uso compartido y acceso.

Herramienta Entrada
links_share { id, domain?, emails: string[] (1–50), role? } → { id, url, access, invited, alreadyShared }
links_unshare { id, domain?, email } → { id, email, removed: true }
links_shares { id, domain? } → { id, access, url, people: [{ email, role, accepted, invitedAt, viaFolder? }] }; { limit?, cursor? } → una página con todo lo que compartiste, { items, cursor }, cada elemento con people
links_shared { limit?, cursor? } → una página de elementos que otras personas compartieron contigo, { items, cursor }, con la url para abrir cada uno
links_leave { id } (el _id o la URL para compartir de links_shared) → { _id, left: true }
links_update access? cambia quién puede abrirlo; resetShareLink: true genera una nueva URL para compartir (la anterior deja de funcionar)

En todas las respuestas, url es la URL para compartir, salvo que el enlace sea público, en cuyo caso es la URL corta. Compartir, dejar de compartir, cambiar el acceso y restablecer el enlace cuentan como un evento cada uno; salir de un elemento compartido no cuenta.

Variantes

Cada enlace es un contenedor de una o más variantes: contenido (url | file | text) más su propio control de acceso (password, starts, expires, maxOpenings, pausado), un weight y condiciones opcionales de visitante when. Sin variants, un enlace tiene una sola variante llamada main. El control de acceso del enlace tiene prioridad sobre el de las variantes. Cada visitante recibe una variante: las variantes cuyo when coincide forman el grupo de candidatas (si no hay ninguna, se usan las incondicionales) y luego se elige una por peso. sticky (true por defecto) mantiene a un visitante que regresa en la misma variante, y restartSplit vuelve a repartir. El kind del enlace es group cuando tiene varias variantes; el status del enlace es mixed cuando las variantes difieren. Máximo 20 variantes por enlace. Estructuras: API HTTP.

links_create acepta variants: [{ name, url | text | storageId (+ fileName, fileType, fileSize), password?, starts?, expires?, maxOpenings?, utm?, weight?, when? }] en lugar de la forma abreviada, además de sticky y forwardParams. links_update acepta sticky, forwardParams y restartSplit. links_list filtra por kind (incluye también group) y por status (incluye también mixed). links_stats devuelve los totales de variants. links_export / links_import usan el CSV de variantes (una fila por variante).

Herramienta Entrada
variants_list { id, domain? }
variants_add { id, domain?, name, url | text | storageId (+ fileName, fileType, fileSize), password?, starts?, expires?, maxOpenings?, utm?, weight?, when? }
variants_update { id, name, domain?, newName?, url?, text?, storageId?, password?, clearPassword?, starts?, clearStarts?, expires?, clearExpires?, maxOpenings?, clearMaxOpenings?, status?, weight?, when?, clearWhen?, utm? }
variants_remove { id, name, domain? }

Claves de when: countries, devices, os, browsers, languages, referrerHosts (arreglos de strings; cada clave definida debe coincidir), además de params.

Reglas de parámetros de consulta. when.params es un arreglo de hasta 10 reglas sobre el query string del visitante, y todas deben cumplirse: { "params": [{ "key": "src", "op": "equals", "value": "newsletter" }] }. op: equals | notEquals | includes | startsWith | endsWith | in (value es una lista separada por |) | exists | missing (las dos últimas no llevan value). Las claves distinguen mayúsculas de minúsculas y los valores se comparan de forma exacta. Los valores de los parámetros nunca se guardan en las analíticas.

Reenvío de parámetros de consulta. forwardParams (booleano en links_create / links_update, false por defecto) agrega todo el query string del visitante a las variantes de tipo URL; los valores del visitante reemplazan a los guardados, incluido utm. Solo aplica a variantes de tipo URL. Sirve para enrutar, no para controlar el acceso.

auth create / auth login / auth logout no son herramientas MCP. Equivalencias: api.md.

¿Te ha resultado útil esta página?