Startseite
Für KI-Assistenten · MCP-Server

BuyUKeSIM MCP-Server

BuyUKeSIM betreibt einen MCP-Server (Model Context Protocol), sodass jeder MCP-fähige KI-Assistent - Claude, ChatGPT, Cursor, VS Code Copilot, Gemini CLI und andere - direkt mit unserem eSIM-Katalog arbeiten kann. Richte deinen Assistenten auf einen Endpunkt, und er kann Tarife suchen, Abdeckung auflisten, die UK-Nummer erklären und eine Bestellung prüfen, alles in normaler Sprache.

Die öffentlichen Tools brauchen keinen Schlüssel und bewegen kein Geld. Ein zweiter, authentifizierter Satz ergänzt ein vorausbezahltes, krypto-finanziertes Agent-Wallet, sodass ein Assistent ein Guthaben aufladen und in deinem Namen eine Reise-/Daten-eSIM kaufen kann. Kein Konto, kein KYC. Diese Seite ist die vollständige Referenz: Endpunkte, Einrichtung pro Client, jedes Tool, Authentifizierung, ausführbare Beispiele, Fehlerbehandlung und FAQ.

Basis-Endpunkt

https://buyukesim.com/mcp

Was ist MCP

Das Model Context Protocol (MCP) ist ein offener Standard, um KI-Assistenten mit externen Tools und Daten zu verbinden. Statt Copy-Paste oder eines Einzweck-Plugins spricht der Assistent ein einziges Protokoll mit jedem kompatiblen Server und entdeckt dessen Tools.

Unser Server implementiert MCP über Streamable HTTP mit JSON-RPC 2.0, Protokollversion 2025-06-18. In der Praxis heißt das: ein HTTPS-Endpunkt, der POST-Anfragen annimmt. Der Assistent ruft initialize auf, dann tools/list, um die verfügbaren Tools zu erfahren, dann tools/call, um ein Tool auszuführen. Von Hand machst du das fast nie - dein MCP-Client erledigt es für dich.

Lies die MCP-Spezifikation auf modelcontextprotocol.io

Schnellstart

Der schnellste Weg ist Claude Code. Ein Befehl fügt den Server mit öffentlichen Browsing-Tools hinzu - kein Schlüssel, keine Konfigurationsdatei:

claude mcp add --transport http buyukesim https://buyukesim.com/mcp

Das war es. Frag deinen Assistenten etwas wie "suche UK-eSIM-Tarife", und er ruft die Tools auf. Für andere Clients siehe Client-Einrichtung unten. Für die Wallet-Tools füge deinen Schlüssel als Bearer-Header hinzu (siehe Authentifizierung).

Endpunkte

Es gibt einen einzigen MCP-Endpunkt. Anfragen sind HTTP POST mit JSON-RPC-Rümpfen. Ein einfaches GET ist keine gültige MCP-Anfrage und liefert 405. Der Bequemlichkeit halber kannst du deinen Schlüssel auch direkt in den URL-Pfad einbetten.

MethodeEndpunktZweck
POSThttps://buyukesim.com/mcpHaupt-MCP-Endpunkt. Alle JSON-RPC-Aufrufe (initialize, tools/list, tools/call) gehen als POST hierhin.
GEThttps://buyukesim.com/mcpKeine gültige MCP-Anfrage - liefert 405 Method Not Allowed. Benutze POST.
POSThttps://buyukesim.com/mcp/ak_live_YOURKEYSchlüssel-in-URL-Form. Derselbe Endpunkt, aber dein API-Schlüssel steht im Pfad, sodass kein Header nötig ist.

Client-Einrichtung

Verwende überall dieselbe Basis-URL: https://buyukesim.com/mcp. Öffentliches Browsen braucht keinen Schlüssel. Für die Wallet-Tools füge einen Header Authorization: Bearer ak_live_YOURKEY hinzu (oder nutze eine der anderen Methoden unten). Ersetze ak_live_YOURKEY durch einen Schlüssel aus create_wallet.

Claude Code (CLI)
# Public tools (browsing, no key)
claude mcp add --transport http buyukesim https://buyukesim.com/mcp

# Authenticated (wallet) - pass your key as a Bearer header
claude mcp add --transport http buyukesim https://buyukesim.com/mcp \
  --header "Authorization: Bearer ak_live_YOURKEY"

# Verify
claude mcp list
Claude Desktop
Settings  ->  Connectors  ->  Add custom connector

  Name: buyukesim
  URL:  https://buyukesim.com/mcp

Public tools work with no key. For the wallet tools,
use a client that lets you send an Authorization header
(Claude Code, Cursor, VS Code, Gemini CLI).
ChatGPT
Settings  ->  Connectors  ->  Add  (Developer mode)

  Name:           buyukesim
  MCP server URL: https://buyukesim.com/mcp

Public browse tools are available immediately.
Cursor
// ~/.cursor/mcp.json
{
  "mcpServers": {
    "buyukesim": {
      "type": "streamableHttp",
      "url": "https://buyukesim.com/mcp",
      "headers": {
        "Authorization": "Bearer ak_live_YOURKEY"
      }
    }
  }
}
VS Code (GitHub Copilot)
// .vscode/mcp.json
{
  "servers": {
    "buyukesim": {
      "type": "http",
      "url": "https://buyukesim.com/mcp",
      "headers": {
        "Authorization": "Bearer ak_live_YOURKEY"
      }
    }
  }
}
Gemini CLI
// ~/.gemini/settings.json
{
  "mcpServers": {
    "buyukesim": {
      "httpUrl": "https://buyukesim.com/mcp",
      "headers": {
        "Authorization": "Bearer ak_live_YOURKEY"
      }
    }
  }
}
Windsurf / Cline / Zed
// mcpServers block (Windsurf, Cline, Zed and similar)
{
  "mcpServers": {
    "buyukesim": {
      "serverUrl": "https://buyukesim.com/mcp"
    }
  }
}

// Fallback for stdio-only clients, via the mcp-remote bridge:
npx mcp-remote https://buyukesim.com/mcp \
  --header "Authorization: Bearer ak_live_YOURKEY"

Öffentliche Tools

Vier schreibgeschützte Tools. Kein Schlüssel, keine Geldbewegung - unbedenklich für jeden Assistenten.

search_esim_plans
country?: string (2-letter ISO), limit?: int

Finde Reise-/Daten-eSIM-Tarife für ein Land. Liefert Datenmenge, Gültigkeit in Tagen, USD-Preis und den package_code, den du an purchase_esim übergibst. country ist ein zweistelliger ISO-Code (zum Beispiel GB); limit begrenzt die Ergebnisse.

list_covered_countries
(none)

Liste jedes Land und jede Region, die die Reise-eSIM abdeckt, jeweils mit einem Ab-Preis. Nimmt keine Argumente.

get_uk_number_info
(none)

Erklärt die UK-Nummer (+44) eSIM - eine echte britische Mobilnummer für Verifizierungs-SMS und Anrufe. Nimmt keine Argumente.

check_order_status
code: string

Bestellung per Kurzcode nachschlagen. Liefert nur den Status, nie persönliche Daten.

Authentifizierte Wallet-Tools

Diese brauchen einen ak_live_-Schlüssel. Das Wallet ist vorausbezahlt und mit Krypto finanziert (über NOWPayments) - kein Konto, kein KYC. Rufe create_wallet einmal auf, um einen Schlüssel zu erzeugen, lade mit create_deposit auf und kaufe dann mit purchase_esim.

ToolParameterZweck
create_walletlabel?: string -> returns api_key + wallet_codeErstelle ein neues Agent-Wallet und liefere seinen api_key (geheim) und wallet_code. Das einzige Wallet-Tool, das selbst keinen Schlüssel braucht - es erzeugt einen. Bewahre den api_key sicher auf.
check_balance(none)Liefert das aktuelle Wallet-Guthaben in USD.
create_depositamount_usd: number (min 10), coin?: stringStarte eine Krypto-Aufladung. amount_usd ist der Einzahlungsbetrag (mindestens 10). coin ist optional, zum Beispiel usdttrc20, btc, eth oder trx. Liefert eine Zahlungsadresse/einen Link; das Guthaben wird bei Bestätigung gutgeschrieben.
list_transactions(none)Liste die Wallet-Transaktionen auf - Einzahlungen und Käufe.
purchase_esimpackage_code: string, request_id?: stringKaufe eine Reise-/Daten-eSIM mit Wallet-Guthaben. package_code stammt aus search_esim_plans. Das ist LIVE und gibt echtes Guthaben aus. Übergib eine request_id, um es idempotent zu machen, sodass ein erneuter Versuch nie doppelt abbucht. Liefert den eSIM-QR-Code.
purchase_uk_numberrequest_id?: stringKaufe eine UK-Nummer (+44) eSIM ab Lager für etwa 25 USD mit Wallet-Guthaben. Das ist LIVE und liefert den QR-Code sofort. Übergib eine request_id, um es idempotent zu machen, sodass ein erneuter Versuch nie doppelt abbucht.

Das Guthaben kann nur für eSIMs ausgegeben werden - es ist nie in Bargeld oder Krypto auszahlbar. Das ist Absicht: Es ist ein Ausgabeguthaben für einen Agenten, keine Börse.

Authentifizierung

Die öffentlichen Tools brauchen nichts. Die Wallet-Tools brauchen deinen ak_live_-Schlüssel aus create_wallet. Es gibt drei gleichwertige Wege, ihn zu senden - wähle den, den dein Client unterstützt.

1Authorization header (recommended)

Sende einen Standard-Bearer-Token-Header. Funktioniert in Claude Code (--header), Cursor, VS Code, Gemini CLI und cURL. Das ist die empfohlene Methode.

Authorization: Bearer ak_live_YOURKEY

2X-API-Key header

Sende den Schlüssel stattdessen in einem X-API-Key-Header. Nützlich für Clients, die eigene Header, aber keine Bearer-Auth erlauben.

X-API-Key: ak_live_YOURKEY

3Key in the URL path

Setze den Schlüssel direkt in den URL-Pfad. Praktisch für Clients, die nur eine URL und keine Header akzeptieren. Behandle diese URL als geheim, da der Schlüssel darin steht.

https://buyukesim.com/mcp/ak_live_YOURKEY

Beispiele

Copy-paste-cURL für den kompletten Ablauf. Beachte den Accept-Header: MCP über Streamable HTTP erfordert Accept: application/json, text/event-stream. Jede id ist nur ein Request-Bezeichner, den du wählst.

1. Sitzung initialisieren (Handshake).

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-06-18",
      "capabilities": {},
      "clientInfo": { "name": "curl", "version": "1.0" }
    }
  }'

2. Verfügbare Tools auflisten.

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{ "jsonrpc": "2.0", "id": 2, "method": "tools/list" }'

3. UK-(GB-)Tarife suchen, öffentlich - kein Schlüssel.

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "search_esim_plans",
      "arguments": { "country": "GB", "limit": 5 }
    }
  }'

4. Ein Wallet erstellen und einen Schlüssel erhalten.

# No key needed - this call mints one. Save the api_key it returns.
curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{
    "jsonrpc": "2.0",
    "id": 4,
    "method": "tools/call",
    "params": {
      "name": "create_wallet",
      "arguments": { "label": "my-agent" }
    }
  }'

# Result contains, for example:
#   api_key:     ak_live_9f3c...   (store this secret)
#   wallet_code: WLT-4821

5. Guthaben prüfen (Bearer-Auth).

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ak_live_YOURKEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 5,
    "method": "tools/call",
    "params": { "name": "check_balance", "arguments": {} }
  }'

6. Eine Krypto-Einzahlung starten.

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ak_live_YOURKEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 6,
    "method": "tools/call",
    "params": {
      "name": "create_deposit",
      "arguments": { "amount_usd": 20, "coin": "usdttrc20" }
    }
  }'

# Returns a crypto payment address / link (NOWPayments).
# Balance is credited once the deposit confirms on-chain.

7. Eine eSIM kaufen (live, idempotent).

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ak_live_YOURKEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 7,
    "method": "tools/call",
    "params": {
      "name": "purchase_esim",
      "arguments": {
        "package_code": "GB_5GB_30D",
        "request_id": "order-2026-07-10-001"
      }
    }
  }'

# LIVE: spends wallet balance and returns the eSIM QR code.
# request_id makes it idempotent - retrying never double-charges.

8. Eine UK-+44-Nummer kaufen (live, idempotent).

curl -s https://buyukesim.com/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer ak_live_YOURKEY" \
  -d '{
    "jsonrpc": "2.0",
    "id": 8,
    "method": "tools/call",
    "params": {
      "name": "purchase_uk_number",
      "arguments": { "request_id": "uknum-2026-07-10-001" }
    }
  }'

# LIVE: buys a UK +44 Number eSIM from stock (~25 USD) and
# returns the QR instantly. request_id makes it idempotent.

Python, mit dem offiziellen mcp-Client und dem Streamable-HTTP-Transport:

# pip install mcp
import asyncio
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

URL = "https://buyukesim.com/mcp"
HEADERS = {"Authorization": "Bearer ak_live_YOURKEY"}  # omit for public tools

async def main():
    async with streamablehttp_client(URL, headers=HEADERS) as (read, write, _):
        async with ClientSession(read, write) as session:
            await session.initialize()

            tools = await session.list_tools()
            print([t.name for t in tools.tools])

            result = await session.call_tool(
                "search_esim_plans", {"country": "GB", "limit": 5}
            )
            print(result.content)

asyncio.run(main())

Node.js, mit dem offiziellen @modelcontextprotocol/sdk:

// npm i @modelcontextprotocol/sdk
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://buyukesim.com/mcp"),
  { requestInit: { headers: { Authorization: "Bearer ak_live_YOURKEY" } } } // omit for public
);

const client = new Client({ name: "buyukesim-demo", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map((t) => t.name));

const res = await client.callTool({
  name: "search_esim_plans",
  arguments: { country: "GB", limit: 5 },
});
console.log(res.content);

Fehlerbehandlung

Probleme auf Protokollebene kommen als standardmäßige JSON-RPC-2.0-Fehler mit numerischem Code und Nachricht zurück. Diese wirst du sehen:

CodeBedeutung
-32700Parse-Fehler - der Anfragerumpf war kein gültiges JSON.
-32600Ungültige Anfrage - das JSON ist keine gültige JSON-RPC-2.0-Anfrage.
-32601Methode nicht gefunden - unbekannte Methode oder ein nicht existierender Tool-Name.
-32602Ungültige Parameter - ein Tool wurde mit fehlenden oder falsch typisierten Argumenten aufgerufen.
-32603Interner Fehler - bei uns ist beim Verarbeiten des Aufrufs etwas fehlgeschlagen.

Fehler auf Tool-Ebene sind anders. Ein Tool, das läuft, aber nicht abschließen kann (etwa unzureichendes Guthaben oder ein unbekannter package_code), wirft keinen JSON-RPC-Fehler. Es liefert ein normales Tool-Ergebnis mit isError: true und einer menschenlesbaren Nachricht im Text-Inhalt, damit dein Assistent sie lesen und erklären kann.

Live vs. kommt noch

Ganz ehrlich: Kaufen ist LIVE. purchase_esim für Reise-/Daten-eSIMs gibt wirklich Wallet-Guthaben aus und liefert einen funktionierenden QR-Code, und purchase_uk_number macht jetzt dasselbe für die UK-Nummer (+44) eSIM - es kauft eine ab Lager für etwa 25 USD und liefert den QR-Code sofort. Das Tool get_uk_number_info beschreibt weiterhin das Produkt; purchase_uk_number kauft es tatsächlich.

Noch eine ehrliche Grenze: Kein Assistent kann die eSIM für dich installieren. Installation bedeutet, das QR-Profil auf deinem eigenen Telefon zu scannen oder anzutippen. Der Assistent kann den Tarif finden, kaufen und dir den QR-Code geben - die finale Installation bleibt immer bei dir.

FAQ

Ist das echtes Geld?

Die öffentlichen Tools bewegen kein Geld. Die Wallet-Tools schon: create_deposit lädt ein echtes vorausbezahltes Guthaben in Krypto auf, und purchase_esim gibt es tatsächlich aus. Alles Schreibgeschützte ist kostenlos.

Kann der Assistent die eSIM für mich installieren?

Nein. Er kann suchen, kaufen und den QR-Code liefern, aber Installieren heißt, den QR auf deinem eigenen Gerät zu scannen. Dieser letzte Schritt bleibt immer bei dir.

Ist es wirklich ohne KYC?

Ja. Kein Konto, keine Identitätsprüfung. Du erstellst ein Wallet, lädst es mit Krypto auf und gibst es für eSIMs aus.

Ist mein Guthaben sicher? Kann ich es abheben?

Das Guthaben kann nur für eSIMs ausgegeben werden - es ist nie in Bargeld oder Krypto auszahlbar. Es ist ein Ausgabeguthaben für einen Agenten, kein Wallet zum Auszahlen.

Was ist mit UK-Nummern?

get_uk_number_info erklärt die UK-Nummer (+44) eSIM, und purchase_uk_number kauft jetzt eine ab Lager für etwa 25 USD mit deinem Wallet-Guthaben und liefert den QR-Code sofort. Es ist live und idempotent über request_id, genau wie purchase_esim.

Wie funktioniert Idempotenz?

Übergib eine stabile request_id an purchase_esim. Wird dieselbe request_id wiederholt, wird der Kauf nicht erneut ausgeführt, sodass ein Netzwerk-Retry nie doppelt abbucht.

Welche Coins kann ich einzahlen?

Gängige wie usdttrc20, btc, eth und trx über NOWPayments. Mindesteinzahlung ist 10 USD. Lass coin weg, um eine Auswahl angeboten zu bekommen.

Muss ich einen Server betreiben?

Nein. Es ist ein gehosteter HTTP-Endpunkt. Füge die URL zu deinem Client hinzu, fertig - nichts zu installieren oder selbst zu hosten.

Support

Fragen, ein Schlüsselproblem oder etwas läuft nicht wie erwartet? Schreib uns auf Telegram an @buyukesimbot, wir helfen gern.

@buyukesimbot

Endpunkt: JSON-RPC 2.0 über HTTP POST (Streamable HTTP), Protokollversion 2025-06-18. Basis-URL https://buyukesim.com/mcp.