Pricing
A physician decision is priced by the size of what you send, and you see the exact price before you escalate.
The formula
+ $2.50 per 1,000 billable tokens after that
+ $1.00 per question beyond the first three,
rounded up to the cent
billable tokens = input tokens + 500 per image
- Preview: free, including the AI answers and references.
- The formula is the standard price, with a 24-hour turnaround. The quote on each decision is the price you pay.
- Per-question commentary (
include_commentary) is included. It doesn't change the quote. - Three questions are included. Each additional question adds $1.00, up to 50 questions per request. Each question's text is limited to 500 characters; put long context in
input. - Additional tokens are prorated: $2.50 per 1,000 is a quarter cent per token, and the total is rounded up to the cent once.
| Input tokens | Images | Billable tokens | Questions | Price |
|---|---|---|---|---|
| 300 | 0 | 300 | 1 | $5.00 (minimum) |
| 800 | 1 | 1,300 | 3 | $5.75 |
| 800 | 1 | 1,300 | 5 | $7.75 |
| 1,001 | 0 | 1,001 | 1 | $5.01 |
| 4,200 | 2 | 5,200 | 3 | $15.50 |
| 10,000 | 3 | 11,500 | 5 | $33.25 |
The quote
Every preview includes a quote:
"quote": {
"price_cents": 675,
"currency": "usd",
"input_tokens": 800,
"image_count": 1,
"billable_tokens": 1300,
"question_count": 4,
"turnaround": "24h",
"expires_at": "2026-11-04T15:00:00Z"
}The price is locked for 24 hours from the preview (expires_at). Once you escalate, it stays fixed through the answer, however long the review takes.
How tokens are counted
Tokens are counted exactly with the o200k_base tokenizer, as ordinary text (strings that look like special tokens are just text). Each field below is counted separately and the counts are summed:
- Every input text string: a string
input, a string messagecontent, and everyinput_textpart. - Every
input_jsonpart, serialized as canonical JSON (below). - Every question
name. - All question
instructionscontent (text and JSON parts, same rules). - Every choice
value; booleans count as the texttrueorfalse. - Every choice
descriptionyou supply. - Every level
labeland every leveldescriptionyou supply.
Not counted:
- Images (each is a flat 500 tokens, wherever it appears; base64 and URLs are never tokenized).
reviewer,external_id,include_commentary,escalate,max_price_cents,type/rolekeys and JSON punctuation of the request itself.- The knowledge-base context and internal questions Appendix adds.
Question names are counted after trimming surrounding whitespace; every other string is counted exactly as sent. The 10,000-token limit applies to input_tokens; images don't count toward it. The same fields are also limited to 100,000 characters in total, checked before tokens are counted.
Canonical JSON
An input_json data value is counted in this canonical compact form:
- Object keys sorted by Unicode code point.
- No insignificant whitespace.
- Numbers exactly as written in your request (no reformatting:
1.50stays1.50). - Strings escaped minimally:
\",\\,\b,\f,\n,\r,\t; other control characters as\u00xx(lowercase hex); U+2028 and U+2029 as\u2028and\u2029. Everything else, including<,>,&and non-ASCII characters, is literal UTF-8. true,falseandnullas literals.
Avoid duplicate keys in one object; only one survives parsing.
Reproduce a quote
These sketches compute input_tokens, image_count, billable_tokens and price_cents for a request body. They use open-source implementations of o200k_base. If yours disagrees with quote.input_tokens, the quote is what you pay; tell us and we'll look.
# pip install tiktoken
import json
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
def tokens(s: str) -> int:
return len(enc.encode_ordinary(s)) # ordinary: no special-token handling
def canonical_json(data) -> str:
# Keys sorted by code point, no whitespace, non-ASCII literal,
# U+2028/U+2029 escaped. Serialize numbers with the same encoder you
# use to send the request, so they match what we received.
s = json.dumps(data, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
return s.replace("\u2028", "\\u2028").replace("\u2029", "\\u2029")
def parts_tokens(content):
"""content: a string, or a list of input parts. Returns (tokens, images)."""
if isinstance(content, str):
return tokens(content), 0
t = i = 0
for p in content:
if p["type"] == "input_text":
t += tokens(p["text"])
elif p["type"] == "input_json":
t += tokens(canonical_json(p["data"]))
elif p["type"] == "input_image":
i += 1
return t, i
def quote(body) -> dict:
t = i = 0
msgs = body["input"]
if isinstance(msgs, str):
msgs = [{"content": msgs}]
for m in msgs:
dt, di = parts_tokens(m["content"]); t += dt; i += di
for q in body["questions"]:
t += tokens(q["name"].strip()) # names are trimmed
dt, di = parts_tokens(q["instructions"]); t += dt; i += di
for c in q.get("choices", []):
v = c["value"]
t += tokens(("true" if v else "false") if isinstance(v, bool) else v)
t += tokens(c.get("description") or "")
for lv in q.get("levels", []):
t += tokens(lv["label"]) + tokens(lv.get("description") or "")
billable = t + 500 * i
extra_questions = max(0, len(body["questions"]) - 3)
# $5.00 for the first 1,000 tokens, 0.25 cents per token after that,
# $1.00 per question beyond three; rounded up to the cent once, at the end.
milli_cents = 500_000 + max(0, billable - 1000) * 250 + extra_questions * 100_000
price = -(-milli_cents // 1000)
return {"input_tokens": t, "image_count": i, "billable_tokens": billable, "price_cents": price}Reservation, charge and release
| Event | Prepaid credits | Invoiced (arrears) accounts |
|---|---|---|
| Preview | Nothing. | Nothing. |
| Escalate | The quoted amount is reserved from available credit. Not charged. | Nothing reserved. |
| Physician answers | The reservation is charged, exactly once, at the quoted price. | The quoted price is added to your monthly invoice. |
| Canceled (by you or Appendix) | The reservation is released. | Nothing is billed. |
- Available credit is your balance minus active reservations. Escalation needs enough available credit; otherwise
402 insufficient_credits. If you have auto-refill on, a refill is attempted first and must succeed before the escalation goes through. - Reservations are shown separately on your billing page and are not usage. Answered decisions appear as a "Decisions API physician reviews" line on your monthly statement or invoice.
- The charge always equals the stored quote. It never depends on the answer: a low-confidence answer is a completed review.
- No SLA remedy. Physicians answer within 24 hours of escalation. If an answer is late, there is no automatic refund, discount, release or cancellation; a late answer is charged at the quoted price. You can cancel any decision a physician hasn't claimed yet.
- Test keys are never charged and never reserve credit.