anyapi-mcp-server

Wenn es eine API hat, kannst du es per MCP anbinden.

Traditionelle MCP-Server wählen eine Handvoll Endpunkte aus und belassen es dabei – was dich auf die Teilmenge einschränkt, die jemand für "ausreichend" hielt. Warum sich mit einem Bruchteil einer API begnügen, wenn man alles haben kann?

anyapi-mcp-server ist ein universeller MCP-Server, der jede REST-API mit KI-Assistenten wie Claude, Cursor und anderen LLM-basierten Tools verbindet – gib einfach eine OpenAPI-Spezifikation oder eine Postman-Collection an. Jeder Endpunkt, den die API bereitstellt, ist sofort verfügbar, mit GraphQL-artiger Feldauswahl und automatischer Schema-Ableitung. Kein benutzerdefinierter Server-Code, keine künstlichen Limits.

Schnellstart

1. Installieren

npm install -g anyapi-mcp-server

2. Zum MCP-Client hinzufügen (Cursor, Claude Desktop, etc.)

{
  "mcpServers": {
    "your-api": {
      "command": "npx",
      "args": [
        "-y",
        "anyapi-mcp-server",
        "--name", "your-api",
        "--spec", "path/to/openapi.json",
        "--base-url", "https://api.example.com",
        "--header", "Authorization: Bearer ${API_KEY}"
      ],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

3. Tools verwenden – Endpunkte mit list_api entdecken, Schemas mit call_api untersuchen, Daten mit query_api abrufen.

Anbieter-Beispiele

Bereit zur Verwendung stehende Konfigurationen für beliebte APIs:

Diese funktionieren mit jeder API, die eine OpenAPI- oder Postman-Spezifikation besitzt – die oben genannten sind nur Beispiele. Stripe, Twilio, Shopify, HubSpot und alles andere mit einer REST-API funktionieren auf die gleiche Weise.

CLI-Referenz

Erforderliche Flags

Optionale Flags

OAuth-Flags

Für APIs, die OAuth 2.0 anstelle von statischen Token verwenden. Wenn eines der drei erforderlichen Flags angegeben wird, sind alle drei erforderlich. Alle Flags unterstützen ${ENV_VAR}.

Siehe den Google Workspace-Leitfaden für ein vollständiges OAuth-Beispiel.

Tools

Der Server stellt vier Tools bereit (plus auth, wenn OAuth konfiguriert ist):

list_api — Endpunkte durchsuchen

Entdecke, was die API bietet. Rufe es ohne Argumente auf, um alle Kategorien zu sehen, gib category an, um Endpunkte in einem Tag aufzulisten, oder search, um Endpunkte nach Schlüsselwörtern zu finden.

call_api — Einen Endpunkt untersuchen

Führt eine echte HTTP-Anfrage aus und gibt das abgeleitete GraphQL-Schema (SDL) zurück – nicht die Daten selbst. Verwende dies, um die Antwortstruktur zu entdecken und suggestedQueries zu erhalten, die du in query_api kopieren kannst. Gibt außerdem Token-Kosten pro Feld (fieldTokenCosts) und einen dataKey für die Cache-Wiederverwendung zurück. Bei PUT/PATCH-Anfragen wird automatisch ein Pre-Write-Backup erstellt (gibt backupDataKey zurück). Unterstützt bodyFile für große Payloads und blockiert Anfragen mit erkannten Platzhalterwerten.

query_api — Daten abrufen

Ruft Daten ab und gibt nur die Felder zurück, die du auswählst über eine GraphQL-Abfrage. Unterstützt sowohl Lese- als auch Schreibvorgänge (Mutationen für POST/PUT/DELETE/PATCH). Übergebe einen dataKey von call_api, um zwischengespeicherte Daten ohne HTTP-Aufrufe wiederzuverwenden.

# Read
{ items { id name status } _count }

# Write
mutation { post_endpoint(input: { name: "example" }) { id } }

Schlüsselparameter:

• maxTokens — Token-Budget für die Antwort. Arrays werden gekürzt, um zu passen. Ohne diesen oder unlimited werden Antworten über ca. 10k Token abgelehnt.

• unlimited — auf true setzen, um die vollständige Antwort ohne Durchsetzung des Token-Budgets zurückzugeben.

• dataKey — Wiederverwendung zwischengespeicherter Daten aus einer vorherigen call_api- oder query_api-Antwort.

• jsonFilter — Punkt-Pfad, um verschachtelte Werte nach der GraphQL-Abfrage zu extrahieren (z. B. "data[].attributes.name").

• bodyFile — absoluter Pfad zu einer JSON-Datei, die als Request-Body verwendet werden soll (schließt sich mit body aus). Verwende dies für große Payloads, die nicht inline gesendet werden können.

• skipBackup — überspringt das automatische Pre-Write-Backup für PUT/PATCH-Anfragen (Standard: false).

explain_api — Dokumentation lesen

Gibt die Spezifikationsdokumentation für einen Endpunkt zurück (Parameter, Request-Body-Schema, Antwortcodes), ohne eine HTTP-Anfrage zu stellen.

auth — OAuth-Authentifizierung

Nur verfügbar, wenn --oauth-*-Flags konfiguriert sind. Verwaltet den OAuth-Flow:

• action: "start" — gibt eine Autorisierungs-URL zurück (oder tauscht Anmeldeinformationen für client_credentials aus)

• action: "exchange" — schließt den Authorization-Code-Flow ab (Callback wird automatisch erfasst)

• action: "status" — zeigt den aktuellen Token-Status an

Token werden automatisch gespeichert und aktualisiert.

Typischer Arbeitsablauf

list_api          → discover what's available
     ↓
explain_api       → read the docs for an endpoint
     ↓
call_api          → inspect the response schema (returns dataKey)
     ↓
query_api         → fetch exactly the fields you need (pass dataKey for zero HTTP calls)
     ↓
query_api         → re-query with different fields using the same dataKey

Funktionsweise

OpenAPI/Postman spec
        │
        ▼
   ┌─────────┐  ┌─────────────┐  ┌──────────┐  ┌───────────┐
   │list_api │  │ explain_api │  │ call_api │  │ query_api │
   │(browse) │  │   (docs)    │  │ (schema) │  │  (data)   │
   └─────────┘  └─────────────┘  └──────────┘  └───────────┘
        │          │ no HTTP          │               │
        ▼          ▼ request          ▼               ▼
   Spec index   Spec index     REST API call    dataKey cache
   (tags,       (params,       (with retry)     hit → no HTTP
    paths)       responses,         │            miss → fetch
                 body schema)       ▼               │
                               Infer schema +       ▼
                               return dataKey   Execute GraphQL
                                                + token budget
                                                  truncation

Funktionen

• Jede REST-API — stelle eine OpenAPI- (JSON/YAML) oder Postman Collection v2.x-Spezifikation als Datei oder URL bereit

• Remote-Spezifikations-Caching — HTTPS-Spezifikationen werden einmal abgerufen und unter ~/.cache/anyapi-mcp/ zwischengespeichert

• GraphQL-Feldauswahl — frage nur die Felder ab, die du aus einer Antwort benötigst

• Schema-Ableitung — erstellt automatisch GraphQL-Schemas aus Live-API-Antworten

• Multi-Sample-Merging — tastet bis zu 10 Array-Elemente für reichhaltigere Schemas ab

• Mutations-Unterstützung — Schreibvorgänge erhalten typisierte GraphQL-Mutationen aus OpenAPI-Body-Schemas

• Intelligente Vorschläge — call_api gibt gebrauchsfertige Abfragen basierend auf dem abgeleiteten Schema zurück

• Antwort-Caching — dateisystembasiertes Cache mit 5-Minuten-TTL; dataKey-Token ermöglichen query_api die Wiederverwendung von Daten ohne HTTP-Aufrufe

• Token-Budget — query_api erzwingt standardmäßig ein Sicherheitslimit von ca. 10k Token; verwende maxTokens, um das tiefste/größte Array zu kürzen, oder unlimited: true für vollständige Antworten

• Token-Kosten pro Feld — call_api gibt einen fieldTokenCosts-Baum zurück, damit das LLM fundierte Feldauswahlen treffen kann

• Rate-Limit-Tracking — analysiert X-RateLimit-*-Header und warnt, wenn Limits fast erschöpft sind

• Paginierungs-Erkennung — erkennt automatisch Cursor-, Next-Page-Token- und Link-basierte Paginierungsmuster in Antworten

• JSON-Filter — query_api akzeptiert einen jsonFilter-Punkt-Pfad für die Extraktion nach der Abfrage (z. B. "data[].name")

• Retry mit Backoff — automatische Wiederholungsversuche für 429/5xx mit exponentiellem Backoff und Retry-After-Unterstützung

• Multi-Format — analysiert JSON-, XML-, CSV- und Klartext-Antworten

• Sicheres Schreiben — PUT/PATCH-Anfragen erstellen automatisch einen Snapshot der Ressource vor dem Schreiben (backupDataKey); Platzhalterwerte (z. B. PLACEHOLDER, TODO, file://) werden erkannt und vor dem Senden blockiert

• Datei-basierter Body — bodyFile-Parameter akzeptiert einen absoluten Pfad zu einer JSON-Datei, was große Payloads ermöglicht, die nicht inline gesendet werden können

• Umfangreiche Fehlermeldungen — strukturierte Fehlermeldungen mit statusspezifischen Vorschlägen und Spezifikationskontext zur Selbstkorrektur

• OAuth 2.0 — Authorization Code (mit PKCE) und Client Credentials Flows mit automatischem Token-Refresh

• Umgebungsvariablen-Interpolation — ${ENV_VAR} in Basis-URLs, Headern und Spezifikationspfaden

• Request-Logging — optionales NDJSON-Log mit Maskierung sensibler Header

Unterstützte Spezifikationsformate

• OpenAPI 3.x (JSON oder YAML)

• OpenAPI 2.0 / Swagger (JSON oder YAML)

• Postman Collection v2.x (JSON)

Lizenz

Proprietär, nicht-kommerziell. Kostenlos für den persönlichen und pädagogischen Gebrauch. Kommerzielle Nutzung erfordert eine schriftliche Genehmigung. Siehe LICENSE für Details.