Lanes and Tide Pricing

Tokentide sells Venice inference at a discount to the Venice list price. The discount moves through the UTC day along a published tide table, and an opt-in Low Tide lane sells capacity that would otherwise go unused at a deeper discount.

• You pay list price × multiplier. The multiplier m is a fraction of the Venice list price: 0.62 means 38% cheaper than Venice. With the default parameters the Standard multiplier never exceeds 0.90, so you always pay at least 10% below Venice.
• The price is applied when you consume, not when you top up. All payment rails fund one USD balance, and the multiplier in force when your request is admitted is locked for the whole request.
• Everyone pays the same price at the same moment. Prices are never personalized. Caps and allowances are access rules, not individual prices.

How a charge is computed#

charge_usd = ceil_to_micro_usd(list_cost_usd × multiplier)        minimum $0.000010 when anything is billable

• list_cost_usd is what Venice would charge at its list price: the cost Venice reports for chat, otherwise usage (tokens, characters, seconds, images) times the Venice price book.
• Requests that Venice does not bill are never charged: failed requests, zero-output responses, and images that come back flagged as content violations.
• Non-streaming responses report the result in X-Tokentide-List-Cost-USD and X-Tokentide-Charge-USD. Streaming responses report it in the final usage chunk (see Streaming responses).

The tide table (Standard lane)#

The Standard lane is the default: streaming and interactive traffic, highest priority, priced by the tide.

m_std(t) = clamp( L_e · (1 − d · τ^γ) · g_inv(t) · g_cong,f(t),  m_min,  m_max )

τ is the fraction of the UTC day that has elapsed (0 at 00:00 UTC, 1 at the next 00:00 UTC).

With L_e = 0.75, d = 0.30 and γ = 3, the table reads:

Commitment. Tomorrow’s table is computed and published at 12:00 UTC (at least 12 hours ahead). Once published it is immutable: GET /v1/market returns it with a hash under tide_table.tomorrow. The live table is on the pricing page.

Surges only go up. Two bounded factors can raise the price above the table, never lower it:

• Inventory surge g_inv (up to 1.5×, recomputed every 60 s) when forecast demand outruns the capacity left for the day.
• Congestion surge g_cong,f (up to 1.5×, per model family) when traffic approaches Venice’s account-wide rate limits for that model.

The result is still capped at m_max. When a model family reaches 97% of its rate limit, Tokentide sheds the lowest-priority traffic first (Low Tide, then new accounts) with 429 rate_limited and a Retry-After, before Venice’s own limits are hit.

Waiting is never free: the table falls by at most 3% of list per hour, so if waiting an hour costs you more than that, buying now is the better deal.

Low Tide lane#

Low Tide is an opt-in, best-effort lane that sells only capacity the forecast says would otherwise be wasted, at a deep discount. It is the Tokentide equivalent of a “flex” tier: synchronous, lowest priority, no latency target, and allowed to say no. A rejected Low Tide request is never charged.

m_lowtide(t) = max( 0.20,  0.70 × m_std(t) )        defaults: 30% below Standard, floor 0.20 (80% below Venice)

With the defaults, Low Tide trades at about 0.42 → 0.37 of list in the evening (58–63% below Venice).

When Low Tide is closed you get 409 lowtide_closed with Retry-After and, when the forecast knows it, X-Tokentide-Lowtide-Opens-At (ISO 8601, UTC). When your hourly cap or daily allowance is used up you get 409 lowtide_cap_reached. A Low Tide request for a model excluded from Low Tide gets 403 model_not_allowed: it is final, so do not retry it; use the Standard lane, or send X-Tokentide-Lowtide-Fallback: standard to run it on Standard. See Errors.

curl https://api.tokentide.app/v1/chat/completions \
  -H "Authorization: Bearer $TOKENTIDE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Tokentide-Lane: lowtide" \
  -H "X-Tokentide-Lowtide-Fallback: standard" \
  -H "X-Tokentide-Max-Multiplier: 0.50" \
  -d '{"model": "deepseek-v4-1-flash", "stream": false, "messages": [{"role": "user", "content": "Classify: …"}]}'

Check before you send#

• GET /v1/market → lowtide.open, lowtide.multiplier, lowtide.opens_at, and lowtide.reason (disabled, killed, no_spare, congested, guard_window, epoch_state or no_discount).
• GET /v1/account → lowtide.allowance_usd, lowtide.used_usd and lowtide.cap_per_hour_usd for your account.

Batch jobs without storing anything on our side#

A deferred batch product would require Tokentide to hold your request bodies, which zero data retention rules out. Instead, the SDKs ship a client-side scheduler, the Tide Runner (TypeScript and Python TideRunner): give it your requests, a deadline and a maximum multiplier; it submits them to Low Tide whenever it is open and within your caps, honors Retry-After and X-Tokentide-Lowtide-Opens-At, and falls back to Standard before the deadline if you allow it. Nothing is stored on our side. See SDK helpers.

Request headers#

All Tokentide request headers are optional.

Response headers#

With X-Tokentide-Debug: 1, responses (error responses too) also carry X-Tokentide-Debug-Upstream-Status, X-Tokentide-Debug-Retries, X-Tokentide-Debug-Timings and X-Tokentide-Debug-Upstream-Id. See Debugging a request.

Venice headers passed through: Content-Type, x-venice-is-content-violation, x-venice-is-blurred, x-venice-enhanced-prompt, x-venice-model-id, x-venice-model-name, Venice deprecation headers (x-venice-deprecated*, x-venice-model-deprecation-*), X-Venice-TEE and X-Venice-TEE-Provider.

Venice headers never exposed: x-venice-balance-* (our balances), Venice x-ratelimit-* (aggregate traffic of the shared account), set-cookie and cf-*. x-venice-version and cf-ray are kept in the request’s metadata for support and appear only with X-Tokentide-Debug: 1.

Never forwarded to Venice: your Authorization, cookies, X-Forwarded-*, your IP address, your User-Agent (replaced by Tokentide/<version>) and any x-vercel-* header.

Streaming responses#

Response headers are sent before the stream starts, so the multiplier, lane, epoch and cross-epoch flag arrive as headers, and the cost arrives in the final usage chunk (sent before data: [DONE] whether or not you set stream_options.include_usage):

{
  "object": "chat.completion.chunk",
  "choices": [],
  "usage": { "prompt_tokens": 14, "completion_tokens": 31, "total_tokens": 45 },
  "cost": { "usd": 0.000028, "diem": 0 },
  "tokentide": {
    "list_cost_usd": "0.000042",
    "multiplier": "0.655078",
    "lane": "standard",
    "epoch": "2026-10-31",
    "savings_usd": "0.000014"
  }
}

Venice’s cost field is rewritten to your actual charge in USD (diem is always 0). If the upstream fails after the stream started, the in-band error chunk is passed through untouched. A stream that ends without its usage chunk is settled provisionally at its worst-case cost and trued up against Venice’s ledger (see Errors).

The daily reset (slack water)#

Venice’s daily capacity resets at 00:00 UTC. Each UTC day is an epoch, and Tokentide runs a small state machine around the reset so that no request is ever priced at tonight’s price while consuming tomorrow’s capacity.

Cross-epoch rule#

At admission Tokentide estimates the worst-case completion time of your request (for chat: time to first token plus max_completion_tokens at a slow token rate). If the request might finish after the reset, it is priced at max(current multiplier, tomorrow’s opening multiplier) and attributed to the next epoch, and the response carries X-Tokentide-Cross-Epoch: true and X-Tokentide-Epoch: <tomorrow>. Tomorrow’s opening multiplier is already published, so this never surprises you. To avoid it:

• lower max_completion_tokens so the request is certain to finish before the reset, or
• send X-Tokentide-Max-Multiplier: the request is then rejected with 409 price_above_limit instead of being priced up.

The capacity held for requests that may run past the reset comes from a small safety buffer that is never sold. When too many of them are in flight at once, a new one answers 503 capacity_unavailable with Retry-After: 10: retry shortly, or lower max_completion_tokens.

Prepaid endpoints and quotes#

Prepaid endpoints (image generation and edits are billed by Venice when they start) are admitted near the reset only when today’s remaining capacity covers the whole request. Otherwise they wait for the new day: 503 epoch_rollover with Retry-After.

Quotes (POST /v1/market/quote) are never valid across the reset.

Market API#

GET /v1/market#

Public, no authentication, CDN-cached for 5 seconds. Multipliers are decimal strings for exactness, with integer *_ppm twins (parts per million, 1000000 = Venice list price). Times are ISO 8601 UTC.

{
  "object": "market",
  "epoch": {
    "id": "2026-10-31",
    "state": "open",
    "starts_at": "2026-10-31T00:00:00.000Z",
    "ends_at": "2026-11-01T00:00:00.000Z",
    "seconds_to_reset": 46800,
    "tau": 0.458333
  },
  "standard": { "multiplier": "0.728337", "multiplier_ppm": 728337, "savings_pct": 27.1 },
  "lowtide": {
    "open": false,
    "multiplier": "0.509836",
    "multiplier_ppm": 509836,
    "savings_pct": 49,
    "opens_at": "2026-10-31T19:40:00.000Z",
    "reason": "no_spare"
  },
  "next_epoch": { "id": "2026-11-01", "open_multiplier": "0.75", "open_multiplier_ppm": 750000 },
  "tide_table": {
    "today": {
      "epoch": "2026-10-31",
      "level": "0.75",
      "decay_depth": "0.3",
      "gamma": 3,
      "m_min": "0.15",
      "m_max": "0.9",
      "lowtide_lambda": "0.7",
      "lowtide_floor": "0.2",
      "published": true,
      "hash": "9c1f…",
      "curve": [
        { "t": "2026-10-31T00:00:00.000Z", "m_ppm": 750000 },
        { "t": "2026-10-31T00:15:00.000Z", "m_ppm": 750000 }
      ]
    },
    "tomorrow": null
  },
  "sales_paused": false,
  "sold_out": false,
  "reopens_at": null,
  "updated_at": "2026-10-31T11:00:00.000Z"
}

• curve has 97 points, every 15 minutes from 00:00 to the next 00:00 UTC (only two are shown here).
• tomorrow has the same shape as today and is null until tomorrow’s table is published at 12:00 UTC.
• lowtide.multiplier is shown even while Low Tide is closed: it is the price you would pay if it opened now.
• sold_out turns true when today’s discounted capacity (the staked DIEM left after our reserve) is used up, and reopens_at then gives the next daily reset (ISO 8601, UTC); otherwise it is null. While sold out, inference requests answer 503 capacity_unavailable (“Today’s discounted capacity is sold out. Sales reopen at the daily reset (00:00 UTC)”) with a Retry-After that counts down to the reset. See Errors.

The live Standard multiplier includes any surge, so it can sit above the table. While the epoch is rolling, standard.multiplier shows the new day’s opening multiplier.

GET /v1/market/stream#

Server-sent events with a fresh snapshot every 15 seconds (event: tick, data: the same JSON as GET /v1/market). The server closes the stream after about 13 minutes with event: reconnect; reconnect when you see it. New connections are limited per network (about 20 per minute) and answer 429 rate_limited beyond that.

curl -N https://api.tokentide.app/v1/market/stream

POST /v1/market/quote#

Locks the current multiplier for 60 seconds, never across the daily reset. Authenticated (API key). The body is optional: {"lane": "standard"} (the default) or {"lane": "lowtide"}. Any other lane or an unknown field answers 400 invalid_request with the field in error.param.

curl https://api.tokentide.app/v1/market/quote \
  -H "Authorization: Bearer $TOKENTIDE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"lane": "lowtide"}'

During the reset quotes answer 503 epoch_rollover (retry after about 30 s); a Low Tide quote while Low Tide is closed answers 409 lowtide_closed.

GET /v1/market/rules#

Everything that decides a price, with the values in force right now: the charge formula and minimum charge, today’s tide table (its parameters, the multiplier at every hour, the slope guard, tomorrow’s opening and publication), the surges and the models they lift, Low Tide (its formula, live status, opening conditions, hourly caps and allowance shares by trust tier), the daily reset with today’s key times (closing window, Low Tide cut-off, video and music queueing cut-offs), quotes, buyer controls and spend caps. Public, no authentication, CDN-cached for 15 seconds.

Add format=markdown for the same rules as a written guide, with a ## section per topic. It is built from the same live numbers, so it never quotes a stale parameter. Per-account Low Tide limits are shares of the day’s capacity: GET /v1/account shows your own amounts.

# Structured rules (JSON)
curl https://api.tokentide.app/v1/market/rules
 
# The same rules as a written guide
curl "https://api.tokentide.app/v1/market/rules?format=markdown"

GET /v1/market/estimate#

What one concrete request costs, computed with the billing arithmetic: pass model plus input_tokens and/or output_tokens for token-priced models, or units for models priced per image, edit, upscale, second of audio or million characters (the unit that GET /v1/models lists). The answer gives the list cost and the charge on both lanes now (live, surges included), at every remaining UTC hour today, at the last same-day moment and at tomorrow’s opening (from the published tide tables, which surges can only raise), and at an optional at time (today, or tomorrow once its table is published). Public, no authentication, CDN-cached for 5 seconds.

curl "https://api.tokentide.app/v1/market/estimate?model=zai-org-glm-5-2&input_tokens=1200&output_tokens=800&at=2026-11-02T22:00:00Z"

Video and music jobs are priced from their parameters: use POST /v1/video/quote or POST /v1/audio/quote (see Video and music). Text requests reserve their worst case at admission (from max_completion_tokens) and are charged their actual usage.

Prices per model#

GET /v1/models keeps Venice’s model_spec.pricing (the list price anyone can verify on venice.ai) and adds a tokentide object per model with both lanes, prices in USD per 1M tokens (or per unit for images, audio seconds and characters), rounded up:

{
  "id": "zai-org-glm-5-2",
  "tokentide": {
    "privacy_tier": "private",
    "standard": {
      "multiplier": "0.655078",
      "input_per_1m": "0.91711",
      "output_per_1m": "2.882344",
      "per_unit": null,
      "unit": null
    },
    "lowtide": {
      "open": true,
      "eligible": true,
      "multiplier": "0.458555",
      "input_per_1m": "0.641977",
      "output_per_1m": "2.017642",
      "per_unit": null,
      "unit": null
    },
    "price_locked_until": null,
    "epoch": "2026-10-31"
  }
}

Why this is fair (and hard to game)#

• Prices apply at consumption, so topping up late in the day gives you nothing extra.
• The table is published ahead and only falls on a schedule; surges only go up, so withholding demand cannot push prices down.
• Interactive traffic needs streaming and a latency target, which Low Tide does not offer.
• Low Tide opens only with projected spare capacity, and its volume per account is bounded by an hourly cap and an allowance earned through Standard spend (one allowance per identity).
• The cross-epoch rule stops anyone from buying tomorrow’s capacity at tonight’s price.
• Reselling Tokentide capacity is prohibited by the Terms.