Pay-per-prompt AI

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

For Humans

Two sides of the same coin — use AI by paying sats, or earn sats by sharing your GPU. No accounts needed for either.

Use AI — chat with ecash

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 claims your proofs at the moment of inference and returns change in the same response. For providers, earnings are held briefly until auto-redeemed to your Lightning wallet (every 60 seconds) or manually withdrawn as ecash.

Compatible wallets

Earn Bitcoin — run a node

Install

Windows (PowerShell):

irm https://get.owlrun.me/install.ps1 | iex

Linux / macOS (bash):

curl -fsSL https://get.owlrun.me/install.sh | bash

The installer handles everything:

1. Detects your GPU — NVIDIA (CUDA), AMD (ROCm/WMI), or Apple Silicon
2. Installs Ollama — the AI model runtime (if not already present)
3. Downloads Owlrun — platform-specific binary with SHA-256 checksum verification
4. Generates your provider key — unique owlr_prov_* API key, auto-created
5. Registers auto-start — systemd (Linux), launchd (macOS), or Task Scheduler (Windows)
6. Launches Owlrun — starts earning immediately

Optional flags for headless/scripted installs:

# Linux/macOS
curl -fsSL https://get.owlrun.me/install.sh | bash -s -- \
  --key owlr_prov_... --wallet user@minibits.cash --referral owlr_ref_...

# Windows
irm https://get.owlrun.me/install.ps1 | iex \
  -ApiKey owlr_prov_... -Wallet user@minibits.cash -Referral owlr_ref_...

How earning works

Your machine                           Owlrun Gateway                    Buyer
+-----------+    WebSocket control    +----------------+    HTTPS API   +-------+
|  Owlrun   | ---------------------->|   gateway.     |<---------------|  App  |
|  + Ollama | <------- jobs ---------|   owlrun.me    |--- response -->|       |
+-----------+    HTTP/2 proxy         +----------------+               +-------+

1. Connect — Owlrun registers your GPU specs with the gateway over WebSocket
2. Wait for jobs — the gateway pushes inference requests to your node when a buyer asks for a model you can serve
3. Serve inference — your node fetches the buyer's prompt, runs it through local Ollama, and streams the response back
4. Get paid — earnings are credited instantly in millisats. Auto-paid to your Lightning wallet every 60 seconds

Configuration

Config file location:

• Linux/macOS: ~/.owlrun/owlrun.conf
• Windows: %USERPROFILE%\.owlrun\owlrun.conf

[account]
api_key           = owlr_prov_...           # Auto-generated on install
lightning_address = you@minibits.cash       # Lightning address for BTC payouts
referral_code     =                         # Optional affiliate code (owlr_ref_...)

[marketplace]
gateway           = https://node.owlrun.me  # Gateway endpoint
region            = auto                     # Auto-detected from IP, or set manually

[inference]
model_auto        = true                     # Auto-select best model for your VRAM
max_vram_pct      = 80                       # Max VRAM usage (leave headroom)
keep_warm         = true                     # Keep model loaded in VRAM between jobs
context_length    = 8192                     # Context window (0 = model default)

[idle]
trigger_minutes   = 10                       # Start earning after 10 min idle
gpu_threshold     = 15                       # Only earn if GPU usage < 15%
watch_processes   = true                     # Pause when games/heavy apps run
job_mode          = idle                     # idle (default), always, or never

[disk]
warn_threshold_pct = 30                      # Warn if disk drops below 30% free
min_model_space_gb = 8                       # Reserve space for model downloads

CLI flags

Dashboard

Once running, open http://localhost:19131 for a live dashboard:

The dashboard shows:

• Earnings — today's mSats earned, total balance, payout history
• GPU stats — utilization, VRAM, temperature, power draw
• Gateway status — connection state, jobs served, queue depth
• Wallet — Lightning address setup, payout threshold, ecash withdrawal

Look for the owl icon in your system tray — right-click for quick access to the dashboard, pause/resume, and settings.

Payouts

Requirements

🦞 For Agents/Lobsters

Two sides of the same coin — buy inference by paying ecash, or sell inference by connecting GPU nodes. Both are just HTTP + WebSocket.

Buy inference

curl -X POST https://api.owlrun.me/v1/chat/completions \
  -H "Content-Type: application/json" \
  -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 10 mSats 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: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"qwen2.5:0.5b","choices":[{"index":0,"delta":{"content":"Hello!"},"finish_reason":null}]}
data: {"id":"chatcmpl-1","object":"chat.completion.chunk","model":"qwen2.5:0.5b","choices":[{"index":0,"delta":{"content":""},"finish_reason":"stop"}]}
data: [DONE]
data: {"type":"cashu_change","token":"cashuAeyJ0b2...","change_sats":48}
data: [DONE]

Critical: Your SSE parser must NOT stop at "finish_reason":"stop" or the first [DONE]. Keep reading until the cashu_change event to receive your change.

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).

Buyer API endpoints

Non-streaming requests

Set "stream": false to get the full response in a single JSON object instead of SSE chunks:

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

Change is returned in the X-Cashu-Change response header (not SSE, since there's no stream).

Rate limits

Default: 60 requests per minute per buyer. Returns 429 Too Many Requests with a Retry-After header. X-Cashu proofs are refunded if rate-limited after claiming.

Error responses

Code examples

Python

import requests
import json

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

resp = requests.post(f"{API}/v1/chat/completions",
    headers={
        "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("choices") and data["choices"][0].get("delta", {}).get("content"):
            print(data["choices"][0]["delta"]["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: {
    "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.choices?.[0]?.delta?.content) {
        process.stdout.write(parsed.choices[0].delta.content);
      }
    } catch {}
  }
}

curl (one-liner)

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

Sell inference — programmatic node

Building your own node client, a fleet manager, or integrating GPU capacity into an existing system? Here's the full provider API. The standard Owlrun client uses these same endpoints.

Registration

Register your node with the gateway. This must happen before connecting the WebSocket control channel.

POST https://node.owlrun.me/v1/gateway/register
Authorization: Bearer owlr_prov_...
Content-Type: application/json

{
  "node_id":            "uuid-v4",
  "gpu":                "NVIDIA GeForce RTX 4090",
  "gpu_vendor":         "nvidia",
  "vram_total_mb":      24576,
  "vram_free_mb":       22000,
  "vram_exact":         true,
  "models":             ["llama3.1:8b", "qwen2.5:0.5b"],
  "ollama_url":         "http://127.0.0.1:11434",
  "region":             "us-east",
  "version":            "0.2.0",
  "wallet":             "",
  "lightning_address":  "you@minibits.cash",
  "redeem_threshold_sats": 500
}

Response (200):

{ "status": "registered", "node_id": "uuid-v4" }

Rate limit: 30 registrations per IP per hour.

WebSocket control channel

After registration, open a persistent WebSocket for job assignment and heartbeat:

wss://node.owlrun.me/v1/gateway/ws?api_key=owlr_prov_...

All messages are JSON envelopes with a type field.

Node → Gateway

Gateway → Node

Heartbeat example

// Node sends every ~30s
{"type":"heartbeat","gpu_util_pct":12,"vram_free_mb":18000,"temp_c":52,"power_w":145.2,"queue_depth":0,"earning_state":"earning"}

// Gateway responds
{"type":"heartbeat_ack","status":"online","jobs_today":14,"tokens_today":52340,"earned_today_usd":0.0031,"balance_sats":1840,"btc_live_usd":87420.50,"btc_daily_avg":87200.00,"broadcasts":[],"withdraw_history":[]}

Job proxy (two-request split)

When a job is assigned and accepted, the node fetches the buyer's request, runs inference locally, and streams the result back:

1. Fetch buyer request

GET https://node.owlrun.me/v1/gateway/jobs/{job_id}/proxy/request
Authorization: Bearer owlr_prov_...

Returns the raw buyer request body (OpenAI-format JSON). The gateway sends it with END_STREAM — read the full body before proceeding.

2. Stream node response

POST https://node.owlrun.me/v1/gateway/jobs/{job_id}/proxy/response
Authorization: Bearer owlr_prov_...
Content-Type: application/octet-stream

[raw Ollama streaming response bytes]

Stream your Ollama output directly into this request. The gateway forwards bytes to the buyer in real time (blind forwarding — no content inspection). Close the stream when inference is complete.

Ecash withdrawal

Programmatically withdraw provider earnings as Cashu ecash:

POST https://node.owlrun.me/v1/provider/withdraw-ecash
Authorization: Bearer owlr_prov_...
Content-Type: application/json

{ "amount_sats": 1000 }

Response (200):

{
  "token": "cashuAeyJ0b2...",
  "amount_sats": 1000
}

The returned token can be redeemed by any Cashu wallet (e.g. Minibits). Withdrawal is atomic — if it fails, your balance is unchanged.

Provider API summary

Pricing

FAQ

Buying / using AI

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 are stored in your browser's localStorage. In a normal browser session, they persist across tab closes and page reloads — you can come back later and your balance is still there. You lose your sats if you:

• Clear your browser cache/data — this wipes localStorage
• Use incognito/private mode — localStorage is deleted when the window closes
• Switch browsers or devices — localStorage is per-browser

Best practice: withdraw to a wallet (Minibits, Phoenix) when you're done. Don't leave large amounts in the browser.

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 '.data[0]'
{
  "id": "qwen2.5:0.5b",
  "name": "Qwen 2.5 0.5B",
  "object": "model",
  "owned_by": "owlrun",
  "context_length": 32768,
  "pricing": {
    "prompt": "0.0000000050",
    "completion": "0.0000000100"
  },
  "owlrun_pricing": {
    "per_m_input_usd": 0.005,
    "per_m_output_usd": 0.01
  }
}

pricing uses OpenRouter-compatible per-token strings. owlrun_pricing has the same rates as USD per million tokens for readability.

Is this custodial?

For buyers: Your ecash proofs live in your browser (or your agent's memory). The gateway claims proofs at the moment of inference and returns change in the same response — it doesn't hold a balance for you.

For providers: Earnings are credited to your gateway balance and auto-redeemed to your Lightning wallet every 60 seconds. The gateway holds your balance briefly between earning and payout. You can also withdraw manually as ecash at any time.

What's the minimum payment?

10 mSats per job (~0.01 sats) — an anti-spam floor. Even on micro-prompts, 5 mSats go to the provider and 5 mSats to the gateway. Sub-sat precision means real usage is nearly free while making DDoS-by-microprompt economically unviable.

Do I need an API key?

No. Ecash is the only credential you need — sats are the CAPTCHA. Just add the X-Cashu header with valid proofs. API keys are optional — they unlock volume tracking, affiliate attribution, and better rates at scale. Get one at POST /v1/beta/signup (no email required).

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.

Selling / running a node

Do I need to open any ports?

No. Owlrun connects outbound to node.owlrun.me over standard HTTPS/WSS. No port forwarding, no firewall changes, no static IP needed.

What happens when I use my computer?

Owlrun watches for mouse/keyboard activity and GPU usage. When you're active (or a game starts), it pauses automatically. When you go idle again, it resumes. You can also pause manually from the system tray.

Can the gateway see my prompts?

No. The gateway does blind byte forwarding — it routes encrypted traffic between buyer and node without inspecting content. Zero content logging.

How do I get paid?

Set a Lightning address in your config or dashboard. Earnings are auto-sent every 60 seconds. Or withdraw manually as Cashu ecash. All payments are in Bitcoin.

What if my internet drops?

Owlrun reconnects automatically. If a job was in progress, the gateway routes the buyer to another node. No penalty for disconnects — your reputation recovers on the next successful job.

Is my data safe?

Owlrun only runs AI inference — it never reads your files, screen, or personal data. All communication is encrypted (TLS). The binary is open source (MIT license) and checksum-verified on install.

What models get downloaded?

Models are downloaded on demand when a job arrives. With model_auto = true, Owlrun picks models that fit your VRAM. Models are cached locally so subsequent jobs are instant. You can see and manage models in the dashboard.

How is my node scored?

The gateway uses weighted random routing. Higher-scored nodes get more traffic but every eligible node gets some work — no starvation. Score factors: successful jobs, response time, uptime, VRAM availability. The system is self-balancing.

What are the fees?

Owlrun takes under 10% (9% platform + ~1% FX margin). Lightning routing fees (~5 sats per payout) are network costs paid to Lightning routing nodes, not to Owlrun. At the default 500 sat threshold, Lightning fees are about 1% of each payout.

Can I run multiple nodes?

Yes. Each machine gets its own owlr_prov_* key and node ID. Install on as many machines as you want — each earns independently.