For providers

Run a node

The sell side of Obol. If you have access to an AI model — a pay-as-you-go API key or a model on your own machine — you can rent it out and earn USDC per token, paid on Arc. Obol never sees your key: your node calls your backend itself.

Have your agent set this up:

A consumer ChatGPT/Claude subscription is not sellable — you need API access (an API key), which is separate. OpenRouter is the easiest: one key unlocks many models.

Before you start — what you need

Three things, from scratch:

1
An OpenAI-compatible model backend + its API key
Easiest is an OpenRouter key (openrouter.ai) — one key, many models. Also works: OpenAI, Groq, Together, Hugging Face router, or a local server (Ollama / vLLM).
2
An EVM wallet private key
Used for your node's identity and to receive payouts. Any wallet works — export a private key from MetaMask or generate one. Keep it secret.
3
Node.js 20+ and the Obol backend repo
The same code that runs the broker. You'll clone it and run one command.

1 · Get the code

bash

git clone https://github.com/simplex-t/obol.git
cd obol
npm install

2 · Configure your node

Create a .env file (secrets load via --env-file, never on the command line):

env

OBOL_NODE_PK=0x...                       # your wallet private key (identity + payout) — keep secret
OBOL_NODE_URL=https://obolservice.onrender.com                   # the live Obol broker to register with
OBOL_NODE_MODEL=qwen2.5-7b               # a model id from Obol's catalog that you serve
OBOL_NODE_BACKEND_URL=https://openrouter.ai/api/v1   # your OpenAI-compatible backend
OBOL_NODE_BACKEND_KEY=sk-or-...          # your backend API key (OpenRouter/OpenAI/Groq/…)
OBOL_NODE_RATE_IN=0.02                   # µUSDC you charge per input token
OBOL_NODE_RATE_OUT=0.1                   # µUSDC you charge per output token

OBOL_NODE_URL must be the live broker above — not localhost (that's only for running everything on one machine). OBOL_NODE_MODEL must be a model id Obol knows (see the Models page) that your backend actually serves.

3 · Launch & earn

1
Launch the node
It exposes an endpoint and announces itself to the broker.
bash
```
npx tsx --env-file=.env src/node.ts
```
2
Pass verification (automatic)
The node signs a challenge with your wallet (identity), returns an HMAC from its health endpoint (endpoint control), and answers a live canary inference (capability). Clear all three and it goes ACTIVE.
3
Serve & earn
Requests route to the cheapest healthy node. You earn your per-token rate on every served call; Obol adds its margin on top for the buyer. Watch status and accrued earnings under Nodes in the app.
4
Get paid on Arc
Accrued earnings pay out to your wallet in USDC on Arc — whole µUSDC per payout, remainder carried forward.

Staying in the pool

The marketplace is trust-minimized. Obol re-counts tokens from the bytes it proxied, so you can't over-bill. Reputation rises with successful calls and decays when idle; repeated failures trip a circuit breaker. A provable over-claim forfeits your bond and ejects the node.

Serve honestly and stay healthy: your rate, reputation, and uptime decide how much traffic — and revenue — you get.

Buy inference instead

Route many models through one API, pay per token

→