Geoff runs on top of StackNet, a decentralized inference network with native crypto primitives. That makes the API useful for crypto builders in three ways:
  1. Pay per call with crypto — settle inference in stablecoins over x402 instead of topping up a credit-card balance.
  2. Wallet-native auth — sign in with a Solana or EVM wallet; no email required.
  3. Crypto-literate models — Geoff models are tuned on up-to-date market data, tokenomics, and on-chain semantics, so agents can reason about chains, wallets, tx data, and DeFi protocols out of the box.

​
1. Pay for inference with crypto (x402)

Every Geoff endpoint accepts payment via the x402 protocol — a standard that lets HTTP servers charge per request, settled in stablecoins. The flow is transparent to your client: 
POST /v1/text/chat
→ 402 Payment Required
   X-Payment-Request: <invoice>

POST /v1/text/chat
   X-Payment: <signed tx>
→ 200 OK
Any x402-aware HTTP client handles the retry automatically. Funded wallets never see the 402.
TypeScript
import { createX402Client } from "x402";

const client = createX402Client({
  privateKey: process.env.WALLET_KEY,
  chain: "solana",
});

const res = await client.fetch("https://geoff.ai/api/v1/text/chat", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "magma",
    messages: [{ role: "user", content: "Explain the Solana fee market." }],
  }),
});
Top up by sending USDC (or any supported stablecoin) to the wallet you signed in with. StackNet deducts from the on-chain balance, not a credit card.

​
2. Sign in with a wallet

StackNet sessions can be minted from a wallet signature, bypassing email/password entirely. The geoff.ai dashboard ships with a wallet button; under the hood it:
  1. Asks the wallet to sign a nonce issued by StackNet.
  2. Exchanges the signature for a JWT (stackauth_jwt) scoped to the wallet’s global ID.
  3. Uses that JWT for every subsequent API call and for x402 settlement.
This means one identity spans dashboard usage, API keys, and on-chain payments — no key reconciliation required. For custom integrations, pass the JWT as a bearer token exactly like an API key: 
curl https://geoff.ai/api/v1/text/chat \
  -H "Authorization: Bearer $WALLET_JWT" \
  -H "Content-Type: application/json" \
  -d '{"model":"duce","messages":[{"role":"user","content":"gm"}]}'
See Authentication for the full handshake.

​
3. Build a crypto-aware agent

Because Geoff models are current on market data and chain semantics, you can wire them into on-chain workflows without a separate RAG layer for basic queries.

​
Example: research agent that explains a token

Python
import requests

def explain_token(symbol: str):
    r = requests.post(
        "https://geoff.ai/api/v1/text/chat",
        headers={"Authorization": "Bearer YOUR_API_KEY"},
        json={
            "model": "magma",
            "messages": [
                {"role": "system", "content": (
                    "You are a crypto analyst. Given a ticker, reply with: "
                    "chain, contract address if known, 2-sentence thesis, "
                    "one key risk. Be specific, no marketing language."
                )},
                {"role": "user", "content": symbol},
            ],
        },
    )
    return r.json()["choices"][0]["message"]["content"]

print(explain_token("JTO"))

​
Example: tx-intent → signed transaction

Pair the model with the code sandbox and a wallet SDK to let natural-language intents compile to real transactions. The model drafts the call; the sandbox runs the SDK; your client signs before broadcast. 
User: "Swap 10 USDC for SOL on Jupiter with 1% slippage."
  ↓ Geoff (magma) drafts a TypeScript snippet using @jup-ag/api
  ↓ Sandbox runs it with read-only keys, returns the unsigned VersionedTransaction
  ↓ Client wallet signs and broadcasts
Keep signing on the client. The agent loop should only ever see unsigned payloads.

​
4. Useful endpoints for crypto apps

Text Chat

Reason over tx data, whitepapers, and on-chain events.

Streaming

Stream research or trading commentary token-by-token.

Code Sandbox

Execute SDK calls and simulations in isolated runtimes.

Image Generation

Generate NFT art, collection thumbnails, or brand assets.

​
Notes on scope and finality

  • x402 settlement is final on-chain — treat each paid request like a micro-transaction.
  • Model output about live markets reflects training data; for tickers that move fast, pair the model with a realtime data source before acting.
  • Private keys never leave the client. StackNet only ever sees signatures and the resulting JWT.