Skip to main content

Seller configuration

A seller reads its settings from ~/.antseed/config.json (change the path with --config or ANTSEED_CONFIG). Keep non-secret settings in the file and secrets such as API keys and the identity key in environment variables. Buyer settings in the same file are covered in Buyer configuration.

You rarely need to edit the JSON by hand. antseed seller setup and the antseed config seller commands write it for you, and antseed config seller show prints the current seller section. When a setting exists in several places, a command-line flag wins over an environment variable, which wins over config.json, which wins over the built-in default.

Providers and services​

Everything a seller announces lives under seller.providers. Each key is a label you choose; plugin names the provider plugin that serves it. Each provider holds one entry per service, keyed by the service ID buyers request.

JSON
{
"seller": {
"providers": {
"inference": {
"plugin": "openai",
"baseUrl": "https://api.example-inference.com",
"defaults": {
"inputUsdPerMillion": 0.5,
"outputUsdPerMillion": 2
},
"services": {
"deepseek-v4-flash": {
"upstreamModel": "<upstream-model-id>",
"categories": ["coding"],
"pricing": {
"inputUsdPerMillion": 0.25,
"cachedInputUsdPerMillion": 0.025,
"outputUsdPerMillion": 1
},
"capabilities": {
"contextWindow": 128000,
"inputs": ["text"],
"toolUse": true
}
}
}
}
}
}
}

Provider fields​

FieldDescription
pluginPlugin name (openai, anthropic, local-llm, …) or an npm package name. Required.
baseUrlUpstream API base URL, without the /v1 suffix. Passed to the openai, openai-responses, local-llm, typesafe, venice-video, fal-video, fal-image, alibaba-video and irp-router plugins as their *_BASE_URL setting, so you don't need to export it separately.
apiKeyEnvName of the environment variable that holds this provider's API key, so two providers on one seller can use different keys. Applies to the anthropic plugin and to the same plugins as baseUrl, except openai-responses, which signs in with the Codex auth file.
pathRewriteExact request paths to rewrite before forwarding upstream, for example { "/v1/chat/completions": "/v4/chat/completions" }. openai plugin only.
fallbackUpstreamsBackup upstreams for the same models, tried in order when the main upstream fails. openai plugin only. See Backup upstreams.
defaultsFallback token pricing for services that don't set their own pricing.
servicesThe services this provider announces.

Providers of the same plugin announce under one provider name (two openai providers both announce as openai). A model that two of them list must have the same terms in both: price, API protocols, unit billing and capabilities. Buyers see one entry per provider name, so the seller refuses to start otherwise; list the model under one of them only, or give it the same terms. A video model can be listed by only one of them, because a video job stays with the upstream account that accepted it.

Backup upstreams​

A provider can list backup upstreams that serve the same models. When the main upstream fails before anything reaches the buyer, the seller sends the request to the next upstream instead of returning the error:

  • the request could not be sent, or timed out,
  • or the upstream answered 401, 402, 403, 404, 408, 429, 500, 502, 503, 504 or 529 (bad key, out of credit, model gone, rate limit or quota, server error).

Other errors, such as 400 for a malformed request, go back to the buyer unchanged. A stream that has already started is never switched.

JSON
{
"seller": {
"providers": {
"kimi": {
"plugin": "openai",
"baseUrl": "https://api.example-inference.com",
"apiKeyEnv": "INFERENCE_API_KEY",
"fallbackUpstreams": [
{
"baseUrl": "https://api.example-backup.com",
"apiKeyEnv": "BACKUP_API_KEY",
"services": {
"kimi-k3.1-pro": { "upstreamModel": "<model-id-at-the-backup>" }
}
}
],
"services": {
"kimi-k3.1-pro": {},
"kimi-k3": {}
}
}
}
}
}
FieldDescription
baseUrlThe backup's API base URL. Required.
apiKeyEnvEnvironment variable that holds the backup's API key. Omit to reuse the provider's key. The seller refuses to start if the variable is not set.
servicesThe services this backup serves, with upstreamModel when the model has another name there. Omit to use the backup for every service of the provider, under the provider's own upstreamModel names.
pathRewritePath rewrites for this backup. Defaults to the provider's pathRewrite.

The buyer gets the model they asked for and pays the service's normal price, whichever upstream answered. Backups share the provider's other settings (extra headers, body fields, concurrency), so only list upstreams that accept the same API.

After an upstream fails for a service, the seller tries it last for that service for 30 seconds, or for as long as its Retry-After header asks (up to 5 minutes), so requests don't keep waiting on an upstream that is out of quota. Model health checks go through the same backups, so a service stays advertised while any of its upstreams works. The seller log shows each switch as [http-relay] <service>: primary upstream <host> failed (HTTP 429); trying fallback <host>.

Service fields​

FieldDescription
upstreamModelModel ID sent upstream. Defaults to the service ID.
imageEditModelVenice image services only: the native edit model that serves /v1/images/edits for this service. See Venice image edits.
extraProtocolsopenai text services only: add openai-responses and/or anthropic-messages alongside Chat Completions. The upstream and fallbacks must already support those APIs; no protocol translation is performed.
pricinginputUsdPerMillion, outputUsdPerMillion and optional cachedInputUsdPerMillion, in USD per million tokens. Overrides the provider's defaults.
categoriesTags announced in discovery. Lowercase letters, digits and hyphens. Buyers can filter on any tag; privacy, legal, uncensored, coding, finance and tee are the well-known ones shown in antseed network browse --tag.
capabilitiesHints about the model. See below.
unitBillingModelsPer-image, per-video, per-character (speech) or per-routing-request pricing. See Unit-billed services.

Set cachedInputUsdPerMillion when your upstream charges less for cache hits. When any seller of a model advertises a cached-input price, buyers count offers of that model that omit it at half their trust score, which can drop them below the buyer's minimum. Free offers are exempt.

The cached-input price must be at most the input price. Buyers skip an offer whose cached input costs more than its input, so the model would get no requests. antseed seller setup, the antseed config seller commands, antseed seller settings and the Gateway Console refuse such a price, and antseed seller start warns about one already in the config. Leave cachedInputUsdPerMillion out to bill cached input at the input price. A service with its own pricing doesn't take the provider's default cached-input price: set it on the service too.

Capabilities​

Capabilities tell buyers what a service can do. They are hints, not enforced limits, and an omitted field means "unknown".

FieldTypeMeaning
contextWindownumberTotal context window in tokens
maxOutputTokensnumberMaximum output tokens per response
inputsstring[]Accepted input modalities: text, image, audio, video, pdf
outputsstring[]Produced output modalities, same values
reasoningbooleanSupports reasoning effort or extended thinking
toolUsebooleanSupports tool calls
structuredOutputbooleanSupports JSON schema responses
supportedParametersstring[]Extra request-body parameters the service accepts, in lowercase snake_case (for example seed, output_format); at most 32
videoobjectOptions a video model accepts. See Image, video and speech services
speechobjectVoices (voices, customVoices) and formats of a speech model. See Voices

Edit the configuration from the CLI​

Add a provider. This also installs its plugin into ~/.antseed/plugins:

Terminal
antseed config seller add-provider inference \
--plugin openai \
--base-url https://api.example-inference.com \
--input 0.5 --cached 0.05 --output 2

For OpenRouter, use --base-url https://openrouter.ai/api.

Add or update a service. The provider must already exist:

Terminal
antseed config seller add-service inference kimi-k2.6 \
--upstream "<upstream-model-id>" \
--input 0.6 --cached 0.06 --output 2.5 \
--categories coding \
--capabilities '{"contextWindow":128000,"inputs":["text"],"toolUse":true,"reasoning":true}'
OptionDescription
--upstream <model>Upstream model ID (defaults to the service ID)
--input, --output, --cached <usd>Token prices in USD per million tokens. --cached is at most --input; leave it out to bill cached input at the input price
--categories <list>Comma-separated tags
--capabilities <json>Capabilities object
--unit-billing-models <json>Unit pricing, see Unit-billed services
--base-url <url>Sets baseUrl on the whole provider

Change single fields or remove entries:

Terminal
antseed config seller set providers.inference.services.deepseek-v4-flash.pricing.inputUsdPerMillion 0.2
antseed config seller set providers.inference.services.deepseek-v4-flash.categories '["coding","privacy"]'
antseed config seller remove-service inference kimi-k2.6
antseed config seller remove-provider inference

config seller set works with service IDs that contain a dot, such as kimi-k2.6, once the service exists: providers.inference.services.kimi-k2.6.pricing.inputUsdPerMillion. Add a new service with add-service. set accepts keys that already exist in the file, the provider and service fields on this page, and the freeTier, freeUsage and restrictedCountries keys shown below. It refuses any other key, and a provider or service that doesn't exist, with an error and a non-zero exit code; add other blocks, such as healthCheck, by editing the file.

antseed seller setup builds the capabilities object with one question per field, tailored to the service: image services are asked about input modalities and supported parameters, text services about context window, modalities, reasoning, tool use and structured output. You can paste a JSON object at the capabilities prompt instead.

Built-in plugins and credentials​

Credentials always come from environment variables, never from config.json.

PluginServesCredential
openaiOpenAI-compatible chat and image APIsOPENAI_API_KEY
anthropicAnthropic Messages APIANTHROPIC_API_KEY
local-llmOllama or llama.cpp (default http://localhost:11434)LOCAL_LLM_API_KEY, optional
typesafeSystem One decision models (POST /v1/systemone)TYPESAFE_API_KEY
venice-videoVideo models behind the Venice video APIVENICE_VIDEO_API_KEY
fal-videofal.ai video modelsFAL_VIDEO_API_KEY
fal-imagefal.ai image models through the OpenAI Images APIFAL_IMAGE_API_KEY
alibaba-videoAlibaba Cloud Model Studio video models (Wan, HappyHorse)ALIBABA_VIDEO_API_KEY
irp-routerAny Inference Routing Protocol router, as an irp-suggest routing service (--base-url)IRP_ROUTER_API_KEY, optional
free-model-routerAn irp-suggest routing service that ranks free models among a buyer's candidatesNone
claude-code, claude-oauth, openai-responsesSubscription credentials, for testing onlyLocal keychain, OAuth token or Codex auth file

Any other npm package that exports a provider plugin works too. See Provider plugin API.

Node settings​

KeyDefaultDescription
seller.publicAddressemptyhost:port buyers should dial. Needed when the address the DHT sees isn't the one buyers can reach, such as behind a load balancer. Check it with antseed seller doctor.
seller.maxConcurrentBuyers50Maximum concurrent requests each provider plugin handles.
seller.maxUploadBodyBytes64 MiBLargest request body accepted from a buyer; at least 1 MiB. ANTSEED_MAX_UPLOAD_BODY_BYTES overrides it.
seller.maxInFlightRequestBytes256 MiBMost request body bytes held at once across all buyers, uploads still arriving included. A request is kept in memory until its response is sent; past the limit a request gets a 503 the buyer retries. Never below seller.maxUploadBodyBytes. ANTSEED_MAX_IN_FLIGHT_REQUEST_BYTES overrides it.
seller.blockedBuyersnoneBuyer peer IDs (40 hex characters, with or without 0x) this seller refuses. Their requests get 403 with code: "buyer_blocked" before any provider, billing or free-tier check runs; the free /v1/models listing stays open to them. ANTSEED_BLOCKED_BUYERS (comma-separated) replaces it.
seller.maxInboundConnectionsPerIp64Buyer connections accepted from one IP at once. Raise it when every buyer reaches the seller through one address, such as a TLS gateway or antseed seller forward.
seller.maxInboundConnections2048Buyer connections held open at once. A buyer keeps its connection between requests, so a busy seller holds one per active buyer; past the limit new buyers are refused. Metadata requests from discovery never count. ANTSEED_MAX_INBOUND_CONNECTIONS overrides it.
seller.inboundIdleTimeoutMs30 minCloses a buyer's connection after this long with no traffic, unless the buyer has a paid channel open. A buyer with only a free usage session open is kept for 2 hours when that is longer. The buyer reconnects on its next request. 0 keeps idle connections. ANTSEED_INBOUND_IDLE_TIMEOUT_MS overrides it.
seller.restrictedCountries["CU","IR","KP","SY","RU"]Countries whose IP addresses are refused. See below.
seller.freeTiernoneRequest allowance for zero-priced services. See below.
seller.providers.<name>.services.<id>.freeTiernoneThat model's own free-tier program, in place of seller.freeTier. On a priced model, a free allowance before the price applies. See Per-model programs.
seller.freeUsage16 requests / 15 minHow often free usage is recorded on-chain. See below.
seller.buyerLimitsnonePer-buyer load limits: tokens each buyer may use per provider per hour, tighter for buyers new to the seller, with optional per-service weights. See below.
seller.healthCheckenabled, 5 min, 3 failuresModel health checks. See below.
seller.gasCheckenabled, 60 s, 0.00005 ETHPauses advertising while the seller wallet holds less ETH than minBalanceEth, checking every intervalMs (at least 10 s). Resumes once funded.
seller.gasRefuelenabled, 0.0005 ETH, 10 USDC, 30 USDC/dayBase mainnet only, and needs seller.gasCheck on. When a gas check finds the wallet below triggerBalanceEth, the seller swaps swapUsdc of the wallet's own USDC for ETH on Uniswap v3 (USDC/WETH 0.05% pool, slippageBps default 100), paying the swap's gas from the ETH still there. At most maxUsdcPerDay in any 24 hours; failures retry with back-off. Set enabled: false to opt out.
seller.verifiersnoneVerifier SDKs to run provers for. See TEE seller.
seller.verificationsnoneDomain and GitHub ownership claims. See Verified identity.
seller.agentDirnoneAnt agent directory. See below.
identity.displayNamederived from peer IDName shown to buyers.
Terminal
antseed config set identity.displayName "Example Inference"
antseed config seller set publicAddress "peer.example.com:6882"

Free-tier limits​

A service is free when its token prices and all unit-billing prices are zero. Free services are unlimited unless you set seller.freeTier, which applies one allowance across all free services, per buyer address, per IP, or both:

JSON
{
"seller": {
"freeTier": {
"maxRequestsPerAddress": 100,
"maxRequestsPerIp": 300,
"windowMs": 86400000
}
}
}

Set at least one of the two limits. windowMs is a sliding window (default 24 hours, minimum 1000). A request is served only while every configured limit has room, and only served requests count. Counters are stored in the seller's metering.db, survive restarts, and are shared across all free services. When a buyer runs out, the seller answers HTTP 429 with code: "free_tier_exhausted", a limitedBy field (address, ip, stake or stake_required) and a Retry-After header. Paid services are unaffected unless you give one its own program; see Per-model programs.

LimitKeyed onCaveat
maxRequestsPerAddressBuyer identity addressA user can create another identity
maxRequestsPerIpConnecting IP, IPv6 grouped by /64Users behind one NAT share it; a seller behind a proxy sees the proxy's IP

When you set both, set the IP limit higher so a shared network isn't cut off by one heavy user. Use nonzero pricing when you need stronger protection.

Terminal
antseed config seller set freeTier.maxRequestsPerAddress 100
antseed config seller set freeTier.maxRequestsPerIp 300

Remove seller.freeTier to make free services unlimited again.

Large free requests​

A new identity costs nothing, so a client that runs out of free requests can resend a long conversation from a fresh address. Two optional settings in a free-tier program limit that:

KeyDefaultDescription
newBuyerMaxInputTokensnoneLargest estimated input, in tokens, served free during an address's first newBuyerRequests free requests in the window. Requires maxRequestsPerAddress.
newBuyerRequests3How many free requests an address counts as new for newBuyerMaxInputTokens.
movedConversationsnonerefuse or log a free request of at least 32,000 estimated input tokens when at least 5 of its long messages, adding up to 32,000 tokens, were first sent by another address in the last 48 hours.
JSON
{
"seller": {
"freeTier": {
"maxRequestsPerAddress": 100,
"newBuyerMaxInputTokens": 32000,
"movedConversations": "refuse"
}
}
}

On a free model, a refused request gets HTTP 403 with code: "free_tier_new_buyer_context" or "free_tier_moved_conversation". On a priced model's free allowance, it is paid at the listed price instead. Either way it doesn't count toward the buyer's limits. Start with "log" to see what movedConversations would refuse: the seller logs each match with --verbose and serves the request. Buyers staked into a tier are never checked. To match conversations, the seller keeps a short hash of each long message in memory, never the text; the first three messages and system prompts are skipped, since apps share them across users.

Staked tiers​

Buyers who lock ANTS in your seller pool get a larger free allowance. Their stake raises your pool weight, which multiplies the points your paid usage earns, so staked free users pay you back through your paid services. Staked tiers are on by default whenever seller.freeTier is set:

Staking power≈ ANTS locked for one yearAllowance
520,00010,0005× the base limit
2,600,00050,00020× the base limit
10,400,000200,000Unlimited

Staking power is ANTS × epochs (weeks) of lock remaining, the same power the seller pool uses for rewards. It is zero until a position activates in the next epoch and shrinks as the lock runs down; a max-locked position keeps 104 epochs of power. The base limit is maxRequestsPerAddress, or maxRequestsPerIp when only that is set.

The seller reads power from AntseedSellerPools for the buyer's own address plus every staker that signed a delegation to that buyer (sent in the x-antseed-free-tier-delegations request header, checked locally, up to 8), and adds it up. Usage is counted on the staked positions themselves, so every buyer behind the same stake shares one allowance, and transferring a position to a new wallet carries its used allowance with it. The seller strips the delegations header before the request reaches your provider. Staked requests skip the per-IP limit and don't count toward the base limits of unstaked buyers. Lookups are cached for 10 minutes; if the chain can't be read, buyers keep the base limits.

Set your own program with stakeTiers, or [] to turn staked tiers off. Up to four tiers; minPower and multiplier must both increase (the first multiplier can be 1), and "unlimited" can only be the last:

JSON
{
"seller": {
"freeTier": {
"maxRequestsPerAddress": 100,
"maxRequestsPerIp": 300,
"stakeTiers": [
{ "minPower": 260000, "multiplier": 10 },
{ "minPower": 5200000, "multiplier": "unlimited" }
]
}
}
}

Your limits and tiers are signed into your peer metadata as free-tier.v1.* capabilities, so buyers, gateways and Antscan can show them. Tiers are only announced when the seller can read the seller pools and deposits contracts. A staked buyer who runs out gets the same 429 with limitedBy: "stake"; every 429 from a seller with tiers also carries stakeTiers and the buyer's current stakePower. See Staked free tier for the buyer side.

Per-model programs​

Give a model its own freeTier under its service to set its own limits and tiers. A model with its own program uses only that program and has its own counters, so its usage never counts against your other models. Models without one use seller.freeTier. If there's no seller-wide program, those models stay unlimited.

On a priced model, its own program is a free allowance. A request the allowance covers is served free, with no payment channel. A request past the allowance is paid at the listed price, never refused. seller.freeTier never applies to a priced model.

Add "stakersOnly": true to serve the program only to buyers whose stake reaches a tier. On a free model, everyone else gets a 429 with limitedBy: "stake_required". On a priced model, everyone else pays the listed price. The base limits are still required: they are what the tier multipliers apply to.

This config gives a free model 100 requests a day, raised for stakers, and makes a priced model free for large stakers while everyone else pays:

JSON
{
"seller": {
"providers": {
"my-provider": {
"plugin": "openai",
"services": {
"glm-5.3-flash": {
"pricing": { "inputUsdPerMillion": 0, "outputUsdPerMillion": 0 },
"freeTier": {
"maxRequestsPerAddress": 100,
"stakeTiers": [
{ "minPower": 1000000, "multiplier": 10 },
{ "minPower": 10000000, "multiplier": "unlimited" }
]
}
},
"kimi-k3": {
"pricing": { "inputUsdPerMillion": 0.6, "outputUsdPerMillion": 2.5 },
"freeTier": {
"maxRequestsPerAddress": 200,
"stakersOnly": true,
"stakeTiers": [{ "minPower": 45000000, "multiplier": 1 }]
}
}
}
}
}
}
}
  • glm-5.3-flash: 100 free requests a day for everyone. 1,000,000 power raises it to 1,000, and 10,000,000 power makes it unlimited.
  • kimi-k3: 200 free requests a day for buyers with at least 45,000,000 power, about 865,000 ANTS locked for a year. Everyone else, and a staker past 200, pays $0.60 / $2.50 per million tokens.

antseed seller start prints each program on its own line, so you can check what you configured.

Each model's program is advertised under a short hash of its id, as free-tier.v1.m<hash>.*. A program that uses the same tiers as seller.freeTier takes one capability string; one with its own tiers takes one string plus one per tier. Peer metadata allows 16 capability strings, and the node always uses 4 or 5 of them. A program that doesn't fit is still enforced, but not advertised, and the node logs a warning.

A response the allowance covered carries x-antseed-free-tier: covered. The seller records no spend for it, and the buyer expects no charge. To add a program from the CLI, pass the whole object: antseed config seller set providers.my-provider.services.glm-5.3-flash.freeTier '{"maxRequestsPerAddress":100}'.

Restricted countries​

By default the seller refuses connections from IP addresses in Cuba, Iran, North Korea, Syria and Russia. The lookup uses the bundled geoip-country database, so no buyer address leaves the seller. It is best effort: buyers behind a VPN are seen at the VPN's address. A refused buyer gets "This seller does not accept connections from your location.", and GET /metadata returns 403 with the same text.

Terminal
antseed config seller set restrictedCountries '["CU","IR","KP","SY","RU"]'
antseed config seller set restrictedCountries '[]' # turn the check off

Buyer limits​

buyerLimits lets a seller control how much load each buyer puts on each provider, so no single buyer can take all of a provider's capacity. It caps the tokens each buyer may use from each provider in a rolling window. Each provider is counted on its own.

  • What counts: uncached input plus output tokens. Cached input is light work and isn't counted.
  • Requests still running count with their estimated size: input plus the output they ask for at most, or 8,192 output tokens when they set no maximum. A burst of parallel requests can't pass on the same usage. An answer that comes back without a usage report counts as that estimate.
  • Over a limit, the buyer gets 429 buyer_usage_limited with retry-after, before any payment step, until enough of its usage leaves the window.
  • New buyers: a buyer whose first payment channel with this seller is less than newBuyers.forHours old (default 72) gets newBuyers.maxTokensPerBuyer, and newBuyers.maxTokensTotal caps all new buyers together, so spreading load across new wallets gains nothing.
  • Service weights: serviceWeights makes a service's tokens count more (or less) against the limits, by service ID. Weight a heavy model so its tokens count as the extra work they are; a service without a weight counts 1.
  • Only tokens: services billed by other units (video, speech, images) are outside these limits.
JSON
{
"seller": {
"buyerLimits": {
"windowMinutes": 60,
"maxTokensPerBuyer": 30000000,
"newBuyers": { "forHours": 72, "maxTokensPerBuyer": 5000000, "maxTokensTotal": 20000000 },
"serviceWeights": { "large-model": 10 }
}
}
}

Every field is optional; a limit left out isn't applied. Counts are kept in memory, so a restart starts them over.

Free-usage records​

Free requests are still recorded on-chain so buyers earn usage credit, and the seller pays the gas. The seller writes a record once recordBatchSize free requests have accumulated on a channel, or recordFlushIntervalMs after the first unrecorded one, whichever comes first, and always before the channel's deadline. Larger values mean fewer transactions; usage is written later, never dropped.

Terminal
antseed config seller set freeUsage.recordBatchSize 64
antseed config seller set freeUsage.recordFlushIntervalMs 3600000

Both must be positive integers; recordFlushIntervalMs must be at least 1000. The free-usage flow itself is described in Payments.

Model health checks​

The seller checks its own services and announces the result in its signed metadata. Buyer traffic counts as a check: a service that served a paid buyer request in the last intervalMs is not probed. Other text services are probed with a one-token request at startup and every intervalMs, and a buyer request that fails upstream triggers an early probe of that service, unless it is already announced as failing. A service that keeps failing is probed less often: every intervalMs, then every second, then every third (with the default 5, 10 and 15 minutes), so a rate-limited or empty upstream account is not hit by every check. After failureThreshold failed checks in a row the service is announced as failing: it stays in the metadata, buyers leave it out of their model lists and automatic routing, and a buyer who pins it gets an error saying the seller's health check is failing and why. The first passed check, or a successful buyer request, marks it healthy again.

Buyers are never told about your upstream account: an upstream that is out of credit or rejects your key is announced as unavailable (reason: "upstream_error"), and a buyer request whose upstream answers with such an error (401, 403, 402 or a billing error) gets a 503 saying the model is unavailable on this seller, not the upstream's error. Your dashboard, antseed seller status, logs and alerts show the real reason.

Image, video and speech services are never probed, because a probe would generate a paid result. An image service on an upstream without such a check (for example images on the OpenAI-compatible plugin) follows the account the upstream's text services found: each check interval while that upstream is out of credit counts as a failed check, and it recovers once the account has credit again. Instead, the Venice and fal video plugins check the account and model list for free every intervalMs (see Image and video services). Their failed buyer requests count as the checks: after failureThreshold upstream failures in a row (401, 402, 403, 5xx, or a request that throws; a 429 means busy, not broken) the service is announced as failing. A passing account or model check doesn't clear that. Because nothing can check it in the meantime, it is announced as unknown again after the same wait a failing text service has between probes, so buyers try it; one more failure marks it failing again, and a successful request marks it healthy.

JSON
{
"seller": {
"healthCheck": { "enabled": true, "intervalMs": 300000, "failureThreshold": 3 }
}
}

The seller also announces, in its signed metadata, how each service served buyers in the last hour: the number of requests, the share the upstream answered without a server-side error, rate limit, timeout or an error inside the stream, and for streamed answers the median and 90th percentile time to the first generated token and the median output speed. The seller keeps running counts rather than every request, so this costs next to nothing at any traffic. It measures these on its own buyer traffic, so there is nothing to configure. Buyers start from these figures for a seller they have not used yet, so a model that keeps failing gets less traffic before each buyer finds out for itself. See discovery.

Ant agent​

An ant agent wraps your service with a persona, guardrails, on-demand knowledge and custom tools. Point agentDir at a directory containing an agent.json manifest, or map service IDs to directories, with "*" as the fallback:

JSON
{
"seller": {
"agentDir": {
"kimi-k2.6": "./agents/coding",
"*": "./agents/default"
}
}
}

Relative paths resolve from the config file's directory. See Provider plugin API and the @antseed/ant-agent README for the manifest format.

Payment settings​

KeyDefaultDescription
payments.crypto.chainIdbase-mainnetbase-mainnet, base-sepolia or base-local
payments.crypto.rpcUrlpublic Base RPCYour Base JSON-RPC endpoint. See Base RPC.
payments.minBudgetPerRequest"10000" ($0.01)Minimum USDC per request, in base units
payments.minSettleDelta"2000" ($0.002)Smallest unsettled amount, in base units, for which the idle settle loop sends a transaction. Closing a channel always settles the full amount. seller start --min-settle-delta 0.002 overrides it in USDC.
payments.serveWhileClosePendingfalseKeep serving channels whose buyer already requested a close on-chain. Work served this way can become uncollectible.
payments.sellerContract.addressnoneAn on-chain seller contract that fronts this peer. Buyers check that your peer address is an operator of the contract.
relayer.enabledtrueRelay buyers' gasless deposit sweeps with your seller wallet and earn the relay fee
relayer.minProfitBaseUnits"0"Minimum profit (relay fee minus estimated gas), in USDC base units
relayer.maxInFlight2Concurrent sweep submissions
relayer.maxPerPeerPerMinute6Sweep requests accepted per buyer per minute

How earnings reach you is covered in Seller payments.

ANTS staking settings​

antseed ants and the seller staking commands find the recognized-usage contracts from the built-in deployment record for payments.crypto.chainId and from the on-chain AntseedRegistry, so nothing needs configuring on Base mainnet. Two optional settings live under payments.crypto:

KeyDescription
explorerApiUrlAntscan base URL used for pool statistics, volume history, seller profiles and closed positions. Defaults to https://antscan.co. Set it to "" to read only the chain, which lists only the pools you stake in.
<contract>AddressPer-contract overrides for local or test deployments: sellerRegistryAddress, sellerPoolsAddress, sellerPoolsRewardsAddress, usageAccountingAddress, usageRewardsAddress, emissionsGateAddress, positionInitAddress, washTradingRegistryAddress, pointsPolicyRegistryAddress, antsTokenAddress, legacyEmissionsContractAddress, legacyStakingContractAddress. positionInitAddress has no on-chain pointer and must be set explicitly outside the built-in deployments.

Environment variables​

Environment variables hold secrets and per-run overrides. The seller-relevant ones are ANTSEED_IDENTITY_HEX, ANTSEED_PASSPHRASE, the plugin credentials above, ANTSEED_BASE_RPC_URL, ANTSEED_SETTLEMENT_IDLE_MS (idle time before settling, default 10 minutes), ANTSEED_MAX_UPLOAD_BODY_BYTES and ANTSEED_VERIFIER_SDKS. See Flags and environment variables for the full list.