Muse Spark 1.2 Contributor cost: cache and reasoning accounting

Which three components determine cost?

Muse Spark 1.2 Contributor cost comes from uncached input, cached input and total output including reasoning. Counting only the visible answer understates usage; charging cached tokens again as ordinary input overstates it.

On 28 August 2026, Meta’s model and pricing documentation required login, so current numerical rates could not be independently verified. This guide invents no rates. Confirm the applicable Contributor input, cache read and output prices in USD per million tokens, and record their date.

Contributor warning: This tier permits Meta to use prompts and completions for model training. Do not submit confidential, personal or customer data. The example below uses only a general question.

Do not add overlapping usage fields

Let P be total input, C its cached portion and O total output. Cost is ((P − C) × input rate + C × cache read rate + O × output rate) / 1,000,000.

C is already part of P, so do not also bill it as ordinary input. R is part of O, so using O + R counts reasoning twice. Multiplying total tokens by one rate incorrectly combines differently priced categories.

Budget for cache misses first

Repeating a prefix does not guarantee a cache hit. Keeping fixed instructions first and the changing question last creates a reusable prefix; the actual C reported in each response determines the discount.

Include a C = 0 scenario in planning. For fixed P and O, potential savings are C × (input rate − cache rate) / 1,000,000. This is arithmetic, not measured savings. Before increasing traffic, examine the achieved cache ratio in a small evaluation containing no sensitive data.

Visible answers do not measure reasoning cost

LLMTR’s Muse Spark guide states that completion_tokens includes reasoning. A short final answer therefore does not imply little output usage. When changing reasoning_effort, compare both O and whether the task was completed correctly.

A small max_tokens budget can run out during reasoning, leaving empty visible content and a length finish_reason. Do not mistake this for a free result. Review effort and output budget together instead of repeatedly sending the same request. Lower effort is not guaranteed to be cheaper or sufficient for every task.

Calculate one response’s usage with Python

Set LLMTR_BASE_URL to the complete API base including /v1, and LLMTR_API_KEY to your LLMTR key. Populate the three MUSE rate variables with your verified Contributor prices; these are calculation inputs for this example.

Running the code sends one paid POST /v1/chat/completions request. No live call was made for this article. Missing usage fields stop the example; it does not invent a zero cached count. Only the calculated amount and finish reason are printed, never prompt or completion content.

Usage calculation with verified rates; no sample response was fabricated

import json
import os
from decimal import Decimal
from urllib.request import Request, urlopen

names = (
    "MUSE_INPUT_USD_PER_1M",
    "MUSE_CACHE_USD_PER_1M",
    "MUSE_OUTPUT_USD_PER_1M",
)
pi, pc, po = (Decimal(os.environ[name]) for name in names)
if any(not rate.is_finite() or rate < 0 for rate in (pi, pc, po)):
    raise ValueError("Invalid rate")

payload = {
    "model": "meta/muse-spark-1.2-contributor",
    "messages": [{"role": "user", "content": "Explain binary search."}],
    "reasoning_effort": "low",
    "max_tokens": 4096,
    "stream": False,
}
request = Request(
    os.environ["LLMTR_BASE_URL"].rstrip("/") + "/chat/completions",
    data=json.dumps(payload).encode("utf-8"),
    headers={
        "Authorization": "Bearer " + os.environ["LLMTR_API_KEY"],
        "Content-Type": "application/json",
    },
    method="POST",
)
with urlopen(request, timeout=90) as response:
    result = json.load(response)

usage = result["usage"]
p = usage["prompt_tokens"]
c = usage["prompt_tokens_details"]["cached_tokens"]
o = usage["completion_tokens"]
if any(type(n) is not int or n < 0 for n in (p, c, o)) or c > p:
    raise ValueError("Inconsistent usage")
cost = (Decimal(p - c) * pi + Decimal(c) * pc + Decimal(o) * po)
cost /= Decimal(1_000_000)
print(json.dumps({
    "estimated_usd": str(cost),
    "finish_reason": result["choices"][0]["finish_reason"],
}))

Track cost per successful task

The calculated amount applies your selected rates to reported usage; it is not invoice verification by itself. Compare it with the LLMTR usage record for the same date and model. Do not add a platform margin to model token rates; account for credit purchase costs separately.

If a task requires several calls, count more than its final response. Sum all relevant call costs during the evaluation period and divide by tasks meeting your acceptance criteria. This exposes settings that appear cheap but require many repetitions.

• Record model identifier, rate date, token breakdown and finish reason.
• Include truncated responses and retries in the outcome assessment.
• Keep prompts, completions and customer content out of cost logs.

Frequently asked questions

Why are current Contributor dollar rates omitted?

Meta’s official pricing page required login on 28 August 2026. To avoid presenting an older catalog value as today’s official rate, the calculation uses rates you verify.

Should cached tokens be added to prompt_tokens?

No. They are already included in total input. Separate C from ordinary input and apply only the cache read rate to that portion.

Do reasoning tokens require another output charge?

No. This model includes reasoning in completion_tokens. Inspect reasoning_tokens to understand output consumption, but do not add it again.

Does an empty answer cost nothing?

Empty text cannot establish that. Check actual usage and finish_reason; reasoning tokens may already have been generated.

Related posts

• What is Muse Spark 1.2 Contributor? Data policy and the standard tier
• muse-spark-1.2-contributor: LLMTR model ID and endpoint

• meta/muse-spark-1.2-contributor
• Model catalog
• Chat Completions guide
• OpenAI / OpenRouter