Test-network preview

Public API router

Status: test-network preview. https://api.keeta.ai/v1 is the planned production base URL.

The router serves Keeta Compute to clients without the macOS app: servers, other platforms, any HTTP client. It speaks the OpenAI chat API and charges per request with x402 on Keeta, in KUSD (in USDC until KUSD is live on the network). There is no account, API key or invoice: the payment is the authorization.

Base URL: https://api.keeta.ai/v1

Endpoints

GET /v1/models

Free. Lists models with at least one online provider, plus any model the router can serve through its fallback, in the OpenAI list format. Each entry has an extra keeta object: how many providers serve the model, and the lowest price per million input and output tokens in Keeta Compute Credit base units (one credit is one US dollar, with 6 decimals, so 50000 is $0.05).

{
  "object": "list",
  "data": [
    {
      "id": "qwen3-8b",
      "object": "model",
      "keeta": {
        "providers": 3,
        "lowestPrice": { "inputPerMillion": "50000", "outputPerMillion": "100000" }
      }
    }
  ]
}

POST /v1/chat/completions

Paid. OpenAI request and response format; stream: true is supported. Set max_tokens: it bounds what the request can cost.

Payment: x402 in Keeta stablecoins

  1. Send the request with no payment. The router picks a provider and answers 402 Payment Required with a PAYMENT-REQUIRED header: base64 JSON, x402 version 2.
  2. Your client signs one Keeta send block for amount to payTo and retries the same request with the PAYMENT-SIGNATURE header. The block is signed, not published.
  3. The router has the x402 facilitator verify the block. The provider checks the quote and reserves a slot for the job, the facilitator settles the payment on Keeta, and only then does the provider run the job. If the provider is offline, busy or refuses the quote, nothing is settled and you are not charged. A payment that does not send the quoted amount to payTo with the job id as the send's external reference (extra.external) is refused before it is settled, so you are not charged for it either.

The payment goes to keeta.ai's settlement account, with the job id written into the send. When the provider's signed receipt bills the job, one Keeta transaction from the settlement account pays the provider what it billed, less the 0.25% network fee, and sends the rest of your payment back to the address that paid. If the job fails or no receipt arrives, the whole payment comes back.

Example 402:

curl -i https://api.keeta.ai/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "qwen3-8b", "messages": [{"role": "user", "content": "Say hello."}], "max_tokens": 256}'
HTTP/2 402
content-type: application/json
payment-required: eyJ4NDAyVmVyc2lvbiI6Mi...

The PAYMENT-REQUIRED header, decoded:

{
  "x402Version": 2,
  "resource": { "url": "https://api.keeta.ai/v1/chat/completions" },
  "accepts": [
    {
      "scheme": "exact",
      "network": "keeta:1413829460",
      "asset": "keeta_<the KUSD token address>",
      "amount": "27",
      "payTo": "keeta_<keeta.ai's settlement address>",
      "maxTimeoutSeconds": 60,
      "extra": {
        "jobId": "job_<id>",
        "external": "job_<id>",
        "assetSymbol": "KUSD",
        "model": "qwen3-8b",
        "maxInputTokens": 20,
        "maxOutputTokens": 256,
        "price": { "inputPerMillion": "50000", "outputPerMillion": "100000" }
      }
    }
  ]
}
FieldMeaning
networkkeeta:1413829460 on the test network, keeta:21378 on the main network
assetThe KUSD token address on that network, or USDC's until KUSD is live there. extra.assetSymbol names it.
amountThe maximum cost in the asset's base units: estimated input tokens plus max_tokens, at the provider's price in credits, one US dollar per credit, rounded up
payTokeeta.ai's settlement address, which pays the serving provider once the job is billed
extraThe job id (also as external, which the Keeta x402 client writes into the send), the asset's symbol, the model, token limits and price the amount was computed from

In the example, 20 × 50000 + 256 × 100000 = 26600000, divided by one million and rounded up: 27 base units, or 0.000027 KUSD.

You pay the maximum up front. After the job, what the receipt did not bill comes back to the paying address in the same transaction that pays the provider.

When the network is full

When no provider can take a request, keeta.ai may answer it from its own capacity so paid requests still get an answer. keeta.ai turns this on per model and sets its price.

Receipts

Every completion served by a network provider carries the provider's signed receipt: model, weights hash, runtime, token counts, price and amount (fields).

event: keeta.receipt
data: {"receipt": {...}, "signature": "..."}

TypeScript buyer

Uses the same packages as the x402-payments skill (verified there with @x402/* 2.28.0 and @keetanetwork/keetanet-client 0.18.7).

npm install @keetanetwork/keetanet-client @x402/core @x402/keeta @x402/fetch
import * as KeetaNet from "@keetanetwork/keetanet-client";
import { x402Client } from "@x402/core/client";
import { wrapFetchWithPayment } from "@x402/fetch";
import { ExactKeetaScheme, KEETA_TESTNET_CAIP2, toClientKeetaSigner } from "@x402/keeta";

// Load the seed from your secret store. Never print, log or commit it.
const account = KeetaNet.lib.Account.fromSeed(process.env.KEETA_SEED!, 0);
const signer = toClientKeetaSigner(account); // opens a UserClient; destroy it when done
const model = "qwen3-8b";
// The router's test-network USDC (6 decimals). @x402 only allows its own default assets unless you opt in.
const TEST_USDC = "keeta_aosjk5tgpgxr3qazd2abxyhj4srqua5c3xgz4lmgxuyrrwzryiqng4vacgwai";

try {
  const client = new x402Client()
    .register(KEETA_TESTNET_CAIP2, new ExactKeetaScheme(signer))
    .setSpendControls({
      maxAmountPerPayment: "$0.05", // cap per request on @x402's default assets
      allowedAssets: [{ network: KEETA_TESTNET_CAIP2, asset: TEST_USDC, maxAmountPerPayment: "50000" }], // 0.05 USDC
    })
    .onBeforePaymentCreation(async ({ selectedRequirements: req }) => {
      const extra = req.extra as { model?: string; assetSymbol?: string } | undefined;
      const stablecoin = extra?.assetSymbol === "KUSD" || extra?.assetSymbol === "USDC";
      if (req.network !== KEETA_TESTNET_CAIP2 || extra?.model !== model || !stablecoin) {
        return { abort: true, reason: "unexpected payment request" };
      }
    });

  const fetchWithPayment = wrapFetchWithPayment(fetch, client);
  const response = await fetchWithPayment("https://api.keeta.ai/v1/chat/completions", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model,
      messages: [{ role: "user", content: "Say hello." }],
      max_tokens: 256,
    }),
  });
  if (!response.ok) throw new Error(`router answered ${response.status}`);

  const completion = await response.json();
  const header = response.headers.get("X-Keeta-Receipt");
  const receipt = header ? JSON.parse(Buffer.from(header, "base64").toString("utf8")) : undefined;
  console.log(completion.choices[0].message.content, receipt?.receipt.amount);
} finally {
  await signer.destroy();
}

Errors

StatusMeaning
400Invalid request: malformed JSON or fields the router does not accept
402Payment required, or the payment failed verification or settlement
404Unknown model
502The provider failed. If it failed before it accepted the job, the payment is not settled and the message says so. If it failed after the job started, the payment was settled, and the PAYMENT-RESPONSE header shows it; the whole payment comes back once the job is settled as failed.
503No provider is available for the model now. Retry after the Retry-After header.

This page as Markdown: router.md. Every Compute page for agents: llms.txt.