---
title: MCP
description: >-
  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.
sidebar:
  label: MCP
  order: 5
---
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](#automation-and-headless-agents). Markdown sin formato: [mcp.md](https://linkdash.dev/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](https://claude.ai/directory/linkdash) (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](https://chatgpt.com/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](https://cursor.com/install-mcp?name=linkdash&config=eyJ1cmwiOiJodHRwczovL2FwaS5saW5rZGFzaC5kZXYvbWNwIn0%3D) 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](https://linkdash.dev/dashboard/keys), 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](https://linkdash.dev/dashboard/keys): `Authorization: Bearer ldash_...`. Son las mismas claves que usa la [API HTTP](/es/api).

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

```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:

```bash
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](/es/folders) 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](/es/sharing).

| 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](/es/api#variantes).

`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](https://linkdash.dev/api.md).
