Muse Wonder API User Guide: Endpoints, Costs, and Reasoning Control

Meta's Muse Wonder API is built around the muse-wonder-1.0 model, served via https://api.meta.ai/v1, and supports three request formats: the Responses API, Chat Completions, and an Anthropic-compatible Messages endpoint. Pricing is $4 per million input tokens and $20 per million output tokens, with a context window of up to 1,048,576 tokens and no surcharge for long context. Reasoning effort can be dialed from minimal up to max, and any OpenAI SDK works by simply swapping the base URL.

Muse Wonder API core parameters at a glance

Before writing any code, take a look at this quick-reference table. All endpoints authenticate via a bearer key, which you create in the Model API console at dev.meta.ai.

Item	Value
Base URL	https://api.meta.ai/v1
Model ID	muse-wonder-1.0
Auth	Authorization: Bearer $MODEL_API_KEY
Endpoints	POST /v1/responses, POST /v1/chat/completions, POST /v1/messages
Pricing per million tokens	Input $4, output $20, cached input $0.20
Context window	1,048,576 tokens, no long-context surcharge
Reasoning effort	minimal, low, medium, high, xhigh, max
Rate limits	3,000 requests/min, 4M tokens/min per team per model
Web search tool	$2.50 per 1,000 queries, plus token costs

One thing to note: the larger Muse Wonder Full model is not available through the API, only bundled into the Muse Code Power and Maximum subscription plans. Cranking Wonder's reasoning effort to max will not turn it into Full.

What is the Responses API? This is a new endpoint OpenAI introduced in 2025 to replace Chat Completions as the preferred interface for building agentic applications. It unifies conversation state, tool calls, structured output, background runs, and streaming events into a single object model, where everything is represented as an item under a response object. Across turns, you can preserve the model's internal state via previous_response_id or by passing back reasoning items. Unlike Chat Completions' messages array, Responses can natively carry reasoning content and tool-call traces, making it friendlier for multi-step tasks. Muse Wonder makes Responses the officially recommended entry point precisely because its core selling points—controllable reasoning effort and cross-turn reasoning retention—are only fully available on this endpoint.

Complete your first API call in three steps

Step 1: Get a key and fire off a request

Create a key on the API keys page of the Model API dashboard and save it as MODEL_API_KEY, then send a request with cURL:

curl https://api.meta.ai/v1/responses \
  -H "Authorization: Bearer $MODEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "muse-wonder-1.0",
    "input": "List three risks in a lease clause that lets the landlord enter without notice.",
    "reasoning": {"effort": "medium"},
    "max_output_tokens": 2048
  }'

With the OpenAI SDK, you only need to change two lines—point base_url at https://api.meta.ai/v1 and switch the model name to muse-wonder-1.0. The response carries a usage block, and you should inspect it on every call: output_tokens_details.reasoning_tokens tells you how much of your output budget went to reasoning, while input_tokens_details.cached_tokens shows how much input got the cached price.

Step 2: Pick the right endpoint

Meta's official getting-started guide recommends the Responses API. It's the correct default for any multi-step work, can retain reasoning state across turns, and can manage conversation history on your behalf. Chat Completions is retained for existing OpenAI-style code. The Messages endpoint accepts Anthropic-format requests, which is exactly what lets Claude Code run on top of Muse Wonder.

Use case	Recommended endpoint
New agents, tool loops, long sessions	Responses
Existing OpenAI-style code, single-turn tasks	Chat Completions
Claude Code or other Anthropic frameworks	Messages
Need reasoning summaries	Responses only

The three formats differ in parameter naming: reasoning effort is reasoning.effort in Responses but top-level reasoning_effort in Chat Completions; output caps are max_output_tokens and max_tokens respectively; structured output uses text.format in Responses rather than response_format.

Step 3: Tune reasoning effort

Muse Wonder always reasons, and passing none returns an HTTP 400 error. Accepted values are minimal, low, medium, high, xhigh, and max; if you omit the parameter, the model chooses on its own. Meta's advice is straightforward: use the lowest level that gives acceptable results, because reasoning tokens are billed at the $20 output price and count against your output cap.

Two practical rules follow. First, at high reasoning effort you should set max_output_tokens generously—at the max level, reasoning takes up a large share of output, and too tight a cap will truncate the answer. Second, log reasoning_tokens by request type so you can see the true cost of each reasoning level on your own workload rather than relying on some benchmark. According to Artificial Analysis testing, the model consumes roughly 54,000 output tokens per task on average at max effort.

In the Responses interface, you can request reasoning summaries by setting reasoning.summary to auto, concise, or detailed. Summaries are not guaranteed and may return an empty array, and the raw reasoning content is never returned.

Reasoning tokens and chain-of-thought billing refers to the intermediate reasoning steps the model generates internally before producing a final answer. These tokens are not part of the user-visible output, but they are still billed at the output price and consume your max_output_tokens allowance. The industry term "thinking budget" refers to controlling this portion. Muse Wonder belongs to the same family of approaches as OpenAI's o-series and Anthropic's extended thinking: a discrete effort level replaces an explicit token count, letting the model scale its own reasoning length. The difference is that some models let you turn reasoning off (such as OpenAI's reasoning_effort: none), whereas Muse Wonder forces reasoning on and returns a 400 for none. Understanding this is critical for cost estimation: even if the answer is only a few dozen tokens, a max-level call can burn tens of thousands of output tokens.

Two ways to retain state across turns

The Responses API offers two modes, and they cannot be mixed.

Stateless encrypted replay is Meta's recommended approach. Send store: false and include: ["reasoning.encrypted_content"], keep the reasoning item returned in the response, and pass it back in the next turn along with the encrypted_content and summary fields (an empty array is fine). The model's reasoning is preserved between turns while Meta stores nothing.

Server-managed history is simpler: pass previous_response_id and send only new input. Note that instructions do not carry across turns—you must resend your system instructions on every request.

first = client.responses.create(model="muse-wonder-1.0", input="Summarize this API's auth flow: ...", instructions="You are an API reviewer.")
second = client.responses.create(model="muse-wonder-1.0", previous_response_id=first.id, instructions="You are an API reviewer.", input="Now list the endpoints that need an OAuth scope.")

Tool calls, structured output, and web search

Function tools follow the OpenAI format in both Responses and Chat Completions. Muse Wonder can call tools in parallel and has been trained to recover from failed tool calls—part of what Meta means by "Active Focus" in its launch blog post. Define tools with JSON schema, execute the function_call items the model returns, and pass back function_call_output items.

If you want code to parse the response, set text.format to a JSON schema in Responses. If you need real-time information, add Meta-hosted web search via tools=[{"type": "web_search"}], which bills an extra $2.50 per 1,000 queries. If you're already testing tool calls for other models, your existing test harness needs no changes—the request format matches OpenAI.

Streaming and background runs

Set stream: true and consume the event stream: response.created, response.output_item.added, response.output_text.delta, response.function_call_arguments.delta, and finally response.completed. Failures end with response.failed. After the request, reasoning summaries arrive as response.reasoning_summary_text.delta.

For long tasks, send background: true. The API acknowledges with "status": "queued", and you can poll or stream lifecycle events from GET /v1/responses/{id}?stream=true. Background and stream: true cannot coexist in the same POST request, the request body is capped at 1 MiB, and background jobs have their own separate limit of 600 new requests per minute. Cancellation is done via POST /v1/responses/{id}/cancel.

Caching repeated content saves 95%

Cached input costs just $0.20 per million tokens, 95% cheaper than the standard $4 input price, and Meta reports this via usage.input_tokens_details.cached_tokens. The pattern that pays off is the same as with other providers: put fixed material (system instructions, tool definitions, reference documents) up front, and put per-request content at the end.

Also monitor the cache write side. According to Artificial Analysis testing, of Wonder's $4.52 cost per task, $1.92 goes to cache writes, exceeding the $1.44 in cache hits. That suggests there may be more room for optimizing your caching strategy than you'd think.

Prefix caching (prompt caching) is an optimization mechanism widely used across major model APIs: if the beginning of two requests is byte-for-byte identical, the server can reuse the KV cache already computed last time, skipping redundant prefill computation and billing only for the new portion. The price of a cache hit is typically 5% to 10% of the standard input price, and Muse Wonder's $0.20 per million tokens sits right in that range. To hit the cache, the prefix must be exactly identical, including the system prompt, tool definitions, and the wording and order of examples—any change invalidates the cache from that point onward. The article notes that cache writes cost more than hits because the first write is billed at the standard price, and caches have a lifetime (typically a few minutes to an hour), after which they must be rewritten. So design your caching strategy around "stable prefix + dynamic suffix," and reuse it within the cache's validity window as much as possible.

Testing the Muse Wonder API in Apidog

A shared Apidog project keeps keys out of chat windows and lets the whole team use the same requests.

1. Create an environment: Name it Meta Model API, set base_url to https://api.meta.ai/v1, and make MODEL_API_KEY a secret variable. Secret values are masked in the UI and never exported.
2. Add three requests: One per endpoint, all carrying Authorization: Bearer {{MODEL_API_KEY}}. For the Responses request, set effort to low, medium, and max respectively to compare costs side by side.
3. Add usage assertions: Add JSONPath assertions on $.usage.output_tokens_details.reasoning_tokens and $.usage.input_tokens_details.cached_tokens. When you expect a cache hit but get zero, that signals a problem with your prefix design, and you can catch it before it reaches production.
4. Simulate a 429 error: Meta's docs recommend exponential backoff starting around 500ms with jitter, while respecting the Retry-After header. Point your client at an Apidog mock that returns 429 with that header to validate retry logic before your team shares the 3,000-request-per-minute limit.
5. Run in CI: Run it via the Apidog CLI so your pipeline fails when the model or pricing changes, rather than letting clients break.

FAQ

Does the Muse Wonder API have a free tier? No. Billing is per token with no minimum spend, so a few trial calls cost just cents, but there is no free allowance.

Is API data used for training? Not in Standard mode. Muse Code subscriptions default to Contributor mode, which does use your data, but that setting lives in Muse Code, not the API.

Can I use Muse Wonder Full through the API? No. It has no callable model ID and no per-token price. Only Muse Code Power and Maximum subscribers can select it.

What are the rate limits, and can they be raised? 3,000 requests and 4 million tokens per minute per model, aggregated across all keys in a team. Meta's pricing page doesn't list tiers or an increase process.

Next steps

Run calls at low, medium, and max effort on a real task from your product, and compare reasoning_tokens before choosing a default. That number, not the $4 headline price, is the billing basis you should track.

Additional context

About Apidog: Apidog is the collaboration tool used in this article to demonstrate API testing, part of a platform that combines "API design + debugging + mocking + automated testing." Its core value is centralizing environment variables, keys, request definitions, and assertions so team members share a single configuration and avoid pasting MODEL_API_KEY into chat windows or code comments. The five steps demonstrated—create an environment, add requests, add usage assertions, simulate a 429, and hook into CI—cover the full chain from local experimentation to pipeline monitoring. The Apidog CLI lets these assertions run in continuous integration, so if Meta changes the model version or pricing, the pipeline can detect it and stop before clients do. If you're already using Postman or Bruno, the approach is similar, with the main differences being team collaboration and the degree of mock-service integration.

One-line Summary

Meta Muse Wonder API supports three endpoint formats, bills on a reasoning-effort ladder, and can save 95% with caching.

Paragraph Summary

Meta's Muse Wonder API centers on muse-wonder-1.0 and offers three endpoints: Responses, Chat Completions, and an Anthropic-compatible Messages endpoint; any OpenAI SDK can connect by swapping the base URL. Pricing is $4 per million input tokens and $20 per million output tokens, cached input is just $0.20, and the context window reaches 1.04 million tokens with no long-context surcharge. Reasoning effort has six levels from minimal to max, the model always reasons, and reasoning tokens are billed at the output price and count against the output cap. Cross-turn state can be achieved via stateless encrypted replay or server-managed history, and the two cannot be mixed. Rate limits are 3,000 requests and 4 million tokens per minute at the team level. The article also covers concrete practices for caching optimization, tool calls, background runs, and Apidog testing.