Sluice Docs

The open market for AI inference. Buy discounted inference, sell the credits you will never burn, pay with USDC, card, or per-call via x402. One OpenAI-compatible endpoint.

Overview

Sluice is a peer-to-peer marketplace for AI model inference. Buyers route their API calls through one OpenAI-compatible gateway and pay in credits. Sellers list surplus credits at a discount. The result is a live order book where the price of inference is set by supply and demand instead of a single provider list price.

The idea is simple. Inference is a commodity: the same model call costs the same compute no matter who runs it, yet most people pay a fixed list price while many others hold credits they will never spend. Sluice puts both sides in one venue, so unused supply finds the buyers who want it and the price lands wherever supply and demand meet. You keep the exact OpenAI request shape you already use, only the base URL and the rate change.

Buyer Quickstart

1. Open the app and sign in with Google, X, or email.
2. Top up credits: Account → Buy credits (pay with card) or Deposit (send USDC).
3. Grab your API key: Account → API key.
4. Call the gateway from any OpenAI-compatible client:

# OpenAI-compatible, only the base URL changes
export SLUICE_API_KEY="inf_..."

curl https://sluicemarkets.com/api/inference \
  -H "Authorization: Bearer $SLUICE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-opus-4.8",
    "messages": [{"role":"user","content":"Hello from Sluice"}],
    "stream": true
  }'

Seller Quickstart

Sellers turn unused credits into USDC. You list an offer at a price per credit; buyers fill the cheapest offers first.

1. Complete KYC (Account → Verify KYC). Selling and sending credits require a verified identity.
2. Open Account → List credits.
3. Choose a model, set your price per credit (e.g. 0.50 = a 50% discount to the buyer), and the amount to list.
4. When a buyer fills your offer, proceeds settle to your balance and the trade appears in your trade history and account ledger.

Agent Quickstart

Autonomous agents can pay per request with no account using the x402 protocol. The agent posts a normal OpenAI-style body, receives a 402 with payment terms, signs a USDC authorization, and retries.

# 1. discovery, what does a call cost?
curl https://sluicemarkets.com/api/x402

# 2. first call returns 402 + payment requirements,
#    client signs EIP-3009 USDC auth and retries with X-PAYMENT

How It Works

Every model has a list price. Sellers post offers below that price. When you send a request, Sluice charges your credits at the marketplace rate and routes the call to the upstream model. The difference between list price and fill price is your realized discount.

Nothing about your integration changes when a fill happens. You send a request, Sluice debits your balance at the going rate, and the call is served by the upstream model as normal. The order book runs underneath, quietly turning surplus into a discount. When no offer sits below list, you simply pay list, so a call never fails for lack of a seller.

The lifecycle of a request

It helps to follow a single call from start to finish. You send an OpenAI-shaped request to the gateway with your bearer token. Sluice authenticates the key, checks you have enough credits, and looks at the order book for that model. If sellers are offering credits below list, your call is priced at the best available rate and the matching amount is debited from your balance. The request is then forwarded to a healthy upstream for that model, the response streams back to you unchanged, and a ledger entry records exactly what was charged. If no offer sits below list, the same flow runs at list price, so the call always completes. From your side it is one HTTP request, everything above happens in the few milliseconds before the model starts generating.

This is why integrating with Sluice is a base URL change rather than a new SDK. The marketplace, the routing, and the metering are invisible at the call site. You write the same code you would write against any OpenAI-compatible endpoint, and the discount simply shows up in how far each credit goes.

Models & Providers

Sluice exposes a catalog of 60+ models across 18 providers, Anthropic, OpenAI, Google, Meta, Mistral, DeepSeek, xAI, Alibaba (Qwen), Moonshot, Zhipu, MiniMax, NVIDIA, Cohere, Perplexity, and more. The full live list is on the Markets page, or via the API:

Every model in the catalog speaks the same OpenAI request shape, so moving from one to another is a single field change. The catalog endpoint returns each model with its provider, list price, and a routing verdict, the same data that powers the live board on the Markets page. New models are added as providers ship them, and anything being deprecated is flagged well before it is removed.

curl https://sluicemarkets.com/api/catalog

Pricing

• Credits are priced 1:1 with USD at provider list price (1 credit = $1).
• Card top-ups (Stripe) buy credits at full price; minimum 5 credits.
• USDC deposits credit 1:1.
• Marketplace is where the discount lives, fill seller offers below list to pay less than $1 per credit of value.

Settlement

Balances are tracked in a ledger. Deposits, card payments, buys, sells, and transfers each write a ledger entry. USDC deposits are matched on-chain to your account by sender wallet and are idempotent, a transaction is never credited twice. Card payments settle through a signed Stripe webhook, also idempotent per checkout session.

Because every movement is a ledger entry, your balance is always reconstructable from history rather than a figure adjusted by hand. That is what makes deposits and payments safe to retry: the same transaction or checkout session can arrive twice and only ever moves your balance once. You can read your own recent fills through the account endpoint and reconcile spend down to the last credit.

Health & Routing

Each inference call is routed to the cheapest healthy provider configured for that model. A provider is only eligible when its key is present in the environment; otherwise Sluice falls back to the default upstream. If a chosen provider errors, the call retries once on the default upstream so a single provider outage never drops your request. The response carries an x-sluice-route header showing which path served it.

Per-model routing can be pinned with the MODEL_ROUTES config, mapping a catalog id to a specific provider and upstream model id:

{ "claude-opus-4.8": { "provider": "openrouter", "model": "anthropic/claude-3.5-sonnet" } }

Security & Privacy

• Auth is handled by Privy (Google, X, email) with an embedded wallet per account.
• API keys are scoped to your account and shown once, rotate from Account → API key.
• Identity verification (KYC) is handled by a third-party provider and required only for selling and sending credits.
• Webhooks (payments, KYC) are verified by signature before any balance change.

Sensitive workloads can run on privacy preserving models where the provider supports zero retention, so a prompt is used to produce your answer and then discarded. Sluice does not sell prompts or build advertising profiles, and balances are guarded by idempotent, signature-verified settlement, so a replayed or forged webhook cannot move funds.

Token

$SLC is the token behind the Sluice marketplace, fair-launched on Pons and live on Robinhood Chain. It is built around one idea: the people who hold it get a better deal on the market they use. Every utility below ties directly to real activity on Sluice, not to speculation.

Detail
Network	Robinhood Chain
Launchpad	ponsfamily.com
Contract address	0x8079b0d5D41f8787905BB851ea380cD3A1800655

$SLC is a utility token for the Sluice marketplace, not an investment or a promise of return. Utility is delivered through the product and may evolve as the market grows.

API Reference, Overview

The Sluice API is OpenAI-compatible. Base URL:

https://sluicemarkets.com/api

Authenticate with a bearer token (inf_...) from Account → API key.

If you have integrated with OpenAI before, you already know this API. The endpoints below mirror the OpenAI surface for chat and images, and add a small set of Sluice-native routes for media jobs, account balance, and wallet payments. Errors follow one JSON shape with a human-readable message, so existing error handling keeps working without changes.

Chat Completions

OpenAI chat/completions-shaped request. Supports stream:true.

{
  "model": "gpt-5.5",
  "messages": [{"role":"user","content":"hi"}],
  "stream": true,
  "temperature": 0.7
}

The request body is the standard chat completions shape. Common fields are supported: model, messages, temperature, top_p, max_tokens, stop, and tool or function calling where the underlying model supports it. Use any model id from the catalog.

With stream:true the response is a server-sent event stream of token deltas, identical to OpenAI, so existing streaming clients parse it without changes. Without it, you get a single JSON completion. Either way the response includes a usage block, and the credits actually charged for the call are reflected in your balance and written to the ledger. On failure the gateway returns the usual JSON error object with a message you can surface to the user, and a single upstream hiccup is retried on the default route before it ever reaches you.

Models

Returns the marketplace catalog: id, provider, context, list price, discount, and live offer counts.

Each entry is everything you need to choose a model at runtime: the id you pass as model, the provider behind it, the context window, the list price per million tokens, the current best discount, and how much seller supply is live. The same data drives the board on the Markets page, so what you see in the UI and what you get from the API are always the same numbers. A good pattern for agents is to pull the catalog once, filter by capability and price, and pin the cheapest model that fits the task.

Image Generation

OpenAI images/generations-shaped request. Charges a flat credit cost per image.

{
  "model": "venice-sd35",
  "prompt": "a koi pond at dusk, ink wash",
  "n": 1,
  "size": "1024x1024"
}

The call is synchronous: it returns once the image is ready. The response follows the OpenAI images shape, a data array where each item carries a url or a base64 b64_json payload you can render directly. Set n to request more than one image in a single call. You are charged a flat credit cost per image returned, and the exact amount comes back in the x-sluice-cost response header so you can reconcile spend.

Video Generation async

Video is generated through a job queue: submit, then poll until ready. Charges a flat credit cost on submit.

{ "model": "seedance-2.0", "prompt": "a koi pond, slow dolly" }
// -> { queue_id, model }

{ "model": "seedance-2.0", "queue_id": "..." }
// PROCESSING -> {status, average_execution_time}; COMPLETED -> mp4 bytes

Because video takes time, the work runs as a job. The first call submits the prompt and returns a queue_id, and a flat credit cost is charged at that moment. You then poll the same endpoint with action=poll every few seconds. While the job runs you get a small JSON status with an average_execution_time estimate, and the moment it finishes the poll returns the finished mp4 bytes directly, which you can drop into a video element or save to disk. A typical clip lands in well under a couple of minutes depending on the model.

Music Generation async

Same submit-then-poll flow for music and sound effects.

{ "model": "minimax-music", "prompt": "lofi piano, rain" }
// -> { queue_id }  then POST /api/music?action=poll

Account & Balance

Returns your USDC balance, credit balance, account UID, and KYC status. Requires your bearer token.

This is the endpoint to call when you want to show a user their state: the USDC sitting in their account wallet, their spendable credit balance, the short UID other users can send credits to, and whether identity verification has been completed. It is also where an agent checks it has enough credits before starting an expensive run.

Public marketplace stats, 24h volume, trades, mean discount, and 7-day series, computed from fills.

x402 Pay-per-call

Pay per request in USDC, no account, no API key. GET returns a discovery document. POST with no X-PAYMENT header returns 402 and payment requirements; sign an EIP-3009 USDC authorization and retry with the X-PAYMENT header to run the call and settle on-chain.

The value of x402 is that an agent never needs an account, a password, or a stored API key. It carries a funded wallet, discovers the price of a call, authorizes exactly that amount, and runs. Each call is its own settlement, so there is no balance to top up and nothing to leak. This is the cleanest path for autonomous software that pays its own way.

Payments, USDC Deposit

Send USDC to your Sluice wallet, then it is matched to your account and credited 1:1. Deposits are scanned automatically and are idempotent per transaction hash.

Payments, Card (Stripe)

Buy credits with a card from Account → Buy credits → Pay with card. Minimum 5 credits, 1 credit = $1. Payment is processed by Stripe Checkout; on success a signed webhook credits your account.

Payments, x402

For agents and per-request billing, see x402 Pay-per-call. Settlement is on-chain in USDC, one authorization per call.

Guides, Cursor / Aider

Any tool that accepts an OpenAI base URL works. Set the base URL to https://sluicemarkets.com/api and the key to your inf_... token. Pick any model id from the catalog.

# Aider example
export OPENAI_API_BASE="https://sluicemarkets.com/api"
export OPENAI_API_KEY="inf_..."
aider --model claude-opus-4.8

Roadmap in progress

Shipping next, in order of priority:

Image, video and music generation, the Studio, card checkout, account UID and credit transfers, and identity verification have all shipped. What is next, in order of priority:

• Multi-provider routing, route each call to the cheapest healthy offer across providers, not a single upstream.
• Withdrawals, cash out balance to USDC on-chain.
• Responses API, the newer OpenAI /responses surface with typed output blocks.
• BYOK seller, sellers bring their own provider key and earn on spread.
• More rails, additional agent payment options beyond x402.