Pricing

API usage is paid for in one of two ways, decided request by request:

1. Your plan allowance. Each Syntic plan includes a number of tokens per month. Requests covered by it cost nothing beyond the plan itself.
2. Usage credits. A prepaid US-dollar balance that is drawn on only after the plan allowance cannot cover a request, and only if an administrator has turned credits on. These requests are charged per token at the model rates below.

Every response tells you which one paid, in the x-syntic-billing-source header: subscription or api_credit.

Model rates

Rates are in US dollars per million tokens and apply only to requests paid from usage credits.

The rate used is the rate of the model that answered. If your request fell back to Amara S1.2 (see Models overview), you pay Amara S1.2 rates.

How one request is priced

A request has three token counts, and each has its own rate:

The prompt includes everything you send: the system message, every earlier turn, tool definitions and tool results. The platform also places a short Syntic system message in front of yours; those tokens are counted as part of the prompt.

Worked example: a chat turn

A request to Amara S1.2 whose prompt is 10,000 tokens, of which 6,000 come from cache, and whose reply is 800 tokens:

  4,000 input         × $2.50  / 1M = $0.0100
  6,000 cached input  × $0.40  / 1M = $0.0024
    800 output        × $12.00 / 1M = $0.0096
                                      -------
                         request total  $0.0220

Worked example: a tool loop

An agent loop on Syntic Code runs five rounds. Each round re-sends the growing conversation, so most of each prompt is cached from the round before:

Round 2, for instance, is 900 uncached tokens at $2.50, 6,000 cached at $0.25 and 250 output at $12.50 per million. Without caching, the same five rounds would cost about $0.12, which is why the order of your messages matters (next section).

Worked example: classifying 100,000 messages

Routing short support messages with Amara Quick, a 400-token instruction block (cached after the first request), an average 120-token message and a 5-token label:

  per request:  120 × $1.50/1M + 400 × $0.25/1M + 5 × $8.00/1M = $0.00032
  100,000 requests                                             ≈ $32.00

Many of these requests may be covered by your plan allowance, in which case they cost nothing extra; the figure is what they would cost on usage credits.

Make caching work for you

Caching is automatic: you do not mark anything. It applies to the beginning of a prompt that matches a recent request exactly. To get the most from it:

• Put content that never changes first: the system message, then tool definitions, then long reference material.
• Put content that changes on every request (the user’s latest question, today’s date, a request ID) at the end.
• Append to a conversation rather than rewriting earlier turns; editing an old message breaks the match from that point on.
• Keep tool definitions in a fixed order.

Plan allowances

Plan allowances are counted in tokens (prompt plus reply), not dollars, and every model draws from the same allowance.

A request is covered by the plan only while all three windows have room. The weekly window is 60% of the monthly figure and the session window 25%, so that one busy afternoon cannot use up a month. On the Free plan, the allowance is shared across every free organization owned by the same person.

Plan prices and what else each plan includes are listed at syntic.ai/pricing.

Usage credits

When a plan window is full, the request is paid from usage credits if all of these hold:

1. Usage credits are turned on for the organization.
2. Credit spend so far this calendar month is below the organization’s monthly spend limit (if one is set).
3. The member sending the request is below their own spend limit, if an administrator set one for them or their group.
4. The balance covers a conservative estimate of what the request could cost (see below).

Otherwise the request is refused with 402 quota_exhausted. The limit field says which condition failed; see Handle usage limits.

The pre-request estimate

Before a credit-paid request runs, the platform checks that your balance could cover it in the worst case: your max_tokens (or 4,096 if you did not set it) at the model’s output rate, plus 8,000 prompt tokens at its input rate. For Amara S1.2 with no max_tokens that is about $0.07. If the balance is lower, the request is refused with limit: "no_credits" even though the balance is not zero.

Setting a realistic max_tokens lowers the estimate, so a small remaining balance can still serve short requests. You are always charged for actual usage, not the estimate.

Buying and reloading credits

Credits are bought in packs, with a bonus on the larger ones:

Auto-reload tops the balance up when it falls to a trigger amount. New organizations start with credits off, a $20 monthly spend limit, and auto-reload off with a $5 trigger and a $15 target. All of this is set in the Console; see Billing & credits.

Streams that end early

Tokens the model has already produced are billed even if your client disconnects mid-stream. If the connection closes before the final usage figures arrive, the request is billed on an estimate of the text sent so far (about four characters per token) plus the prompt. Cancel long generations by setting max_tokens rather than by dropping the connection.

Track what you spend

• Per request: read usage from the response (or from the last streamed chunk) and the x-syntic-billing-source header. Multiply by the rates above to compute cost in your own logs.
• Per organization: the Console’s Usage page shows plan windows, credit balance and spend this month. See Usage & cost.

RATES = {  # $ per 1M tokens: input, cached input, output
    "Amara S1.2": (2.50, 0.40, 12.00),
    "Amara Quick": (1.50, 0.25, 8.00),
    "Amara Deep": (2.50, 0.25, 12.50),
    "Syntic Code": (2.50, 0.25, 12.50),
    "Syntic Code Fast": (4.50, 0.70, 20.00),
}
 
def credit_cost(model, usage):
    """What a request costs if it was paid from usage credits."""
    rin, rcache, rout = RATES[model]
    details = usage.get("prompt_tokens_details") or {}
    cached = min(usage.get("cached_tokens") or details.get("cached_tokens") or 0, usage["prompt_tokens"])
    fresh = usage["prompt_tokens"] - cached
    return (fresh * rin + cached * rcache + usage["completion_tokens"] * rout) / 1_000_000

Questions

Do failed requests cost anything? Requests refused before reaching the model (authentication, rate limit, quota, validation errors) are not billed. A request that fails part-way through a stream is billed for the tokens already produced.

Does the plan allowance count dollars or tokens? Tokens. Model rates only matter once a request is paid from credits.

Are tool definitions billed? Yes. They are part of the prompt on every request that includes them, which is why keeping them stable (and therefore cached) helps.

Can I get a lower rate at high volume? Enterprise plans are quoted individually; contact sales through syntic.ai/pricing.

Related pages

• Limits: rate and size limits.
• Billing & credits: buying credits and setting spend limits.
• Control costs: practical ways to spend less.