Muse Ember’s 200K-token boundary reprices the whole request
Muse Ember’s long-context rate applies to the entire request once input exceeds 200K tokens. Here are the published rates, including how cached tokens and conversation history count.
Muse Ember’s higher long-context prices apply to the entire request, not just the tokens beyond 200,000. Meta counts cached input toward that threshold. If you continue a stored conversation with previous_response_id—a reference to an earlier response—the included conversation also counts as input for the pricing decision. That makes the published $0.10-per-million input rate a conditional starting price, not the price of every call.
Meta introduced Muse Ember on November 9 as a model for repeated agent work such as tool calls, routing, coding subtasks, and document processing. The billing boundary, rather than a speed or quality ranking, is the practical question to settle before putting it into a high-volume workflow.
What changes when input passes 200K tokens?
Meta’s Model API pricing and rate limits list two tiers for Muse Ember. Rates below are in US dollars per one million billable tokens, for the named token category:
| Billable token category | Request input up to and including 200K | Request input above 200K |
|---|---|---|
| Uncached input | $0.10 | $0.30 |
| Cached input | $0.004 | $0.012 |
| Output | $0.50 | $1.50 |
The tier is selected by total input tokens in that request, including cached input. At 200,000 input tokens, the lower tier applies; at 200,001, the higher tier applies to all billed input and output tokens in that request. These are not progressive tax brackets. The higher price does not apply only to token 200,001 and beyond.
This table is for token charges on Meta Model API. It does not include taxes, separately priced web-search grounding, or charges from other services. Meta lists web-search grounding separately at $2.50 per 1,000 queries when the tool is used; no such query is assumed in the examples below.
What does a one-token crossing do to an example bill?
Take two hypothetical billable requests, not measured invoices, with no cached input and 10,000 output tokens apiece. The inputs are deliberately chosen to sit on either side of the published boundary:
| Hypothetical request | Input charge | Output charge | Token subtotal |
|---|---|---|---|
| 200,000 uncached input + 10,000 output | 200,000 × $0.10 / 1,000,000 = $0.020000 | 10,000 × $0.50 / 1,000,000 = $0.005000 | $0.025000 |
| 200,001 uncached input + 10,000 output | 200,001 × $0.30 / 1,000,000 = $0.0600003 | 10,000 × $1.50 / 1,000,000 = $0.015000 | $0.0750003 |
The extra input token does not itself cost five cents. Crossing the boundary changes the applicable rates for the whole request, including the same 10,000 output tokens. For these particular assumed counts, the token subtotal is roughly three times as high; that is not a claim that every real workload costs exactly three times more. Output length, cached share, and other charges can change the comparison.
Access and billing channels are separate
On Meta Model API, the model ID is muse-ember-1.0. Meta’s Muse Ember model documentation lists a 1,048,576-token context window, a 524,288-token maximum output, and text, image, video, audio, and PDF input. Its output is text. These are capacity limits, not a promise that a near-limit call receives the lowest price.
Model API offers Muse Ember in Standard mode only, on pay-as-you-go billing; there is no Contributor-mode API variant. Muse Code separately offers it through pay-as-you-go and every subscription plan. This article’s table describes Meta Model API pay-as-you-go, not a subscription allowance.
During this review, Meta’s documentation site redirected our browser to a region-unavailable page. The pricing rules here use public documentation extracts saved before that restriction, with the higher rates also stated in the public release announcement. We have not verified local account signup or made model calls. Before purchasing, confirm access and current billing terms for your own account in an authorized region and channel.
Vercel also announced meta/muse-ember on AI Gateway on November 9. That establishes its route announcement, not availability for every account or region. It does not establish that Meta API invoices, gateway charges, and Muse Code subscription allowances are interchangeable.
Cached tokens and conversation history still count
A cache hit makes a token cheaper to bill, but it does not remove that token from the input count used to choose the tier. For example, assume a request reports 180,000 uncached input tokens, 30,000 cached input tokens, and 10,000 output tokens. Total input is 210,000, so all three categories use the higher tier: $0.054 for uncached input, $0.00036 for cached input, and $0.015 for output, or $0.06936 in hypothetical token charges. This example assumes those exact billable counts and a real cache hit; it is not a prediction of a cache-hit rate.
Meta’s pricing documentation also says a request that continues a stored conversation using previous_response_id includes that conversation in its input. Do not estimate the tier from only the newest message while treating earlier context as absent. Check the reported input and cached-input counts for the whole request when evaluating a repeated agent loop.
For a budget check, sample the longest conversations in an existing, authorized workload. Record each request’s total input, cached input, output, and billing channel; select the tier from total input, then price uncached input, cached input, and output separately. Compare those estimates with the target account’s invoice before expanding usage. Where access has not been confirmed, keep this a forecast rather than assuming you can run the test. If your estimate sits near 200K, the difference between a short turn and a carried-over conversation matters more than the headline rate. Compare the bill for your actual request shape and billing channel before changing models; the published table alone cannot establish performance or savings for your tasks.