Dokumentation

Mit nodexch entwickeln

Alles, was eine erste Integration braucht, in der Reihenfolge, in der du es brauchst. Jede Route und ihre Felder stehen in der API-Referenz.

Schnellstart

nodexch spricht die Coinset-API: jede Methode ist POST /<method> auf https://api.nodexch.com mit einem JSON-Body, und die Antwort des Node kommt Byte für Byte zurück. Ein Coinset-Client ändert seine Basis-URL und fügt einen Schlüssel hinzu.

Jedes Beispiel liest das Gateway aus NODEXCH_URL und deinen Schlüssel aus NODEXCH_KEY. Sie laufen vor jedem Release gegen ein echtes Gateway, funktionieren also wie geschrieben.

examples/curl/first-call.sh
#!/bin/sh
# The health check needs no key; every Coinset method is POST /<method> with a JSON body.
set -eu
url="${NODEXCH_URL:-https://api.nodexch.com}"

curl -fsS "$url/health"
echo

curl -fsS "$url/get_blockchain_state" \
  -H "Authorization: Bearer $NODEXCH_KEY" \
  -d '{}'
echo

Das TypeScript-Beispiel nutzt den typisierten Client, der aus dem OpenAPI-Dokument der API erzeugt wird: jeder Pfad und jeder Request-Body wird vom Compiler geprüft. /openapi.json ist dasselbe Dokument für jeden anderen Generator.

Ganzzahlen jenseits von 253 (Netspace, große Beträge) kommen genau so an, wie der Node sie schreibt, und JSON.parse rundet sie stillschweigend: parse solche Antworten mit einem Parser, der große Ganzzahlen kennt, wo der genaue Wert zählt; Event-Frames schreiben sie als Strings.

Was du abfragen kannst

nodexch beantwortet die Methoden von Coinset und ergänzt eigene Kanäle unter /x/…. Das sind die Familien, jede mit einigen ihrer Routen; alle, mit jedem Feld, stehen in der API-Referenz.

Blöcke
Blöcke, Block-Records, ihre Spends und die Coins, die sie hinzufügen und entfernen./get_block_record_by_height/get_blocks/get_block_spends/get_additions_and_removals
Coins
Coin-Records nach Name, Puzzle-Hash, Parent oder Hint; Puzzles und Solutions./get_coin_record_by_name/get_coin_records_by_puzzle_hash/get_coin_records_by_hint/get_puzzle_and_solution
Transaktionen
Transaktionen mit Coinsets Zusammenfassung dessen, was sie getan haben, und Reorgs./get_transaction/get_transactions_by_p2/get_pending_transactions_by_p2/get_reorgs
Adressen, Token und NFTs
Was eine Adresse hält: XCH, CAT-Token, NFTs und Singletons./get_xch_balance_by_p2/get_cat_balances_by_p2/get_nft_ids_by_p2/get_singleton_info
Mempool und Gebühren
Was im Mempool wartet, was ein Spend jetzt kostet, und das Einreichen eines Spends./get_all_mempool_items/get_mempool_item_by_tx_id/get_fee_estimate/push_tx
Angebote
Angebote nach ID, Token, NFT oder Adresse, ihr Status und der Handelsverlauf./get_offer/get_offers_by_cat_asset_id/push_offer/x/offers/v1/trades
Die eigenen Kanäle von nodexch
Die Nodes des Netzwerks, Mempool und Gebühren in Bändern, Token-Namen und -Icons, der XCH-Preis./x/node/v1/network/x/node/v1/mempool/x/node/v1/fees/x/assets/v1/assets/x/price/v1/xch
Live-Events
Dieselbe Chain als Stream: ein WebSocket oder Server-Sent Events./ws/events

Schlüssel

Sende einen Schlüssel als Authorization: Bearer <key>. Ohne ihn antworten nur die Proben (/up, /ready, /health), das OpenAPI-Dokument (/openapi.json) und diese Website.

  • Geheime Schlüssel (nxs_…) sind für Server. Setze nie einen in eine Webseite, ein App-Bundle oder eine URL.
  • Öffentliche Schlüssel (nxp_…) sind für Browser. Sie funktionieren nur von den Origins, für die sie ausgegeben wurden, bekommen von der Adresse eines Besuchers nicht mehr als ein Besucher ohne Schlüssel und öffnen nie die Betreiber-Routen.
  • Browser können auf einem WebSocket oder einer EventSource keine Header setzen, daher nehmen /ws und /events einen öffentlichen Schlüssel auch als ?key=. Ein geheimer Schlüssel in einer URL wird abgelehnt.
  • Ein durchgesickerter Schlüssel wird rotiert: der neue gilt sofort, der alte endet sofort. Halte den neuen also für das Deployment bereit, wenn du rotierst.

Limits

Der Tarif eines Schlüssels legt eine Rate pro Minute, ein Kontingent pro Monat und eine Zahl offener Streams fest. Jede Antwort mit Schlüssel sagt, wo du stehst:

HeaderBedeutung
x-ratelimit-limit, x-ratelimit-remainingAnfragen in dieser Minute
x-quota-limit, x-quota-remainingAnfragen in diesem Monat
retry-afterBei 429 oder 503: Sekunden, bis der nächste Versuch gelingen kann
x-nodexch-tierWoher die Antwort kam: eine Cache-Stufe (immutable, peak, state, mempool), none, index, passthrough oder stream
ETagSchick ihn als If-None-Match zurück und bekomm ein 304, solange sich nichts geändert hat

Antworten, über die die Chain nicht hinweggegangen ist, kommen aus dem Cache, Polling ist also günstig; die Live-Events unten sind noch günstiger.

Tarife und Kontingent

Wie ein Tarif bezahlt wird, was er gibt und was an seinen Rändern passiert. Die Kontoseite zeigt alles für dein Konto.

  • Jeder Tarif wird monatlich oder jährlich verkauft; der Jahrespreis ist zwölf Monate abzüglich der Ersparnis, die die Preisseite zeigt. Chia kennt keine Lastschrift, daher ist jeder Zeitraum eine Rechnung, die du auf der Kontoseite in XCH bezahlst: mit Sage in einem Klick oder mit einem Chia-Vault über Adresse, Betrag und Memo. Die Rechnung für die Verlängerung entsteht 7 Tage vor Ende des Zeitraums, und eine Mail erinnert dich, wenn du eine Adresse angegeben hast.
  • Dein Kontingent gibt es einmal pro Konto, geteilt von allen Schlüsseln. Es läuft vom Tag deines Abos bis zum selben Tag des nächsten Monats, auch bei einem Jahrestarif (es wird monatlich gewährt). Ungenutzte Anfragen werden nicht übertragen. Die Kontoseite zeigt, was übrig ist und wann es neu beginnt, in UTC.
  • Bei null antworten Anfragen mit 429 quota_exceeded, einem retry-after-Header sowie x-quota-reset und resets_at im Body: dem Zeitpunkt, an dem das Kontingent neu beginnt. Jede Antwort trägt x-quota-limit, x-quota-remaining und x-quota-reset. Es gibt kein Nachkaufen: ein Upgrade beginnt heute einen neuen Zeitraum mit vollem Kontingent.
  • Ein Upgrade wird jetzt voll bezahlt und beginnt an diesem Tag einen neuen Zeitraum; der Rest des alten wird nicht angerechnet. Ein Downgrade und eine Kündigung gelten zum Ende des bezahlten Zeitraums. Es gibt keine Erstattung: der bezahlte Zeitraum läuft aus.
  • Wird eine Verlängerung nicht bezahlt, folgen auf das Ende des Zeitraums 7 Tage Nachfrist. Dann sind Konto und Schlüssel im kostenlosen Tarif: nie gesperrt, nur mit den Gratis-Limits. Eine spätere Zahlung beginnt an diesem Tag einen neuen Zeitraum.
  • Eine E-Mail-Adresse ist optional, ein bezahlter Tarif braucht aber eine bestätigte: Erinnerungen und Sicherheitshinweise gehen dorthin. Sie ist nie ein Weg zur Anmeldung. Verlierst du alle Passkeys, registriert ein an sie gesendeter Link einen neuen Passkey, der 24 Stunden später anmeldet; ein Passkey, den du noch hast, kann das vorher abbrechen. Ohne Adresse lässt sich ein verlorener Passkey nicht wiederherstellen.

Fehler

Die eigenen Fehler von nodexch sind JSON mit einem HTTP-Status und einem stabilen Code:

Ein Fehler
{"success": false, "error": "an API key is required: send Authorization: Bearer <key>", "code": "unauthorized"}

Eine Ablehnung durch den Node selbst behält dagegen die Form von Coinset: HTTP 200 mit success: false und error (etwa ein Block, den es nicht gibt). Prüfe success in jeder Antwort.

StatusCodeWann
400bad_request, validation_failedDer Body ist kein JSON, oder ein Feld fehlt oder ist fehlerhaft; der Fehler nennt das Feld.
401unauthorizedKein Schlüssel, oder einer, den das Gateway nicht kennt oder der widerrufen wurde.
401key_expiredDer Tarif des Schlüssels ist über sein Bezahlt-bis-Datum hinaus.
403forbiddenDer Schlüssel darf diese Route nicht nutzen: ein öffentlicher Schlüssel auf einer Betreiber-Route, oder von einem Origin, für den er nicht ausgegeben wurde.
404not_foundKeine solche Route oder Methode.
429rate_limited, quota_exceededÜber der Rate pro Minute oder dem Monatskontingent; warte retry-after Sekunden.
501not_enabledDieses Deployment bedient diese Familie von Methoden nicht („index not enabled“).
502upstream_failedDer Node oder der Upstream hat nicht geantwortet.
503unavailableStartet gerade oder ohne Budget; retry-after sagt, wann ein neuer Versuch lohnt.

Paging

Die Coinset-Methoden blättern wie bei Coinset: Höhenbereiche mit start und end (end nicht eingeschlossen, höchstens 1.000 Blöcke auf einmal).

Die eigenen Listen von nodexch unter /x/… nehmen limit und cursor. Jede Seite trägt next_cursor; gib ihn als cursor für die nächste Seite mit, bis er null ist.

Die Handelshistorie, Seite für Seite
curl -s "https://api.nodexch.com/x/offers/v1/trades?asset_id=xch&limit=100" \
  -H "Authorization: Bearer $NODEXCH_KEY"
curl -s "https://api.nodexch.com/x/offers/v1/trades?asset_id=xch&limit=100&cursor=<next_cursor>" \
  -H "Authorization: Bearer $NODEXCH_KEY"

Live-Events

Ein WebSocket, /ws?events=peak,transaction,reorg,dashboard, oder dieselben Frames als Server-Sent Events auf /events. Ohne events bekommt ein Stream die vier Typen von Coinset; offer ist der eigene von nodexch und kommt nur auf Wunsch.

Jeder Frame ist {"network", "seq", "message": {"type", "data"}}. seq zählt jeden Frame, den das Gateway sendet, ein Stream mit weniger Typen sieht also Lücken; das sind keine verlorenen Frames.

examples/typescript/events.ts
// The live events: open /ws, wait for the next peak, close. Frames are
// {"network","seq","message":{"type","data"}}, as Coinset sends them.
import { eventsUrl } from "../../clients/typescript/src/index.ts";

const base = process.env.NODEXCH_URL ?? "https://api.nodexch.com";
// Browsers put a publishable key in the URL; a server may send its secret key as a header instead.
const socket = new WebSocket(eventsUrl(base, ["peak"], process.env.NODEXCH_PUBLISHABLE_KEY));

let done = false;
const timeout = setTimeout(() => {
  console.error("no peak within 60 s");
  process.exit(1);
}, 60_000);

socket.addEventListener("message", (event) => {
  const frame = JSON.parse(String(event.data));
  if (frame.message?.type === "peak") {
    console.log(`peak ${frame.message.data.height} on ${frame.network} (seq ${frame.seq})`);
    done = true;
    clearTimeout(timeout);
    socket.close();
  }
});
socket.addEventListener("error", () => {
  if (done) return;
  console.error("the stream failed");
  process.exit(1);
});
  • peak

    Ein neuer Peak; tx sagt, ob es ein Transaktionsblock ist.

    Beispiel-Frame
    peak
    {
      "network": "mainnet",
      "seq": 1,
      "message": {
        "type": "peak",
        "data": {
          "height": 8412345,
          "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "tx": true,
          "timestamp": 1790480000
        }
      }
    }
  • transaction

    Mempool-IDs in Stapeln: pending beim Eintreffen, confirmed mit dem Block, der sie aufnahm, removed, wenn sie ohne einen verschwanden.

    Beispiel-Frames (3)
    transaction · pending
    {
      "network": "mainnet",
      "seq": 2,
      "message": {
        "type": "transaction",
        "data": {
          "ids": [
            "0x7777777777777777777777777777777777777777777777777777777777777777"
          ],
          "status": "pending",
          "height": null
        }
      }
    }
    transaction · confirmed
    {
      "network": "mainnet",
      "seq": 3,
      "message": {
        "type": "transaction",
        "data": {
          "ids": [
            "0x7777777777777777777777777777777777777777777777777777777777777777"
          ],
          "status": "confirmed",
          "height": 8412346
        }
      }
    }
    transaction · removed
    {
      "network": "mainnet",
      "seq": 4,
      "message": {
        "type": "transaction",
        "data": {
          "ids": [
            "0x8888888888888888888888888888888888888888888888888888888888888888"
          ],
          "status": "removed",
          "height": null
        }
      }
    }
  • reorg

    Der Peak ist auf einen anderen Zweig gewechselt; alles, was bei den alten Höhen gelesen wurde, kann sich geändert haben.

    Beispiel-Frame
    reorg
    {
      "network": "mainnet",
      "seq": 5,
      "message": {
        "type": "reorg",
        "data": {
          "old_peak_height": 8412346,
          "old_peak_hash": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
          "new_peak_height": 8412346,
          "new_peak_hash": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
          "reorg_depth": 1,
          "detected_at_ms": 1790480031250
        }
      }
    }
  • dashboard

    Der Feed, den die Startseite eines Explorers braucht, ein kind nach dem anderen.

    Beispiel-Frames (4)
    dashboard · mempool_delta
    {
      "network": "mainnet",
      "seq": 6,
      "message": {
        "type": "dashboard",
        "data": {
          "kind": "mempool_delta",
          "added": [
            {
              "id": "0x7777777777777777777777777777777777777777777777777777777777777777",
              "first_seen_ms": 1790480012000,
              "fee_mojos": 50000000,
              "cost": 12000000,
              "spends": 2,
              "additions": [
                {
                  "parent_coin_info": "0xdddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
                  "puzzle_hash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                  "amount": 1000
                }
              ],
              "removals": [
                {
                  "parent_coin_info": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
                  "puzzle_hash": "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
                  "amount": 1000
                }
              ],
              "addition_count": 3,
              "removal_count": 2,
              "kind": "cat",
              "asset_ids": [
                "0x9999999999999999999999999999999999999999999999999999999999999999"
              ],
              "assets": {
                "xch": "50000000",
                "cats": [
                  {
                    "asset_id": "0x9999999999999999999999999999999999999999999999999999999999999999",
                    "amount": "1000"
                  }
                ],
                "nfts": 0,
                "dids": 0,
                "singletons": 0
              }
            }
          ],
          "removed": [
            "0x8888888888888888888888888888888888888888888888888888888888888888"
          ]
        }
      }
    }
    dashboard · live
    {
      "network": "mainnet",
      "seq": 7,
      "message": {
        "type": "dashboard",
        "data": {
          "kind": "live",
          "peak_height": 8412345,
          "mempool_size": 236,
          "mempool_cost": 88500547228,
          "mempool_fees": 350012,
          "synced": true
        }
      }
    }
    dashboard · block
    {
      "network": "mainnet",
      "seq": 8,
      "message": {
        "type": "dashboard",
        "data": {
          "kind": "block",
          "height": 8412345,
          "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
          "timestamp": 1790480000,
          "fees": 350012,
          "additions": 42,
          "removals": 17,
          "record": {
            "height": 8412345,
            "header_hash": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            "timestamp": 1790480000,
            "fees": 350012,
            "weight": 36893488147419103000
          },
          "spends": 17,
          "assets": {
            "xch": "12209542198803",
            "cats": [
              {
                "asset_id": "0xcccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
                "amount": "3938"
              }
            ],
            "nfts": 1,
            "dids": 0,
            "singletons": 2
          }
        }
      }
    }
    dashboard · netspace
    {
      "network": "mainnet",
      "seq": 10,
      "message": {
        "type": "dashboard",
        "data": {
          "kind": "netspace",
          "bytes": "16487192343748823040000",
          "difficulty": 2384,
          "height": 8412345
        }
      }
    }
  • offer

    Eine neue Offer aus dem Splash-Netzwerk, mit den Offer-Feldern von Coinset und der Offer-Datei, mit der man sie annimmt (hier gekürzt).

    Beispiel-Frame
    offer
    {
      "network": "mainnet",
      "seq": 10,
      "message": {
        "type": "offer",
        "data": {
          "offer_id": "8b239d3813a72e10cec3efa6b05841017cef2828add97026cd8352a53378e4da",
          "status": "open",
          "first_seen_ms": 1790480012000,
          "last_updated_ms": 1790480012000,
          "maker_p2s": [
            "d8b1e0d9a0e46b3403dff2f6c27fc46bc13e6f5ee5ff09dc28d28d28d51be422"
          ],
          "offered_cat_asset_ids": [
            "ec25b77bc54df637392d6a0f542de65f45020405d0f36ced723bff2870c378b1"
          ],
          "requested_cat_asset_ids": [],
          "offered_nft_ids": [],
          "requested_nft_ids": [],
          "offered_xch_mojos": 0,
          "requested_xch_mojos": 500003000000,
          "offered_cat_mojos": {
            "ec25b77bc54df637392d6a0f542de65f45020405d0f36ced723bff2870c378b1": 1000
          },
          "fee_mojos": 0,
          "pending_p2s": [],
          "offer": "offer1qqr83wcuu2rykcmqvpsxygqqemhmlaekcenaz02ma6hs5w600dhjlv…",
          "source": "splash",
          "network": "mainnet"
        }
      }
    }

Agenten (MCP)

KI-Agenten lesen nodexch über seinen MCP-Server unter https://api.nodexch.com/mcp: das Orderbuch eines Paars, das günstigste Angebot zuerst, ein Angebot mit seinem Text, das Dekodieren eines Angebots, die letzten Trades, das Kreditboard und Preise. Er liest nur, berührt nie eine Wallet, und jeder Tool-Aufruf wird in Credits auf deinem geheimen Schlüssel abgerechnet, wie die Routen, die er nutzt.

Claude Code

Erstelle auf der Agenten-Seite einen Schlüssel für den Agenten, der dort gleich in diesen Befehl eingesetzt wird, und füge den Server einmal hinzu. Claude Code speichert den Schlüssel in seinen Einstellungen; in der .mcp.json eines Projekts schreibst du stattdessen "NODEXCH_KEY": "${NODEXCH_KEY}" in die env des Servers, dann kommt er aus der Umgebung.

examples/mcp/claude-code.sh
#!/bin/sh
# Connects Claude Code to nodexch in one install (@nodexch/mcp, TASK-176.04): the offer book,
# offers, trades, the loan board and prices, publishing an offer, metered in credits on your secret
# API key (nodexch.com, Account); and the Xchonnect wallet tools, run on your computer, which ask
# your wallet to take, make or cancel offers (nodexch never sees those requests).
#
# --scope user: every project of yours; the key is stored in ~/.claude.json. In a project's
# .mcp.json write "NODEXCH_KEY": "${NODEXCH_KEY}" in its env instead: Claude Code reads it from
# the environment, and the key stays out of the file.
# The key is passed to `claude mcp add` as an argument (-e), visible in the process list while it runs.
set -eu
: "${NODEXCH_KEY:?set NODEXCH_KEY=nxs_...}"
url="${NODEXCH_URL:-https://api.nodexch.com}"
command -v npx >/dev/null 2>&1 || { echo "nodexch: Node.js 22.12 or newer is needed (npx runs @nodexch/mcp)" >&2; exit 1; }

claude mcp add --scope user nodexch -e NODEXCH_KEY="$NODEXCH_KEY" -e NODEXCH_URL="$url" \
  -- npx -y @nodexch/mcp
claude mcp list

Dieselbe Installation bringt die Xchonnect-Wallet-Werkzeuge (@nodexch/mcp führt sie auf deinem Computer aus): Der Agent koppelt sich mit deiner Wallet und bittet sie, Angebote anzunehmen oder zu erstellen, und die Wallet entscheidet innerhalb der Regeln, die du für den Agenten festlegst. Trades laufen nie über nodexch.

Claude im Web, auf dem Desktop und auf dem Handy

Füge https://api.nodexch.com/mcp als benutzerdefinierten Connector hinzu; Claude meldet sich über nodexch mit deinem Passkey an und bekommt einen eigenen Schlüssel, es gibt also nichts zu kopieren. Claude Free erlaubt einen benutzerdefinierten Connector, für das Wallet-Plugin bleibt dann kein Platz: Die Agenten-Seite, Tab Claude, sagt, was das bedeutet und wie du trotzdem handelst.

Im Browser, ohne Plugin

Die Agenten-Seite koppelt sich selbst mit deiner Wallet, für einen Agenten, der in deinem Browser arbeitet, etwa Claude in Chrome. Die Sitzung bleibt verschlüsselt in diesem Browser; nodexch signiert jede Kopplung für dein Konto und kann die Sitzung nicht lesen; sein Relay trägt nur versiegelte Nachrichten. Der Agent und sein Anbieter sehen die Seite. Von dort liest sie die Regeln deiner Wallet, nimmt und erstellt Angebote, stellt Leitern und storniert; das ist langsamer als ein lokales Plugin und noch nicht mit Claude in Chrome erprobt.

Claude Desktop, Cursor und VS Code

Dieselbe Installation in einer Konfigurationsdatei. Setze deinen Schlüssel statt nxs_your_secret_key ein (VS Code fragt danach) oder nimm die Datei von der Agenten-Seite, die ihn einträgt; dort steht auch, wo jede Datei liegt.

examples/mcp/claude-desktop.json
{
  "mcpServers": {
    "nodexch": {
      "command": "npx",
      "args": ["-y", "@nodexch/mcp"],
      "env": {
        "NODEXCH_KEY": "nxs_your_secret_key"
      }
    }
  }
}

Tools

Was jedes Tool tut und was ein Aufruf höchstens kostet: die Gewichte der Routen, die es ausführt, ein Viertel für eine Antwort aus dem Cache, nichts bei einem Fehler. Jedes Ergebnis sagt, was es gekostet hat und was übrig ist.

ToolCreditsWas es tut
search_assets1Findet die Asset-ID eines Tokens nach Ticker oder Name.
offer_book2Die offenen Angebote eines Paars, das günstigste zuerst.
best_offer3Das günstigste Angebot eines Paars, mit seinem Text zum Annehmen.
get_offer1Ein offenes Angebot: Beträge, Preis, Ablauf und sein Text.
partial_offers2Partial offers
get_partial_offer1Get a partial offer
decode_offer2Liest einen Angebotstext: was er gibt, verlangt und kostet.
post_offer5Veröffentlicht ein Angebot deiner Wallet im Orderbuch und im Splash-Netzwerk.
recent_trades1Angenommene Angebote, die neuesten zuerst.
loan_board1Offene Kreditangebote in diesem Netzwerk.
prices2XCH in USD und Tokenpreise in XCH.

Die Protokollnachrichten selbst (initialize, tools/list) kosten nichts. Ein Tarif ohne einen Kanal bekommt einen Tool-Fehler, der einen Tarif mit ihm nennt.

Von Hand

examples/curl/mcp.sh
#!/bin/sh
# The MCP server for agents is POST /mcp with a secret key: one JSON-RPC message per request.
# An MCP client (Claude Code) does this for you; here is what it sends.
set -eu
: "${NODEXCH_KEY:?set NODEXCH_KEY=nxs_...}"
url="${NODEXCH_URL:-https://api.nodexch.com}"

mcp() {
  curl -fsS "$url/mcp" \
    -H "Authorization: Bearer $NODEXCH_KEY" \
    -H 'Content-Type: application/json' \
    -H 'Accept: application/json, text/event-stream' \
    -d "$1"
  echo
}

mcp '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"curl","version":"1"}}}'
mcp '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'