Subnet 33 Jobs API

What this is

Send a chunk of text, get a list of tags back. Each request is paid for in USDC stablecoin using x402 — an open HTTP-native payment standard. No accounts, no API keys, no monthly bill: you pay per call, and the payment is bound cryptographically to that single request.

Supported job category for the initial release: tagging of raw text. Submit websites, articles, named-entity extraction targets, or meeting minutes; receive a normalized tag list.

Powered by Bittensor subnet 33

Behind the scenes, every job you submit is dispatched to miners on Bittensor subnet 33 — a decentralized network of nodes specializing in semantic tagging. ReadyAI operates this API as a payment-gated entry point: you pay in USDC via x402, and subnet 33 miners do the work. Results from multiple miners are aggregated server-side into a single tag list before being returned.

You don't need TAO, a Bittensor wallet, or any subnet-specific tooling to use the API — a standard EVM wallet with USDC on Base is the only client requirement.

How a request flows

1. Quote. POST /jobs-api/v1/quote with the job type, category, and declared content size. Get back a quote ID and the exact USDC amount required.
2. Pay & submit. POST /jobs-api/v1/jobs with the quote ID, full payload, and an X-PAYMENT header containing your signed payment authorization (your x402 client builds this from the 402 challenge). The server verifies and settles the payment, then queues the job. You receive a jobId and a short-lived JWT.
3. Poll for result. GET /jobs-api/v1/jobs/{jobId} with the JWT in Authorization: Bearer <token>. Status moves queued → processing → complete (or failed). Results are retained for 30 days.

Priority tiers

Both the quote and job requests accept an optional priority field that trades cost against turnaround. The price scales off the normal rate:

• LOW — 0.9× the normal price
• NORMAL — 1.0× (the default; omit the field to use it)
• HIGH — 1.2× the normal price
• X_HIGH — 2.0× the normal price

The tier is locked into your quote, so the amount you're quoted is the amount you pay. Send the same priority on both the quote and the job — a mismatch is rejected.

Extra tags

Set the optional extraTags flag (boolean, default false) to have your job processed by more miners before the result is finalized — broader, richer tag coverage. This multiplies the price by 1.5×, stacking on top of the priority multiplier (e.g. X_HIGH + extraTags = 2.0 × 1.5 = 3.0×). Like priority, it's locked into the quote and must match on both the quote and the job.

Getting set up with x402

You need three things on the client side:

1. A wallet (any standard EVM-compatible wallet — a private key your client can sign with).
2. USDC on Base (mainnet) to pay for requests.
3. An x402-aware HTTP client. The reference implementations ship Python, TypeScript, and Go SDKs that wrap your existing HTTP client and transparently sign & retry on a 402 response.

Minimal Python example

import httpx
from eth_account import Account
from x402 import x402Client
from x402.http.clients.httpx import x402HttpxClient
from x402.mechanisms.evm import EthAccountSigner
from x402.mechanisms.evm.exact import register_exact_evm_client

account = Account.from_key("0x...your private key...")
client = x402Client()
register_exact_evm_client(client, EthAccountSigner(account), networks=["base"])

API = "https://your-deployment.example"

async def submit():
    async with (
        httpx.AsyncClient(base_url=API) as plain,
        x402HttpxClient(x402_client=client, base_url=API) as paid,
    ):
        # 1. Get a quote (no payment required).
        quote = (await plain.post("/jobs-api/v1/quote", json={
            "jobType": "tagging",
            "declaredSize": 256,
            "category": "WEBSITE",
        })).json()

        # 2. Submit the paid job. x402HttpxClient handles the 402 handshake.
        job = (await paid.post("/jobs-api/v1/jobs", json={
            "quoteId": quote["quoteId"],
            "jobType": "tagging",
            "category": "WEBSITE",
            "payload": {"content": ""},
        })).json()

        # 3. Poll for the result.
        token = job["token"]
        result = (await plain.get(
            f"/jobs-api/v1/jobs/{job['jobId']}",
            headers={"Authorization": f"Bearer {token}"},
        )).json()
        print(result)

For a full reference of every endpoint, request shape, and response schema, see the interactive Swagger UI.

Payment transparency

All paid requests settle as USDC transfers on Base mainnet to a single ReadyAI-operated receiving wallet. Every successful job submission is one on-chain transfer — you can verify it from the transaction hash returned by your x402 client and follow live activity, balances, and historical inflows on Basescan:

0x85B47b40455ab2Bd7921f76dCe841B48C82d627C

75% of enrichment revenue goes to alpha buybacks. Every API call flowing through the pipeline — whether from existing enterprise customers or new Jobs submissions — funds buybacks of SN33 alpha from the open market. All on-chain, all verifiable. Real revenue from real customers flowing back into alpha.

API reference

The complete API spec — every endpoint, request body, response shape, error code, and example payload — lives in the interactive Swagger UI. The raw OpenAPI document is available at /jobs-api/openapi.json if you want to generate clients or import it into another tool.

Resources

Support