NewHow we catch a seller listing the wrong model, and refund you if one does.

Sellers

You can list inference capacity you are licensed to resell on MartLLM: an account at one of the providers on our list, under a plan that permits resale. Buyer requests for a model can be routed to your offer, and you are credited the full amount the buyer pays for each request.

To list an offer from the browser, use the seller page: Account → Sell capacity → New offer. It walks you through five steps: Provider, Discover, Health test, Pricing, Review. Nothing goes live until you confirm, and buyers are sent to a new offer once it passes our model check and a person on our team has approved it.

Everything the page does is also an API, so your agent can do it too (see For agents).

From the terminal

npx uberllm sell

One command does the same as the seller page. It needs Node.js 18 or newer.

  1. You name the provider and paste your key. Typing is hidden, and a key is never accepted as a command-line flag (in a script, use --key-env NAME).
  2. The key is checked with the provider, and only sent there. For OpenRouter, DeepSeek, Venice AI, Moonshot AI / Kimi, Ollama Cloud and Morpheus you see the remaining balance, read from the provider's own balance API. For the other providers the key is checked with the provider's model list, which is free, and you read the balance in your provider account.
  3. You are asked before the key is sent to MartLLM. On no, nothing is sent.
  4. You choose the models and the price (Enter matches the lowest price buyers get now), and a second yes lists them through /v1/seller/offers/bulk, 10 models per request. If a request fails, what was already listed is shown; run the command again for the rest (models already listed are skipped).

Your MartLLM key is read from UBERLLM_API_KEY, or from the one uberllm init saved. Without one, the command checks your provider key and opens the seller form with the provider chosen (/seller/new?provider=<id>).

Option What it does
--provider <id> The provider to sell from. --providers prints the list.
--key-env <NAME> Read the provider key from this environment variable.
--check-only Check the key and the balance, send nothing to MartLLM.
--models <a,b> Model ids to list. Default: every model we can list from the key.
--discount <percent> Price this far below list price. Default: match the lowest price buyers get now.
--precision <full|8bit|below8> How your provider runs open-weight models.
--daily-cap <usd> Stop sending buyers once this much is spent on an offer in a day.
--yes Do not ask before sending the key to MartLLM and listing (for scripts).

Step-by-step guides for every verified provider, with what each provider's terms said when we read them: Sell unused AI credits.

Providers you can sell from

  • Only providers on our list. When you add an offer you pick the provider from the list (GET /seller/providers) and paste your key; the address comes from the list. Your own server, or any address that is not on the list, is refused. To sell from a provider that is not listed, ask us to add it: [email protected]. We test a provider before we add it: its model list, a small request, how it reports errors and usage, its prices and whether its terms allow resale.
  • Verified providers. Providers marked Verified (trusted: true) are run by a company we have checked. Buyers are sent to offers on verified providers by default. Offers on the other providers on the list reach only buyers who turned on Also use sellers on providers we have not verified for their key.
  • Offers listed before this rule on an address that is not on the list get no buyers and can't be turned on again (provider_listed: false, with the reason in blocked_reason). Their sales history stays. To keep selling, list the model again from a provider on the list.

How an offer works

  • One provider key, one base URL, many models. An offer is one model served through one key at one address. The same key can serve as many models as you like, but you can't list the same model twice on the same key and address — a second one is refused with 409 duplicate_offer_for_credential (and, when the existing offer is yours, its id in error.detail.existing_offer_id).
  • We pick the provider's name for the model, you don't. The provider may call a model differently from us (we call it deepseek/deepseek-v4-flash, the provider calls it deepseek-v4-flash). We read the provider's model list with your key and list a model only when the provider's name is the same model as ours: the same name once the maker's prefix, capital letters and - _ . are set aside, with at most a date or version stamp on the end. Discovery does this for you. If you send upstream_model yourself it must be one of the names in the provider's list and the same model, or the offer is refused. If we can't read the provider's model list with your key, the offer is refused with the reason.
  • Your key's shape is checked first. For providers whose keys have a documented form (for example OpenRouter keys start with sk-or-v1-, Groq keys with gsk_), a key in another form is refused before we send anything.
  • Your key is encrypted at rest, decrypted only to serve a request sent to you, never returned by any read and never logged. A new key is tested before it is accepted — if the test fails, your old key stays. Removing an offer erases the stored key.

Pricing

Text offers are priced as a discount off the model's list price (the price a buyer would pay going direct). Send discount_pct (e.g. 45 = 45% off) or the same thing as multiplier (0.55). Per-token prices (input_usd_per_mtok / output_usd_per_mtok) are no longer accepted for text models.

"match_best": true sets your price to the deepest discount buyers can get on that model right now. You can change it any time.

Buyers pay your price; all of it is credited to you as each request completes. MartLLM takes no fee from your sales. Your own cost is whatever your provider charges your key.

Optional daily_cap_usd: once buyers have spent that much on the offer in a day, it stops getting requests until the next day.

Health

Health is measured on real buyer traffic. The only other requests we send your key are the test request below and those of the model check.

  • When you list or turn on an offer, or change its key, we send one small test request (it may use a tiny bit of your quota).
  • If a buyer's request to you fails, the buyer is moved to the next seller and your offer sits out of routing for a while: 30 s → 1 min → 2 min → 10 min for server errors and timeouts, 10 → 20 → 40 → 60 min for a refused key or no credit, 15–30 s for rate limits. When the wait ends your offer gets requests again; a request that goes through resets it.
  • Fixed it sooner? POST /seller/offers/{id}/reset-health (the Fixed it, try again button) puts it back at once. So does a new key or address that passes its test.
  • If your provider refuses your key or says the account has no credit twice in a row, we email you (at most once a day) with the offers affected.
  • If your provider says your key is not valid (HTTP 401 or 403) three times in a row, the offer is paused and the health log says why (key_rejected). Fix the key (or add a new one with Change key), then turn the offer on: we test the key again first.
  • GET /seller/health-log says, in plain words, why an offer was skipped and when it came back.

Quality compared with other hosts

Every reply your offer serves is also checked against the request it answered: tool calls are valid JSON, name a tool the buyer offered and fit that tool's arguments; replies are not cut well short of the length the buyer asked for or run past it; the buyer's thinking setting is followed; and a reply that thinks also answers. Every few minutes your rates are compared with the other hosts of the same model over the last two days. Most hosts that fall behind have a setting wrong (a tool-call parser, an output length limit, reasoning options), so this is feedback, not a penalty for cheating:

  • Far behind the others on one of these, and your offer is still live but buyers are sent to other hosts of the model first (for tool problems, only buyers who use tools). Your Selling page says what is wrong, in plain words.
  • It lifts by itself within minutes once your numbers are back in line.
  • A new offer, or one with little traffic, is not compared until it has enough replies: it is neither favoured nor held back.

From listing to live

Every new offer goes through the same steps, and the Selling page shows where each offer is:

  1. Listed. Your key passed the test request when you confirmed.
  2. Model check. We check that your server answers as the model you listed. This usually takes a few minutes. See Model check.
  3. Team review. A person on our team approves the offer. Until then the Selling page shows it as In review. The model check and the review run at the same time.
  4. Live. Buyers are sent to it. We email you when it is approved.

If our team does not approve an offer, it is paused and shows Not approved with the reason, and we email you the same reason. Fix what it says, then turn the offer on again: it comes back to our team for review.

A new key, server address or model on an offer is a new offer: it goes through the model check and the review again. While an offer waits for review you can still change its price or pause it.

Model check

Buyers pay for the model you list, so we check that your offer really serves it.

The rules

  • Serve the exact model you list. Not a smaller, cheaper, older or differently tuned model, and not a mix of models.
  • Add nothing to the request. No instructions, system prompt or tools of your own, and nothing cut from what the buyer sent. A resold chat app or coding tool that adds its own instructions breaks this rule.
  • Pass token counts through unchanged, exactly as the model counted them.
  • Don't change the answers. No padding to make replies longer, no trimming, no rewriting: send back what the model wrote.
  • Pass tags through unchanged. A buyer's request may reach you with tags like [EMAIL_3f9a2c1b] in place of secrets and personal data. Send them to the model as they are, and send back the model's answer with them as they are.

How we check

  • Every offer is reviewed by a person on our team before any buyer is sent to it. Until then the Selling page shows it as In review.
  • Every offer is also checked before any buyer is sent to it. Until it passes, the Selling page shows it as Checking; once both are done it goes Live. A new key, address or model is reviewed and checked again the same way.
  • Offers keep being checked for as long as they are listed, also after they go Live, on real traffic and with checks that look like any other request and can come at any time. A live offer can go back to Checking for a while; buyers are sent to it again once the check passes.
  • Checks use a little of your quota and are paid like any other request.
  • We don't publish how the checks work or when they run.

When an offer fails a check

  • It is Paused, and you can't turn it back on yourself. Listing the same key again as a new offer is refused too.
  • Your payouts are held while our team reviews it. What that offer earned and was not paid out yet can go back to the buyers it served.
  • The Selling page and GET /seller/offers say why, in plain words (listing_state: "paused" with check_reason), and we email you.
  • To have it checked again, fix what serves the offer, then write to [email protected].

When a seller is caught serving a different model than listed

  • Your seller account is suspended and all your offers stop at once.
  • Earnings not yet paid out are forfeited and used to refund the buyers your offers served. Payouts not yet sent are canceled.
  • You can't list on MartLLM again, with the same provider key, server, payout address or email.
  • The Selling page says so, and GET /seller/offers answers listing_state: "suspended". Write to [email protected] about it.

Open-weight models: say how you run them

Open-weight models (GPT-OSS, Qwen, DeepSeek, GLM, Kimi, MiniMax and others whose weights are published) can be run at full quality or compressed to save memory. A compressed copy answers a little worse, and no test can reliably tell it from the full model. So when you list an open-weight model you say how your server runs it, and buyers see your answer on the model's page:

  • Full quality (16-bit): the weights as published (bf16 / fp16), or better.
  • 8-bit: fp8 or int8.
  • Below 8-bit (6-bit or 4-bit): anything smaller.

A new listing of an open-weight model needs one of the three. Offers listed before 1 November 2026 show "Precision not stated" until you set it (Selling page → the offer → Price and precision). Stating a higher precision than your server really runs is a different model than listed: the account is suspended, as below. Closed models (Claude, GPT-5, Gemini…) don't ask.

Padded token counts

When your server reports far more prompt tokens than a request really holds, the buyer is billed, and you are paid, for at most about 2× our own count of the request's prompt tokens, plus a small allowance for tool definitions and images. Below that, requests are billed exactly as your server reports them.

The reply side works the same way. We count the text your reply sends back: the answer, tool-call arguments, and the reasoning when the model shows it in full. The buyer is billed, and you are paid, for at most 1.15× what the real model reports for that much text, plus 16 tokens. "What the real model reports" is learned from our own trusted route for the same model.

Reasoning the reply does not show (Claude, GPT and Gemini hide or summarize it, or it comes back encrypted) cannot be counted. It is allowed up to what the real model uses in 99 of 100 replies at the same reasoning effort and a similar prompt size. That figure comes from the model maker's own service when we have it, and from our trusted route otherwise.

Until we have enough replies of a model to set these limits, its replies are billed as your server reports them. An honest server is very rarely capped. Replies that go over the limit also count against your offer's checks, the same as before.

Earnings and payouts

The seller console has six tabs: Earnings, Payouts, Offers (each model you sell, grouped by provider, filter by Live / In review / Needs attention, and your saved provider keys), New offer, Agent keys and Provider Market.

  • Provider Market (GET /seller/market): each provider key you list over the last 30 days: what it earned, the calls it served, and its win rate, the share it won of every call buyers made on the same models (through anyone, so a ceiling, not demand aimed at you). It also shows today's take against each key's daily limits (they reset at 00:00 UTC).

  • GET /seller/earnings?range=7d|30d|90d|all — earned, sales and tokens, by model, with the market around each of your models (cheapest discount right now and the market's realized discount in the last hour) so you can see how to price. daily lists what you earned each UTC day with sales, and avg_discount_pct how far under list price buyers paid on average (absent until you have sales on a model with a list price).

  • GET /seller/payouts — available to pay out (owed_usd), on hold (held_usd, and next_release_at: when the next part is ready), on the way and paid as separate numbers, where your payouts are sent (payout_method, null until you set it), plus your payout history.

  • PUT /seller/payout-method {method, address} — where to send your money: {"method":"paypal","address":"[email protected]"} (the email of your PayPal account) or {"method":"usdc_base","address":"0x…"} (your wallet on Base, 0x and 40 hex characters; we send USDC on the Base network only). Answers the saved {method, address, set_at}. In the console: Payouts → Payout destination.

Earnings are held before they can be paid out: 14 days while you are a new seller (your first 30 days, or until you have earned $500 in total), then 7 days. That way buyers can be refunded if an offer turns out not to serve the model it lists. The Selling page shows Available to pay out and On hold, with the date the next part is ready. Money can also stay on hold, with no date, while a check on one of your offers is running.

Payouts over $100 need a one-time identity check. Before we send a payout over $100, a person on our team confirms who you are. We email you to set it up; until then that payout waits, and nothing is lost.

Once out of the hold, what's available goes into a payout automatically once it reaches $5, or 72 hours after your oldest unpaid sale came out of the hold (checked every 10 minutes). You can also ask for one at any time (POST /seller/payouts/request, the Pay me now button). You have one payout on the way at a time: what you earn meanwhile stays owed and goes into your next payout once the current one is paid (asking for another answers 409 payout_already_on_the_way).

Our team sends each payout to the PayPal email or USDC (Base) wallet you set, usually within 2 business days of it starting. If a payout starts before you have set one, we email the owners of your account to ask, and send it once you do. A payout counts as paid only once it has really been sent; the payment reference then shows next to it, and we email you that it was sent.

If a payout can't be delivered (for example the PayPal email can't receive money), it shows as Didn't go through with the reason. Nothing is lost: the amount is owed to you again and goes out with your next payout, and we email you to check where we send your money.

API

Signed in on the web, the seller API is under /api/v1/seller. With your MartLLM API key (the one your agent got from uberllm sign-in), the same API is under /v1/seller.

Agent keys (Selling › Agent keys) let a script or agent manage your offers without your login and without your spending key. An agent key calls only /v1/seller: it can create, change, pause and remove offers, test keys, read earnings and ask for a payout, and list, create and revoke agent keys (GET/POST /v1/seller/agent-keys {name}, DELETE /v1/seller/agent-keys/{id}; the full key is answered once). It can't make AI requests, spend credit, change where your payouts go (/seller/payout-method answers 403 agent_key_not_allowed), or manage API keys, credit or your account. Up to 25 per account; revoking one takes effect at once, and offers it created keep running.

curl https://api.martllm.com/v1/seller/offers -H "Authorization: Bearer $UBERLLM_SELLER_KEY"
Call What it does
POST /seller/register {display_name?} Start selling (once). The name is optional: left out, you are shown as "Seller" plus 4 letters. The Selling page does this for you.
GET /seller/providers The providers you can sell from: id, name, base_url, and trusted (verified).
POST /seller/discover {base_url, api_key} or {config_id} The models a key can serve, matched to ours (open_weights: true = listing it needs a precision). Costs no quota.
POST /seller/test {base_url, api_key, models[]} One small test request per model.
POST /seller/offers/bulk List many models on one key: {endpoint_url, api_key, save_config, daily_cap_usd, precision, offers:[{model_id, upstream_model, precision, discount_pct | match_best}]}. precision (full, 8bit or below8) is required for open-weight models; the top-level one applies to every open-weight model in the batch. Each model is tested as it's listed; one that fails is left out with the reason.
POST /seller/offers List one model: {model_id, endpoint_url, api_key, upstream_model, precision, discount_pct, daily_cap_usd}.
GET /seller/offers · GET /seller/offers/{id} Your offers with price, % off, health, state (listing_state: review, checking, live, paused or suspended; needs_review: true while our team has not approved it; review_note with the reason when our team did not approve it; with check_reason when it failed the model check) and live rank (where you stand among everything buyers can be sent to for that model). provider_listed: false = its address is not on our provider list: no buyers, can't be turned on, reason in blocked_reason.
PATCH /seller/offers/{id} Reprice (discount_pct), cap (daily_cap_usd, 0 removes it), precision (open-weight models), status: paused | active (an offer that failed the model check can't be turned back on).
POST /seller/offers/{id}/rotate-credential {api_key} New key, tested before it's accepted.
POST /seller/offers/{id}/reset-health Back into routing now.
DELETE /seller/offers/{id} Remove: out of routing, stored key erased.
GET /seller/configs · DELETE /seller/configs/{id} Saved keys for starting new offers (only a 4-character hint is ever shown).
GET /seller/health-log Why offers were skipped or paused (key_rejected = the provider refused the key three times in a row).
GET /seller/earnings · GET /seller/payouts · POST /seller/payouts/request Money: what's available, on hold, on the way and paid.
PUT /seller/payout-method {method: paypal | usdc_base, address} Where your payouts are sent: a PayPal email or a USDC wallet on Base.
curl https://api.martllm.com/v1/seller/offers/bulk \
  -H "Authorization: Bearer $UBERLLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint_url": "https://openrouter.ai/api/v1",
    "api_key": "<your provider key>",
    "save_config": true,
    "offers": [
      { "model_id": "meta-llama/llama-3.3-70b-instruct", "match_best": true }
    ]
  }'

endpoint_url must be a provider's base_url from GET /seller/providers. Where the provider names a model differently from us, send upstream_model: the server_model that POST /seller/discover returned for that model.

For agents

Your agent already has a MartLLM API key after sign-in. It can register, find models on a provider key, list them and watch earnings with the calls above under /v1/seller. No other key type is needed.

Only list what you may resell

  • ✅ Capacity at a provider on our list that you are allowed to resell.
  • ❌ Your own server, or a provider that is not on our list. Ask us to add a provider: [email protected].
  • ❌ A provider key whose terms do not let you resell it or give others access. Many providers' terms do not: check yours before you list it.
  • ❌ Stolen, leaked, shared, free-trial or evaluation keys. An offer that breaks these rules is removed.

Use a dedicated provider key with a spending cap. You are responsible for the licensing and lawful operation of what you list.