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, danachclaude mcp login linkdash(oder/mcpin 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.jsonmit"url"und ohneheadershinzu. - Codex:
codex mcp add linkdash --url https://api.linkdash.dev/mcp, danachcodex 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.

