---
title: MCP
description: >-
  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.
sidebar:
  label: MCP
  order: 5
---
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](#automation-and-headless-agents). Als reines Markdown: [mcp.md](https://linkdash.dev/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](https://claude.ai/directory/linkdash) (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](https://chatgpt.com/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](https://cursor.com/install-mcp?name=linkdash&config=eyJ1cmwiOiJodHRwczovL2FwaS5saW5rZGFzaC5kZXYvbWNwIn0%3D) 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](https://linkdash.dev/dashboard/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](https://linkdash.dev/dashboard/keys): `Authorization: Bearer ldash_...`, dieselben Schlüssel wie für die [HTTP-API](/de/api).

**Cursor** (`~/.cursor/mcp.json` oder `.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"` (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:

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

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](/de/folders).

| 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](/de/sharing).

| 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](/de/api#varianten).

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