Token360
Log InSign Up

Get model pricing

GET/v1/models/{model_id}/pricing

Return the price your account pays for one model right now.

Use the id from GET /v1/models as model_id. Upper and lower case both work. The model field in the response is the id to keep.

Authentication

Authorization Bearer

Required. Send an API key (sk-...). A request without a key returns 401.

The price is for the account that owns the key. An enterprise key returns that enterprise's price, including a negotiated price when one exists. A personal key does not receive another enterprise's negotiated price.

Path Parameters

model_idstringrequired

Model id from GET /v1/models, field data[].id.

What you pay

  1. Pick one rule in plan.rules. Rules are already in the order to try. Use the first rule whose when_expr matches this request. { "all": [] } matches every request, so a rule with that condition is the price for every time an earlier rule did not match.
  2. Read rate on each component of that rule. For tokens, unit 1M means USD per 1 million tokens. The top-level unit per_1m_tokens means the same thing.
  3. Apply the account factor:
    • price_factor is a number: payable = rate × price_factor
    • price_factor is null: payable = rate

discount_percent_off restates the factor as a percent. 0.80 and 20.00 are the same discount. Do not subtract the percent again after multiplying.

Which offer you have

LISTStandard list price for this model.rate
MODEL_FACTORThis enterprise has a factor on this model. The rate is the list price before that factor.rate × price_factor
PLATFORM_FACTORThis personal account has a factor. Same arithmetic as MODEL_FACTOR.rate × price_factor
TENANT_PLANA price negotiated for this enterprise. The rate is already that price.rate

plan.source says where the rate came from. TENANT_PLAN is the negotiated price. PLATFORM_DEFAULT is the platform list price, which you still multiply by price_factor when that field is present.

When a rule applies

when_expr.all lists conditions that must all be true. These two fields are the usual ones:

utc_weekdayDay of week in UTC. 1 is Monday, 7 is Sunday. op in means the day is one of the listed numbers.
utc_minute_of_dayMinute of the UTC day, from 0 (00:00) to 1439 (23:59). op between and [60, 239] means minute 60 through minute 239, which is 01:00 UTC up to but not including 04:00 UTC.
JSON
1{
2  "all": [
3    { "op": "between", "field": "utc_minute_of_day", "value": [60, 239] },
4    { "op": "in", "field": "utc_weekday", "value": [1, 2, 3, 4, 5] }
5  ]
6}

That rule is Monday through Friday, 01:00–03:59 UTC. { "all": [] } has no condition, so it is the price at every other time.

What each component charges

uncached_input_tokensInput tokens that were not served from cache.
input_tokens, prompt_tokensInput tokens.
cache_read_tokensInput tokens served from cache.
cache_creation_tokensTokens written into cache.
output_tokens, completion_tokensGenerated output tokens.
thinking_tokens, reasoning_tokensReasoning tokens, when the model bills them separately.

type linear means the charge grows in proportion to usage. rate is the price for one unit of that meter.

Some components also include:

  • included_units: this many units are free; the rate applies after that.
  • subtract: meters already billed by another component. They are removed here so the same usage is not billed twice.
  • dimension_per_unit: how many raw units make one billed unit. When this field is absent, one unit of usage is one billed unit.

name is the plan title. description is the rule's name. price_type is an internal label. None of the three changes the amount you pay.

as_of is the UTC time of this response. The body is the current price only. It does not list older discounts.

Response

objectstring

Always model.pricing.

modelstring

Model id to send in later requests.

currencystring

Currency of rate, such as USD.

unitstring

per_1m_tokens. Token rates are per 1 million tokens, the same as a component unit of 1M.

offerstring

LIST: pay rate. MODEL_FACTOR or PLATFORM_FACTOR: pay rate × price_factor. TENANT_PLAN: negotiated price, pay rate.

price_factornumber|null

Account factor. 0.80 means you pay 80% of rate. Null means rate is already what you pay. Do not also subtract discount_percent_off.

discount_percent_offnumber|null

The same factor written as a percent off. 0.80 is 20.00. Null when there is no factor below 1.

planobject

Rules for this model, and where the rates came from.

plan.sourcestring

PLATFORM_DEFAULT: list price, then apply price_factor when present. TENANT_PLAN: negotiated price, pay rate as shown.

plan.rulesobject[]

Try these in order. Use the first rule whose when_expr matches.

as_ofstring

UTC time of this response.

Errors

401authentication_error—No API key.
404not_found_errormodel_not_foundUnknown model, or this account cannot use it.

Request

Shell
1curl https://api.token360.ai/v1/models/example-model/pricing \
2  -H "Authorization: Bearer sk-your-api-key"

Response

The numbers are an illustration. Call the endpoint for the live price.

JSON
1{
2  "object": "model.pricing",
3  "model": "example-model",
4  "currency": "USD",
5  "unit": "per_1m_tokens",
6  "offer": "MODEL_FACTOR",
7  "price_factor": 0.80,
8  "discount_percent_off": 20.00,
9  "plan": {
10    "source": "PLATFORM_DEFAULT",
11    "rules": [
12      {
13        "name": "Example model",
14        "price_type": "PRICING_PLAN_V2",
15        "description": "weekday-morning",
16        "when_expr": {
17          "all": [
18            { "op": "between", "field": "utc_minute_of_day", "value": [60, 239] },
19            { "op": "in", "field": "utc_weekday", "value": [1, 2, 3, 4, 5] }
20          ]
21        },
22        "components": [
23          { "type": "linear", "meter": "uncached_input_tokens", "unit": "1M", "rate": 1.00 },
24          { "type": "linear", "meter": "output_tokens", "unit": "1M", "rate": 2.00 }
25        ]
26      },
27      {
28        "name": "Example model",
29        "price_type": "PRICING_PLAN_V2",
30        "description": "other-times",
31        "when_expr": { "all": [] },
32        "components": [
33          { "type": "linear", "meter": "uncached_input_tokens", "unit": "1M", "rate": 0.50 },
34          { "type": "linear", "meter": "output_tokens", "unit": "1M", "rate": 1.00 }
35        ]
36      }
37    ]
38  },
39  "as_of": "2026-10-18T15:00:00Z"
40}

On a Monday at 02:00 UTC the first rule matches. Input is 1.00 × 0.80 = 0.80 USD per 1 million tokens. Output is 2.00 × 0.80 = 1.60.

At any other time the second rule matches. Input is 0.50 × 0.80 = 0.40 USD per 1 million tokens. Output is 0.80.

Was this page helpful?