Sari la conținut
LinkdashLinkdash
Română
Esc
↑↓navighează↵deschide⌘Jprevizualizează
Pe această pagină

MCP

MCP remote la https://api.linkdash.dev/mcp. Autentifică-te cu OAuth din Claude, ChatGPT, Cursor și Codex sau folosește o cheie API.

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. Markdown simplu: 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 (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, 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 î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, 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: Authorization: Bearer ldash_..., aceleași chei ca la API-ul HTTP.

Cursor (~/.cursor/mcp.json sau .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" (î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:

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 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.

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.

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.

Ți-a fost utilă această pagină?