Zum Inhalt springen
LinkdashLinkdash
Deutsch
Esc
↑↓navigieren↵öffnen⌘Jvorschau
Auf dieser Seite

MCP

Remote-MCP unter https://api.linkdash.dev/mcp. Melde dich per OAuth aus Claude, ChatGPT, Cursor und Codex an oder nutze einen API-Schlüssel.

Remote-MCP unter https://api.linkdash.dev/mcp. Füge die URL in deinem Client hinzu und melde dich mit deinem Linkdash-Konto an. Für Agents, bei denen niemand am Browser sitzt, verwendest du stattdessen einen API-Schlüssel. Als reines Markdown: mcp.md.

Verbinden

Gib dem Client nur die URL https://api.linkdash.dev/mcp. Er öffnet eine Linkdash-Anmeldung und danach einen Zustimmungsbildschirm, der die App und die Website nennt, zu der sie zurückkehrt. Erlaube den Zugriff, dann erhält der Client ein Token für dein Konto.

  • claude.ai und Claude Desktop: Öffne Linkdash im Connector-Verzeichnis (oder Customize → Connectors und suche nach Linkdash) und klicke auf Connect.
  • ChatGPT: Ein Eintrag im ChatGPT-Plugin-Verzeichnis kommt bald. Bis dahin wählst du unter Plugins + → Add custom MCP server, gibst die URL oben ein und wählst OAuth.
  • Claude Code: claude mcp add --transport http linkdash https://api.linkdash.dev/mcp, danach claude mcp login linkdash (oder /mcp in einer Sitzung).
  • Cursor: Add to Cursor installiert den Server mit einem Klick; melde dich dann an, wenn Cursor danach fragt. Alternativ fügst du den Server in mcp.json mit "url" und ohne headers hinzu.
  • Codex: codex mcp add linkdash --url https://api.linkdash.dev/mcp, danach codex mcp login linkdash.

Die App erhält denselben Zugriff wie ein API-Schlüssel. Verbundene Apps findest du unter Dashboard → API-Keys, wo du sie mit Trennen sofort widerrufen kannst.

Automatisierung und Headless-Agents

Für die Anmeldung muss jemand am Browser sitzen. Für CI-Jobs, geplante Agents, Server und Code, der MCP direkt aufruft, sendest du stattdessen einen API-Schlüssel: Authorization: Bearer ldash_..., dieselben Schlüssel wie für die HTTP-API.

Cursor (~/.cursor/mcp.json oder .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" (in JSON brauchst du "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"

Lokal: Convex-.site-URL + /mcp.

Dateien

Sende keine Bytes über MCP-JSON. Erzeuge eine URL ({uploadUrl,storageId}), lade die Datei per PUT vom Host hoch und erstelle dann den Link:

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

MCP-Tools: files_upload_url gibt {uploadUrl,storageId} zurück → der Host lädt per PUT nach uploadUrl hoch → links_create mit dieser storageId. Optionale Vorschaukarte: previewName, previewDescription, previewImageStorageId (gleicher Upload-Ablauf). Mit dem optionalen maxOpenings wird der Link nach so vielen Aufrufen pausiert; links_update kann den Wert erhöhen oder clearMaxOpenings übergeben. Gib uploadUrl nicht an den Nutzer aus.

Tools

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 (ohne id) GET /shares links_shares (ohne 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 oder editor)
links_unlock { id, variant?, password?, variantPassword? } → das Ziel; entsperrt eine passwortgeschützte Variante für einen Editor für 30 Minuten
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
(Host-PUT nach dem Erzeugen der 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_*

Ordner

Ein Ordner ist ein Link, der die Elemente auflistet, die du hineinlegst. Das Modell dahinter findest du unter Ordner.

Tool Eingabe
links_create { kind: "folder", name, … } erstellt einen Ordner; jeder Create-Aufruf akzeptiert folder (Slug) und folderDomain?, um das Element in einem Ordner zu erstellen. Die Antwort enthält folder
links_list Eine Seite, { items, cursor } (limit 1–100, Standard 50; gib cursor so lange zurück, bis er null ist). q sucht nach Wörtern; folder: "<slug>" listet, was direkt darin liegt; folder: "root" listet die oberste Ebene; kind kennt zusätzlich folder. Zeilen enthalten folder, Ordnerzeilen zusätzlich items
links_move { id, domain?, folder: string | null, folderDomain? } → { id, folder }
links_copy { id, domain? } → { id, url, access, kind, folder } (gleicher Zugriff, neue Freigabe-URL, keine Personen)
links_delete contents?: "keep" | "delete" für Ordner (Standard keep)

links_export / links_import ergänzen die Spalten folder und access, und Zeilen mit kind folder erstellen Ordner.

Zugriff und Freigabe

Neue Links und Ordner sind eingeschränkt: url ist https://linkdash.dev/s/<token>, und nur du und die Personen, mit denen du teilst, können sie öffnen. Übergib access bei links_create oder links_update: restricted (Standard), link (alle mit der Freigabe-URL) oder public (alle, über die Kurz-URL). Fordere access: "public" an, wenn der Link öffentlich gepostet wird. Siehe Freigabe und Zugriff.

Tool Eingabe
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? } → eine Seite mit allem, was du geteilt hast, { items, cursor }, jeweils mit people
links_shared { limit?, cursor? } → eine Seite mit Elementen, die andere mit dir geteilt haben, { items, cursor }, jeweils mit der url zum Öffnen
links_leave { id } (die _id oder Freigabe-URL aus links_shared) → { _id, left: true }
links_update access? ändert, wer den Link öffnen kann; resetShareLink: true stellt eine neue Freigabe-URL aus (die alte funktioniert dann nicht mehr)

Jede url in einer Antwort ist die Freigabe-URL, außer der Link ist öffentlich – dann ist es die Kurz-URL. Teilen, Freigabe entfernen, Zugriffsänderungen und Zurücksetzen zählen jeweils als ein Ereignis; Verlassen nicht.

Varianten

Jeder Link ist ein Container für eine oder mehrere Varianten: Inhalt (url | file | text) plus eigene Sperre (password, starts, expires, maxOpenings, pausiert), ein weight und optionale Besucherbedingungen when. Ohne variants hat ein Link eine Variante namens main. Die Sperre des Links hat Vorrang vor den Sperren der Varianten. Ein Besucher bekommt genau eine Variante: Varianten, deren when zutrifft, bilden den Pool (sonst die bedingungslosen), danach wird gewichtet ausgewählt; sticky (Standard true) hält wiederkehrende Besucher auf derselben Variante, und restartSplit mischt neu. Der kind des Links ist group bei mehreren Varianten; der status des Links ist mixed, wenn sich die Varianten unterscheiden. Maximal 20 Varianten pro Link. Datenstrukturen: HTTP-API.

links_create akzeptiert variants: [{ name, url | text | storageId (+ fileName, fileType, fileSize), password?, starts?, expires?, maxOpenings?, utm?, weight?, when? }] statt der Kurzform, dazu sticky und forwardParams. links_update akzeptiert sticky, forwardParams und restartSplit. links_list filtert nach kind (zusätzlich group) und status (zusätzlich mixed). links_stats liefert Summen pro Variante unter variants. links_export / links_import verwenden das Varianten-CSV (eine Zeile pro Variante).

Tool Eingabe
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? }

Schlüssel für when: countries, devices, os, browsers, languages, referrerHosts (Arrays aus Strings; jeder gesetzte Schlüssel muss zutreffen), dazu params.

Regeln für Query-Parameter. when.params ist ein Array mit bis zu 10 Regeln für den Query-String des Besuchers, und jede Regel muss erfüllt sein: { "params": [{ "key": "src", "op": "equals", "value": "newsletter" }] }. op: equals | notEquals | includes | startsWith | endsWith | in (value ist eine durch | getrennte Liste) | exists | missing (bei den letzten beiden ohne value). Schlüssel unterscheiden Groß- und Kleinschreibung, Werte werden exakt verglichen. Parameterwerte werden nie in den Analysedaten gespeichert.

Query-Parameter weiterleiten. forwardParams (Boolean bei links_create / links_update, Standard false) hängt den gesamten Query-String des Besuchers an URL-Varianten an; Werte des Besuchers überschreiben gespeicherte Werte, auch utm. Nur für URL-Varianten. Dient dem Routing, nicht der Zugriffskontrolle.

auth create / auth login / auth logout sind keine MCP-Tools. Zuordnung: api.md.

War diese Seite hilfreich?