Pay-per-prompt AI

No accounts. No API keys. No credit cards. Just sats and inference.

For Humans

Owlrun Chat lets you talk to AI models and pay per prompt with Bitcoin ecash. No signup, no accounts — your sats are your session.

How it works

Your browser holds ecash proofs (digital cash tokens) in local storage. When you send a prompt, the browser attaches those proofs to the request. The gateway verifies them, runs inference on a GPU node, and returns the AI response along with your change.

The gateway never holds your funds. It claims your proofs at the moment of inference and returns change in the same response. Zero custody.

Compatible wallets

🦞 For Agents/Lobsters

curl -X POST https://api.owlrun.me/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-Cashu: cashuAeyJ0b2..." \
  -d '{"model":"qwen2.5:0.5b","messages":[{"role":"user","content":"Hello"}],"stream":true}'

X-Cashu header

The X-Cashu header carries a cashuA token — base64url-encoded JSON containing ecash proofs from our mint (mint.owlrun.me).

Payment flow

1. Claim — Gateway swaps your proofs at the mint (atomic, pre-job). If proofs are invalid or spent, you get 402.
2. Inference — Your prompt is routed to the best available GPU node.
3. Billing — Actual cost calculated from token count. Minimum 2 sats per job.
4. Change — Overpayment returned as a cashu_change SSE event at the end of the stream.

Change delivery

Change arrives as the last SSE event after inference completes:

data: {"model":"qwen2.5:0.5b","message":{"content":"Hello!"},"done":false}
data: {"model":"qwen2.5:0.5b","message":{"content":""},"done":true,...}
data: {"type":"cashu_change","token":"cashuAeyJ0b2...","change_sats":48}

Critical: Your SSE parser must NOT stop at "done":true. Keep reading until the stream closes to catch the change event.

Pre-job refund

If inference fails before starting (no nodes available, node rejected), your proofs are returned via the X-Cashu-Change response header — not SSE (streaming hasn't started).

API endpoints

Error responses

Code examples

Python

import requests
import json

API = "https://api.owlrun.me"
KEY = "owlr_buy_YOUR_KEY"
TOKEN = "cashuAeyJ0b2..."  # your ecash token

resp = requests.post(f"{API}/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {KEY}",
        "X-Cashu": TOKEN,
        "Content-Type": "application/json",
    },
    json={
        "model": "qwen2.5:0.5b",
        "messages": [{"role": "user", "content": "What is Bitcoin?"}],
        "stream": True,
    },
    stream=True,
)

change_token = None
for line in resp.iter_lines():
    if not line:
        continue
    text = line.decode()
    if text.startswith("data: "):
        text = text[6:]
    try:
        data = json.loads(text)
        if data.get("type") == "cashu_change":
            change_token = data["token"]
            print(f"\nChange: {data['change_sats']} sats")
        elif data.get("message", {}).get("content"):
            print(data["message"]["content"], end="", flush=True)
    except json.JSONDecodeError:
        pass

# change_token contains your remaining sats — save it for next request

JavaScript (Node.js)

const resp = await fetch("https://api.owlrun.me/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": "Bearer owlr_buy_YOUR_KEY",
    "X-Cashu": "cashuAeyJ0b2...",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "qwen2.5:0.5b",
    messages: [{ role: "user", content: "What is Bitcoin?" }],
    stream: true,
  }),
});

const reader = resp.body.getReader();
const decoder = new TextDecoder();
let buffer = "";

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop();
  for (const line of lines) {
    const trimmed = line.trim();
    if (!trimmed) continue;
    const data = trimmed.startsWith("data: ") ? trimmed.slice(6) : trimmed;
    try {
      const parsed = JSON.parse(data);
      if (parsed.type === "cashu_change") {
        console.log(`\nChange: ${parsed.change_sats} sats`);
        // Save parsed.token for next request
      } else if (parsed.message?.content) {
        process.stdout.write(parsed.message.content);
      }
    } catch {}
  }
}

curl (one-liner)

curl -N https://api.owlrun.me/v1/chat/completions \
  -H "Authorization: Bearer owlr_buy_YOUR_KEY" \
  -H "X-Cashu: cashuAeyJ0b2..." \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen2.5:0.5b","messages":[{"role":"user","content":"Hello"}],"stream":true}'

Pricing

FAQ

Where do I get ecash?

Use the Lightning top-up in chat.owlrun.me — scan the QR with any Lightning wallet. Or send ecash from Minibits.

What happens if I close the tab?

Your ecash proofs live in your browser's local storage. If you close the tab without withdrawing, the proofs are lost. Always withdraw first.

Can I use this from my own code?

Yes. The API is OpenAI-compatible. Add the X-Cashu header with ecash proofs and you're good. See the code examples above.

What models are available?

Check GET /v1/models for the current list with live pricing. During beta, availability depends on connected provider nodes.

curl https://api.owlrun.me/v1/models | jq
{
  "object": "list",
  "data": [
    {
      "id": "qwen2.5:0.5b",
      "object": "model",
      "owned_by": "owlrun",
      "pricing": {
        "per_m_input_usd": 0.02,
        "per_m_output_usd": 0.06
      }
    }
  ]
}

Is this custodial?

No. The gateway never holds your funds. Your ecash proofs are in your browser (or your agent's memory). The gateway claims proofs at the moment of inference and returns change in the same response. Zero custody.

What's the minimum payment?

2 sats per job — an anti-spam floor. Even on micro-prompts, 1 sat goes to the provider and 1 sat to the gateway. This "pay to play" minimum makes DDoS-by-microprompt economically unviable while keeping real usage nearly free.

Can agents use this without an API key?

Currently an API key is required for authentication. The ecash provides payment. We're working toward making ecash the only credential needed — sats are the CAPTCHA.

What if my payment fails?

If proofs are invalid or spent, you get a 402 error. If no nodes are available, your proofs are returned via the X-Cashu-Change response header. The gateway never charges for failed inference.