---
title: MCP
description: >-
  Zdalny serwer MCP pod adresem https://api.linkdash.dev/mcp. Zaloguj się przez
  OAuth z Claude, ChatGPT, Cursora i Codexa albo użyj klucza API.
sidebar:
  label: MCP
  order: 5
---
Zdalny serwer MCP pod adresem `https://api.linkdash.dev/mcp`. Dodaj ten URL do swojego klienta i zaloguj się kontem Linkdash. Jeśli agent działa bez człowieka przy przeglądarce, użyj zamiast tego [klucza API](#automation-and-headless-agents). Czysty markdown: [mcp.md](https://linkdash.dev/mcp.md).

## Połączenie

Podaj klientowi tylko URL `https://api.linkdash.dev/mcp`. Klient otworzy logowanie do Linkdash, a potem ekran zgody z nazwą aplikacji i stroną, na którą wrócisz. Kiedy zezwolisz na dostęp, klient dostanie token do twojego konta.

- **claude.ai i Claude Desktop:** otwórz [Linkdash w katalogu konektorów](https://claude.ai/directory/linkdash) (albo Customize → Connectors i wyszukaj Linkdash) i kliknij **Connect**.
- **ChatGPT:** wpis w katalogu pluginów ChatGPT pojawi się wkrótce. Do tego czasu w [Plugins](https://chatgpt.com/plugins) wybierz **+** → **Add custom MCP server**, wpisz powyższy URL i wybierz OAuth.
- **Claude Code:** `claude mcp add --transport http linkdash https://api.linkdash.dev/mcp`, a potem `claude mcp login linkdash` (albo `/mcp` w sesji).
- **Cursor:** [Add to Cursor](https://cursor.com/install-mcp?name=linkdash&config=eyJ1cmwiOiJodHRwczovL2FwaS5saW5rZGFzaC5kZXYvbWNwIn0%3D) instaluje serwer jednym kliknięciem. Potem zaloguj się, kiedy Cursor o to poprosi. Możesz też dodać serwer do `mcp.json` z `"url"` i bez `headers`.
- **Codex:** `codex mcp add linkdash --url https://api.linkdash.dev/mcp`, a potem `codex mcp login linkdash`.

Aplikacja dostaje taki sam dostęp jak klucz API. Połączone aplikacje znajdziesz w [Panel → Klucze API](https://linkdash.dev/dashboard/keys), gdzie **Odłącz** od razu odbiera im dostęp.

## Automatyzacja i agenci headless

Logowanie wymaga człowieka przy przeglądarce. Dla zadań CI, agentów uruchamianych według harmonogramu, serwerów i kodu, który woła MCP bezpośrednio, wysyłaj zamiast tego [klucz API](https://linkdash.dev/dashboard/keys): `Authorization: Bearer ldash_...`. To te same klucze co w [HTTP API](/pl/api).

**Cursor** (`~/.cursor/mcp.json` lub `.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"` (w JSON potrzebne jest `"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"`

Lokalnie: URL `.site` z Convex + `/mcp`.

## Pliki

Nie wysyłaj bajtów przez JSON w MCP. Wygeneruj URL (`{uploadUrl,storageId}`), wyślij plik z hosta przez PUT, a potem utwórz 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}'
```

Narzędzia MCP: `files_upload_url` zwraca `{uploadUrl,storageId}` → host wysyła plik przez PUT na `uploadUrl` → `links_create` z tym `storageId`. Opcjonalna karta podglądu: `previewName`, `previewDescription`, `previewImageStorageId` (ten sam upload). Opcjonalne `maxOpenings` wstrzymuje link po tylu otwarciach. `links_update` może podnieść ten limit albo przekazać `clearMaxOpenings`. Nie pokazuj użytkownikowi `uploadUrl`.

## Narzędzia

| 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` (bez id) | `GET /shares` | `links_shares` (bez `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 lub editor) |
| `links_unlock` | `{ id, variant?, password?, variantPassword? }` → cel linku; odblokowuje wariant chroniony hasłem dla edytora na 30 minut |
| `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 z hosta po wygenerowaniu 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_*` |

## Foldery

Folder to link, który wyświetla listę elementów, które do niego wrzucisz. Jak to działa, opisuje strona [Foldery](/pl/folders).

| Narzędzie | Wejście |
| --- | --- |
| `links_create` | `{ kind: "folder", name, … }` tworzy folder. Każde tworzenie przyjmuje `folder` (slug) i `folderDomain?`, żeby utworzyć element w folderze. Odpowiedź zawiera `folder` |
| `links_list` | Jedna strona, `{ items, cursor }` (`limit` 1-100, domyślnie 50; odsyłaj `cursor`, dopóki nie będzie `null`). `q` dopasowuje słowa; `folder: "<slug>"` wyświetla to, co jest bezpośrednio w środku; `folder: "root"` wyświetla najwyższy poziom; `kind` przyjmuje też `folder`. Wiersze zawierają `folder`, a wiersze folderów zawierają `items` |
| `links_move` | `{ id, domain?, folder: string \| null, folderDomain? }` → `{ id, folder }` |
| `links_copy` | `{ id, domain? }` → `{ id, url, access, kind, folder }` (ten sam dostęp, nowy URL udostępniania, bez osób) |
| `links_delete` | `contents?: "keep" \| "delete"` dla folderów (domyślnie `keep`) |

`links_export` / `links_import` dodają kolumny `folder` i `access`, a wiersze z `kind` `folder` tworzą foldery.

## Dostęp i udostępnianie

Nowe linki i foldery mają dostęp ograniczony: `url` to `https://linkdash.dev/s/<token>`, który otworzysz tylko ty i osoby, którym go udostępnisz. Przekaż `access` w `links_create` albo `links_update`: `restricted` (domyślnie), `link` (każdy z URL-em udostępniania) albo `public` (każdy, pod krótkim URL-em). Proś o `access: "public"`, kiedy link ma zostać opublikowany. Więcej w [Udostępnianie i dostęp](/pl/sharing).

| Narzędzie | Wejście |
| --- | --- |
| `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? }` → jedna strona wszystkiego, co udostępniłeś, `{ items, cursor }`, każdy element z `people` |
| `links_shared` | `{ limit?, cursor? }` → jedna strona elementów, które inni ci udostępnili, `{ items, cursor }`, z `url` do otwarcia każdego z nich |
| `links_leave` | `{ id }` (`_id` albo URL udostępniania z `links_shared`) → `{ _id, left: true }` |
| `links_update` | `access?` zmienia, kto może otworzyć link; `resetShareLink: true` generuje nowy URL udostępniania (stary przestaje działać) |

Każdy `url` w odpowiedzi to URL udostępniania, chyba że link jest publiczny. Wtedy to krótki URL. Udostępnienie, cofnięcie udostępnienia, zmiana dostępu i reset liczą się jako jedno zdarzenie każde. Opuszczenie się nie liczy.

## Warianty

Każdy link to kontener na jeden lub więcej **wariantów**. Wariant to treść (`url` | `file` | `text`) plus jego własne ograniczenia (`password`, `starts`, `expires`, `maxOpenings`, wstrzymanie), `weight` i opcjonalne warunki dla odwiedzających `when`. Bez `variants` link ma jeden wariant o nazwie `main`. Ograniczenia linku mają pierwszeństwo przed ograniczeniami wariantów. Odwiedzający dostaje jeden wariant: pulę tworzą warianty, których `when` pasuje (a jeśli żaden nie pasuje, warianty bezwarunkowe), a potem następuje losowanie z wagami. `sticky` (domyślnie `true`) trzyma powracającego odwiedzającego przy tym samym wariancie, a `restartSplit` losuje przydział od nowa. `kind` linku z kilkoma wariantami to `group`. `status` linku to `mixed`, kiedy warianty się różnią. Maksymalnie 20 wariantów na link. Struktury: [HTTP API](/pl/api#warianty).

`links_create` zamiast skróconej formy przyjmuje `variants: [{ name, url | text | storageId (+ fileName, fileType, fileSize), password?, starts?, expires?, maxOpenings?, utm?, weight?, when? }]`, a do tego `sticky` i `forwardParams`. `links_update` przyjmuje `sticky`, `forwardParams` i `restartSplit`. `links_list` filtruje po `kind` (dochodzi `group`) i `status` (dochodzi `mixed`). `links_stats` zwraca sumy dla `variants`. `links_export` / `links_import` używają CSV wariantów (jeden wiersz na wariant).

| Narzędzie | Wejście |
| --- | --- |
| `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? }` |

Klucze `when`: `countries`, `devices`, `os`, `browsers`, `languages`, `referrerHosts` (tablice stringów; każdy ustawiony klucz musi pasować), a do tego `params`.

**Reguły parametrów zapytania.** `when.params` to tablica maksymalnie 10 reguł dotyczących query stringa odwiedzającego. Spełniona musi być każda reguła: `{ "params": [{ "key": "src", "op": "equals", "value": "newsletter" }] }`. `op`: `equals` | `notEquals` | `includes` | `startsWith` | `endsWith` | `in` (`value` to lista rozdzielona znakiem `|`) | `exists` | `missing` (dwa ostatnie nie przyjmują `value`). Wielkość liter w kluczach ma znaczenie, a wartości są porównywane dokładnie. Wartości parametrów nigdy nie trafiają do analityki.

**Przekazywanie parametrów zapytania.** `forwardParams` (wartość logiczna w `links_create` / `links_update`, domyślnie `false`) dokleja cały query string odwiedzającego do wariantów URL. Wartości odwiedzającego nadpisują zapisane, łącznie z `utm`. Działa tylko dla wariantów URL. To routing, a nie kontrola dostępu.

`auth create` / `auth login` / `auth logout` nie są narzędziami MCP. Mapowanie: [api.md](https://linkdash.dev/api.md).
