diff --git a/content/guides/assets/playtomic.svg b/content/guides/assets/playtomic.svg
new file mode 100644
index 0000000..ef04922
--- /dev/null
+++ b/content/guides/assets/playtomic.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/content/guides/de/connect-playtomic-to-chatgpt.mdx b/content/guides/de/connect-playtomic-to-chatgpt.mdx
new file mode 100644
index 0000000..47c05fd
--- /dev/null
+++ b/content/guides/de/connect-playtomic-to-chatgpt.mdx
@@ -0,0 +1,122 @@
+---
+title: "Verfügbare Padelplätze auf Playtomic mit ChatGPT suchen"
+description: "Hol Playtomic in ChatGPT mit dem MCP-Connector aus AnythingMCP. Suche verfügbare Padelplätze auf Playtomic mit ChatGPT, vergleiche Preise, finde offene Matches auf deinem Level — ohne das Chatfenster zu verlassen."
+category: "connectors"
+keyword: "Padelplatz auf Playtomic mit ChatGPT suchen, Playtomic ChatGPT, Padel ChatGPT, Padel-Buchung GPT, Playtomic MCP ChatGPT, Padel KI Assistent"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "de"
+---
+
+
+
+
+
+> 💡 **Keine Installation? Nutze [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** Einloggen, **Connectors → Playtomic** (oder **Playtomic Public** für Zero-Setup), MCP-API-Key erzeugen. Kein Docker, kein Clone. Spring direkt zum Abschnitt *Connector in ChatGPT hinzufügen*.
+
+## Verfügbare Padelplätze auf Playtomic mit ChatGPT suchen
+
+ChatGPT unterstützt das **Model Context Protocol** in Custom Connectors auf den Tarifen Plus, Team und Enterprise. Mit AnythingMCP, das Playtomic als MCP-Tools ausspielt, kannst du verfügbare Padelplätze auf Playtomic mit ChatGPT auf Deutsch suchen:
+
+- *"Zeig mir freie 90-Minuten-Padel-Slots am Samstag zwischen 18 und 20 Uhr im Umkreis von 25 km um München."*
+- *"Finde die günstigsten Indoor-Crystal-Padel-Plätze in Berlin für morgen."*
+- *"Welche Vereine in Hamburg haben freie Plätze an Werktagabenden?"*
+- *"Gibt es offene Padel-Matches auf meinem Level am Wochenende?"*
+
+ChatGPT ruft die Playtomic-API per MCP auf und liefert eine knappe Liste von Vereinen, Zeiten und Preisen.
+
+### Zwei Connectors, wähl dein Level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Null | E-Mail + Passwort |
+| Tools | 4 (Vereine, Verfügbarkeit, Configuration) | 13 (alles + Profil, Level, Statistik, Matches) |
+| Preise | Generisch | Mit Mitgliedsrabatten |
+| Ideal für | Öffentliche Bots, Embedded-Suche, Ausprobieren | Tägliche Nutzung, Match-Finder |
+
+Beide gleichzeitig installierbar — kein Konflikt.
+
+### Voraussetzungen
+
+- Playtomic-Konto (nur für Full-Connector).
+- AnythingMCP lokal oder auf [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- ChatGPT Plus / Team / Enterprise (Custom Connectors sind kostenpflichtigen Tarifen vorbehalten).
+
+### Schritt 1 — Playtomic-Zugang besorgen (nur Full)
+
+Für **public** spring zu Schritt 2 — kein Konto nötig. Für **full** auf https://playtomic.io einloggen und E-Mail + Passwort bereithalten.
+
+### Schritt 2 — Playtomic-Adapter auf cloud.anythingmcp.com installieren (no code)
+
+1. Auf **[cloud.anythingmcp.com](https://cloud.anythingmcp.com)** einloggen.
+2. **Connectors → Playtomic → Install** (oder **Playtomic (Public)** für Zero-Setup).
+3. Für den Full-Adapter einfügen:
+ - `PLAYTOMIC_EMAIL` — deine Playtomic-E-Mail
+ - `PLAYTOMIC_PASSWORD` — dein Klartext-Passwort (at-rest verschlüsselt, nur per TLS gesendet)
+4. MCP-API-Key unter **Profile → MCP API Keys → New Key** erzeugen und kopieren.
+
+### Schritt 3 — Connector in ChatGPT hinzufügen (no code, 4 Klicks)
+
+1. **ChatGPT → Settings → Connectors → Add custom connector** (nur Bezahltarife).
+2. Trag ein:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer → MCP-API-Key einfügen
+3. **Save** klicken und die Tool-Liste freigeben.
+4. Neuen Chat öffnen → das 🔧-Symbol zeigt alle Playtomic-Tools. Stell deine Padel-Frage.
+
+JWT-Refresh (~1 h), `401`-Retries und Token-Caching laufen serverseitig.
+
+### Verfügbare Tools
+
+#### Playtomic Public (4 Tools, keine Auth)
+
+| Tool | Was es macht |
+|---|---|
+| `playtomic_search_tenants` | Vereine im Umkreis einer Koordinate finden |
+| `playtomic_get_tenant` | Vereins-Detail |
+| `playtomic_get_availability` | Freie Slots + Preise pro Tag |
+| `playtomic_get_sport_configuration` | Kanonische Enums |
+
+#### Playtomic full (13 Tools, Login)
+
+| Gruppe | Tools |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Dein Konto** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Matches** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Events** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Mit geplanten ChatGPT-Prompts automatisieren
+
+ChatGPT Plus/Team bietet **scheduled prompts**. Beispiele:
+
+- *"Jeden Freitag um 17 Uhr: die günstigsten 90-Minuten-Padel-Slots in meiner Nähe für Samstagvormittag."*
+- *"Sonntagabends: offene Padel-Matches auf meinem Level für die kommende Woche."*
+- *"Am Ersten jedes Monats: Zusammenfassung der gespielten Matches und Top-Verein."*
+
+Der Playtomic-JWT wird zwischen Läufen wiederverwendet — keine Login-Welle.
+
+### FAQ
+
+**Ist die Playtomic-API offiziell?**
+Nein. Undokumentierte interne API der Playtomic-App; kann sich ohne Vorwarnung ändern.
+
+**Kann ich über ChatGPT buchen?**
+Nein, dieser Connector ist read-only. Mit ChatGPT den Slot finden, dann in der App buchen.
+
+**Liefert der Public-Connector falsche Preise?**
+Er liefert *generische* Preise. Mit Mitgliedschaftsrabatten den **full** Connector installieren — er sendet `user_id=me` und du siehst die Mitgliedstarife.
+
+**Warum sehe ich kein "Add connector" in ChatGPT?**
+Custom Connectors erfordern Plus, Team oder Enterprise. Kostenlose Tarife können keine MCP-Server hinzufügen — entweder upgraden oder Claude bzw. Copilot nutzen.
+
+**Welche Sportarten werden unterstützt?**
+Hauptsächlich `PADEL`. Auch `TENNIS` und `FUTSAL`, wo Vereine sie publizieren.
+
+### Nächste Schritte
+
+- [Playtomic mit Claude verbinden](./connect-playtomic-to-claude)
+- [Playtomic mit Copilot verbinden](./connect-playtomic-to-copilot)
+- [Playtomic mit OpenClaw verbinden](./connect-playtomic-to-openclaw)
+- [Padelplätze mit KI finden — Cross-Client-Anleitung](./find-padel-courts-with-ai)
diff --git a/content/guides/de/connect-playtomic-to-claude.mdx b/content/guides/de/connect-playtomic-to-claude.mdx
new file mode 100644
index 0000000..21476e8
--- /dev/null
+++ b/content/guides/de/connect-playtomic-to-claude.mdx
@@ -0,0 +1,171 @@
+---
+title: "Verfügbare Padelplätze auf Playtomic mit Claude AI suchen"
+description: "Verbinde Playtomic mit Claude Desktop oder Claude Code über AnythingMCP. Suche verfügbare Padelplätze auf Playtomic mit Claude, vergleiche Preise, finde offene Matches auf deinem Level — alles in Klartext, ohne durch die Buchungs-App zu scrollen."
+category: "connectors"
+keyword: "Padelplatz auf Playtomic mit Claude suchen, Padel Claude AI, Padel buchen Claude, Playtomic Claude, Padel-Verfügbarkeit KI, Playtomic MCP Claude"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "de"
+---
+
+
+
+
+
+> 💡 **Keine Installation? Nutze [cloud.anythingmcp.com](https://cloud.anythingmcp.com) direkt.** Einloggen, **Connectors → Playtomic** klicken, Playtomic-E-Mail + -Passwort einfügen (oder **Playtomic Public** für Zero-Setup wählen), MCP-API-Key erzeugen — fertig. Kein Docker, kein `git clone`, kein lokaler Server. Spring direkt zum Abschnitt *Connector in Claude einrichten*.
+
+## Verfügbare Padelplätze auf Playtomic mit Claude suchen — Schluss mit App-Scrollen
+
+Padel ist die am schnellsten wachsende Rückschlagsportart Europas, aber einen freien Platz auf Playtomic zu finden bedeutet immer noch: App öffnen, Vereine durchschalten, Preise vergleichen, raten welche Plätze indoor sind. Verbinde Playtomic mit **Claude** über AnythingMCP und du fragst einmal, in Klartext:
+
+- *"Finde einen Padelplatz im Umkreis von 20 km um Freiburg am Samstag zwischen 18 und 20 Uhr."*
+- *"Vergleiche die Preise für 90-Minuten-Slots bei allen Padel-Vereinen in München für morgen Vormittag."*
+- *"Zeig mir freie Indoor-Crystal-Plätze am Donnerstagabend in Berlin."*
+- *"Gibt es offene Padel-Matches auf meinem Level dieses Wochenende?"*
+
+Claude fragt die Playtomic-API direkt ab, verknüpft Plätze mit Verfügbarkeit und liefert eine knappe Auswahl — oft schneller als die offizielle App.
+
+### Zwei Connectors, wähl dein Level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Null — installieren und los | E-Mail + Passwort |
+| Tools | 4 (Vereine, Verfügbarkeit, Configuration) | 13 (alles + Profil, Level, Statistik, offene Matches) |
+| Preise | Generisch | Mit Mitgliedsrabatten |
+| Ideal für | Ausprobieren, öffentliche Bots, Embedded-Suche | Tägliche persönliche Nutzung, Match-Finder |
+
+Du kannst beide gleichzeitig installieren — sie kommen sich nicht in die Quere. Die meisten Nutzer wählen **full**; **public** ist perfekt fürs Onboarding oder geteilte Bots.
+
+### Voraussetzungen
+
+- Ein Playtomic-Konto (nur für den Full-Connector). Der kostenlose Tarif reicht.
+- AnythingMCP lokal oder auf [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- Claude Desktop, Claude Code oder [claude.ai](https://claude.ai) mit einem Plan, der Custom Connectors unterstützt.
+
+### Schritt 1 — Playtomic-Zugang besorgen (nur Full-Connector)
+
+Wenn du nur den **public** Read-only-Adapter willst, spring zu Schritt 2 — kein Konto nötig.
+
+Für den **full** Adapter:
+
+1. Bei https://playtomic.io einloggen (oder registrieren).
+2. E-Mail und Passwort notieren. AnythingMCP verschlüsselt das Passwort at-rest (AES-256-GCM) und sendet es nur per TLS an Playtomics Login-Endpunkt.
+
+Es gibt keinen API-Key zu erzeugen. Playtomic hat keine öffentliche Developer-Konsole; dieser Connector nutzt denselben `/api/v3/auth/login`-Endpunkt wie die Mobile App.
+
+### Schritt 2 — Playtomic-Adapter installieren
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Öffne `http://localhost:3000/connectors/store`, suche **Playtomic** und wähle:
+
+- **Playtomic (Public)** → **Install** klicken. Fertig. Keine Credentials.
+- **Playtomic** → `PLAYTOMIC_EMAIL` und `PLAYTOMIC_PASSWORD` eintragen, dann **Install**.
+
+Die 4 Public-Tools bzw. 13 Full-Tools stehen jetzt im Katalog.
+
+### Schritt 3 — Connector in Claude einrichten (no code, 4 Klicks)
+
+Empfohlener Weg — funktioniert auf **claude.ai web** ohne lokale Config-Datei.
+
+1. Öffne **[claude.ai/customize/connectors](https://claude.ai/customize/connectors)**.
+2. Klicke **"Add custom connector"**.
+3. Trag ein:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer token → MCP-API-Key einfügen (aus AnythingMCP → **Profile → MCP API Keys → New Key**)
+4. **Connect** klicken.
+
+Alle Playtomic-Tools erscheinen im Chat. Token-Caching, JWT-Refresh (~1 h) und `401`-Retries laufen serverseitig.
+
+
+Fortgeschritten: Claude Desktop / Claude Code (JSON / CLI)
+
+Bei den **Desktop-Apps** gilt die Web-UI nicht — du bearbeitest eine lokale Config.
+
+**Claude Desktop** — editiere `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) bzw. `%AppData%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+ "mcpServers": {
+ "playtomic": {
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": {
+ "Authorization": "Bearer YOUR_MCP_API_KEY"
+ }
+ }
+ }
+}
+```
+
+Claude Desktop neu starten. Playtomic-Tools erscheinen im 🔧-Menü.
+
+**Claude Code** — ein CLI-Befehl:
+
+```bash
+claude mcp add playtomic \
+ --transport http \
+ --url https://cloud.anythingmcp.com/mcp \
+ --header "Authorization: Bearer YOUR_MCP_API_KEY"
+```
+
+Mit `claude mcp list` prüfen.
+
+
+
+### Verfügbare Tools
+
+#### Playtomic Public (4 Tools, keine Auth)
+
+| Tool | Was es macht |
+|---|---|
+| `playtomic_search_tenants` | Vereine im Umkreis einer Koordinate finden |
+| `playtomic_get_tenant` | Vollständiges Detail eines Vereins (Plätze, Öffnungszeiten, Galerie) |
+| `playtomic_get_availability` | Freie Slots eines Tages mit Preisen |
+| `playtomic_get_sport_configuration` | Kanonische Sport-Enums |
+
+#### Playtomic full (13 Tools, Login)
+
+| Gruppe | Tools |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Dein Konto** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Matches** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Events** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Automatisieren — wiederkehrende Padelsuche
+
+Kombiniere Claude mit einem Scheduler (cron, Apple Kurzbefehle, n8n, eine wiederkehrende Claude-Code-Session) und mach aus einer Einmal-Frage eine Gewohnheit:
+
+- *"Jeden Freitag um 17 Uhr: die günstigsten 90-Minuten-Padel-Slots in meiner Nähe für Samstagvormittag."*
+- *"Sonntagabends: offene Padel-Matches auf meinem Level in der Stadt für die kommende Woche."*
+- *"Einmal im Monat: Zusammenfassung wie viele Matches ich gespielt habe und in welchem Verein am häufigsten."*
+
+Der Token-Cache von AnythingMCP ist serverseitig, also benutzen geplante Läufe denselben JWT — keine Login-Welle.
+
+### FAQ
+
+**Speichert AnythingMCP mein Klartext-Passwort?**
+Nur im verschlüsselten `authConfig`-Blob (AES-256-GCM). Das Passwort fließt über TLS zum Playtomic-Login-Endpunkt — wird nie geloggt.
+
+**Ist die Playtomic-API offiziell?**
+Nein. Es handelt sich um eine undokumentierte interne API der Playtomic-Mobile-App, rekonstruiert für Read-only-Zwecke. Endpunkte können sich ohne Vorwarnung ändern — bei Problemen im AnythingMCP-Repo nach Updates schauen.
+
+**Kann ich über Claude buchen?**
+Nein. Playtomic hat keine dokumentierte öffentliche Buchungs-API; der Zahlungsfluss ist außerhalb des Scopes. Nutze Claude zum Finden des Slots, buche dann in der Playtomic-App.
+
+**Liefert der Public-Connector falsche Preise?**
+Er liefert *generische* Preise. Wenn du Mitgliedschaften mit Rabatten hast, installiere den **full** Connector — er sendet `user_id=me` und du siehst die Mitgliedstarife.
+
+**Welche Sportarten werden unterstützt?**
+Hauptsächlich `PADEL`. `TENNIS` und `FUTSAL` funktionieren ebenfalls, wo Vereine sie auf Playtomic veröffentlichen.
+
+### Nächste Schritte
+
+- [Playtomic mit ChatGPT verbinden](./connect-playtomic-to-chatgpt)
+- [Playtomic mit Copilot verbinden](./connect-playtomic-to-copilot)
+- [Playtomic mit OpenClaw verbinden](./connect-playtomic-to-openclaw)
+- [Padelplätze mit KI finden — die Cross-Client-Anleitung](./find-padel-courts-with-ai)
diff --git a/content/guides/de/connect-playtomic-to-copilot.mdx b/content/guides/de/connect-playtomic-to-copilot.mdx
new file mode 100644
index 0000000..7ca45a4
--- /dev/null
+++ b/content/guides/de/connect-playtomic-to-copilot.mdx
@@ -0,0 +1,113 @@
+---
+title: "Verfügbare Padelplätze auf Playtomic mit GitHub Copilot suchen"
+description: "Bring Playtomic in GitHub Copilot Chat / Visual Studio Code über den MCP-Connector aus AnythingMCP. Suche Padelplätze auf Playtomic mit Copilot, automatisiere Match-Alerts, baue Padel-aware Coding-Workflows."
+category: "connectors"
+keyword: "Padelplatz auf Playtomic mit Copilot suchen, Playtomic Copilot, Padel VS Code, GitHub Copilot Playtomic, Padel MCP Copilot"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "de"
+---
+
+
+
+
+
+> 💡 **Keine Installation? Nutze [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** MCP-API-Key erzeugen, Copilot auf `https://cloud.anythingmcp.com/mcp` zeigen lassen, fertig.
+
+## Verfügbare Padelplätze auf Playtomic mit GitHub Copilot suchen
+
+GitHub Copilot Chat in VS Code unterstützt das **Model Context Protocol**. Mit AnythingMCP, das Playtomic als MCP-Tools ausspielt, kannst du verfügbare Padelplätze auf Playtomic mit Copilot direkt im Editor suchen — praktisch, wenn du an einer Padel-Side-App arbeitest oder dir zwischen Commits einen Samstag-Slot besorgst:
+
+- *"Zeig mir freie Padelplätze im Umkreis von 20 km heute Abend ab 19 Uhr."*
+- *"Exportier meine Padel-Match-Historie des Jahres als JSON für eine Test-Fixture."*
+- *"Generiere einen CRON-Ausdruck, der freitags 17 Uhr auslöst und Playtomic nach Samstagvormittag-Slots fragt."*
+
+Copilot ruft Playtomic per MCP und liefert strukturierte Ergebnisse direkt in Code oder Chat.
+
+### Zwei Connectors, wähl dein Level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Null | E-Mail + Passwort |
+| Tools | 4 (read-only) | 13 (read-only) |
+| Preise | Generisch | Mit Mitgliedsrabatten |
+| Ideal für | Öffentliche Bots, Demos, Embedded-Suche | Persönliche Nutzung |
+
+### Voraussetzungen
+
+- VS Code mit der GitHub-Copilot-Chat-Erweiterung (MCP-Support).
+- Playtomic-Konto (nur Full).
+- AnythingMCP lokal oder auf cloud.anythingmcp.com.
+
+### Schritt 1 — Playtomic-Adapter installieren
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+`http://localhost:3000/connectors/store` öffnen → **Playtomic** suchen → **Playtomic (Public)** installieren (keine Creds) oder **Playtomic** (mit `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`).
+
+MCP-API-Key in **Profile → MCP API Keys → New Key** erzeugen.
+
+### Schritt 2 — MCP-Server in Copilot in VS Code hinzufügen
+
+Lege/aktualisiere `.vscode/mcp.json` im Workspace (oder benutzerweit `~/.config/Code/User/mcp.json`):
+
+```json
+{
+ "servers": {
+ "playtomic": {
+ "type": "http",
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": { "Authorization": "Bearer YOUR_MCP_API_KEY" }
+ }
+ }
+}
+```
+
+VS Code neu laden. Copilot Chat → 🔧 **Tools** Picker → Playtomic aktivieren. Loslegen.
+
+### Verfügbare Tools
+
+#### Playtomic Public (4 Tools)
+
+| Tool | Was es macht |
+|---|---|
+| `playtomic_search_tenants` | Geo-Suche nach Padel-Vereinen |
+| `playtomic_get_tenant` | Vereinsdetail |
+| `playtomic_get_availability` | Freie Slots + Preise |
+| `playtomic_get_sport_configuration` | Sport-Enums (Dauern, Platztypen) |
+
+#### Playtomic full (13 Tools)
+
+Discovery + Konto + offene Matches + Empfehlungen + Turniere + Ligen. Volle Tabelle in der [Claude-Anleitung](./connect-playtomic-to-claude).
+
+### Code-mit-Padel-Workflows
+
+Copilot macht Playtomic für Entwickler nützlich:
+
+- *"Ich schreibe eine Court-Finder-App. Rufe `playtomic_search_tenants` für 5 europäische Städte und schreib mir eine Postgres-Seed-Datei."*
+- *"Generiere einen TypeScript-Typen für die `playtomic_get_availability`-Response — nutze das echte JSON, das ich erhalte."*
+- *"Plotte die letzten 12 Monate von `playtomic_get_my_stats` in eine chartjs-Config."*
+
+### FAQ
+
+**Funktioniert das ohne GitHub Copilot Pro?**
+Die MCP-Integration von Copilot Chat ist in Pro und Business enthalten. Auch der Personal-Tarif unterstützt MCP in aktuellen VS-Code-Releases.
+
+**Wo gehört der MCP-API-Key hin — `mcp.json` oder `.env`?**
+Beides geht. Im geteilten Workspace lieber `${env:ANYTHINGMCP_KEY}` in `mcp.json` und den Key in `.env` (gitignored).
+
+**Kann ich AnythingMCP lokal laufen lassen?**
+Ja — Copilot auf `http://localhost:4000/mcp` zeigen, lokalen API-Key nutzen.
+
+**Warum schlägt `playtomic_get_my_profile` fehl?**
+Vermutlich hast du die **public**-Variante installiert (ohne Auth). Installier **Playtomic (full)** für persönliche Daten.
+
+### Nächste Schritte
+
+- [Playtomic mit Claude verbinden](./connect-playtomic-to-claude)
+- [Playtomic mit ChatGPT verbinden](./connect-playtomic-to-chatgpt)
+- [Playtomic mit OpenClaw verbinden](./connect-playtomic-to-openclaw)
+- [Padelplätze mit KI finden — Cross-Client-Anleitung](./find-padel-courts-with-ai)
diff --git a/content/guides/de/connect-playtomic-to-openclaw.mdx b/content/guides/de/connect-playtomic-to-openclaw.mdx
new file mode 100644
index 0000000..f439d7b
--- /dev/null
+++ b/content/guides/de/connect-playtomic-to-openclaw.mdx
@@ -0,0 +1,105 @@
+---
+title: "Verfügbare Padelplätze auf Playtomic mit OpenClaw suchen"
+description: "Verbinde Playtomic mit OpenClaw über AnythingMCP. Suche Padelplätze auf Playtomic mit OpenClaw und lokalen LLM-Clients, automatisiere Platz-Alerts, halte Padel-Workflows komplett auf deiner Maschine."
+category: "connectors"
+keyword: "Padelplatz auf Playtomic mit OpenClaw suchen, Playtomic OpenClaw, Playtomic lokales LLM, Padel self-hosted, Padel MCP OpenClaw"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "de"
+---
+
+
+
+
+
+> 💡 **Keine Installation? Nutze [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** MCP-API-Key erzeugen, OpenClaw auf `https://cloud.anythingmcp.com/mcp` zeigen. Fertig.
+
+## Verfügbare Padelplätze auf Playtomic mit OpenClaw suchen
+
+OpenClaw ist der Open-Source-Desktop-Client für self-hosted und Frontier-LLMs mit nativer **Model-Context-Protocol**-Unterstützung. Kombinier OpenClaw mit dem Playtomic-Connector aus AnythingMCP und du kannst verfügbare Padelplätze auf Playtomic mit OpenClaw suchen — lokal, mit dem Modell deiner Wahl (Llama, Mistral, Qwen, GPT-4o, Claude…), ohne SaaS-Bindung:
+
+- *"Finde Indoor-Crystal-Padelplätze frei morgen im Umkreis von 20 km."*
+- *"Zeig mir die günstigsten 90-Minuten-Slots diese Woche."*
+- *"Liste offene Matches auf meinem Padel-Level am Wochenende."*
+- *"Fass meine letzten 30 Tage Playtomic-Aktivität zusammen."*
+
+OpenClaw routet die Tool-Aufrufe per MCP, dein Modell übernimmt das natürlichsprachige Reasoning.
+
+### Zwei Connectors, wähl dein Level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Null | E-Mail + Passwort |
+| Tools | 4 (read-only) | 13 (read-only) |
+| Preise | Generisch | Mit Mitgliedsrabatten |
+| Ideal für | Geteilte Presets, Demos, Embedded-Bots | Tägliche Nutzung |
+
+### Voraussetzungen
+
+- OpenClaw auf macOS, Windows oder Linux.
+- Playtomic-Konto (nur Full).
+- AnythingMCP lokal oder auf cloud.anythingmcp.com.
+
+### Schritt 1 — Playtomic-Adapter installieren
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+`http://localhost:3000/connectors/store` öffnen → **Playtomic** suchen → **Playtomic (Public)** (zero config) und/oder **Playtomic** (mit `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`) installieren.
+
+MCP-API-Key in **Profile → MCP API Keys → New Key** erzeugen.
+
+### Schritt 2 — MCP-Server in OpenClaw hinzufügen
+
+OpenClaw verwaltet MCP-Server unter **Settings → Model Context Protocol**. Server hinzufügen:
+
+- **Name:** `Playtomic`
+- **Transport:** HTTP
+- **URL:** `https://cloud.anythingmcp.com/mcp`
+- **Headers:** `Authorization: Bearer YOUR_MCP_API_KEY`
+
+Speichern. OpenClaw verbindet, listet die Playtomic-Tools, die nun in jedem Chat verfügbar sind — unabhängig vom Modell.
+
+### Verfügbare Tools
+
+#### Playtomic Public (4 Tools)
+
+| Tool | Was es macht |
+|---|---|
+| `playtomic_search_tenants` | Geo-Suche nach Padel-Vereinen |
+| `playtomic_get_tenant` | Vereinsdetail mit Plätzen |
+| `playtomic_get_availability` | Freie Slots + Preise für ein Datum |
+| `playtomic_get_sport_configuration` | Sport-Enums |
+
+#### Playtomic full (13 Tools)
+
+Discovery + Konto + offene Matches + Empfehlungen + Turniere + Ligen. Volle Tabelle in der [Claude-Anleitung](./connect-playtomic-to-claude).
+
+### Warum OpenClaw + Playtomic ein starkes Paar ist
+
+- **Datenschutz** — Padelplatzsuche, ohne die Anfrage an ein US-gehostetes Commercial-LLM zu senden. Lokales Modell laufen lassen — nur Playtomic sieht deine IP.
+- **Kosten** — keine Token-Rechnung für tägliche Verfügbarkeits-Checks.
+- **Modell-Freiheit** — Llama 3 → Mixtral → GPT-4o → Claude Sonnet, alle mit denselben Playtomic-Tools.
+
+### FAQ
+
+**Funktioniert das offline?**
+Die LLM-Hälfte schon (lokales Modell). Die Playtomic-Hälfte braucht Internet — sie ruft `app.playtomic.io`.
+
+**Welche lokalen Modelle handeln MCP-Tool-Aufrufe am besten?**
+Modelle mit gutem Function-Calling: Llama 3.1 70B, Mixtral 8×22B, Qwen 2.5 Coder, Hermes 3. 8-B-Modelle reichen für die 4 Tools des Public-Connectors; für die 13 Tools des Full lieber größer.
+
+**Wo lebt der Bearer-Token auf meiner Maschine?**
+Im System-Keychain (macOS) bzw. Credential Manager (Windows) bzw. Secret Service (Linux). Nie im Klartext-Config.
+
+**Kann ich den Full deaktivieren und nur den Public behalten?**
+Ja — nur **Playtomic (Public)** installieren, oder den Full in AnythingMCPs Katalog deaktivieren.
+
+### Nächste Schritte
+
+- [Playtomic mit Claude verbinden](./connect-playtomic-to-claude)
+- [Playtomic mit ChatGPT verbinden](./connect-playtomic-to-chatgpt)
+- [Playtomic mit Copilot verbinden](./connect-playtomic-to-copilot)
+- [Padelplätze mit KI finden — Cross-Client-Anleitung](./find-padel-courts-with-ai)
diff --git a/content/guides/de/find-padel-courts-with-ai.mdx b/content/guides/de/find-padel-courts-with-ai.mdx
new file mode 100644
index 0000000..485720e
--- /dev/null
+++ b/content/guides/de/find-padel-courts-with-ai.mdx
@@ -0,0 +1,104 @@
+---
+title: "Padelplätze mit KI finden — Playtomic + Claude, ChatGPT, Copilot, OpenClaw"
+description: "Schluss mit dem Scrollen in der Playtomic-App. Lass Claude, ChatGPT, Copilot oder OpenClaw verfügbare Padelplätze auf Playtomic suchen, Preise vergleichen und offene Matches auf deinem Level finden. Ein MCP-Connector, vier Clients."
+category: "connectors"
+keyword: "Padelplatz mit KI finden, Padelplatz Playtomic KI suchen, Padel-Verfügbarkeit KI, Padel-Assistent, Padel Claude ChatGPT, Playtomic MCP"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "de"
+---
+
+
+
+
+
+## Padelplätze mit KI finden — die Kurzversion
+
+Padel boomt in ganz Europa. Einen freien Platz zur richtigen Zeit, am richtigen Ort, indoor oder outdoor, zum richtigen Preis zu finden, bedeutet immer noch: durch die Playtomic-App scrollen — Vereinsliste, einen öffnen, zum Datum wischen, Kalender prüfen, zurück, nächster Verein. Genau die falsche Form für einen Handy-Screen, und genau die richtige Form für ein Sprachmodell.
+
+Diese Seite ist die Cross-Client-Übersicht. Wähl deinen KI-Assistenten und leg los:
+
+- 🟣 **[Padelplätze mit Claude suchen](./connect-playtomic-to-claude)** — Claude Desktop, Claude Code, claude.ai web.
+- 🟢 **[Padelplätze mit ChatGPT suchen](./connect-playtomic-to-chatgpt)** — ChatGPT Plus / Team / Enterprise.
+- 🔵 **[Padelplätze mit GitHub Copilot suchen](./connect-playtomic-to-copilot)** — Copilot Chat in VS Code.
+- 🦫 **[Padelplätze mit OpenClaw suchen](./connect-playtomic-to-openclaw)** — Open-Source-Desktop-Client, jedes lokale oder Cloud-LLM.
+
+Alle vier nutzen dasselbe Backend: den Playtomic-Connector für [AnythingMCP](https://github.com/HelpCode-ai/anythingmcp). Eine Installation, alle Clients.
+
+## So funktioniert es
+
+[AnythingMCP](https://anythingmcp.com) ist ein Open-Source-Server, der jede API als MCP-Tools (Model Context Protocol) verfügbar macht. Der Playtomic-Connector kapselt Playtomics interne API — dieselbe, die die Mobile App nutzt — und verwandelt sie in 4 bis 13 Tools, die deine KI direkt aufruft:
+
+```
+Du → "Padelplätze um Berlin Samstag abends unter 40€ für 90 Minuten"
+ ↓
+KI-Client (Claude / ChatGPT / Copilot / OpenClaw)
+ ↓ MCP
+AnythingMCP-Server
+ ↓ HTTP
+Playtomic /api/v1/tenants + /api/v1/availability
+ ↓
+Gefilterte Auswahl freier, bezahlbarer Plätze
+```
+
+## Zwei Connectors, wähl dein Level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Null — installieren und los | Playtomic-E-Mail + -Passwort |
+| Tools | 4 (Vereine, Verfügbarkeit, Configuration) | 13 (alles + Profil, Level, Statistik, offene Matches, Empfehlungen) |
+| Preise | Generisch | Mit Mitgliedsrabatten |
+| Ideal für | Geteilte Prompts, öffentliche Bots, schnelle Demos | Tägliche Nutzung, Match-Finder |
+
+Der **public**-Connector ist unter den AnythingMCP-Integrationen einzigartig: Er funktioniert **ohne Credentials**, weil Playtomics Verein- und Verfügbarkeits-Endpunkte by design offen sind. Wenn du nur freie Plätze finden willst, reicht der Public-Adapter — und du kannst Padel-aware-Prompts mit anderen teilen, ohne Setup je Nutzer.
+
+## Was du fragen kannst
+
+Generische, modell-unabhängige Prompts (mit **public** + ein paar, die den Full brauchen):
+
+| Bedürfnis | Beispiel-Prompt | Connector |
+|---|---|---|
+| Platz heute Abend | *"Padel-Slots im Umkreis von 15 km heute Abend ab 19 Uhr, 60–90 min."* | public |
+| Preise vergleichen | *"Günstigste 90-Minuten-Crystal-Plätze in München Sonntagmorgen."* | public |
+| Nur Indoor | *"Indoor-Padelplätze frei morgen Abend in Hamburg."* | public |
+| Aktuelles Level | *"Was ist mein aktuelles Padel-Level?"* | full |
+| Offenes Match auf meinem Level | *"Offene Matches auf meinem Level am Wochenende in der Nähe."* | full |
+| Statistik | *"Wie viele Matches habe ich dieses Jahr gespielt?"* | full |
+| Top-Vereine | *"In welchen Vereinen war ich in den letzten 3 Monaten am häufigsten?"* | full |
+| Kommende Turniere | *"Padel-Turniere in Deutschland in den nächsten 60 Tagen."* | full |
+
+## Die Suche automatisieren
+
+Derselbe Connector funktioniert für Einmal-Fragen und für wiederkehrende Automatisierung. Kombinier deine KI mit ihrem Scheduler (Claude-Code-Session, ChatGPT scheduled prompts, cron + Copilot CLI, OpenClaw + System-cron) und du hast einen permanenten Padel-Wachhund:
+
+- *"Jeden Freitag um 17 Uhr: günstigste Samstag-Vormittag-Slots im Umkreis von 20 km."*
+- *"Sonntagabends: offene Matches auf meinem Level für die kommende Woche."*
+- *"Am Ersten jedes Monats: Monats-Statistik + Top-Verein."*
+
+Da AnythingMCP den Playtomic-JWT serverseitig cached und transparent erneuert, melden sich geplante Läufe nie neu an.
+
+## Warum das die Playtomic-App schlägt
+
+- **Eine Anfrage, mehrere Vereine** — die App lässt dich Vereine einzeln öffnen; die KI fächert in einem Rutsch über alle Vereine im Radius auf.
+- **Constraints in Klartext** — "indoor, Crystal, unter 40 €, 90 Minuten, zwischen 18 und 21" ist ein Satz für die KI vs. fünf Filter in der App.
+- **Joins** — die KI verknüpft Verfügbarkeit mit Platzeigenschaften (indoor/outdoor, single/double, Crystal/Panoramic), so dass du nicht erst spät merkst, dass der freie Slot der unbeliebte Platz am Straßenrand ist.
+- **Wiederkehrend** — Schedules sind erstklassig, kein Workaround.
+
+## Stabilität und Ethik
+
+Die hier genutzte Playtomic-API ist **undokumentiert und aus der iOS-App rekonstruiert**. In der Praxis stabil (muss sie sein, die App hängt davon ab), aber Playtomic bietet keinen SLA. AnythingMCP hält das Anfragevolumen niedrig (≤1 req/s im stabilen Betrieb je Nutzer) und identifiziert sich ehrlich — kein User-Agent-Spoofing.
+
+Wenn dir ein freier-Plätze-Bot nützt: Bitte buche die Plätze tatsächlich über Playtomic, wenn du sie findest. So bleibt die API für Playtomic wirtschaftlich interessant.
+
+## Loslegen
+
+Der schnellste Weg ist der **public**-Connector. Kein Konto, keine Credentials, ~3 Minuten Setup:
+
+1. Wähl deinen KI-Client unten.
+2. Folge der entsprechenden Anleitung — je 3 Schritte.
+3. Erster Prompt: *"Finde Padelplätze im Umkreis von 25 km um [deine Stadt] am Samstag zwischen 18 und 21 Uhr."*
+
+- [Padelplätze mit Claude suchen](./connect-playtomic-to-claude)
+- [Padelplätze mit ChatGPT suchen](./connect-playtomic-to-chatgpt)
+- [Padelplätze mit Copilot suchen](./connect-playtomic-to-copilot)
+- [Padelplätze mit OpenClaw suchen](./connect-playtomic-to-openclaw)
diff --git a/content/guides/en/connect-playtomic-to-chatgpt.mdx b/content/guides/en/connect-playtomic-to-chatgpt.mdx
new file mode 100644
index 0000000..8f0a47d
--- /dev/null
+++ b/content/guides/en/connect-playtomic-to-chatgpt.mdx
@@ -0,0 +1,124 @@
+---
+title: "Search Available Padel Courts on Playtomic with ChatGPT"
+description: "Bring Playtomic into ChatGPT via the MCP connector built into AnythingMCP. Search available padel courts on Playtomic with ChatGPT, compare prices, surface open matches at your level — without leaving the chat window."
+category: "connectors"
+keyword: "search padel courts on Playtomic with ChatGPT, find padel court ChatGPT, Playtomic ChatGPT, padel availability ChatGPT, Playtomic MCP ChatGPT, padel booking GPT"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "en"
+---
+
+
+
+
+
+> 💡 **No install? Use [cloud.anythingmcp.com](https://cloud.anythingmcp.com) directly.** Sign in, click **Connectors → Playtomic**, paste your Playtomic email + password (or pick **Playtomic Public** for zero setup), mint an MCP API key — done. No Docker, no `git clone`, no local server. Skip ahead to the *Add the connector in ChatGPT* section below.
+
+## Search available padel courts on Playtomic with ChatGPT
+
+ChatGPT supports the **Model Context Protocol** in custom connectors on Plus, Team and Enterprise plans. With AnythingMCP exposing Playtomic's API as MCP tools, you can search available padel courts on Playtomic with ChatGPT in plain English — no app switching, no OAuth ceremonies:
+
+- *"Show me 90-minute padel slots free on Saturday between 6 and 8 PM within 25 km of Milan."*
+- *"Find the cheapest indoor crystal padel courts in Madrid tomorrow."*
+- *"Which clubs in Barcelona have open courts on weekday evenings?"*
+- *"Are there open padel matches at my level this weekend?"*
+
+ChatGPT calls the Playtomic API directly through MCP and hands you a tight shortlist of clubs, times and prices.
+
+### Two connectors, pick your level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero — install and go | Email + password |
+| Tools | 4 (clubs, availability, configuration) | 13 (everything + your profile, level, stats, matches) |
+| Pricing | Generic | Member discounts applied |
+| Best for | Public bots, embedded search, trying out | Daily personal use, matching at your level |
+
+You can install both — they don't conflict.
+
+### Prerequisites
+
+- A Playtomic account (only for the full connector).
+- AnythingMCP running locally or on [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- ChatGPT Plus / Team / Enterprise (custom connectors are gated to paid tiers).
+
+### Step 1 — Get your Playtomic access (full connector only)
+
+If you only want the **public** read-only adapter, skip to Step 2 — no account needed.
+
+For the **full** adapter, sign in at https://playtomic.io and keep your email + password handy. AnythingMCP encrypts the password at rest (AES-256-GCM) and only sends it over TLS to Playtomic's login endpoint.
+
+### Step 2 — Install the Playtomic adapter on cloud.anythingmcp.com (no code)
+
+1. Sign in on **[cloud.anythingmcp.com](https://cloud.anythingmcp.com)**.
+2. Open **Connectors → Playtomic → Install** (or **Playtomic (Public)** for the zero-setup variant).
+3. For the full adapter, paste:
+ - `PLAYTOMIC_EMAIL` — your Playtomic account email
+ - `PLAYTOMIC_PASSWORD` — your plain password (encrypted at rest, sent only via TLS)
+4. Mint an MCP API key under **Profile → MCP API Keys → New Key**. Copy it.
+
+### Step 3 — Add the connector in ChatGPT (no code, 4 clicks)
+
+1. Open **ChatGPT → Settings → Connectors → Add custom connector** (Plus / Team / Enterprise only).
+2. Fill in:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer → paste your MCP API key
+3. Click **Save** and approve the tool list.
+4. Start a new chat → the 🔧 icon shows all Playtomic tools. Ask any padel search question.
+
+The ~1 h JWT refresh, `401` retries, and token caching are handled server-side. You never see Playtomic's auth layer.
+
+### Available tools
+
+#### Playtomic Public (4 tools, no auth)
+
+| Tool | What it does |
+|---|---|
+| `playtomic_search_tenants` | Find clubs near a coordinate, filter by sport / radius |
+| `playtomic_get_tenant` | Full detail of one club (courts, opening info, gallery) |
+| `playtomic_get_availability` | Free slots for a day, with prices |
+| `playtomic_get_sport_configuration` | Canonical sport enums |
+
+#### Playtomic full (13 tools, login)
+
+| Group | Tools |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Your account** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Matches** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Events** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Automate it
+
+Pair ChatGPT with its **scheduled prompts** (Plus/Team feature) and turn one-off padel searches into a habit:
+
+- *"Every Friday at 5 PM, list the cheapest 90-minute padel slots near my home for Saturday morning."*
+- *"Every Sunday evening, show open padel matches at my level for the coming week."*
+- *"On the 1st of each month, summarise how many matches I've played and which club I went to most."*
+
+The Playtomic JWT is reused across scheduled runs — no re-login storm.
+
+### FAQ
+
+**Is the Playtomic API official?**
+No. This is an undocumented internal API used by Playtomic's mobile app. Endpoints can change without notice.
+
+**Can I book a court via ChatGPT?**
+No. This connector is read-only — find the right slot with ChatGPT, then book in the Playtomic app.
+
+**Does the public connector return wrong prices?**
+It returns *generic* pricing. If you have linked club memberships with discounts, use the **full** connector — it passes `user_id=me` so member rates apply.
+
+**Why doesn't my "Add connector" option appear in ChatGPT?**
+Custom connectors require ChatGPT Plus, Team, or Enterprise. Free accounts can't add MCP servers — upgrade or use Claude Desktop / Claude Code free tiers.
+
+**Which sports are supported?**
+Mainly `PADEL`. `TENNIS` and `FUTSAL` also work where clubs publish them on Playtomic.
+
+### Next steps
+
+- [Connect Playtomic to Claude](./connect-playtomic-to-claude)
+- [Connect Playtomic to Copilot](./connect-playtomic-to-copilot)
+- [Connect Playtomic to OpenClaw](./connect-playtomic-to-openclaw)
+- [Find padel courts with AI — the cross-client guide](./find-padel-courts-with-ai)
diff --git a/content/guides/en/connect-playtomic-to-claude.mdx b/content/guides/en/connect-playtomic-to-claude.mdx
new file mode 100644
index 0000000..04a6218
--- /dev/null
+++ b/content/guides/en/connect-playtomic-to-claude.mdx
@@ -0,0 +1,171 @@
+---
+title: "Search Available Padel Courts on Playtomic with Claude AI"
+description: "Connect Playtomic to Claude Desktop or Claude Code with AnythingMCP. Search available padel courts on Playtomic with Claude, compare prices across clubs, find open matches at your level — in plain English, no booking app to scroll."
+category: "connectors"
+keyword: "search padel courts on Playtomic with Claude, find padel court Claude, Playtomic Claude, padel availability AI, Playtomic MCP Claude, automate padel search, padel booking Claude"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "en"
+---
+
+
+
+
+
+> 💡 **No install? Use [cloud.anythingmcp.com](https://cloud.anythingmcp.com) directly.** Sign in, click **Connectors → Playtomic**, paste your Playtomic email + password (or pick the **Playtomic Public** variant for zero setup), mint an MCP API key — done. No Docker, no `git clone`, no local server. Skip ahead to the *Add the connector in Claude* section below.
+
+## Search available padel courts on Playtomic with Claude — no more app scrolling
+
+Padel is the fastest-growing racquet sport in Europe, but searching available courts on Playtomic still means tapping through the mobile app, switching between clubs, comparing prices, and guessing which courts are indoor. Plug Playtomic into **Claude** through AnythingMCP and you ask once, in plain English:
+
+- *"Find me a padel court within 20 km of Milan this Saturday between 7 and 9 PM."*
+- *"Compare 90-minute slot prices across all padel clubs in Barcelona for tomorrow morning."*
+- *"Show me indoor crystal courts free on Thursday evening in Freiburg."*
+- *"Are there open padel matches at my level this weekend near me?"*
+
+Claude calls the Playtomic API directly, joins courts to availability, and hands you a tight shortlist — usually faster than the official app would for the same search.
+
+### Two connectors, pick your level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero — install and go | Email + password |
+| Tools | 4 (clubs, availability, configuration) | 13 (everything + your profile, level, stats, open matches, recommendations) |
+| Pricing | Generic | Member discounts applied |
+| Best for | Quickly trying out, public court searches, sharing prompts | Daily personal use, finding matches at your level |
+
+You can install both — they don't conflict. Most people pick **full** for personal use; **public** is ideal for embedding into shared bots or onboarding flows.
+
+### Prerequisites
+
+- A Playtomic account (only for the full connector). The free tier is enough.
+- AnythingMCP running locally or on [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- Claude Desktop, Claude Code, or [claude.ai](https://claude.ai) on a paid plan that supports custom connectors.
+
+### Step 1 — Get your Playtomic access (full connector only)
+
+If you only want the **public** read-only adapter, skip to Step 2 — no account needed.
+
+For the **full** adapter:
+
+1. Sign in (or sign up) at https://playtomic.io.
+2. Make a note of your email and password. AnythingMCP encrypts the password at rest (AES-256-GCM) and only sends it to Playtomic's login endpoint over TLS.
+
+There is no API key to generate. Playtomic has no public developer console; this connector wraps the same `/api/v3/auth/login` endpoint the mobile app uses.
+
+### Step 2 — Install the Playtomic adapter
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Open `http://localhost:3000/connectors/store`, search for **Playtomic**, and choose:
+
+- **Playtomic (Public)** → click **Install**. Done. No credentials.
+- **Playtomic** → fill `PLAYTOMIC_EMAIL` and `PLAYTOMIC_PASSWORD`, then **Install**.
+
+The 4 public tools or 13 full tools are now in your catalog.
+
+### Step 3 — Add the connector in Claude (no code, 4 clicks)
+
+The recommended path — works on **claude.ai web** without touching any config file.
+
+1. Open **[claude.ai/customize/connectors](https://claude.ai/customize/connectors)**.
+2. Click **"Add custom connector"**.
+3. Fill in:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer token → paste your MCP API key (from AnythingMCP → **Profile → MCP API Keys → New Key**)
+4. Click **Connect** to authorize.
+
+All Playtomic tools appear in your chat — start asking about courts. Token caching, the ~1 h JWT refresh, and `401` retries are handled server-side.
+
+
+Advanced: Claude Desktop / Claude Code (JSON / CLI)
+
+For the **desktop apps**, the web UI doesn't apply — you edit a local config file instead.
+
+**Claude Desktop** — edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%AppData%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+ "mcpServers": {
+ "playtomic": {
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": {
+ "Authorization": "Bearer YOUR_MCP_API_KEY"
+ }
+ }
+ }
+}
+```
+
+Restart Claude Desktop. Playtomic tools appear in the 🔧 menu.
+
+**Claude Code** — one CLI command:
+
+```bash
+claude mcp add playtomic \
+ --transport http \
+ --url https://cloud.anythingmcp.com/mcp \
+ --header "Authorization: Bearer YOUR_MCP_API_KEY"
+```
+
+Verify with `claude mcp list`.
+
+
+
+### Available tools
+
+#### Playtomic Public (4 tools, no auth)
+
+| Tool | What it does |
+|---|---|
+| `playtomic_search_tenants` | Find clubs near a coordinate, filter by sport / radius |
+| `playtomic_get_tenant` | Full detail of one club (courts, opening info, gallery) |
+| `playtomic_get_availability` | Free slots for a day across one or more clubs, with prices |
+| `playtomic_get_sport_configuration` | Canonical sport enums (durations, court types, surfaces) |
+
+#### Playtomic full (13 tools, login)
+
+| Group | Tools |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Your account** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Matches** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Events** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Automate it — recurring padel searches
+
+Pair Claude with a scheduler (cron, Apple Shortcuts, n8n, a recurring Claude Code session) and turn one-off prompts into a habit:
+
+- *"Every Friday at 5 PM, send me the cheapest 90-minute padel slots near my home for Saturday morning."*
+- *"On Sunday evenings, list open padel matches at my level in the city for the coming week."*
+- *"Once a month, summarise how many matches I've played and which club I went to most."*
+
+Because the AnythingMCP token cache is server-side, scheduled runs reuse the same Playtomic JWT — no re-login storm.
+
+### FAQ
+
+**Does AnythingMCP store my plain Playtomic password?**
+Only inside the encrypted `authConfig` blob (AES-256-GCM). The password is sent to Playtomic's login endpoint over TLS, never logged.
+
+**Is the Playtomic API official?**
+No. This is an undocumented internal API used by Playtomic's mobile app, reverse-engineered for read-only use. Endpoints can change without notice — if a tool breaks, check the AnythingMCP repo for updates.
+
+**Can I book a court via Claude?**
+Not in this connector. Playtomic has no documented public booking API and the booking flow involves payment handlers we deliberately don't automate. Use Claude to find the right slot, then book in the Playtomic app.
+
+**Does the public connector return wrong prices?**
+It returns Playtomic's *generic* pricing. If your account has linked club memberships with discounts, install the **full** connector instead — it passes `user_id=me` so member rates are applied.
+
+**Which sports are supported?**
+Mainly `PADEL`, but `TENNIS` and `FUTSAL` work too where clubs publish them on Playtomic.
+
+### Next steps
+
+- [Connect Playtomic to ChatGPT](./connect-playtomic-to-chatgpt)
+- [Connect Playtomic to Copilot](./connect-playtomic-to-copilot)
+- [Connect Playtomic to OpenClaw](./connect-playtomic-to-openclaw)
+- [Find padel courts with AI — the cross-client guide](./find-padel-courts-with-ai)
diff --git a/content/guides/en/connect-playtomic-to-copilot.mdx b/content/guides/en/connect-playtomic-to-copilot.mdx
new file mode 100644
index 0000000..b2887b0
--- /dev/null
+++ b/content/guides/en/connect-playtomic-to-copilot.mdx
@@ -0,0 +1,113 @@
+---
+title: "Search Available Padel Courts on Playtomic with GitHub Copilot"
+description: "Add Playtomic to GitHub Copilot Chat / Visual Studio Code via the MCP connector in AnythingMCP. Search padel courts on Playtomic with Copilot, automate match alerts, and build padel-aware coding workflows."
+category: "connectors"
+keyword: "search padel courts on Playtomic with Copilot, Playtomic Copilot, Playtomic VS Code, padel MCP Copilot, GitHub Copilot Playtomic"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "en"
+---
+
+
+
+
+
+> 💡 **No install? Use [cloud.anythingmcp.com](https://cloud.anythingmcp.com) directly.** Mint an MCP API key, point Copilot at `https://cloud.anythingmcp.com/mcp`, done.
+
+## Search available padel courts on Playtomic with GitHub Copilot
+
+GitHub Copilot Chat in VS Code now supports the **Model Context Protocol**. With AnythingMCP exposing Playtomic as MCP tools, you can search available padel courts on Playtomic with Copilot right inside your editor — useful when you're coding a padel side-project, building a court-finder app, or just sneaking a Saturday slot between commits:
+
+- *"Show me free padel courts within 20 km tonight after 7 PM."*
+- *"List my padel match history this year as a JSON I can paste into a test fixture."*
+- *"Generate a CRON expression that fires on Fridays at 5 PM and queries Playtomic for Saturday morning slots."*
+
+Copilot calls the Playtomic API through MCP and returns structured results you can drop straight into code or a chat reply.
+
+### Two connectors, pick your level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero | Email + password |
+| Tools | 4 read-only | 13 (read-only) |
+| Pricing | Generic | Member discounts applied |
+| Best for | Public bots, demos, embedded search | Personal use, level-matched matches |
+
+### Prerequisites
+
+- VS Code with the GitHub Copilot Chat extension (MCP support).
+- A Playtomic account (only for the full connector).
+- AnythingMCP running locally or on cloud.anythingmcp.com.
+
+### Step 1 — Install the Playtomic adapter
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Open `http://localhost:3000/connectors/store` → search **Playtomic** → install **Playtomic (Public)** (no creds) or **Playtomic** (paste `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`).
+
+Mint an MCP API key under **Profile → MCP API Keys → New Key**.
+
+### Step 2 — Add the MCP server to Copilot in VS Code
+
+Add or update `.vscode/mcp.json` in your workspace (or the user-level `~/.config/Code/User/mcp.json`):
+
+```json
+{
+ "servers": {
+ "playtomic": {
+ "type": "http",
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": { "Authorization": "Bearer YOUR_MCP_API_KEY" }
+ }
+ }
+}
+```
+
+Reload the VS Code window. Open Copilot Chat → click the 🔧 **Tools** picker → enable Playtomic. Start asking.
+
+### Available tools
+
+#### Playtomic Public (4 tools, no auth)
+
+| Tool | What it does |
+|---|---|
+| `playtomic_search_tenants` | Find clubs near a coordinate |
+| `playtomic_get_tenant` | Single-club detail |
+| `playtomic_get_availability` | Free slots + prices for a day |
+| `playtomic_get_sport_configuration` | Sport enums (durations, court types) |
+
+#### Playtomic full (13 tools, login)
+
+Discovery + your account + open matches + recommendations + tournaments + leagues. See [the Claude guide](./connect-playtomic-to-claude) for the full table.
+
+### Code-with-padel workflows
+
+Copilot makes Playtomic genuinely useful for developers building padel-adjacent things:
+
+- *"I'm writing a court-finder app. Hit `playtomic_search_tenants` for 5 European cities and write me a Postgres seed file."*
+- *"Generate a TypeScript type for the `playtomic_get_availability` response — use the actual JSON I get back."*
+- *"Plot my last 12 months of `playtomic_get_my_stats` into a chartjs config."*
+
+### FAQ
+
+**Does this work without GitHub Copilot Pro?**
+Copilot Chat's MCP integration is included in Pro and Business. Personal-tier Copilot also has MCP support in recent releases of VS Code.
+
+**Where do I store the MCP API key — in `mcp.json` or a `.env`?**
+Both work. For a shared workspace, prefer `${env:ANYTHINGMCP_KEY}` interpolation in `mcp.json` and keep the key in your `.env` (gitignored).
+
+**Can I run AnythingMCP locally and skip cloud.anythingmcp.com?**
+Yes — point Copilot at `http://localhost:4000/mcp` and use a local API key. Same tools.
+
+**Why is `playtomic_get_my_profile` failing?**
+You probably installed the **public** variant, which has no auth. Install **Playtomic (full)** if you want personal-data tools.
+
+### Next steps
+
+- [Connect Playtomic to Claude](./connect-playtomic-to-claude)
+- [Connect Playtomic to ChatGPT](./connect-playtomic-to-chatgpt)
+- [Connect Playtomic to OpenClaw](./connect-playtomic-to-openclaw)
+- [Find padel courts with AI — the cross-client guide](./find-padel-courts-with-ai)
diff --git a/content/guides/en/connect-playtomic-to-openclaw.mdx b/content/guides/en/connect-playtomic-to-openclaw.mdx
new file mode 100644
index 0000000..fed9c02
--- /dev/null
+++ b/content/guides/en/connect-playtomic-to-openclaw.mdx
@@ -0,0 +1,105 @@
+---
+title: "Search Available Padel Courts on Playtomic with OpenClaw"
+description: "Connect Playtomic to OpenClaw via AnythingMCP. Search padel courts on Playtomic with OpenClaw's local LLM clients, automate court alerts, and run padel workflows entirely on your own machine."
+category: "connectors"
+keyword: "search padel courts on Playtomic with OpenClaw, Playtomic OpenClaw, Playtomic local LLM, padel MCP OpenClaw, self-hosted padel AI"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "en"
+---
+
+
+
+
+
+> 💡 **No install? Use [cloud.anythingmcp.com](https://cloud.anythingmcp.com) directly.** Mint an MCP API key, point OpenClaw at `https://cloud.anythingmcp.com/mcp`. Done.
+
+## Search available padel courts on Playtomic with OpenClaw
+
+OpenClaw is the open-source desktop client for self-hosted and frontier LLMs with native **Model Context Protocol** support. Combine OpenClaw with AnythingMCP's Playtomic connector and you can search available padel courts on Playtomic with OpenClaw — locally, with whatever model you prefer (Llama, Mistral, Qwen, GPT-4o, Claude…), no SaaS lock-in:
+
+- *"Find indoor crystal padel courts free tomorrow within 20 km of my home."*
+- *"Show me the cheapest 90-minute slots this week."*
+- *"List open matches at my padel level near Madrid this weekend."*
+- *"Summarise my last 30 days of Playtomic activity."*
+
+OpenClaw routes the tool calls through MCP and your model handles the natural-language reasoning.
+
+### Two connectors, pick your level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero | Email + password |
+| Tools | 4 (read-only) | 13 (read-only) |
+| Pricing | Generic | Member discounts applied |
+| Best for | Sharing prompt presets, demos, embedded bots | Personal daily use |
+
+### Prerequisites
+
+- OpenClaw installed on macOS, Windows or Linux.
+- A Playtomic account (full connector only).
+- AnythingMCP running locally or on cloud.anythingmcp.com.
+
+### Step 1 — Install the Playtomic adapter
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Open `http://localhost:3000/connectors/store` → search **Playtomic** → install **Playtomic (Public)** (zero config) and/or **Playtomic** (paste `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`).
+
+Mint an MCP API key under **Profile → MCP API Keys → New Key**.
+
+### Step 2 — Add the MCP server to OpenClaw
+
+OpenClaw stores MCP server configuration in its **Settings → Model Context Protocol** panel. Add a new server:
+
+- **Name:** `Playtomic`
+- **Transport:** HTTP
+- **URL:** `https://cloud.anythingmcp.com/mcp`
+- **Headers:** `Authorization: Bearer YOUR_MCP_API_KEY`
+
+Save. OpenClaw connects, lists Playtomic tools, and they become available in any chat regardless of the underlying model.
+
+### Available tools
+
+#### Playtomic Public (4 tools, no auth)
+
+| Tool | What it does |
+|---|---|
+| `playtomic_search_tenants` | Geo search for padel clubs |
+| `playtomic_get_tenant` | Full club detail with courts |
+| `playtomic_get_availability` | Free slots + prices for a date |
+| `playtomic_get_sport_configuration` | Sport enums |
+
+#### Playtomic full (13 tools, login)
+
+Discovery + your account + open matches + recommendations + tournaments + leagues. See [the Claude guide](./connect-playtomic-to-claude) for the full table.
+
+### Why OpenClaw + Playtomic is a strong pairing
+
+- **Privacy** — search padel courts without sending the query to a US-hosted commercial LLM. Run a local model and only Playtomic sees your IP.
+- **Cost** — no per-token bill for daily padel availability checks.
+- **Model freedom** — swap Llama 3 for Mixtral for GPT-4o for Claude Sonnet, all hitting the same Playtomic tools.
+
+### FAQ
+
+**Does this work offline?**
+The LLM half can be offline (local model). The Playtomic half needs internet — it's hitting `app.playtomic.io`.
+
+**Which local models handle MCP tool calls best?**
+For padel-style structured questions, any model with solid function-calling: Llama 3.1 70B, Mixtral 8×22B, Qwen 2.5 Coder, Hermes 3. Smaller 8 B models work for the public connector's 4 tools; the full 13-tool variant benefits from larger models.
+
+**Where does the bearer token live on my machine?**
+OpenClaw stores it in the system keychain on macOS / Windows Credential Manager / Linux secret service. Never in plain config.
+
+**Can I disable the full connector and only allow the public one?**
+Yes — install only **Playtomic (Public)**, or disable the full connector in AnythingMCP's catalog UI.
+
+### Next steps
+
+- [Connect Playtomic to Claude](./connect-playtomic-to-claude)
+- [Connect Playtomic to ChatGPT](./connect-playtomic-to-chatgpt)
+- [Connect Playtomic to Copilot](./connect-playtomic-to-copilot)
+- [Find padel courts with AI — the cross-client guide](./find-padel-courts-with-ai)
diff --git a/content/guides/en/find-padel-courts-with-ai.mdx b/content/guides/en/find-padel-courts-with-ai.mdx
new file mode 100644
index 0000000..120ee6e
--- /dev/null
+++ b/content/guides/en/find-padel-courts-with-ai.mdx
@@ -0,0 +1,104 @@
+---
+title: "Find Padel Courts with AI — Playtomic + Claude, ChatGPT, Copilot, OpenClaw"
+description: "Stop scrolling the Playtomic app. Let any AI assistant — Claude, ChatGPT, Copilot, OpenClaw — search available padel courts on Playtomic, compare prices, and find open matches at your level. One MCP connector, four clients."
+category: "connectors"
+keyword: "find padel court with AI, search padel courts Playtomic AI, padel court availability AI, padel booking assistant, padel Claude ChatGPT, Playtomic MCP"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "en"
+---
+
+
+
+
+
+## Find padel courts with AI — the short version
+
+Padel is exploding across Europe. Finding a free court at the right time, in the right kind of room, at the right price, still means tapping through Playtomic's mobile app: scroll the club list, open one, swipe to the date, eyeball the calendar, back out, try another. It's the kind of task that's *exactly* the wrong shape for a phone screen, and *exactly* the right shape for a language model.
+
+This page is the cross-client overview. Pick your AI assistant and jump in:
+
+- 🟣 **[Search padel courts with Claude](./connect-playtomic-to-claude)** — Claude Desktop, Claude Code, claude.ai web.
+- 🟢 **[Search padel courts with ChatGPT](./connect-playtomic-to-chatgpt)** — ChatGPT Plus / Team / Enterprise.
+- 🔵 **[Search padel courts with GitHub Copilot](./connect-playtomic-to-copilot)** — Copilot Chat in VS Code.
+- 🦫 **[Search padel courts with OpenClaw](./connect-playtomic-to-openclaw)** — open-source desktop client, any local or cloud LLM.
+
+All four use the same backend: the Playtomic connector for [AnythingMCP](https://github.com/HelpCode-ai/anythingmcp). One install, all clients.
+
+## How it works
+
+[AnythingMCP](https://anythingmcp.com) is an open-source server that exposes any API as MCP (Model Context Protocol) tools. The Playtomic connector wraps Playtomic's internal API — the same one used by the mobile app — and turns it into 4 to 13 tools your AI can call directly:
+
+```
+You → "Find padel courts near Barcelona Saturday night under €40 for 90 minutes"
+ ↓
+AI client (Claude / ChatGPT / Copilot / OpenClaw)
+ ↓ MCP
+AnythingMCP server
+ ↓ HTTP
+Playtomic /api/v1/tenants + /api/v1/availability
+ ↓
+Filtered shortlist of free, affordable courts
+```
+
+## Two connectors, pick your level
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero — install and go | Playtomic email + password |
+| Tools | 4 (clubs, availability, sport config) | 13 (everything + your profile, level, stats, open matches, recommendations) |
+| Pricing | Generic | Member discounts applied |
+| Best for | Sharing prompts, public bots, quick demos | Daily personal use, level-matched matches |
+
+The **public** connector is unique to Playtomic among AnythingMCP integrations: it works with **zero credentials**, because Playtomic's tenant-list and availability endpoints are open by design. If you only want to find free courts, the public adapter is enough — and lets you share Playtomic-aware prompts with anyone, no per-user setup.
+
+## What you can ask
+
+Generic, model-agnostic prompts that work across all four clients (with the **public** connector and a few that need the full one):
+
+| Need | Example prompt | Connector |
+|---|---|---|
+| Court near me, tonight | *"Padel slots within 15 km tonight after 7 PM, 60–90 min."* | public |
+| Compare prices | *"Cheapest 90-minute crystal courts in Madrid Sunday morning."* | public |
+| Indoor only | *"Indoor padel courts free tomorrow evening in Berlin."* | public |
+| My current level | *"What's my padel level right now?"* | full |
+| Open match at my level | *"Open matches at my level this weekend near my home."* | full |
+| Stats | *"How many matches have I played this year?"* | full |
+| Top clubs | *"At which clubs have I played most over the last 3 months?"* | full |
+| Upcoming tournament | *"Padel tournaments in Spain in the next 60 days."* | full |
+
+## Automate the search
+
+The same connector works for one-off questions and for recurring automation. Pair the AI of your choice with its scheduler (Claude Code session, ChatGPT scheduled prompts, cron + Copilot CLI, OpenClaw + system cron) and you have an always-on padel watcher:
+
+- *"Every Friday at 5 PM: cheapest Saturday-morning slots within 20 km of home."*
+- *"Every Sunday evening: open matches at my level for the coming week."*
+- *"On the 1st of each month: monthly stats summary + top club."*
+
+Because AnythingMCP caches the Playtomic JWT server-side and refreshes it transparently, scheduled runs never re-login from scratch.
+
+## Why this beats the Playtomic app
+
+- **One query, multiple clubs** — the app makes you open clubs one by one; the AI fans out across all clubs in your radius in one shot.
+- **Constraints in plain English** — "indoor, crystal, under €40, 90 minutes, between 18 and 21" is one sentence to the AI vs. five filters in the app.
+- **Joins** — the AI can cross-reference availability with court properties (indoor/outdoor, single/double, crystal/panoramic) so you don't get a free slot and discover it's the unloved street-side court.
+- **Recurring** — schedules are first-class, not a workaround.
+
+## Stability and ethics
+
+The Playtomic API used here is **undocumented and reverse-engineered** from the iOS app. It's stable in practice (it has to be, the app depends on it), but Playtomic offers no SLA. AnythingMCP keeps request volume low (≤1 req/s steady state per user) and identifies itself honestly — no User-Agent spoofing.
+
+If you find a free-court bot useful, the polite thing to do is to actually book courts through Playtomic when you find one. That keeps the API economically interesting for them to maintain.
+
+## Get started
+
+The fastest path is the **public** connector. No account, no credentials, ~3 minutes of setup:
+
+1. Pick your AI client below.
+2. Follow the corresponding guide — each is 3 steps.
+3. First prompt: *"Find padel courts within 25 km of [your city] this Saturday between 18:00 and 21:00."*
+
+- [Search padel courts with Claude](./connect-playtomic-to-claude)
+- [Search padel courts with ChatGPT](./connect-playtomic-to-chatgpt)
+- [Search padel courts with Copilot](./connect-playtomic-to-copilot)
+- [Search padel courts with OpenClaw](./connect-playtomic-to-openclaw)
diff --git a/content/guides/it/connect-playtomic-to-chatgpt.mdx b/content/guides/it/connect-playtomic-to-chatgpt.mdx
new file mode 100644
index 0000000..747b00f
--- /dev/null
+++ b/content/guides/it/connect-playtomic-to-chatgpt.mdx
@@ -0,0 +1,122 @@
+---
+title: "Cercare campi da padel disponibili su Playtomic con ChatGPT"
+description: "Porta Playtomic dentro ChatGPT con il connettore MCP di AnythingMCP. Cerca campi da padel disponibili su Playtomic con ChatGPT, confronta i prezzi, trova partite aperte al tuo livello — senza uscire dalla chat."
+category: "connectors"
+keyword: "cercare campi da padel su Playtomic con ChatGPT, Playtomic ChatGPT, padel ChatGPT, prenotare padel GPT, automatizzare padel ChatGPT, padel MCP ChatGPT"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "it"
+---
+
+
+
+
+
+> 💡 **Niente installazione? Usa [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** Accedi, vai su **Connectors → Playtomic**, incolla email e password (oppure scegli **Playtomic Public** per zero setup), crea una chiave API MCP. Niente Docker, niente clone. Salta alla sezione *Aggiungi il connettore in ChatGPT*.
+
+## Cercare campi da padel disponibili su Playtomic con ChatGPT
+
+ChatGPT supporta il **Model Context Protocol** nei connettori personalizzati sui piani Plus, Team ed Enterprise. Con AnythingMCP che espone Playtomic come tool MCP, puoi cercare campi da padel disponibili su Playtomic con ChatGPT in italiano:
+
+- *"Mostrami slot da 90 minuti liberi sabato tra le 18 e le 20 entro 25 km da Milano."*
+- *"Trova i campi indoor in cristallo più economici a Madrid per domani."*
+- *"Quali circoli a Barcellona hanno campi liberi la sera nei giorni feriali?"*
+- *"Ci sono partite aperte al mio livello questo weekend?"*
+
+ChatGPT chiama l'API Playtomic via MCP e ti restituisce una shortlist con circoli, orari e prezzi.
+
+### Due connettori, scegli il tuo livello
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero | Email + password |
+| Tool | 4 (circoli, disponibilità, configurazione) | 13 (tutto + profilo, livello, statistiche, partite) |
+| Prezzi | Generici | Sconti soci applicati |
+| Ideale per | Bot pubblici, ricerca embedded, prova | Uso quotidiano, partite al tuo livello |
+
+Puoi installarli entrambi — non si pestano i piedi.
+
+### Prerequisiti
+
+- Un account Playtomic (solo per il connettore full).
+- AnythingMCP in locale o su [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- ChatGPT Plus / Team / Enterprise (i connettori personalizzati richiedono un piano a pagamento).
+
+### Passo 1 — Recupera l'accesso Playtomic (solo full)
+
+Per il **public** salta al Passo 2 — niente account. Per il **full** accedi su https://playtomic.io e tieni a portata email + password.
+
+### Passo 2 — Installa il connettore Playtomic su cloud.anythingmcp.com (no code)
+
+1. Accedi su **[cloud.anythingmcp.com](https://cloud.anythingmcp.com)**.
+2. Apri **Connectors → Playtomic → Install** (oppure **Playtomic (Public)** per la variante zero-setup).
+3. Per l'adapter full, incolla:
+ - `PLAYTOMIC_EMAIL` — la tua email Playtomic
+ - `PLAYTOMIC_PASSWORD` — la tua password (cifrata a riposo, inviata solo in TLS)
+4. Crea una chiave API MCP in **Profile → MCP API Keys → New Key**. Copiala.
+
+### Passo 3 — Aggiungi il connettore in ChatGPT (no code, 4 click)
+
+1. Apri **ChatGPT → Settings → Connectors → Add custom connector** (solo piani a pagamento).
+2. Compila:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer → incolla la tua chiave API MCP
+3. Clicca **Save** e approva la lista dei tool.
+4. Apri una nuova chat → l'icona 🔧 mostra tutti i tool Playtomic. Fai la tua domanda padel.
+
+Il refresh del JWT (~1 h), i retry sui `401` e il caching del token sono gestiti server-side. Non vedi mai il layer auth di Playtomic.
+
+### Tool disponibili
+
+#### Playtomic Public (4 tool, niente auth)
+
+| Tool | Cosa fa |
+|---|---|
+| `playtomic_search_tenants` | Cerca circoli vicino a una coordinata |
+| `playtomic_get_tenant` | Dettaglio completo di un circolo |
+| `playtomic_get_availability` | Slot liberi per un giorno, con prezzi |
+| `playtomic_get_sport_configuration` | Enum canonici |
+
+#### Playtomic full (13 tool, login)
+
+| Gruppo | Tool |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Il tuo account** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Partite** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Eventi** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Automatizza con i prompt schedulati di ChatGPT
+
+ChatGPT Plus / Team include i **prompt schedulati**. Esempi pronti:
+
+- *"Ogni venerdì alle 17, elenca gli slot da 90 minuti più economici per padel sabato mattina vicino casa."*
+- *"La domenica sera, mostrami le partite di padel aperte al mio livello per la settimana che inizia."*
+- *"Il primo di ogni mese, riassumi quante partite ho giocato e dove sono andato di più."*
+
+Il JWT Playtomic viene riusato fra esecuzioni — niente login ripetuti.
+
+### FAQ
+
+**L'API Playtomic è ufficiale?**
+No. È un'API interna non documentata usata dall'app Playtomic; può cambiare senza preavviso.
+
+**Posso prenotare via ChatGPT?**
+No, questo connettore è in sola lettura. Usa ChatGPT per trovare lo slot, poi prenota dall'app.
+
+**Il connettore pubblico restituisce prezzi sbagliati?**
+Restituisce prezzi *generici*. Se hai sconti soci, installa il connettore **full** — passa `user_id=me` e vedi i prezzi da socio.
+
+**Perché non vedo "Add connector" in ChatGPT?**
+I connettori personalizzati richiedono Plus, Team o Enterprise. Sui piani gratuiti non si possono aggiungere server MCP — fai upgrade oppure usa Claude o Copilot.
+
+**Quali sport sono supportati?**
+Soprattutto `PADEL`, ma anche `TENNIS` e `FUTSAL` dove disponibili.
+
+### Prossimi passi
+
+- [Collegare Playtomic a Claude](./connect-playtomic-to-claude)
+- [Collegare Playtomic a Copilot](./connect-playtomic-to-copilot)
+- [Collegare Playtomic a OpenClaw](./connect-playtomic-to-openclaw)
+- [Cercare campi da padel con l'AI — guida cross-client](./find-padel-courts-with-ai)
diff --git a/content/guides/it/connect-playtomic-to-claude.mdx b/content/guides/it/connect-playtomic-to-claude.mdx
new file mode 100644
index 0000000..985ad03
--- /dev/null
+++ b/content/guides/it/connect-playtomic-to-claude.mdx
@@ -0,0 +1,171 @@
+---
+title: "Cercare campi da padel disponibili su Playtomic con Claude AI"
+description: "Collega Playtomic a Claude Desktop o Claude Code tramite AnythingMCP. Cerca campi da padel disponibili su Playtomic con Claude, confronta i prezzi dei circoli, trova partite aperte al tuo livello — tutto in linguaggio naturale, senza più navigare l'app."
+category: "connectors"
+keyword: "cercare campi da padel su Playtomic con Claude, padel Claude AI, prenotare padel con Claude, Playtomic Claude, automatizzare ricerca padel, assistente padel AI"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "it"
+---
+
+
+
+
+
+> 💡 **Niente installazione? Usa [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** Accedi, vai su **Connectors → Playtomic**, incolla email e password Playtomic (oppure scegli **Playtomic Public** per zero setup), crea una chiave API MCP — fatto. Niente Docker, niente `git clone`, niente server locale. Salta direttamente alla sezione *Aggiungi il connettore in Claude*.
+
+## Cercare campi da padel disponibili su Playtomic con Claude — basta scrollare l'app
+
+Il padel è lo sport con racchetta che cresce più in fretta in Europa, ma cercare un campo libero su Playtomic significa ancora aprire l'app, saltare da un circolo all'altro, confrontare i prezzi e indovinare quali campi sono al coperto. Collega Playtomic a **Claude** con AnythingMCP e chiedi una volta sola, in italiano:
+
+- *"Trovami un campo da padel entro 20 km da Milano sabato sera tra le 19 e le 21."*
+- *"Confronta i prezzi degli slot da 90 minuti nei circoli di Roma per domani mattina."*
+- *"Mostrami i campi indoor in cristallo liberi giovedì sera a Bologna."*
+- *"Ci sono partite aperte al mio livello questo weekend vicino a casa?"*
+
+Claude interroga l'API Playtomic, incrocia campi e disponibilità e ti restituisce una shortlist — di solito più veloce dell'app ufficiale.
+
+### Due connettori, scegli il tuo livello
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero — installi e via | Email + password |
+| Tool | 4 (circoli, disponibilità, configurazione) | 13 (tutto + profilo, livello, statistiche, partite aperte) |
+| Prezzi | Generici | Sconti soci applicati |
+| Ideale per | Provare, bot pubblici, ricerca pubblica | Uso quotidiano personale, partite al tuo livello |
+
+Puoi installarli entrambi — non entrano in conflitto. La maggior parte degli utenti sceglie **full** per uso personale; **public** è perfetto per onboarding rapidi o bot condivisi.
+
+### Prerequisiti
+
+- Un account Playtomic (solo per il connettore full). Il piano gratuito basta.
+- AnythingMCP in locale o su [cloud.anythingmcp.com](https://cloud.anythingmcp.com).
+- Claude Desktop, Claude Code, o [claude.ai](https://claude.ai) su un piano a pagamento che supporti i connettori personalizzati.
+
+### Passo 1 — Recupera l'accesso Playtomic (solo connettore full)
+
+Se vuoi solo l'adapter **public** in sola lettura, salta al Passo 2 — nessun account necessario.
+
+Per l'adapter **full**:
+
+1. Accedi (o registrati) su https://playtomic.io.
+2. Annota email e password. AnythingMCP cifra la password a riposo (AES-256-GCM) e la invia solo via TLS all'endpoint di login Playtomic.
+
+Non esiste una API key da generare. Playtomic non ha una console sviluppatori pubblica; questo connettore usa lo stesso endpoint `/api/v3/auth/login` dell'app mobile.
+
+### Passo 2 — Installa il connettore Playtomic
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Apri `http://localhost:3000/connectors/store`, cerca **Playtomic** e scegli:
+
+- **Playtomic (Public)** → clicca **Installa**. Fatto. Niente credenziali.
+- **Playtomic** → inserisci `PLAYTOMIC_EMAIL` e `PLAYTOMIC_PASSWORD`, poi **Installa**.
+
+I 4 tool pubblici o i 13 tool completi sono ora nel tuo catalogo.
+
+### Passo 3 — Aggiungi il connettore in Claude (no code, 4 click)
+
+Il percorso consigliato — funziona su **claude.ai web** senza toccare file di configurazione.
+
+1. Apri **[claude.ai/customize/connectors](https://claude.ai/customize/connectors)**.
+2. Clicca **"Add custom connector"**.
+3. Compila:
+ - **Name:** `Playtomic`
+ - **URL:** `https://cloud.anythingmcp.com/mcp`
+ - **Authentication:** Bearer token → incolla la tua chiave API MCP (da AnythingMCP → **Profile → MCP API Keys → New Key**)
+4. Clicca **Connect** per autorizzare.
+
+Tutti i tool Playtomic appaiono in chat. Il caching del token, il refresh del JWT (~1 ora) e il retry sui `401` sono gestiti server-side.
+
+
+Avanzato: Claude Desktop / Claude Code (JSON / CLI)
+
+Per le **app desktop**, l'interfaccia web non si applica — modifichi un file di config locale.
+
+**Claude Desktop** — modifica `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) o `%AppData%\Claude\claude_desktop_config.json` (Windows):
+
+```json
+{
+ "mcpServers": {
+ "playtomic": {
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": {
+ "Authorization": "Bearer YOUR_MCP_API_KEY"
+ }
+ }
+ }
+}
+```
+
+Riavvia Claude Desktop. I tool Playtomic appaiono nel menu 🔧.
+
+**Claude Code** — un solo comando CLI:
+
+```bash
+claude mcp add playtomic \
+ --transport http \
+ --url https://cloud.anythingmcp.com/mcp \
+ --header "Authorization: Bearer YOUR_MCP_API_KEY"
+```
+
+Verifica con `claude mcp list`.
+
+
+
+### Tool disponibili
+
+#### Playtomic Public (4 tool, niente auth)
+
+| Tool | Cosa fa |
+|---|---|
+| `playtomic_search_tenants` | Cerca circoli vicino a una coordinata, filtra per sport / raggio |
+| `playtomic_get_tenant` | Dettaglio completo di un circolo (campi, orari, gallery) |
+| `playtomic_get_availability` | Slot liberi per un giorno, con prezzi |
+| `playtomic_get_sport_configuration` | Enum canonici di sport / durate / superfici |
+
+#### Playtomic full (13 tool, login)
+
+| Gruppo | Tool |
+|---|---|
+| **Discovery** | `playtomic_search_tenants`, `playtomic_get_tenant`, `playtomic_get_availability`, `playtomic_get_sport_configuration` |
+| **Il tuo account** | `playtomic_get_my_profile`, `playtomic_get_my_level`, `playtomic_get_my_stats`, `playtomic_get_top_clubs` |
+| **Partite** | `playtomic_find_open_matches`, `playtomic_get_match`, `playtomic_match_recommendations` |
+| **Eventi** | `playtomic_list_tournaments`, `playtomic_list_leagues` |
+
+### Automatizza — ricerche padel ricorrenti
+
+Abbina Claude a uno scheduler (cron, Shortcuts su Apple, n8n, una sessione ricorrente di Claude Code) e trasforma una richiesta in un'abitudine:
+
+- *"Ogni venerdì alle 17, mandami gli slot da 90 minuti più economici vicino casa per sabato mattina."*
+- *"La domenica sera, mostrami le partite aperte al mio livello in città per la settimana che inizia."*
+- *"Una volta al mese, riassumi quante partite ho giocato e in che circolo sono andato di più."*
+
+Il token cache di AnythingMCP è server-side, quindi le esecuzioni schedulate riusano lo stesso JWT — niente login ripetuti.
+
+### FAQ
+
+**AnythingMCP conserva la mia password Playtomic in chiaro?**
+Solo dentro il blob cifrato `authConfig` (AES-256-GCM). La password viaggia in TLS verso l'endpoint di login Playtomic, mai loggata.
+
+**L'API Playtomic è ufficiale?**
+No. È un'API interna non documentata usata dall'app mobile Playtomic, ricostruita per uso in sola lettura. Gli endpoint possono cambiare senza preavviso — se un tool smette di funzionare, controlla il repository AnythingMCP per gli aggiornamenti.
+
+**Posso prenotare un campo via Claude?**
+No, non con questo connettore. Playtomic non ha un'API di booking pubblica documentata e il flusso di pagamento è fuori scope. Usa Claude per trovare lo slot giusto, poi prenota dall'app Playtomic.
+
+**Il connettore pubblico restituisce prezzi sbagliati?**
+Restituisce i prezzi *generici* Playtomic. Se hai membership/sconti al tuo circolo, installa il connettore **full** — passa `user_id=me` quindi vedi le tariffe da socio.
+
+**Quali sport sono supportati?**
+Soprattutto `PADEL`, ma anche `TENNIS` e `FUTSAL` dove i circoli li pubblicano su Playtomic.
+
+### Prossimi passi
+
+- [Collegare Playtomic a ChatGPT](./connect-playtomic-to-chatgpt)
+- [Collegare Playtomic a Copilot](./connect-playtomic-to-copilot)
+- [Collegare Playtomic a OpenClaw](./connect-playtomic-to-openclaw)
+- [Cercare campi da padel con l'AI — guida cross-client](./find-padel-courts-with-ai)
diff --git a/content/guides/it/connect-playtomic-to-copilot.mdx b/content/guides/it/connect-playtomic-to-copilot.mdx
new file mode 100644
index 0000000..1447d00
--- /dev/null
+++ b/content/guides/it/connect-playtomic-to-copilot.mdx
@@ -0,0 +1,113 @@
+---
+title: "Cercare campi da padel disponibili su Playtomic con GitHub Copilot"
+description: "Aggiungi Playtomic a GitHub Copilot Chat dentro VS Code grazie al connettore MCP di AnythingMCP. Cerca campi da padel disponibili su Playtomic con Copilot mentre programmi e costruisci workflow padel-aware."
+category: "connectors"
+keyword: "cercare campi da padel su Playtomic con Copilot, Playtomic Copilot, padel VS Code, GitHub Copilot Playtomic, padel MCP Copilot"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "it"
+---
+
+
+
+
+
+> 💡 **Niente installazione? Usa [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** Crea una chiave API MCP, punta Copilot a `https://cloud.anythingmcp.com/mcp`, fatto.
+
+## Cercare campi da padel disponibili su Playtomic con GitHub Copilot
+
+GitHub Copilot Chat in VS Code supporta il **Model Context Protocol**. Con AnythingMCP che espone Playtomic come tool MCP, puoi cercare campi da padel disponibili su Playtomic con Copilot dentro l'editor — comodo se stai sviluppando un side-project legato al padel, o vuoi infilare uno slot del sabato tra un commit e l'altro:
+
+- *"Mostrami i campi da padel liberi entro 20 km stasera dopo le 19."*
+- *"Esporta la mia storia partite padel di quest'anno come JSON da incollare in una fixture di test."*
+- *"Genera un'espressione CRON che parte il venerdì alle 17 e interroga Playtomic per gli slot di sabato mattina."*
+
+Copilot chiama Playtomic via MCP e ti restituisce risultati strutturati, da incollare direttamente nel codice o in una risposta in chat.
+
+### Due connettori, scegli il tuo livello
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero | Email + password |
+| Tool | 4 (sola lettura) | 13 (sola lettura) |
+| Prezzi | Generici | Sconti soci applicati |
+| Ideale per | Bot pubblici, demo, ricerca embedded | Uso personale, partite al tuo livello |
+
+### Prerequisiti
+
+- VS Code con l'estensione GitHub Copilot Chat (supporto MCP).
+- Un account Playtomic (solo per il connettore full).
+- AnythingMCP in locale o su cloud.anythingmcp.com.
+
+### Passo 1 — Installa il connettore Playtomic
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Apri `http://localhost:3000/connectors/store` → cerca **Playtomic** → installa **Playtomic (Public)** (no creds) oppure **Playtomic** (inserisci `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`).
+
+Crea una chiave API MCP in **Profile → MCP API Keys → New Key**.
+
+### Passo 2 — Aggiungi il server MCP a Copilot in VS Code
+
+Aggiungi/aggiorna `.vscode/mcp.json` nel workspace (o quello a livello utente `~/.config/Code/User/mcp.json`):
+
+```json
+{
+ "servers": {
+ "playtomic": {
+ "type": "http",
+ "url": "https://cloud.anythingmcp.com/mcp",
+ "headers": { "Authorization": "Bearer YOUR_MCP_API_KEY" }
+ }
+ }
+}
+```
+
+Ricarica la finestra di VS Code. Apri Copilot Chat → clicca il selettore 🔧 **Tools** → abilita Playtomic. Inizia a chiedere.
+
+### Tool disponibili
+
+#### Playtomic Public (4 tool)
+
+| Tool | Cosa fa |
+|---|---|
+| `playtomic_search_tenants` | Geo search circoli padel |
+| `playtomic_get_tenant` | Dettaglio singolo circolo |
+| `playtomic_get_availability` | Slot liberi + prezzi |
+| `playtomic_get_sport_configuration` | Enum sport (durate, tipi di campo) |
+
+#### Playtomic full (13 tool)
+
+Discovery + account + partite aperte + recommendations + tornei + leghe. Tabella completa nella [guida Claude](./connect-playtomic-to-claude).
+
+### Workflow "padel + codice" che funzionano
+
+Copilot rende Playtomic davvero utile per chi sviluppa qualcosa di adiacente al padel:
+
+- *"Sto scrivendo un'app trova-campi. Chiama `playtomic_search_tenants` per 5 città europee e scrivimi un seed Postgres."*
+- *"Genera un tipo TypeScript per la risposta di `playtomic_get_availability` — usa il JSON che ottengo davvero."*
+- *"Plotta gli ultimi 12 mesi di `playtomic_get_my_stats` in una config chartjs."*
+
+### FAQ
+
+**Funziona senza GitHub Copilot Pro?**
+L'integrazione MCP di Copilot Chat è inclusa nei piani Pro e Business. Anche il tier personale ha supporto MCP nelle release recenti di VS Code.
+
+**La chiave API MCP la metto in `mcp.json` o in un `.env`?**
+Entrambi vanno bene. Per un workspace condiviso, usa l'interpolazione `${env:ANYTHINGMCP_KEY}` in `mcp.json` e tieni la chiave in `.env` (gitignored).
+
+**Posso girare AnythingMCP localmente e saltare cloud.anythingmcp.com?**
+Sì — punta Copilot a `http://localhost:4000/mcp` e usa una chiave API locale.
+
+**Perché `playtomic_get_my_profile` fallisce?**
+Probabilmente hai installato la variante **public**, che è senza auth. Installa **Playtomic (full)** se ti servono i tool sui dati personali.
+
+### Prossimi passi
+
+- [Collegare Playtomic a Claude](./connect-playtomic-to-claude)
+- [Collegare Playtomic a ChatGPT](./connect-playtomic-to-chatgpt)
+- [Collegare Playtomic a OpenClaw](./connect-playtomic-to-openclaw)
+- [Cercare campi da padel con l'AI — guida cross-client](./find-padel-courts-with-ai)
diff --git a/content/guides/it/connect-playtomic-to-openclaw.mdx b/content/guides/it/connect-playtomic-to-openclaw.mdx
new file mode 100644
index 0000000..7db6dc2
--- /dev/null
+++ b/content/guides/it/connect-playtomic-to-openclaw.mdx
@@ -0,0 +1,105 @@
+---
+title: "Cercare campi da padel disponibili su Playtomic con OpenClaw"
+description: "Collega Playtomic a OpenClaw via AnythingMCP. Cerca campi da padel disponibili su Playtomic con OpenClaw e LLM locali, automatizza alert sui campi liberi, mantieni i workflow padel sulla tua macchina."
+category: "connectors"
+keyword: "cercare campi da padel su Playtomic con OpenClaw, Playtomic OpenClaw, Playtomic LLM locale, padel self-hosted, padel MCP OpenClaw"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "it"
+---
+
+
+
+
+
+> 💡 **Niente installazione? Usa [cloud.anythingmcp.com](https://cloud.anythingmcp.com).** Crea una chiave API MCP, punta OpenClaw a `https://cloud.anythingmcp.com/mcp`. Fatto.
+
+## Cercare campi da padel disponibili su Playtomic con OpenClaw
+
+OpenClaw è il client desktop open-source per LLM self-hosted e di frontiera con supporto nativo del **Model Context Protocol**. Abbina OpenClaw al connettore Playtomic di AnythingMCP e puoi cercare campi da padel disponibili su Playtomic con OpenClaw — localmente, con il modello che preferisci (Llama, Mistral, Qwen, GPT-4o, Claude…), senza lock-in SaaS:
+
+- *"Trova i campi da padel indoor in cristallo liberi domani entro 20 km da casa."*
+- *"Mostrami gli slot da 90 minuti più economici questa settimana."*
+- *"Elenca le partite aperte al mio livello padel vicino a Madrid questo weekend."*
+- *"Riassumi i miei ultimi 30 giorni di attività Playtomic."*
+
+OpenClaw instrada le chiamate ai tool via MCP e il tuo modello gestisce il ragionamento in linguaggio naturale.
+
+### Due connettori, scegli il tuo livello
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero | Email + password |
+| Tool | 4 (sola lettura) | 13 (sola lettura) |
+| Prezzi | Generici | Sconti soci applicati |
+| Ideale per | Preset condivisi, demo, bot embedded | Uso quotidiano personale |
+
+### Prerequisiti
+
+- OpenClaw installato su macOS, Windows o Linux.
+- Un account Playtomic (solo per il connettore full).
+- AnythingMCP in locale o su cloud.anythingmcp.com.
+
+### Passo 1 — Installa il connettore Playtomic
+
+```bash
+git clone https://github.com/HelpCode-ai/anythingmcp.git
+cd anythingmcp && docker compose up -d
+```
+
+Apri `http://localhost:3000/connectors/store` → cerca **Playtomic** → installa **Playtomic (Public)** (zero config) e/o **Playtomic** (inserisci `PLAYTOMIC_EMAIL` + `PLAYTOMIC_PASSWORD`).
+
+Crea una chiave API MCP in **Profile → MCP API Keys → New Key**.
+
+### Passo 2 — Aggiungi il server MCP a OpenClaw
+
+OpenClaw gestisce la configurazione dei server MCP in **Settings → Model Context Protocol**. Aggiungi un nuovo server:
+
+- **Name:** `Playtomic`
+- **Transport:** HTTP
+- **URL:** `https://cloud.anythingmcp.com/mcp`
+- **Headers:** `Authorization: Bearer YOUR_MCP_API_KEY`
+
+Salva. OpenClaw si connette, elenca i tool Playtomic e questi diventano disponibili in qualsiasi chat, qualunque sia il modello sottostante.
+
+### Tool disponibili
+
+#### Playtomic Public (4 tool)
+
+| Tool | Cosa fa |
+|---|---|
+| `playtomic_search_tenants` | Geo search circoli padel |
+| `playtomic_get_tenant` | Dettaglio circolo con campi |
+| `playtomic_get_availability` | Slot liberi + prezzi per una data |
+| `playtomic_get_sport_configuration` | Enum sport |
+
+#### Playtomic full (13 tool)
+
+Discovery + account + partite aperte + recommendations + tornei + leghe. Tabella completa nella [guida Claude](./connect-playtomic-to-claude).
+
+### Perché OpenClaw + Playtomic è una coppia forte
+
+- **Privacy** — cerca campi padel senza spedire la query a un LLM commerciale ospitato negli USA. Gira un modello locale: solo Playtomic vede il tuo IP.
+- **Costo** — niente bolletta a token per i check di disponibilità quotidiani.
+- **Libertà di modello** — passi da Llama 3 a Mixtral a GPT-4o a Claude Sonnet, sempre con gli stessi tool Playtomic.
+
+### FAQ
+
+**Funziona offline?**
+La metà LLM può girare offline (modello locale). La metà Playtomic richiede internet — chiama `app.playtomic.io`.
+
+**Quali modelli locali gestiscono meglio le chiamate ai tool MCP?**
+Per domande padel strutturate, qualsiasi modello con buon function-calling: Llama 3.1 70B, Mixtral 8×22B, Qwen 2.5 Coder, Hermes 3. I modelli 8 B vanno bene per i 4 tool del connettore public; per i 13 tool del full meglio modelli più grandi.
+
+**Dove sta il bearer token sulla mia macchina?**
+OpenClaw lo memorizza nel keychain di sistema (macOS / Credential Manager su Windows / secret service su Linux). Mai in config in chiaro.
+
+**Posso disabilitare il full e tenere solo il public?**
+Sì — installa solo **Playtomic (Public)**, o disabilita il full nell'interfaccia del catalogo di AnythingMCP.
+
+### Prossimi passi
+
+- [Collegare Playtomic a Claude](./connect-playtomic-to-claude)
+- [Collegare Playtomic a ChatGPT](./connect-playtomic-to-chatgpt)
+- [Collegare Playtomic a Copilot](./connect-playtomic-to-copilot)
+- [Cercare campi da padel con l'AI — guida cross-client](./find-padel-courts-with-ai)
diff --git a/content/guides/it/find-padel-courts-with-ai.mdx b/content/guides/it/find-padel-courts-with-ai.mdx
new file mode 100644
index 0000000..ad7cac6
--- /dev/null
+++ b/content/guides/it/find-padel-courts-with-ai.mdx
@@ -0,0 +1,104 @@
+---
+title: "Cercare campi da padel con l'AI — Playtomic + Claude, ChatGPT, Copilot, OpenClaw"
+description: "Smetti di scorrere l'app Playtomic. Lascia che Claude, ChatGPT, Copilot o OpenClaw cerchino i campi da padel disponibili su Playtomic, confrontino i prezzi e trovino partite aperte al tuo livello. Un connettore MCP, quattro client."
+category: "connectors"
+keyword: "cercare campi da padel con AI, ricerca campi padel Playtomic AI, padel disponibilità AI, assistente padel, padel Claude ChatGPT, Playtomic MCP"
+publishedAt: "2026-05-23"
+adapterSlug: "playtomic"
+lang: "it"
+---
+
+
+
+
+
+## Cercare campi da padel con l'AI — versione breve
+
+Il padel sta esplodendo in tutta Europa. Trovare un campo libero, all'orario giusto, indoor o outdoor giusto, al prezzo giusto, continua a significare scrollare l'app Playtomic: lista circoli, aprine uno, scorri al giorno, occhio al calendario, esci, riprova. È *esattamente* la cosa sbagliata per uno schermo telefonico, e *esattamente* la cosa giusta per un modello linguistico.
+
+Questa pagina è la panoramica cross-client. Scegli il tuo assistente AI e via:
+
+- 🟣 **[Cercare campi da padel con Claude](./connect-playtomic-to-claude)** — Claude Desktop, Claude Code, claude.ai web.
+- 🟢 **[Cercare campi da padel con ChatGPT](./connect-playtomic-to-chatgpt)** — ChatGPT Plus / Team / Enterprise.
+- 🔵 **[Cercare campi da padel con GitHub Copilot](./connect-playtomic-to-copilot)** — Copilot Chat in VS Code.
+- 🦫 **[Cercare campi da padel con OpenClaw](./connect-playtomic-to-openclaw)** — client desktop open-source, qualunque LLM locale o cloud.
+
+Tutti e quattro usano lo stesso backend: il connettore Playtomic per [AnythingMCP](https://github.com/HelpCode-ai/anythingmcp). Un'installazione, tutti i client.
+
+## Come funziona
+
+[AnythingMCP](https://anythingmcp.com) è un server open-source che espone qualsiasi API come tool MCP (Model Context Protocol). Il connettore Playtomic incapsula l'API interna di Playtomic — la stessa usata dall'app — e la trasforma in 4 o 13 tool che la tua AI può chiamare direttamente:
+
+```
+Tu → "Trova campi da padel vicino a Milano sabato sera sotto i 40€ per 90 minuti"
+ ↓
+Client AI (Claude / ChatGPT / Copilot / OpenClaw)
+ ↓ MCP
+Server AnythingMCP
+ ↓ HTTP
+Playtomic /api/v1/tenants + /api/v1/availability
+ ↓
+Shortlist filtrata di campi liberi e accessibili
+```
+
+## Due connettori, scegli il tuo livello
+
+| | **Playtomic Public** | **Playtomic (full)** |
+|---|---|---|
+| Setup | Zero — installi e via | Email + password Playtomic |
+| Tool | 4 (circoli, disponibilità, configurazione) | 13 (tutto + profilo, livello, statistiche, partite, recommendations) |
+| Prezzi | Generici | Sconti soci applicati |
+| Ideale per | Bot pubblici, demo, prompt condivisi | Uso quotidiano, partite al tuo livello |
+
+Il connettore **public** è unico tra gli adapter AnythingMCP: funziona **senza credenziali**, perché gli endpoint Playtomic per la lista dei circoli e la disponibilità sono pubblici di design. Se vuoi solo trovare campi liberi, l'adapter pubblico basta — e ti permette di condividere prompt padel con chiunque, senza setup per utente.
+
+## Cosa puoi chiedere
+
+Prompt generici e indipendenti dal modello, validi su tutti e quattro i client (col **public** + qualcuno che richiede il full):
+
+| Esigenza | Esempio | Connettore |
+|---|---|---|
+| Un campo stasera | *"Slot padel entro 15 km stasera dopo le 19, 60–90 min."* | public |
+| Confronto prezzi | *"Campi in cristallo più economici a Roma domenica mattina, 90 min."* | public |
+| Solo indoor | *"Campi indoor liberi domani sera a Bologna."* | public |
+| Il mio livello attuale | *"Qual è il mio livello di padel ora?"* | full |
+| Partita aperta al mio livello | *"Partite aperte al mio livello questo weekend vicino casa."* | full |
+| Statistiche | *"Quante partite ho giocato quest'anno?"* | full |
+| Top circoli | *"In quali circoli ho giocato di più negli ultimi 3 mesi?"* | full |
+| Tornei futuri | *"Tornei di padel in Italia nei prossimi 60 giorni."* | full |
+
+## Automatizza la ricerca
+
+Lo stesso connettore funziona sia per domande una-tantum sia per automazioni ricorrenti. Abbina l'AI che preferisci al suo scheduler (sessione Claude Code, prompt schedulati ChatGPT, cron + Copilot CLI, OpenClaw + cron di sistema) e hai un sorvegliante padel sempre attivo:
+
+- *"Ogni venerdì alle 17: slot più economici per sabato mattina entro 20 km."*
+- *"La domenica sera: partite aperte al mio livello per la settimana che inizia."*
+- *"Il 1° del mese: statistiche del mese + circolo preferito."*
+
+Il JWT Playtomic è cachato server-side e refreshato in modo trasparente, quindi le esecuzioni schedulate non rifanno mai il login da capo.
+
+## Perché batte l'app Playtomic
+
+- **Una sola query, più circoli** — l'app ti fa aprire i circoli uno alla volta; l'AI li attraversa tutti nel raggio in un colpo solo.
+- **Vincoli in italiano** — "indoor, cristallo, sotto i 40 euro, 90 minuti, tra le 18 e le 21" è una frase per l'AI vs. cinque filtri nell'app.
+- **Join** — l'AI incrocia disponibilità e proprietà del campo (indoor/outdoor, single/double, cristallo/panoramico) così non scopri all'ultimo che lo slot libero è quello sul lato strada.
+- **Ricorrente** — gli scheduler sono di prima classe, non un workaround.
+
+## Stabilità ed etica
+
+L'API Playtomic qui usata è **non documentata e ricostruita** dall'app iOS. È stabile in pratica (deve esserlo, l'app ci dipende), ma Playtomic non offre un SLA. AnythingMCP tiene basso il volume di richieste (≤1 req/s a regime per utente) e si identifica onestamente — niente spoofing dello User-Agent.
+
+Se questo bot ti diventa utile, la cosa corretta è prenotare davvero i campi via Playtomic quando li trovi. Mantiene l'API economicamente interessante da supportare per loro.
+
+## Inizia
+
+Il percorso più rapido è il connettore **public**. Niente account, niente credenziali, ~3 minuti di setup:
+
+1. Scegli il tuo client AI sotto.
+2. Segui la guida corrispondente — ognuna è in 3 passi.
+3. Primo prompt: *"Trova campi da padel entro 25 km da [la tua città] sabato tra le 18 e le 21."*
+
+- [Cercare campi da padel con Claude](./connect-playtomic-to-claude)
+- [Cercare campi da padel con ChatGPT](./connect-playtomic-to-chatgpt)
+- [Cercare campi da padel con Copilot](./connect-playtomic-to-copilot)
+- [Cercare campi da padel con OpenClaw](./connect-playtomic-to-openclaw)
diff --git a/packages/backend/src/adapters/catalog.ts b/packages/backend/src/adapters/catalog.ts
index a21856a..387ceb9 100644
--- a/packages/backend/src/adapters/catalog.ts
+++ b/packages/backend/src/adapters/catalog.ts
@@ -127,6 +127,8 @@ import * as pinterest from './intl/pinterest.json';
import * as pipedrive from './intl/pipedrive.json';
import * as plaid from './intl/plaid.json';
import * as planeSo from './intl/plane-so.json';
+import * as playtomic from './intl/playtomic.json';
+import * as playtomicPublic from './intl/playtomic-public.json';
import * as recurly from './intl/recurly.json';
import * as reddit from './intl/reddit.json';
import * as sageBusinessCloud from './intl/sage-business-cloud.json';
@@ -373,6 +375,8 @@ const RAW_ADAPTERS: AdapterDefinition[] = [
pipedrive as unknown as AdapterDefinition,
plaid as unknown as AdapterDefinition,
planeSo as unknown as AdapterDefinition,
+ playtomic as unknown as AdapterDefinition,
+ playtomicPublic as unknown as AdapterDefinition,
recurly as unknown as AdapterDefinition,
reddit as unknown as AdapterDefinition,
sageBusinessCloud as unknown as AdapterDefinition,
diff --git a/packages/backend/src/adapters/intl/playtomic-public.json b/packages/backend/src/adapters/intl/playtomic-public.json
new file mode 100644
index 0000000..d87000f
--- /dev/null
+++ b/packages/backend/src/adapters/intl/playtomic-public.json
@@ -0,0 +1,138 @@
+{
+ "slug": "playtomic-public",
+ "name": "Playtomic (Public)",
+ "description": "Find padel, tennis, and futsal courts worldwide — read-only, no account needed. Search clubs near you, check court availability and pricing, browse Playtomic's tenant catalog. 4 tools, zero setup.",
+ "instructions": "This connector wraps Playtomic's **public** read endpoints — no login, no API key, no setup. It's the fastest way to give an AI agent the ability to find padel/tennis courts and check availability.\n\n**What you can do without an account**:\n- Search clubs (tenants) by geo coordinate + radius, optionally filtered by sport.\n- Fetch a single club's full details (resources/courts, opening info, address, timezone, images).\n- Read free time slots for a given day across one or more clubs, with prices.\n- Read Playtomic's sport configuration (allowed durations, resource types, sport list).\n\n**What requires the full Playtomic connector instead**:\n- Your own profile, level, match history, social graph.\n- Open matches you can join.\n- Member/club-specific discounted pricing (this connector returns generic pricing).\n- Booking a court (write operations are not exposed — Playtomic has no official public booking API).\n\n**Pricing notes**:\n- `price` is a string like `\"48 EUR\"` — parse amount + currency separately.\n- Same `start_time` may appear multiple times with different `duration` values (60/90/120 min). These are alternative bookings of the same slot, not separate free slots.\n- `duration` is in **minutes**.\n\n**Time handling**:\n- `local_start_min` / `local_start_max` are naive ISO-8601 in the tenant's local timezone — find the timezone in `tenant.address.timezone` (e.g. `Europe/Berlin`).\n- For a full-day window use `2026-05-23T00:00:00` → `2026-05-23T23:59:59`.\n\n**Joining availability back to courts**: every availability row has a `resource_id`; map it back to `tenant.resources[].name` from `get_tenant` to know which court (indoor/outdoor, single/double, etc.).\n\n**Rate limits**: Playtomic has no published public-API SLA. Be gentle — under 1 req/s is safe. The connector identifies itself honestly as AnythingMCP (no UA spoofing).\n\n**Stability**: this is an undocumented/internal API reverse-engineered from the iOS app. Endpoints can change without notice. If a tool breaks, check the docs URL for updates.\n\n**Suggested starter prompts**:\n- \"Find padel clubs within 30 km of Milan that are open today.\"\n- \"What time slots are free on Saturday afternoon at FREIBURG PADEL?\"\n- \"Compare prices across all padel clubs in Madrid for Sunday morning, 90-minute sessions.\"\n- \"Which courts in Barcelona offer indoor crystal padel?\"",
+ "region": "intl",
+ "category": "sports",
+ "icon": "playtomic",
+ "docsUrl": "https://playtomic.io",
+ "featured": true,
+ "priority": 80,
+ "requiredEnvVars": [],
+ "connector": {
+ "name": "Playtomic Public API",
+ "type": "REST",
+ "baseUrl": "https://app.playtomic.io",
+ "authType": "NONE",
+ "authConfig": {}
+ },
+ "tools": [
+ {
+ "name": "playtomic_search_tenants",
+ "description": "Search Playtomic clubs (tenants) — typically by geo coordinate + radius. Returns active clubs with their courts (`resources[]`), address, timezone, and images. Use this first to find clubs near a city, then pass the `tenant_id` values into `playtomic_get_availability` to check free slots.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "coordinate": {
+ "type": "string",
+ "description": "Geo center as `lat,lon` (e.g. `48.0708,7.9006` for Freiburg, `41.3851,2.1734` for Barcelona). Required for geo search."
+ },
+ "radius": {
+ "type": "integer",
+ "description": "Search radius in meters. Default 50000 (50 km). Max practical ~100000.",
+ "default": 50000
+ },
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "description": "Sport filter. Most clubs are PADEL."
+ },
+ "size": {
+ "type": "integer",
+ "description": "Max clubs to return (default 20).",
+ "default": 20,
+ "minimum": 1,
+ "maximum": 100
+ },
+ "page": {
+ "type": "integer",
+ "description": "0-based page index for pagination.",
+ "default": 0
+ }
+ },
+ "required": ["coordinate"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/tenants",
+ "queryParams": {
+ "coordinate": "$coordinate",
+ "radius": "$radius",
+ "sport_id": "$sport_id",
+ "size": "$size",
+ "page": "$page",
+ "playtomic_status": "ACTIVE"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_tenant",
+ "description": "Get full detail of a single Playtomic club by `tenant_id` — including all courts (`resources[]` with indoor/outdoor, single/double, surface), opening info, contact, gallery. Use this after `playtomic_search_tenants` to drill into a specific club, or to enrich availability results (join `availability.resource_id` → `tenant.resources[].name`).",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "tenant_id": {
+ "type": "string",
+ "description": "Tenant UUID from `playtomic_search_tenants` (e.g. `7176a7b5-757e-46c0-8f04-e42ff7219563`)."
+ }
+ },
+ "required": ["tenant_id"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/tenants/{tenant_id}"
+ }
+ },
+ {
+ "name": "playtomic_get_availability",
+ "description": "Read free court slots for a given day at one or more clubs. Returns an array, one entry per court (`resource_id`), each with `slots[]` of `{ start_time, duration (min), price (string like \"48 EUR\") }`. The same `start_time` may appear with multiple durations (60/90/120) — those are alternative bookings, not separate slots.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "description": "Sport.",
+ "default": "PADEL"
+ },
+ "tenant_id": {
+ "type": "string",
+ "description": "One tenant UUID, or several comma-separated (e.g. `id1,id2,id3`). Use IDs returned by `playtomic_search_tenants`."
+ },
+ "local_start_min": {
+ "type": "string",
+ "description": "Naive ISO-8601 lower bound in the tenant's local timezone, e.g. `2026-05-23T00:00:00`. For a full day, pair with `local_start_max` = `T23:59:59` on the same date."
+ },
+ "local_start_max": {
+ "type": "string",
+ "description": "Naive ISO-8601 upper bound, same-day end e.g. `2026-05-23T23:59:59`."
+ }
+ },
+ "required": ["tenant_id", "local_start_min", "local_start_max"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/availability",
+ "queryParams": {
+ "sport_id": "$sport_id",
+ "tenant_id": "$tenant_id",
+ "local_start_min": "$local_start_min",
+ "local_start_max": "$local_start_max"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_sport_configuration",
+ "description": "Read Playtomic's canonical sport configuration — enums for allowed durations, court properties (indoor/outdoor/roofed, single/double, wall/crystal/panoramic), and supported sports. Useful to validate filters before calling other tools.",
+ "parameters": {
+ "type": "object",
+ "properties": {}
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v2/configuration"
+ }
+ }
+ ]
+}
diff --git a/packages/backend/src/adapters/intl/playtomic-public.live.spec.ts b/packages/backend/src/adapters/intl/playtomic-public.live.spec.ts
new file mode 100644
index 0000000..482b014
--- /dev/null
+++ b/packages/backend/src/adapters/intl/playtomic-public.live.spec.ts
@@ -0,0 +1,46 @@
+import * as adapter from './playtomic-public.json';
+
+const a = adapter as unknown as {
+ slug: string;
+ category: string;
+ requiredEnvVars: string[];
+ connector: { baseUrl: string; authType: string; authConfig: Record };
+ tools: Array<{
+ name: string;
+ endpointMapping: { method: string; path: string; queryParams?: Record };
+ }>;
+};
+
+describe('playtomic-public adapter — static spec conformance', () => {
+ it('is the read-only NONE-auth variant in the sports category', () => {
+ expect(a.slug).toBe('playtomic-public');
+ expect(a.category).toBe('sports');
+ expect(a.connector.baseUrl).toBe('https://app.playtomic.io');
+ expect(a.connector.authType).toBe('NONE');
+ expect(a.requiredEnvVars).toEqual([]);
+ });
+
+ it('exposes exactly the 4 public read tools', () => {
+ expect(a.tools.map((t) => t.name).sort()).toEqual([
+ 'playtomic_get_availability',
+ 'playtomic_get_sport_configuration',
+ 'playtomic_get_tenant',
+ 'playtomic_search_tenants',
+ ]);
+ });
+
+ it('search_tenants forces playtomic_status=ACTIVE and accepts geo coordinate', () => {
+ const t = a.tools.find((x) => x.name === 'playtomic_search_tenants')!;
+ expect(t.endpointMapping.method).toBe('GET');
+ expect(t.endpointMapping.path).toBe('/api/v1/tenants');
+ expect(t.endpointMapping.queryParams?.coordinate).toBe('$coordinate');
+ expect(t.endpointMapping.queryParams?.playtomic_status).toBe('ACTIVE');
+ });
+
+ it('availability uses the documented /api/v1/availability path and naive ISO bounds', () => {
+ const t = a.tools.find((x) => x.name === 'playtomic_get_availability')!;
+ expect(t.endpointMapping.path).toBe('/api/v1/availability');
+ expect(t.endpointMapping.queryParams?.local_start_min).toBe('$local_start_min');
+ expect(t.endpointMapping.queryParams?.local_start_max).toBe('$local_start_max');
+ });
+});
diff --git a/packages/backend/src/adapters/intl/playtomic.json b/packages/backend/src/adapters/intl/playtomic.json
new file mode 100644
index 0000000..c033ae4
--- /dev/null
+++ b/packages/backend/src/adapters/intl/playtomic.json
@@ -0,0 +1,387 @@
+{
+ "slug": "playtomic",
+ "name": "Playtomic",
+ "description": "Full Playtomic access for padel, tennis, and futsal players. Search clubs and availability, find open matches to join, read your own profile, level, stats, history, and recommendations. 13 tools, email + password auth with automatic JWT refresh.",
+ "instructions": "## Authentication (handled automatically)\n\nPlaytomic uses email + password to mint a ~1-hour JWT. The AnythingMCP `LOGIN_TOKEN` engine handles login, caching, and refresh:\n\n1. `POST https://app.playtomic.io/api/v3/auth/login` with `{ email, password, requested_user_roles: [\"ROLE_CUSTOMER\"] }`.\n2. The response contains `access_token` (JWT, ~1h TTL) and `refresh_token` (~60d).\n3. Every tool call attaches `Authorization: Bearer `.\n4. The engine proactively re-logs in 60 s before expiry and on any `401`. Tokens are cached encrypted in the `connector_auth_cache` DB table.\n\n## Credentials\n\n- `PLAYTOMIC_EMAIL` — your Playtomic account email.\n- `PLAYTOMIC_PASSWORD` — your plain account password. Stored encrypted; only sent over TLS to Playtomic's login endpoint.\n\n## When dedicated tools are not enough\n\nThe 13 tools below cover the common Playtomic workflows. Anything not exposed (e.g. accepting a join request, creating a match, paying for a booking) requires Playtomic's mobile app — there is no documented public booking write API and we deliberately don't expose write endpoints.\n\n## Public vs full connector\n\nIf you only want to **search clubs and check availability** (no account, no personal data), use the `playtomic-public` connector instead — same 4 read tools but no credentials needed.\n\n## Pricing notes\n\n- `price` is a string like `\"48 EUR\"` — parse amount + currency.\n- The same `start_time` may appear with several `duration` values (60/90/120 min). These are alternative bookings of the same slot, not separate free slots.\n- `duration` is in **minutes**.\n- If your account has linked club memberships, pricing returned by `playtomic_get_availability` reflects your member discount.\n\n## Time handling\n\n- `local_start_min` / `local_start_max` are naive ISO-8601 in the **tenant's** local timezone (see `tenant.address.timezone`, e.g. `Europe/Berlin`). For a full day use `T00:00:00` → `T23:59:59` on the same date.\n- Match/course/tournament date filters use the same naive ISO format unless otherwise noted.\n\n## Joining availability to courts\n\nEvery availability row has a `resource_id`. Map it back to `tenant.resources[]` (from `playtomic_get_tenant`) to know court name, indoor/outdoor, single/double, surface.\n\n## Levels & match recommendations\n\n- `level_value` is your Playtomic skill rating (typically 0–7). `level_confidence` reflects how many matches the rating is based on.\n- `playtomic_match_recommendations` returns open matches at your level near a coordinate. Empty array = no recommendations right now (it's normal).\n\n## Rate limits\n\nPlaytomic has no published SLA. Keep request volume reasonable (≤1 req/s steady state). The engine auto-handles `401` with a retry-after-relogin and gives up after one retry — if you see `401` twice, check that your credentials are correct.\n\n## Stability\n\nThis is an undocumented/internal API reverse-engineered from the Playtomic iOS app. Endpoints can change without notice. If a tool starts failing, check the AnythingMCP docs for a connector update.\n\n## Useful starter prompts\n\n- \"Find open padel matches at my level near Milan this weekend.\" → `playtomic_match_recommendations`\n- \"What's my current padel level on Playtomic?\" → `playtomic_get_my_level`\n- \"How many padel matches have I won this year?\" → `playtomic_get_my_stats`\n- \"At which clubs do I play the most?\" → `playtomic_get_top_clubs`\n- \"Show me free crystal-court slots tomorrow afternoon within 20 km of my home.\" → `playtomic_search_tenants` + `playtomic_get_availability`\n- \"Are there any padel tournaments coming up near Barcelona?\" → `playtomic_list_tournaments`",
+ "region": "intl",
+ "category": "sports",
+ "icon": "playtomic",
+ "docsUrl": "https://playtomic.io",
+ "featured": true,
+ "priority": 90,
+ "requiredEnvVars": ["PLAYTOMIC_EMAIL", "PLAYTOMIC_PASSWORD"],
+ "connector": {
+ "name": "Playtomic",
+ "type": "REST",
+ "baseUrl": "https://app.playtomic.io",
+ "authType": "LOGIN_TOKEN",
+ "authConfig": {
+ "loginUrl": "https://app.playtomic.io/api/v3/auth/login",
+ "loginMethod": "POST",
+ "loginBody": {
+ "requested_user_roles": ["ROLE_CUSTOMER"],
+ "email": "${username}",
+ "password": "${password}"
+ },
+ "username": "{{PLAYTOMIC_EMAIL}}",
+ "password": "{{PLAYTOMIC_PASSWORD}}",
+ "tokenJsonPath": "access_token",
+ "expiryJsonPath": "access_token_expiration",
+ "expiryFormat": "iso8601",
+ "refreshOn401": true,
+ "proactiveRefreshSeconds": 60,
+ "headerName": "Authorization",
+ "headerTemplate": "Bearer ${token}"
+ }
+ },
+ "tools": [
+ {
+ "name": "playtomic_search_tenants",
+ "description": "Search Playtomic clubs (tenants) — typically by geo coordinate + radius. Returns active clubs with their courts (`resources[]`), address, timezone, images. Use this first to find clubs near a city; pass `tenant_id` values into `playtomic_get_availability` to check free slots.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "coordinate": {
+ "type": "string",
+ "description": "Geo center as `lat,lon` (e.g. `48.0708,7.9006`). Required for geo search."
+ },
+ "radius": {
+ "type": "integer",
+ "description": "Search radius in meters. Default 50000 (50 km).",
+ "default": 50000
+ },
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "description": "Sport filter."
+ },
+ "size": {
+ "type": "integer",
+ "description": "Max clubs to return (default 20).",
+ "default": 20,
+ "minimum": 1,
+ "maximum": 100
+ },
+ "page": {
+ "type": "integer",
+ "description": "0-based page index.",
+ "default": 0
+ }
+ },
+ "required": ["coordinate"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/tenants",
+ "queryParams": {
+ "coordinate": "$coordinate",
+ "radius": "$radius",
+ "sport_id": "$sport_id",
+ "size": "$size",
+ "page": "$page",
+ "playtomic_status": "ACTIVE"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_tenant",
+ "description": "Get full detail of a single Playtomic club by `tenant_id` (UUID) — including all courts, opening info, contact, gallery. Use after `playtomic_search_tenants` or to join availability rows to court metadata.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "tenant_id": { "type": "string", "description": "Tenant UUID." }
+ },
+ "required": ["tenant_id"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/tenants/{tenant_id}"
+ }
+ },
+ {
+ "name": "playtomic_get_availability",
+ "description": "Read free court slots for a given day at one or more clubs. With this connector pricing reflects your account (member discounts if any). Returns an array, one entry per court, each with `slots[]` of `{ start_time, duration (min), price (string e.g. \"48 EUR\") }`.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "default": "PADEL"
+ },
+ "tenant_id": {
+ "type": "string",
+ "description": "One tenant UUID, or several comma-separated (e.g. `id1,id2,id3`)."
+ },
+ "local_start_min": {
+ "type": "string",
+ "description": "Naive ISO-8601 lower bound in tenant local time, e.g. `2026-05-23T00:00:00`."
+ },
+ "local_start_max": {
+ "type": "string",
+ "description": "Naive ISO-8601 upper bound, e.g. `2026-05-23T23:59:59`."
+ }
+ },
+ "required": ["tenant_id", "local_start_min", "local_start_max"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/availability",
+ "queryParams": {
+ "sport_id": "$sport_id",
+ "tenant_id": "$tenant_id",
+ "local_start_min": "$local_start_min",
+ "local_start_max": "$local_start_max",
+ "user_id": "me"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_sport_configuration",
+ "description": "Read Playtomic's canonical sport configuration — enums for allowed durations, court properties (indoor/outdoor/roofed, single/double, wall/crystal/panoramic), supported sports. Reference data; rarely changes.",
+ "parameters": { "type": "object", "properties": {} },
+ "endpointMapping": { "method": "GET", "path": "/api/v2/configuration" }
+ },
+ {
+ "name": "playtomic_get_my_profile",
+ "description": "Full profile of the authenticated user — name, email, phone, communications language, `linked_accounts` per club, accepted commercial/privacy flags. Useful as a health check.",
+ "parameters": { "type": "object", "properties": {} },
+ "endpointMapping": { "method": "GET", "path": "/api/v2/users/me" }
+ },
+ {
+ "name": "playtomic_get_my_level",
+ "description": "Your Playtomic skill level per sport — `level_value` (typically 0–7), `level_confidence` (matches-based confidence), `status`. Pass `with_history=true` to include historical level changes.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "with_history": {
+ "type": "boolean",
+ "description": "Include level history.",
+ "default": false
+ }
+ }
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/levels",
+ "queryParams": {
+ "user_id": "me",
+ "with_history": "$with_history"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_my_stats",
+ "description": "Lifetime match results for the authenticated user in a given sport — `played`, `won`, `lost`, `drawn`, `validating`, `rejected`.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "default": "PADEL"
+ }
+ }
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/matches_summary/results",
+ "queryParams": {
+ "player_user_id": "me",
+ "sport_id": "$sport_id"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_top_clubs",
+ "description": "Clubs where the authenticated user plays most often (all-time or last 3 months). Returns `[{ tenant_id, count }]` ordered by frequency. Enrich with `playtomic_get_tenant` to get names.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "default": "PADEL"
+ },
+ "size": {
+ "type": "integer",
+ "description": "Max clubs to return (default 10).",
+ "default": 10
+ },
+ "last_three_months_only": {
+ "type": "boolean",
+ "description": "Restrict to last 3 months (uses the `/last_three_months` variant). Default false (all-time).",
+ "default": false
+ }
+ }
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/matches_summary/top_tenants_by_player",
+ "queryParams": {
+ "player_user_id": "me",
+ "sport_id": "$sport_id",
+ "size": "$size"
+ }
+ }
+ },
+ {
+ "name": "playtomic_find_open_matches",
+ "description": "Search open matches in a date window (people looking for partners). Filter by `match_status` and `join_request_status`. Useful with phrases like 'show me open padel matches this weekend at my level'.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "after_end_date": {
+ "type": "string",
+ "description": "Naive ISO-8601 lower bound on match end date (e.g. `2026-05-23T00:00:00`)."
+ },
+ "before_end_date": {
+ "type": "string",
+ "description": "Naive ISO-8601 upper bound on match end date."
+ },
+ "match_status": {
+ "type": "string",
+ "description": "Comma-separated statuses (default `PENDING,IN_PROGRESS`).",
+ "default": "PENDING,IN_PROGRESS"
+ },
+ "size": {
+ "type": "integer",
+ "description": "Max matches to return.",
+ "default": 20,
+ "minimum": 1,
+ "maximum": 100
+ }
+ },
+ "required": ["after_end_date", "before_end_date"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/matches",
+ "queryParams": {
+ "after_end_date": "$after_end_date",
+ "before_end_date": "$before_end_date",
+ "match_status": "$match_status",
+ "size": "$size",
+ "sort": "start_date,created_at,ASC",
+ "disable_price_calculation": "true"
+ }
+ }
+ },
+ {
+ "name": "playtomic_get_match",
+ "description": "Full detail of a single match by `match_id` — teams, players, location/tenant, lock_id, status.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "match_id": { "type": "string", "description": "Match UUID." }
+ },
+ "required": ["match_id"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/matches/{match_id}"
+ }
+ },
+ {
+ "name": "playtomic_match_recommendations",
+ "description": "Playtomic's algorithmic match recommendations for the authenticated user, given a geo center. Returns open matches at the user's level near the coordinate. Empty array = no recommendations right now.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "coordinate": {
+ "type": "string",
+ "description": "Geo center as `lat,lon`."
+ },
+ "size": {
+ "type": "integer",
+ "description": "Max recommendations.",
+ "default": 10,
+ "minimum": 1,
+ "maximum": 50
+ },
+ "page": { "type": "integer", "default": 0 }
+ },
+ "required": ["coordinate"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/match_recommendations",
+ "queryParams": {
+ "coordinate": "$coordinate",
+ "size": "$size",
+ "page": "$page",
+ "user_id": "me",
+ "with_price_calculation": "false"
+ }
+ }
+ },
+ {
+ "name": "playtomic_list_tournaments",
+ "description": "List tournaments visible to the authenticated user, filtered by start date and status.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "to_start_date": {
+ "type": "string",
+ "description": "Upper bound (naive ISO-8601) on tournament start."
+ },
+ "status": {
+ "type": "string",
+ "description": "Comma-separated statuses.",
+ "default": "PENDING,IN_PROGRESS"
+ },
+ "size": { "type": "integer", "default": 20 }
+ },
+ "required": ["to_start_date"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v2/tournaments",
+ "queryParams": {
+ "to_start_date": "$to_start_date",
+ "status": "$status",
+ "user_id": "me",
+ "size": "$size",
+ "sort": "start_date,created_at,ASC"
+ }
+ }
+ },
+ {
+ "name": "playtomic_list_leagues",
+ "description": "List open leagues near a coordinate, optionally for a sport and skill level.",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "coordinate": { "type": "string", "description": "`lat,lon`." },
+ "radius": { "type": "integer", "default": 50000 },
+ "sport_id": {
+ "type": "string",
+ "enum": ["PADEL", "TENNIS", "FUTSAL"],
+ "default": "PADEL"
+ },
+ "for_level": {
+ "type": "number",
+ "description": "Your level (e.g. 3.5) — Playtomic filters leagues you're eligible for."
+ },
+ "size": { "type": "integer", "default": 10 }
+ },
+ "required": ["coordinate"]
+ },
+ "endpointMapping": {
+ "method": "GET",
+ "path": "/api/v1/leagues",
+ "queryParams": {
+ "coordinate": "$coordinate",
+ "radius": "$radius",
+ "sport_id": "$sport_id",
+ "status": "OPEN,IN_PROGRESS",
+ "visibility": "PUBLIC",
+ "available_places": "true",
+ "for_level": "$for_level",
+ "size": "$size",
+ "page": "0"
+ }
+ }
+ }
+ ]
+}
diff --git a/packages/backend/src/adapters/intl/playtomic.live.spec.ts b/packages/backend/src/adapters/intl/playtomic.live.spec.ts
new file mode 100644
index 0000000..c8087b7
--- /dev/null
+++ b/packages/backend/src/adapters/intl/playtomic.live.spec.ts
@@ -0,0 +1,73 @@
+import * as adapter from './playtomic.json';
+
+const a = adapter as unknown as {
+ slug: string;
+ category: string;
+ requiredEnvVars: string[];
+ connector: {
+ baseUrl: string;
+ authType: string;
+ authConfig: Record;
+ };
+ tools: Array<{
+ name: string;
+ endpointMapping: { method: string; path: string; queryParams?: Record };
+ }>;
+};
+
+describe('playtomic adapter — static spec conformance', () => {
+ it('is the full LOGIN_TOKEN variant in the sports category', () => {
+ expect(a.slug).toBe('playtomic');
+ expect(a.category).toBe('sports');
+ expect(a.connector.baseUrl).toBe('https://app.playtomic.io');
+ expect(a.connector.authType).toBe('LOGIN_TOKEN');
+ expect(a.requiredEnvVars).toEqual(['PLAYTOMIC_EMAIL', 'PLAYTOMIC_PASSWORD']);
+ });
+
+ it('login posts to /api/v3/auth/login with ROLE_CUSTOMER and reads access_token + expiration', () => {
+ const auth = a.connector.authConfig as Record;
+ expect(auth.loginUrl).toBe('https://app.playtomic.io/api/v3/auth/login');
+ expect(auth.loginMethod).toBe('POST');
+ expect(auth.tokenJsonPath).toBe('access_token');
+ expect(auth.expiryJsonPath).toBe('access_token_expiration');
+ expect(auth.expiryFormat).toBe('iso8601');
+ const body = auth.loginBody as Record;
+ expect(body.requested_user_roles).toEqual(['ROLE_CUSTOMER']);
+ expect(body.email).toBe('${username}');
+ expect(body.password).toBe('${password}');
+ });
+
+ it('exposes 13 tools including personal + discovery endpoints', () => {
+ expect(a.tools).toHaveLength(13);
+ const names = a.tools.map((t) => t.name);
+ [
+ 'playtomic_search_tenants',
+ 'playtomic_get_tenant',
+ 'playtomic_get_availability',
+ 'playtomic_get_sport_configuration',
+ 'playtomic_get_my_profile',
+ 'playtomic_get_my_level',
+ 'playtomic_get_my_stats',
+ 'playtomic_get_top_clubs',
+ 'playtomic_find_open_matches',
+ 'playtomic_get_match',
+ 'playtomic_match_recommendations',
+ 'playtomic_list_tournaments',
+ 'playtomic_list_leagues',
+ ].forEach((n) => expect(names).toContain(n));
+ });
+
+ it('availability passes user_id=me so member pricing is applied', () => {
+ const t = a.tools.find((x) => x.name === 'playtomic_get_availability')!;
+ expect(t.endpointMapping.queryParams?.user_id).toBe('me');
+ });
+
+ it('personal tools (level/stats/top_clubs) use player_user_id=me — no numeric ID required', () => {
+ const stats = a.tools.find((x) => x.name === 'playtomic_get_my_stats')!;
+ expect(stats.endpointMapping.queryParams?.player_user_id).toBe('me');
+ const top = a.tools.find((x) => x.name === 'playtomic_get_top_clubs')!;
+ expect(top.endpointMapping.queryParams?.player_user_id).toBe('me');
+ const level = a.tools.find((x) => x.name === 'playtomic_get_my_level')!;
+ expect(level.endpointMapping.queryParams?.user_id).toBe('me');
+ });
+});
diff --git a/packages/frontend/public/logos/connectors/playtomic.svg b/packages/frontend/public/logos/connectors/playtomic.svg
new file mode 100644
index 0000000..ef04922
--- /dev/null
+++ b/packages/frontend/public/logos/connectors/playtomic.svg
@@ -0,0 +1 @@
+
\ No newline at end of file
diff --git a/packages/frontend/src/app/connectors/store/page.tsx b/packages/frontend/src/app/connectors/store/page.tsx
index e75d440..82dafb5 100644
--- a/packages/frontend/src/app/connectors/store/page.tsx
+++ b/packages/frontend/src/app/connectors/store/page.tsx
@@ -121,6 +121,7 @@ const CATEGORY_LABELS: Record = {
maps: 'Maps & Geo',
travel: 'Travel',
cms: 'CMS',
+ sports: 'Sports',
};
const AUTH_LABELS: Record = {
+