---
title: CLI
description: >-
  Installiere linkdash-cli von npm und führe dann den Befehl `linkdash` aus.
  Erfolgreiche Befehle geben JSON auf stdout aus. Hilfe und Fehler erscheinen
  als Klartext auf stderr.
sidebar:
  label: CLI
  order: 3
---
```bash
npm i -g linkdash-cli
# or: pnpm add -g linkdash-cli / bun add -g linkdash-cli / npx linkdash-cli@latest
```

Das npm-Paket heißt `linkdash-cli`. Der Befehl heißt `linkdash`.

HTTP-Entsprechung: [HTTP-API](/de/api). MCP: [MCP](/de/mcp). Agent-Skill: [Agent-Skill](/de/skill). Preise: [Preise](/de/pricing). Reines Markdown: [cli.md](https://linkdash.dev/cli.md).

Es gibt kein `--json`-Flag. Bei Fehlern ist der Exit-Code 1.

## Authentifizierung

```bash
linkdash auth create
linkdash auth login
linkdash auth whoami
linkdash auth logout
```

Noch kein Konto? `auth create` öffnet https://linkdash.dev/sign-up und kehrt danach mit dem CLI-Code zu https://linkdash.dev/device zurück, damit du die Anmeldung bestätigen kannst. Du hast schon ein Konto? `auth login` öffnet `/device`. Headless: Setze `LINKDASH_TOKEN` auf ein Session-Token aus `auth create` oder `auth login`. Erfinde keine Tokens.

Session-Datei: `~/.config/linkdash/config.json` (Modus 0600).

Die CLI kann E-Mail, Passwort und Abrechnung nicht ändern. Schick Nutzer dafür ins [Dashboard](https://linkdash.dev/dashboard/billing). API-Schlüssel (HTTP und MCP): [API-Schlüssel](https://linkdash.dev/dashboard/keys).

## Befehle

```
linkdash <command> [options]
```

| Befehl | Was er tut |
| --- | --- |
| `auth create` | Registrierung im Browser, danach Gerätefreigabe |
| `auth login` | Geräte-Login im Browser |
| `auth logout` | Gespeicherte Session vergessen |
| `auth whoami` | Angemeldetes Konto als JSON |
| `links list` | Links und Ordner seitenweise auflisten (`--limit`, `--cursor`) |
| `links get <id>` | Ein einzelner Link |
| `links create --url <url>` | Kurzlink aus einer URL |
| `links create --file <path>` | Datei hochladen und einen Link erhalten |
| `links create --text <text>` | Snippet speichern |
| `links create --folder <name>` | [Ordner](/de/folders) erstellen |
| `links create --variant <name> …` | Link mit mehreren Varianten (Split / Targeting) |
| `links update <id>` | Ziel, Datei, Passwort, Ablauf, Domain, Status, Sticky oder weitergeleitete Parameter ändern |
| `links move <id> --in <folder-id>` | Link oder Ordner in einen Ordner verschieben (`--root` für die oberste Ebene) |
| `links copy <id>` | Kopie mit neuem Slug im selben Ordner anlegen |
| `links delete <id>` | Link löschen (die Elemente eines Ordners rücken eine Ebene nach oben; `--with-contents` löscht sie) |
| `links share <id> --email <email>` | Per E-Mail mit Personen [teilen](/de/sharing) (`--email` wiederholen; mit `--role editor` dürfen sie es ändern; jede neue Person bekommt eine Einladungs-E-Mail) |
| `links unshare <id> --email <email>` | Zugriff einer Person entfernen |
| `links shares [id]` | Wer es außer dir öffnen kann, auch über einen übergeordneten Ordner. Ohne ID: alles, wozu du Personen eingeladen hast, seitenweise (`--limit`, `--cursor`) |
| `links shared` | Was andere mit dir geteilt haben, seitenweise (`--limit`, `--cursor`) |
| `links leave <_id \| share URL>` | Etwas aufgeben, das mit dir geteilt wurde |
| `links role <id> --email <e> --role viewer\|editor` | Eine von dir eingeladene Person zum Viewer oder Editor machen |
| `links unlock <_id \| share URL>` | Passwort eines geteilten Elements eingeben, um sein Ziel 30 Minuten lang zu sehen und zu bearbeiten |
| `links activity <id>` | Wer ein Element geändert hat und wie |
| `links reset-link <id>` | Neue Share-URL; die alte `linkdash.dev/s/`-URL funktioniert nicht mehr |
| `links stats <id>` | Summen für Besuche, Downloads und Wiedergaben, auch pro Variante, plus Crawler |
| `links export` | Alle Links als CSV ausgeben (eine Zeile pro Variante) |
| `links import <file>` | URL- und Textzeilen aus CSV importieren |
| `links variants list <id>` | Varianten eines Links |
| `links variants add <id> --name <n>` | Variante hinzufügen |
| `links variants update <id> <name>` | Variante ändern |
| `links variants remove <id> <name>` | Variante entfernen |
| `webhooks list` | Webhook-Endpunkte auflisten (Secret maskiert) |
| `webhooks get <id>` | Eine Webhook-URL anzeigen (Secret maskiert) |
| `webhooks create --url <https>` | HTTPS-Endpunkt hinzufügen (Secret wird einmalig angezeigt) |
| `webhooks rotate <id>` | Neues Signing-Secret ausstellen |
| `webhooks delete <id>` | Webhook entfernen |
| `domains list` | Eigene Hostnamen auflisten |
| `domains add <host>` | Hostnamen hinzufügen (1 im Free-Plan) |
| `domains connect <host>` | Domain-Connect-Apply-URL oder null |
| `domains verify <host>` | DNS mit Unkey prüfen |
| `domains remove <host>` | Hostnamen entfernen |
| `-h, --help` | Hilfe (Klartext) |
| `-v, --version` | Version |

Wenn derselbe Slug auf zwei Domains des Besitzers existiert, gib `--domain` an.

## Flags für create und update

Der Slug ist die ID des Links und, wenn der Link öffentlich ist, auch sein öffentlicher Pfad. Der Name ist nur für dich sichtbar. Neue Links sind eingeschränkt (siehe [Zugriff und Teilen](#access-and-sharing)). Create nimmt **genau eines** von: `--url`, `--file` oder `--text` (daraus wird die Variante `main`), `--variant`-Blöcke (siehe [Varianten](#variants)) oder `--folder <name>` (siehe [Ordner](#folders)).

| Flag | Hinweise |
| --- | --- |
| `--url <url>` | Ziel-URL |
| `--file <path>` | Hochzuladende Datei (beim Erstellen, oder beim Update die Bytes ersetzen) |
| `--text <text>` | Snippet |
| `--access <restricted\|link\|public>` | Wer es öffnen kann. Standard `restricted`. Siehe [Zugriff und Teilen](#access-and-sharing) |
| `--reset-share-link` | Neue Share-URL ausstellen (nur update) |
| `--slug <id>` | Öffentlicher Pfad: `a-z0-9` und innere Bindestriche, 1–64 |
| `--name <label>` | Privates Label |
| `--tag <tag>` | Wiederholbar. Kleinbuchstaben, keine Kommas. Max. 20 |
| `--starts <when>` | Nach `7d`, `24h`, `30m` oder zu einem ISO-Datum live gehen |
| `--password <secret>` | Zum Öffnen dieses Passwort verlangen |
| `--expires <when>` | Nach `7d`, `24h`, `30m` oder ab einem ISO-Datum nicht mehr ausliefern |
| `--max-openings <n>` | Nach so vielen Öffnungen pausieren. Weglassen für unbegrenzt |
| `--domain <host>` | Auf diesem Host statt auf `lida.sh` ausliefern |
| `--in <folder-id>` | In diesem Ordner erstellen (nur create; `--in-domain <host>`, falls sich der Ordner-Slug wiederholt) |
| `--status <active\|paused>` | Pausieren oder fortsetzen (nur update) |
| `--sticky` / `--no-sticky` | Wiederkehrende Besucher behalten dieselbe Variante (standardmäßig sticky) |
| `--restart-split` | Sticky-Zuweisungen neu mischen (nur update) |
| `--forward-params` / `--no-forward-params` | Den Query-String des Besuchers an URL-Varianten anhängen (standardmäßig aus). Siehe [Query-Parameter weiterleiten](#forward-query-parameters) |
| `--variant <name>` | Einen Varianten-Block beginnen (nur create). Siehe [Varianten](#variants) |
| `--weight <n>` `--when <key=v1,v2>` | Pro Variante. Siehe [Varianten](#variants) und [Regeln für Query-Parameter](#query-parameter-rules) |
| `--preview-name <text>` | Öffentlicher Unfurl-Name |
| `--preview-description <text>` | Öffentliche Unfurl-Beschreibung |
| `--preview-image <path>` | Öffentliches Unfurl-Bild |
| `--utm-source` `--utm-medium` `--utm-campaign` `--utm-term` `--utm-content` | Nur für URL-Links |
| `--clear-password` `--clear-expires` `--clear-starts` `--clear-tags` `--clear-preview` `--clear-name` `--clear-max-openings` | Nur update |

`--status` akzeptiert nur `active` oder `paused`. Abgelaufen ergibt sich aus `--expires`, geplant aus `--starts`. Bis zum Start liefert die öffentliche Auflösung not-found. Ist `--max-openings` erreicht, pausiert der Link; erhöhe die Zahl oder nutze `--clear-max-openings`, um ihn wieder auszuliefern. Bereits genutzte Öffnungen bleiben gezählt, bis du das Limit änderst oder entfernst.

Slugs auf `lida.sh` werden von allen gemeinsam genutzt. Ist ein Wort schon vergeben, füge eine [eigene Domain](/de/domains) hinzu und versuch es erneut mit `--domain`. Ein Link auf einer Branded Domain wird nicht zusätzlich auf `lida.sh` veröffentlicht.

## Flags für list

Gibt eine Seite aus, `{items, cursor}`: `--limit` ist 1-100 (Standard 50); übergib `--cursor` mit dem `cursor` der vorherigen Seite, bis er `null` ist. Eine Seite kann weniger Elemente als `--limit` enthalten, wenn ein Filter einige überspringt. `--q` findet ganze Wörter, wobei das letzte als Präfix gilt (`laun` findet `example.com/launch`), sortiert nach Relevanz; `--in` listet einen Ordner auf, Ordner zuerst; ansonsten das Neueste zuerst.

| Flag | Hinweise |
| --- | --- |
| `--limit <n>` | Elemente pro Seite, 1-100 (Standard 50) |
| `--cursor <c>` | Der `cursor` der vorherigen Seite |
| `--q <text>` | Wörter in Name, Slug, Variantennamen und -zielen, Dateinamen, Snippet-Text und Tags suchen |
| `--tag <tag>` | Nach Tag filtern |
| `--kind <url\|file\|text\|folder\|group>` | Nach Art filtern (`group` = mehrere Varianten) |
| `--status <status>` | `active`, `paused`, `expired`, `scheduled` oder `mixed` |
| `--in <folder-id\|root>` | Nur, was direkt in diesem Ordner oder auf der obersten Ebene liegt. Ohne das Flag wird alles aufgelistet |

## Varianten

Jeder Link ist ein Container für eine oder mehrere **Varianten**. Eine Variante besteht aus dem Inhalt (URL, Datei oder Text) plus eigenem Gate (`--password`, `--starts`, `--expires`, `--max-openings`), einem `--weight` und optionalen Besucherbedingungen (`--when`). Ohne `--variant` hat ein Link eine Variante namens `main`, und jeder Befehl oben ist eine Kurzform dafür. Ein Besucher bekommt genau eine Variante: Varianten, deren `--when` passt, bilden den Pool (passt keine, bilden ihn die bedingungslosen Varianten), danach folgt eine gewichtete Auswahl. Mit Sticky-Zuweisung (Standard) behält ein wiederkehrender Besucher dieselbe Variante. Das Gate des Links selbst hat Vorrang vor den Gates der Varianten. Variantennamen: Kleinbuchstaben, Ziffern, innere Bindestriche, 1–40 Zeichen, eindeutig pro Link. Max. 20 Varianten.

Das `kind` des Links ist bei einer Variante deren Art und bei mehreren `group`. Der `status` des Links ist das Link-Gate, falls gesetzt (`paused`, `scheduled`, `expired`), sonst der gemeinsame Status der Varianten, sonst `mixed`. `variantStatuses` zählt `{active, paused, expired, scheduled}`.

### Mit Varianten-Blöcken erstellen

```bash
linkdash links create --slug promo --variant a --url https://example.com/a --variant b --url https://example.com/b --weight 3
linkdash links create --slug hi --variant de --url https://example.de --when country=DE,AT --variant rest --url https://example.com
```

`--variant <name>` beginnt einen Varianten-Block. Flags danach gehören bis zum nächsten `--variant` zu dieser Variante: `--url|--file|--text`, `--password`, `--starts`, `--expires`, `--max-openings`, `--weight <n>`, `--when <key=v1,v2>` (wiederholbar), `--utm-*`. Link-Flags (`--slug --name --tag --domain --preview-* --password --starts --expires --max-openings --sticky --no-sticky --forward-params`) kommen vor das erste `--variant`.

### Varianten-Unterbefehle

```bash
linkdash links variants list promo
linkdash links variants add promo --name mobile --url https://m.example.com --when device=mobile
linkdash links variants update promo mobile --when country=DE,AT --when device=mobile --weight 2
linkdash links variants update promo b --status paused
linkdash links variants remove promo b
```

`variants add <id> --name <n>` nimmt eines von `--url`, `--file`, `--text` sowie Gate-Flags, `--weight`, `--when`, `--utm-*`. `variants update <id> <name>` nimmt `--name <new>`, Inhalt, Gate-Flags, `--status active|paused`, `--weight`, `--when`, `--clear-when`, `--clear-password`, `--clear-starts`, `--clear-expires`, `--clear-max-openings`. Ein Link behält immer mindestens eine Variante.

### `--when`-Schlüssel

| Schlüssel | JSON-Feld | Werte |
| --- | --- | --- |
| `country` | `countries` | ISO-2-Codes (`DE`, `AT`) |
| `device` | `devices` | `mobile` `tablet` `desktop` |
| `os` | `os` | `windows` `macos` `android` `ios` `linux` `other` |
| `browser` | `browsers` | `edge` `chrome` `firefox` `safari` `other` |
| `language` | `languages` | Präfix-Abgleich (`de`, `en-us`) |
| `referrer` | `referrerHosts` | Host-Suffix (`twitter.com`) |

Jeder gesetzte Schlüssel muss passen. `--when country=DE,AT --when device=mobile` entspricht `{ "countries": ["DE","AT"], "devices": ["mobile"] }`.

### Regeln für Query-Parameter

`--when` nimmt auch `param:`-Regeln für den Query-String des Besuchers (`lida.sh/promo?src=newsletter`). Schlüssel unterscheiden Groß- und Kleinschreibung, Werte werden exakt verglichen, max. 10 Regeln pro Variante. Kommas trennen die Werte von `--when`, daher kann ein Parameterwert kein Komma enthalten; verwende `|` für Listen.

| Syntax | JSON-`op` | Passt, wenn |
| --- | --- | --- |
| `param:KEY=VALUE` | `equals` | der Wert genau `VALUE` ist |
| `param:KEY!=VALUE` | `notEquals` | der Wert abweicht oder der Schlüssel fehlt |
| `param:KEY~=VALUE` | `includes` | der Wert `VALUE` enthält |
| `param:KEY^=VALUE` | `startsWith` | der Wert mit `VALUE` beginnt |
| `param:KEY$=VALUE` | `endsWith` | der Wert auf `VALUE` endet |
| `param:KEY=v1\|v2` | `in` | der Wert einer aus der Liste ist |
| `param:KEY?` or `param:KEY` | `exists` | der Schlüssel vorhanden ist |
| `param:!KEY` | `missing` | der Schlüssel fehlt |

```bash
linkdash links variants add promo --name news --url https://example.com/news --when param:src=newsletter
linkdash links variants add promo --name pro --url https://example.com/pro --when "param:plan~=pro"
linkdash links variants add promo --name ref --url https://example.com/ref --when "param:ref?"
```

JSON-Form: `"when": { "params": [{ "key": "src", "op": "equals", "value": "newsletter" }] }` (`value` entfällt bei `exists` / `missing`). Parameterwerte werden beim Öffnen abgeglichen und nie in den Analytics gespeichert.

### Query-Parameter weiterleiten

`--forward-params` / `--no-forward-params` bei `links create` und `links update` (auf Link-Ebene, standardmäßig aus) hängt den gesamten Query-String des Besuchers an URL-Varianten an: `lida.sh/promo?src=nl` öffnet `https://example.com/?src=nl`. Werte des Besuchers überschreiben gespeicherte Werte, auch `--utm-*`. Datei- und Textvarianten ignorieren die Einstellung. Das ist Routing, keine Zugriffskontrolle: Jeder kann Parameter anhängen. Parameterwerte werden nicht in den Analytics gespeichert. `links get` zeigt die Einstellung als `forwardParams`.

### Sticky und Split neu starten

`links update <id> --sticky` / `--no-sticky` legt fest, ob ein wiederkehrender Besucher dieselbe Variante behält. `links update <id> --restart-split` mischt die Sticky-Zuweisungen neu. Inhalts-Flags bei `links update` funktionieren nur für Links mit einer einzigen Variante; ansonsten verwende `links variants update <id> <name>`.

## Ordner

Ein Ordner ist ein Link, der die Elemente auflistet, die du hineinlegst. Wie die öffentliche Seite und der Zugriff funktionieren, erfährst du unter [Ordner](/de/folders).

```bash
linkdash links create --folder "Q4 launch" --slug q4
linkdash links create --file ./deck.pdf --in q4
linkdash links move k3m9xq --in q4
linkdash links move k3m9xq --root
linkdash links list --in q4
linkdash links copy k3m9xq
linkdash links delete q4 --with-contents
```

`--folder <name>` setzt den Ordnernamen (nicht `--name`) und nimmt `--slug`, `--domain`, `--password`, `--starts`, `--expires`, `--max-openings`, `--tag`, `--preview-*` und `--in`. Es lässt sich nicht mit `--url`, `--file`, `--text` oder `--variant` kombinieren. `links move` gibt `{id, folder}` aus. `links copy` behält die Zugriffsstufe, bekommt aber eine neue Share-URL; Personen werden nicht mitkopiert. `links delete` auf einen Ordner verschiebt seine Elemente eine Ebene nach oben; `--with-contents` löscht sie ebenfalls. Zeilen von list, get und create enthalten `folder` (den Slug des übergeordneten Ordners oder `null`); Ordnerzeilen enthalten zusätzlich `items`.

## Zugriff und Teilen

Neue Links und Ordner sind `restricted`: Ihre `url` ist `https://linkdash.dev/s/<token>`, die nur du und die Personen, mit denen du teilst, im angemeldeten Zustand öffnen können. `--access link` macht diese URL für alle zugänglich, die sie haben. `--access public` liefert den Link unter seiner Kurz-URL aus (`lida.sh/<slug>` oder deine eigene Domain). Verwende `--access public` für Links, die du öffentlich postest. Der Slug bleibt für jeden Befehl die ID, und seine Kurz-URL bleibt reserviert, solange der Link nicht öffentlich ist. Das vollständige Modell findest du unter [Teilen und Zugriff](/de/sharing).

```bash
linkdash links create --url https://example.com/launch --access public
linkdash links share q4 --email anna@example.com --email ben@example.com
linkdash links shares q4
linkdash links unshare q4 --email ben@example.com
linkdash links shared
linkdash links leave https://linkdash.dev/s/<token>
linkdash links share q4 --email cara@example.com --role editor
linkdash links role q4 --email cara@example.com --role viewer
linkdash links unlock https://linkdash.dev/s/<token>
linkdash links activity q4
linkdash links shares
linkdash links update q4 --access link
linkdash links reset-link q4
```

| Befehl | Ausgabe |
| --- | --- |
| `links share <id> --email <e> [--email <e> …]` | `{id, url, access, invited, alreadyShared}` |
| `links unshare <id> --email <e>` | `{id, email, removed: true}` |
| `links shares <id>` | `{id, access, url, people: [{email, role: "viewer", accepted, invitedAt, viaFolder?}]}` |
| `links shares` (ohne ID) | `{items: [{id, name?, kind, access, url, people: [{email, accepted, invitedAt}]}], cursor}`, zuletzt geteilte zuerst |
| `links shared` | `{items: [{_id, _creationTime, kind, title?, status, hasPassword, access, url, itemCount?, sharedBy?, sharedAt}], cursor}`, neueste zuerst |
| `links leave <_id \| share URL>` | `{_id, left: true}` |
| `links role <id> --email <e> --role <r>` | `{id, email, role}` |
| `links unlock <_id \| share URL>` | `{_id, variant, unlocked: true, minutes: 30, kind, destinationUrl? \| textContent? \| fileName?}` |
| `links activity <id>` | `{items: [{_id, _creationTime, action, detail?, actor}], cursor}` |
| `links reset-link <id>` (oder `links update <id> --reset-share-link`) | `{id, access, url}` |

`--role editor` macht jemanden zum Editor: Editoren können das Element ändern und seine Statistiken sehen, aber weder Passwörter, Slug, Domain, Zugriff oder Freigaben ändern noch löschen, verschieben oder kopieren; ein passwortgeschütztes Ziel erfordert zuerst `links unlock` (30 Minuten). Editoren verwenden die `_id` oder Share-URL aus `links shared`. Alle Befehle nehmen `--domain <host>`, wenn sich der Slug wiederholt. `url` in der Ausgabe von `create`, `get`, `list`, `update`, `copy` und `share` ist die Share-URL, außer der Link ist öffentlich, dann ist es die Kurz-URL; Zeilen enthalten `access`. Bis zu 200 Personen pro Element, 50 E-Mails pro Aufruf, 100 Einladungs-E-Mails pro Konto und Tag. Die beiden Listen geben jeweils eine Seite aus: `--limit` ist 1-100 (Standard 50); übergib `--cursor` der vorherigen Seite, bis `cursor` `null` ist. `links leave` nimmt die `_id` oder `url` aus `links shared`; Zugriff über einen übergeordneten geteilten Ordner bleibt bestehen. Teilen, Freigabe entfernen, eine Zugriffsänderung und ein Reset zählen jeweils als ein Ereignis; Verlassen nicht.

## Statistiken

```bash
linkdash links stats <id> --last 24h
```

`--last` ist eine Dauer (`24h`, `7d`). Standard `24h`. Das JSON enthält `visits`, `downloads`, `plays`, `visitsInLast`, `countries`, `referrers`, `variants` (Summen pro Variante), `visitors` (jeweils mit `variant`) und `crawlers` (`[{crawler, company, category, hits, lastSeen}]`: Bots und Link-Vorschauen, die den Link abgerufen haben – sie werden nie als Besuche gezählt).

## CSV

Spalten: `slug,kind,name,variant,url,text,fileName,status,domain,tags,starts,expires,maxOpenings,weight,when,created,folder,access`. Eine Zeile pro Variante. `kind`, `status`, `url`, `text`, `fileName`, `weight` und `when` (JSON-String) gelten pro Variante; der Rest gilt pro Link und wiederholt sich. `folder` ist der Slug des Ordners, in dem der Link liegt. `access` ist `restricted`, `link` oder `public`. Keine Passwörter, Share-Tokens oder Personen.

```bash
linkdash links export > links.csv
linkdash links import links.csv
```

Der Import gruppiert Zeilen nach Slug + Domain. Die erste Zeile erstellt den Link mit seiner Variante; weitere Zeilen fügen Varianten hinzu. Bei einem bestehenden Link aktualisiert die erste Zeile die Link-Felder, danach aktualisiert jede Zeile die gleichnamige Variante, falls vorhanden, und fügt sie sonst hinzu. Dateizeilen ohne Bytes werden mit einem Fehler pro Zeile übersprungen. Zeilen mit `kind` = `folder` (mit einem `name`) erstellen Ordner; die Spalte `folder` legt jeden Link in seinen Ordner, sobald alle Zeilen existieren. Ein leeres `access` macht neue Links eingeschränkt und lässt bestehende Links unverändert.

## Beispiele

```bash
linkdash links create --url https://example.com/q4/deck.pdf --slug deck --name "Q4 deck"
linkdash links create --file ./deck.pdf --expires 7d --starts 1d
linkdash links create --url https://example.com --max-openings 1
linkdash links update k3m9xq --max-openings 5
linkdash links update k3m9xq --clear-max-openings
linkdash links create --text "release checklist" --tag launch --tag q4
linkdash links list --q deck --tag launch --kind file --status paused
linkdash links get welcome --domain go.example.com
linkdash links update deck --file ./new.pdf
linkdash links update k3m9xq --status paused
linkdash links create --slug promo --variant a --url https://example.com/a --variant b --url https://example.com/b --weight 3
linkdash links variants add promo --name mobile --url https://m.example.com --when device=mobile
linkdash links update promo --no-sticky --restart-split
linkdash links create --folder "Q4 launch" --slug q4
linkdash links move k3m9xq --in q4
linkdash links create --url https://example.com/launch --access public
linkdash links share q4 --email anna@example.com
```

Siehe auch [Ordner](/de/folders), [Teilen und Zugriff](/de/sharing), [Webhooks](/de/webhooks) und [eigene Domains](/de/domains).
