Muse Wonder API: Model ID, Pricing and First-Request Checks

The Muse Wonder API uses muse-wonder-1.0 on Meta Model API. Before wiring it into a coding agent, confirm the route, prepare a small request, and decide what evidence counts as completion. A successful HTTP response alone does not establish correct output, working tools or a cheaper finished task.

AI-generated editorial illustration, not a product screenshot or model result.

Documentation checked October 14, 2026. The request below has not been sent. The companion checks run locally against synthetic fixtures; they do not demonstrate account access, inference quality or actual charges.

Choose the Muse Wonder API route before copying an example

Use Meta's documented standard-model identifier, not the Full subscription label. Meta lists Wonder on its Responses, Chat Completions and Messages endpoints. Wonder Full is a separate Muse Code subscription variant, unavailable through Meta Model API on this review date. Model availability.

For an initial text probe, this guide uses POST https://api.meta.ai/v1/responses. Meta documents a structured response body and different ways to carry history between calls. Its generic examples often name Muse Spark; those examples are not evidence of a Wonder run. The current reasoning guide does include a Wonder-specific Responses example. Responses protocol, Wonder reasoning example.

OpenAI-compatible describes a protocol, not access to every client feature. Check the endpoint's fields before moving a configuration from another provider. Do not infer DataLLM Lab or third-party gateway availability from the official Meta listing.

For the subscription decision, use the companion Muse Wonder vs Muse Wonder Full access guide. The remainder here concerns the standard Meta API route.

Prepare one bounded request without repository access

The proposed request JSON and offline first-request kit are available as downloads. The kit contains the response checker, synthetic tests and instructions; its checks do not send a Meta request or read API keys.

Start with a disposable text prompt, no files and no tools. The following is a proposed request body, not a recorded request or returned answer:

{
  "model": "muse-wonder-1.0",
  "input": "Reply with exactly READY and no other text.",
  "reasoning": {"effort": "low"},
  "max_output_tokens": 512,
  "store": false
}

On Responses, reasoning uses the nested reasoning.effort field. The output budget covers reasoning and visible text together. low is a conservative choice for this probe, not a speed or quality measurement. A short limit can still yield an incomplete response. Setting effort to max does not select Full. Reasoning controls and billing.

Save the body as request.json. After checking your account's access and billing, a reader can send it with:

curl --fail-with-body --max-time 90 \
  https://api.meta.ai/v1/responses \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @request.json --output response.json

This command can incur charges. Keep the key in a local environment or approved secret store; do not include it in the body, screenshots or a support transcript. The guide does not create an account or verify your entitlement.

store: false selects a non-stored response in this protocol. It is not a declaration about all service logs, retention obligations or organizational compliance. Treat those as a separate data-policy review before sending private material.

Inspect completion, model identity and usage separately

Require a complete response object before accepting a probe. Inspect the returned model identifier, terminal status and typed output items. Reject an error, incomplete response, refusal, unexpected tool request or empty text rather than presenting it as success.

The local companion response and cost checker additionally requires the text READY. That only checks this tiny output contract. It cannot verify which weights actually served the request, diagnose deceptive output or demonstrate useful coding ability. A model field is a reported identifier, not independent identity proof.

Run the checker on the saved JSON body with python3 reconcile_api_cost.py response.json. The checker itself sends no requests and reads no API keys. A nonzero exit requires review, not an automatic retry.

Preserve usage even for attempts whose answer you reject. Missing token details mean incomplete billing evidence, not zero cost. Keep a sanitized record containing the requested and reported model, effort, output budget, completion state, usage, attempt number and any tool charges. Redact private content before sharing the record.

For real coding work, replace READY with task-specific acceptance: executed tests, an inspected diff and permission boundaries. A response saying tests passed is not an executed test record. DataLLM Lab's evaluation methodology explains the distinction; its historical results are not Wonder evidence.

Muse Wonder API pricing: use the complete billable token count

Meta publishes the following Standard-mode rates, checked October 14, 2026. Wonder has no Contributor-mode API tariff on this date. These are Meta's rates, not a gateway quote or a Muse Code subscription allowance. Official pricing.

Cached input is part of total input, not another input quantity to add. On Responses, read usage.input_tokens_details.cached_tokens; do not presume that a repeated prompt earned the discount. Prompt caching.

For total input I, confirmed cached input C, and billable output O:

Token cost in USD = ((I - C) x 4.00 + C x 0.20 + O x 20.00) / 1,000,000

The following numbers are hypothetical arithmetic for a separate workload, not measured token counts or predictions for the 512-token probe above:

One cached first attempt plus the full second attempt totals $0.1296. If 1,800 of the 2,000 output tokens were reasoning, the calculation would still use 2,000, not 3,800. A small visible answer can therefore have a larger output charge than its displayed length suggests.

The companion checker calculates a range when cache details are missing. For 10,000 input and 2,000 output tokens, the theoretical token-only range is $0.0420 to $0.0800. That uncertainty is a reason to retain the usage evidence, not to report the lower bound as a bill.

Set stopping rules before adding retries and tools

A request budget should cover every attempt, not just the successful answer. The table excludes search, external tools, review time, taxes and provider adjustments. Meta separately lists web search at $2.50 per 1,000 queries. Add that charge when using the billed search tool. Token and search pricing.

For a first integration, use one retry owner and a small total-attempt cap. Stop on invalid fields, missing permission or billing configuration; repeating an unchanged request does not repair them. Handle rate limiting with the provider's delay guidance. If a connection ends after submission, do not assume the operation never happened. Error handling.

Your client timeout is a waiting limit, not proof of canceled server work. Treat an ambiguous result as unresolved. Do not automatically repeat an agent's write, deployment or payment operation merely because the surrounding model call timed out.

Meta's published limits apply per team, so multiple keys do not create independent quota pools. Add a shared queue and a task-level spend ceiling before running concurrent agents. Large context capacity also needs a budget: input plus requested output must fit the documented window. Rate limits, Output limits.

FAQ

Is the Muse Wonder API free?

The published standard route is token-priced. Any trial, credit or another provider's promotion needs its own current terms. Do not treat a subscription or temporary credit as an unlimited free API.

Can I get Muse Wonder Full by changing the model ID?

Not through Meta Model API on October 14, 2026. Full access belongs to eligible Muse Code subscriptions; increasing reasoning effort on standard Wonder does not change that route.

Does a million-token context window guarantee better coding?

No. Capacity does not establish retrieval accuracy, correct edits or tool execution. Evaluate one bounded task with preserved inputs, executed acceptance checks and all attempted costs before widening access.

Conclusion

Begin a Muse Wonder API integration with one inspectable request and a separate usage record. Establish route and completion first, then evaluate useful work under fixed acceptance and spending limits. Keep hypothetical estimates separate from actual billing and avoid adding repository permissions until that evidence exists.