Documentation

Aetheron sells AI work one call at a time. You ask an endpoint to do something, it answers with a price, you pay from your own wallet, and you ask again. There is no account, no subscription and no API key. Everything here describes that exchange and the ways to drive it.

A paid endpoint answers an unpaid request with the terms of payment, so curl is a complete client.

curl -sX POST https://aetheronprotocol.com/api/prompt-optimizer \
     -H 'Content-Type: application/json' \
     -d '{"text": "make this prompt better"}'

That returns 402 with an amount and a destination. Send the transfer, then repeat the call with the signature in X-TX-SIG.

Four messages and one transfer. Nothing else.

{
  "status": 402,
  "component": "prompt-optimizer",
  "required": 0.25,
  "currency": "USDC",
  "network": "Solana",
  "wallet": "<receiving address>",
  "accepted_methods": ["USDC"]
}

A client never needs telling out of band what a call costs. Everything required to pay is in the response that refused you.

AI components

The first three need only an Anthropic key. The last two read Solana and Ethereum, and fall back to whatever sources remain when a provider is missing.

Agent templates

Nine complete Python projects at $4.99 each. You download the source and it is yours: they run on your machine and depend on nothing here to keep working. Each ships with a README, a config.json, its requirements and a licence.

Browse the agent store →

Output formats

Every component returns a written report. Pass format in the request body to choose how it is rendered.

Anything else is rejected rather than silently downgraded, so a typo surfaces as a 422 instead of quietly returning the wrong thing.

Request headers

Paid endpoints

Free endpoints

A generated OpenAPI explorer is also available at /api-explorer.

Jobs and downloads

Work runs asynchronously. A verified paid call answers 202 with a task id.

{
  "message": "Prompt queued for processing",
  "asset_id": "X402-PROMPT-A1B2C3D4E5",
  "task_id": "9f2c8ab1-..."
}

Poll /api/job-status/{task_id} until it reports success, then fetch the download URL it returns. Report filenames are cryptographically random, because they are served from a public bucket and the name is the only thing protecting them.

Errors

Payment methods

Partial payments

Underpay and the shortfall is recorded against your wallet for that component, so a later transfer completes the purchase. The 402 tells you exactly what remains.

{
  "status": 402,
  "message": "Partial payment received",
  "paid": 0.10,
  "required": 0.25,
  "remaining": 0.15,
  "currency": "USDC"
}

The signature that paid it is spent and cannot be presented again.

Security model

Aetheron holds no keys and can sign nothing. Verifying payment means checking that its own balance rose, not that a transfer happened somewhere.

The signer must also be the wallet claiming the purchase. Claiming a payment is an insert keyed on the signature, so two requests racing with the same signature cannot both be credited.

Browser first and framework agnostic. It does not hide the payment step: nothing is auto-paid, and no transaction is built or signed for you.

npm install aetheron-sdk

import { AetheronSDK } from "aetheron-sdk";

const aetheron = new AetheronSDK(wallet, connection);

try {
  await aetheron.promptOptimizer({ text: "make this prompt better" });
} catch (err) {
  const terms = aetheron.getPaymentInfo(err);   // null if it was a real error
  terms?.required;   // 0.25
  terms?.wallet;     // where to send it
}

// once the user has signed and sent the transfer
const report = await aetheron.promptOptimizer(
  { text: "make this prompt better", format: "pdf" },
  { txSig }
);

promptOptimizer, codeExplainer, promptTester, contractIntel and downloadAgent all wrap callPaidComponent, which accepts any endpoint, so the Risk Engine and anything added later is reachable before a named method exists. The endpoint defaults to the origin serving the page.

The same calls from a terminal, for scripting bulk prompt or code analysis. Not yet shipped. This page will show usage the day it does, rather than documentation for something you cannot install.

Exposes the components as tools, so an agent can buy and run one directly. The 402 exchange is already the whole interface and nothing about it is specific to a browser. Also not yet shipped.

Self-hosting

Aetheron is MIT licensed and runs on your own machine with Python 3.11 and Redis. There is no database to provision: leave DB_HOST empty and the ledger is a local SQLite file.

git clone https://github.com/Aetheron402/Aetheron
cd Aetheron

python -m venv .venv
.venv/bin/pip install -r requirements.txt
cp .env.example .env          # set PAYMENT_WALLET and OPENAI_API_KEY

redis-server --daemonize yes
.venv/bin/uvicorn Aetheron:app --reload
.venv/bin/celery -A celery_worker.celery worker --loglevel=info

Configuration

Nothing is hardcoded. Every setting is an environment variable, documented in .env.example. Exactly three are required.

Licence

MIT. Fork it, run it, charge for it. The components are the product; the code that takes payment for them was never the secret.

Source and issues on GitHub →