---
title: MCP
description: >-
  MCP remote la https://api.linkdash.dev/mcp. Autentifică-te cu OAuth din
  Claude, ChatGPT, Cursor și Codex sau folosește o cheie API.
sidebar:
  label: MCP
  order: 5
---
MCP remote la `https://api.linkdash.dev/mcp`. Adaugă URL-ul în clientul tău și autentifică-te cu contul tău Linkdash. Pentru agenții care rulează fără o persoană la browser, folosește în schimb o [cheie API](#automation-and-headless-agents). Markdown simplu: [mcp.md](https://linkdash.dev/mcp.md).

## Conectare

Dă clientului doar URL-ul `https://api.linkdash.dev/mcp`. Clientul deschide o pagină de autentificare Linkdash, apoi un ecran de consimțământ care afișează numele aplicației și site-ul la care te întoarce. Permite accesul, iar clientul primește un token pentru contul tău.

- **claude.ai și Claude Desktop:** deschide [Linkdash în directorul de conectori](https://claude.ai/directory/linkdash) (sau Customize → Connectors și caută Linkdash) și dă clic pe **Connect**.
- **ChatGPT:** o listare în directorul de pluginuri ChatGPT va apărea în curând. Până atunci, în [Plugins](https://chatgpt.com/plugins), alege **+** → **Add custom MCP server**, introdu URL-ul de mai sus și alege OAuth.
- **Claude Code:** `claude mcp add --transport http linkdash https://api.linkdash.dev/mcp`, apoi `claude mcp login linkdash` (sau `/mcp` într-o sesiune).
- **Cursor:** [Adaugă în Cursor](https://cursor.com/install-mcp?name=linkdash&config=eyJ1cmwiOiJodHRwczovL2FwaS5saW5rZGFzaC5kZXYvbWNwIn0%3D) îl instalează dintr-un clic, apoi autentifică-te când îți cere Cursor. Sau adaugă serverul în `mcp.json` cu `"url"` și fără `headers`.
- **Codex:** `codex mcp add linkdash --url https://api.linkdash.dev/mcp`, apoi `codex mcp login linkdash`.

Aplicația primește același acces ca o cheie API. Aplicațiile conectate sunt listate în [Panou → Chei API](https://linkdash.dev/dashboard/keys), unde **Deconectează** le revocă imediat.

## Automatizare și agenți headless

Autentificarea necesită o persoană la browser. Pentru joburi CI, agenți programați, servere și cod care apelează MCP direct, trimite în schimb o [cheie API](https://linkdash.dev/dashboard/keys): `Authorization: Bearer ldash_...`, aceleași chei ca la [API-ul HTTP](/ro/api).

**Cursor** (`~/.cursor/mcp.json` sau `.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"` (în JSON ai nevoie de `"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-ul `.site` din Convex + `/mcp`.

## Fișiere

Nu trimite octeți prin JSON-ul MCP. Generează un URL (`{uploadUrl,storageId}`), trimite fișierul cu PUT de pe host, apoi creează linkul:

```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}'
```

Unelte MCP: `files_upload_url` returnează `{uploadUrl,storageId}` → hostul face PUT la `uploadUrl` → `links_create` cu acel `storageId`. Card de previzualizare opțional: `previewName`, `previewDescription`, `previewImageStorageId` (încărcat la fel). Cu `maxOpenings` opțional, linkul intră în pauză după numărul respectiv de deschideri; `links_update` poate crește valoarea sau poate trimite `clearMaxOpenings`. Nu-i afișa utilizatorului `uploadUrl`.

## Unelte

| 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` (fără id) | `GET /shares` | `links_shares` (fără `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 sau editor) |
| `links_unlock` | `{ id, variant?, password?, variantPassword? }` → ținta; deblochează pentru un editor o variantă protejată cu parolă, timp de 30 de minute |
| `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` |
| (PUT de pe host după generarea URL-ului) | `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_*` |

## Foldere

Un folder este un link care listează elementele pe care le pui în el. Vezi [Foldere](/ro/folders) pentru cum funcționează.

| Unealtă | Intrare |
| --- | --- |
| `links_create` | `{ kind: "folder", name, … }` creează un folder; orice creare acceptă `folder` (slug) și `folderDomain?` ca să creeze elementul într-un folder. Răspunsul include `folder` |
| `links_list` | O pagină, `{ items, cursor }` (`limit` 1-100, implicit 50; trimite înapoi `cursor` până devine `null`). `q` caută după cuvinte; `folder: "<slug>"` listează ce se află direct în folder; `folder: "root"` listează nivelul de sus; `kind` acceptă și `folder`. Rândurile conțin `folder`, iar rândurile de tip folder conțin `items` |
| `links_move` | `{ id, domain?, folder: string \| null, folderDomain? }` → `{ id, folder }` |
| `links_copy` | `{ id, domain? }` → `{ id, url, access, kind, folder }` (același acces, URL de partajare nou, fără persoane) |
| `links_delete` | `contents?: "keep" \| "delete"` pentru foldere (implicit `keep`) |

`links_export` / `links_import` adaugă coloanele `folder` și `access`, iar rândurile cu `kind` `folder` creează foldere.

## Acces și partajare

Linkurile și folderele noi sunt restricționate: `url` este `https://linkdash.dev/s/<token>`, pe care îl pot deschide doar tu și persoanele cu care îl partajezi. Trimite `access` la `links_create` sau `links_update`: `restricted` (implicit), `link` (oricine are URL-ul de partajare) sau `public` (oricine, la URL-ul scurt). Cere `access: "public"` când linkul va fi postat public. Vezi [Partajare și acces](/ro/sharing).

| Unealtă | Intrare |
| --- | --- |
| `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? }` → o pagină cu tot ce ai partajat, `{ items, cursor }`, fiecare cu `people` |
| `links_shared` | `{ limit?, cursor? }` → o pagină cu elementele pe care alții le-au partajat cu tine, `{ items, cursor }`, cu `url`-ul pentru deschiderea fiecăruia |
| `links_leave` | `{ id }` (`_id`-ul sau URL-ul de partajare din `links_shared`) → `{ _id, left: true }` |
| `links_update` | `access?` schimbă cine îl poate deschide; `resetShareLink: true` emite un URL de partajare nou (cel vechi nu mai funcționează) |

Fiecare `url` din răspuns este URL-ul de partajare. Excepție fac linkurile publice, pentru care e URL-ul scurt. Partajarea, anularea partajării, schimbările de acces și resetările contează fiecare ca un eveniment; părăsirea unei partajări nu se contează.

## Variante

Fiecare link este un container cu una sau mai multe **variante**: conținut (`url` | `file` | `text`) plus propriile restricții de acces (`password`, `starts`, `expires`, `maxOpenings`, pauză), un `weight` și condiții opționale pentru vizitatori, `when`. Fără `variants`, un link are o singură variantă, numită `main`. Restricțiile linkului au prioritate față de cele ale variantelor. Un vizitator primește o singură variantă: variantele al căror `when` se potrivește formează setul de candidați (altfel, cele fără condiții), iar din el se alege una ponderat. `sticky` (implicit `true`) îi păstrează aceeași variantă unui vizitator care revine, iar `restartSplit` refă distribuția. `kind` al linkului este `group` când are mai multe variante; `status` al linkului este `mixed` când variantele diferă. Maximum 20 de variante per link. Structuri: [API HTTP](/ro/api#variante).

`links_create` acceptă `variants: [{ name, url | text | storageId (+ fileName, fileType, fileSize), password?, starts?, expires?, maxOpenings?, utm?, weight?, when? }]` în locul formei prescurtate, plus `sticky` și `forwardParams`. `links_update` acceptă `sticky`, `forwardParams` și `restartSplit`. `links_list` filtrează după `kind` (acceptă și `group`) și `status` (acceptă și `mixed`). `links_stats` returnează totalurile pentru `variants`. `links_export` / `links_import` folosesc CSV-ul de variante (un rând per variantă).

| Unealtă | Intrare |
| --- | --- |
| `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? }` |

Cheile din `when`: `countries`, `devices`, `os`, `browsers`, `languages`, `referrerHosts` (array-uri de stringuri; fiecare cheie setată trebuie să se potrivească), plus `params`.

**Reguli pentru parametrii de query.** `when.params` este un array de până la 10 reguli aplicate query string-ului vizitatorului, iar toate regulile trebuie îndeplinite: `{ "params": [{ "key": "src", "op": "equals", "value": "newsletter" }] }`. `op`: `equals` | `notEquals` | `includes` | `startsWith` | `endsWith` | `in` (`value` este o listă separată prin `|`) | `exists` | `missing` (fără `value` pentru ultimele două). Cheile sunt case-sensitive, iar valorile se compară exact. Valorile parametrilor nu sunt stocate niciodată în analytics.

**Transmiterea parametrilor de query.** `forwardParams` (boolean pe `links_create` / `links_update`, implicit `false`) adaugă întregul query string al vizitatorului la variantele URL; valorile vizitatorului le suprascriu pe cele stocate, inclusiv `utm`. Funcționează doar pentru variantele URL. Ține de rutare, nu de controlul accesului.

`auth create` / `auth login` / `auth logout` nu sunt unelte MCP. Corespondențe: [api.md](https://linkdash.dev/api.md).
