Skip to main content

Pricing

A physician decision is priced by the size of what you send, and you see the exact price before you escalate.

The formula

price = $5.00 for the first 1,000 billable tokens and 3 questions
+ $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 tokensImagesBillable tokensQuestionsPrice
30003001$5.00 (minimum)
80011,3003$5.75
80011,3005$7.75
1,00101,0011$5.01
4,20025,2003$15.50
10,000311,5005$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 message content, and every input_text part.
  • Every input_json part, serialized as canonical JSON (below).
  • Every question name.
  • All question instructions content (text and JSON parts, same rules).
  • Every choice value; booleans count as the text true or false.
  • Every choice description you supply.
  • Every level label and every level description you 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/role keys 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.50 stays 1.50).
  • Strings escaped minimally: \", \\, \b, \f, \n, \r, \t; other control characters as \u00xx (lowercase hex); U+2028 and U+2029 as \u2028 and \u2029. Everything else, including <, >, & and non-ASCII characters, is literal UTF-8.
  • true, false and null as 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

EventPrepaid creditsInvoiced (arrears) accounts
PreviewNothing.Nothing.
EscalateThe quoted amount is reserved from available credit. Not charged.Nothing reserved.
Physician answersThe 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.
Buying credits. Credits, auto-refill and invoices work as described in the developer pricing & credits guide; one balance covers both APIs.