Muse Wonder API Guide: Endpoints, Reasoning, and Cost

Muse Wonder is a Model API model from Meta, offering muse-wonder-1.0 through https://api.meta.ai/v1. It supports three request formats simultaneously: the Responses API, Chat Completions, and an Anthropic-compatible Messages endpoint. Authentication uses a Bearer key, pricing is $4 per million input tokens and $20 for output, cached input is just $0.20, the context window reaches 1,048,576 tokens, and there is no long-context surcharge.

For developers familiar with the OpenAI SDK, migrating to Muse Wonder takes just two lines of code — swap the base_url and api_key. This article walks from getting a key all the way to a runnable agent loop, covering endpoint selection, reasoning effort control, cross-turn state management, tool calling, streaming output, background execution, and interpreting usage fields.

Muse Wonder API Core Parameters

Before writing your first line of code, take a look at this spec sheet.

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 and 4 million tokens per minute, per team per model
Web search tool	$2.50 per 1,000 queries, plus token costs

One commonly misunderstood point: the larger Muse Wonder Full model is not available in the API — it is only accessible via Muse Code's Power and Maximum subscription plans. Setting Wonder's reasoning effort to max will not turn it into Full.

Step 1: Get a key and make your first call

Create a key on the API keys page of the Model API console, and save it as the environment variable MODEL_API_KEY. Make your first 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
  }'

If you use the OpenAI SDK, only the base_url and the key need to change; everything else stays exactly the same. Besides text, the response also returns a usage block. Get in the habit of checking 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 received the cached rate.

Step 2: Choose the right endpoint

Meta's quickstart uses the Responses API, and it is also the default correct choice for multi-step tasks — it preserves the reasoning process between turns and manages conversation history for you. Chat Completions is aimed at existing code already using the OpenAI SDK. The Messages endpoint accepts Anthropic-format requests, and it is precisely through this endpoint that Claude Code runs on top of Muse Wonder.

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

Parameter naming differs across the three formats. Reasoning effort is reasoning.effort in Responses and top-level reasoning_effort in Chat Completions. Output caps are max_output_tokens and max_tokens respectively. Structured output in Responses uses text.format, not response_format.

What is the Responses API? This is the next-generation interface OpenAI launched in 2025 to replace Chat Completions, abstracting a "conversation" into an ordered series of items (messages, tool calls, reasoning items, etc.), with native support for server-side session state, background execution, and built-in tools. Muse Wonder's Responses endpoint largely aligns with this design, so fields like previous_response_id, reasoning.encrypted_content, and tools all follow OpenAI semantics directly. For developers, this means code originally written for OpenAI Responses can run by simply swapping base_url and key.

The Messages endpoint and Anthropic format is Anthropic Claude API's native request format, structured around system plus a messages array, with tool calls expressed through tool_use / tool_result content blocks — markedly different from OpenAI style. Muse Wonder provides a compatible implementation, letting clients like Claude Code, already deeply tied to the Anthropic format, switch the underlying model without modification. This is the core value of its existence among the three endpoint types.

Step 3: Control reasoning effort

Muse Wonder always reasons, and setting none returns HTTP 400. Accepted levels are minimal, low, medium, high, xhigh, and max; if omitted, the model chooses the level itself. Meta's advice is the same as always: use the lowest level that produces acceptable results, because reasoning tokens are billed at the $20 output rate and count against your output cap.

Two practical rules follow from this. First, at high effort, leave plenty of headroom in max_output_tokens; at the max level, reasoning consumes a large portion of output, and too tight a cap will truncate the answer. Second, log reasoning_tokens by request type to understand what each effort level costs in your own traffic, rather than looking at benchmarks. The Artificial Analysis run that scored the model at 52 used max effort, at roughly 54,000 output tokens per task.

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

Reasoning tokens are the internal monologue of modern "thinking" models: the model first produces intermediate reasoning not shown directly to the user, then outputs the final answer. This content is billed exactly like normal output, so at high effort settings it can consume the vast majority of the output budget. Benchmarking organizations often evaluate at the highest effort, causing reported cost figures to vastly exceed real production levels. To estimate true cost, sample and log reasoning_tokens by request type in your own traffic, then multiply by the corresponding rate.

reasoning.summary requests a readable summary of that reasoning process from the model, not the raw reasoning content itself. The raw chain of thought is generally considered sensitive and possibly noisy, and most vendors choose not to return it; the summary is a secondarily generated compressed version, so it may be empty or highly paraphrase-like, and is not suitable as a basis for debugging reasoning logic.

Step 4: Passing state between 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"], save the reasoning items returned in the response, and pass them back in the next turn together with their encrypted_content and a summary field (an empty array is fine). The model's reasoning process survives across turns without Meta storing anything.

Server-managed history is simpler: pass previous_response_id and send only the new input. Note that instructions are not carried automatically, so you must resend 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.")

Step 5: Tools, structured output, and web search

Function tools follow the OpenAI format in both Responses and Chat Completions. Muse Wonder calls tools in parallel and is trained to recover from failed calls — this is one of the meanings of Active Focus in Meta's launch post. Define tools with a JSON schema, execute the function_call items the model returns, then pass back function_call_output items.

To let code parse responses, set text.format to a JSON schema in Responses. To get time-sensitive information, add Meta's managed search with tools=[{"type": "web_search"}], billed at $2.50 per 1,000 queries plus token costs.

Step 6: Streaming output and background execution

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

For long tasks, send background: true. The API acknowledges receipt with "status": "queued", after which you can poll or consume lifecycle events on GET /v1/responses/{id}?stream=true. Background mode cannot be combined with stream: true in a POST, the request body cap is 1 MiB, and there is a separate limit of 600 new background submissions per team per minute. Cancel with POST /v1/responses/{id}/cancel.

Step 7: Caching for repeated content

Cached input costs just $0.20 per million tokens, 95% cheaper than the standard $4 rate, and Meta reports hits via usage.input_tokens_details.cached_tokens. The pattern that secures the discount is the same as with other providers: put stable content (system instructions, tool definitions, reference documents) first, and put content that changes per request last. Also pay attention to cache writes — in that Artificial Analysis run, $1.92 of Wonder's $4.52 per task was cache writes, more than the $1.44 in cache hits.

Prompt caching works like this: the provider hashes the request prefix, and charges the discounted price when that prefix hits the cache. Therefore the prefix must be byte-for-byte stable — change even one character in the system instructions and everything after the cache invalidation point is recomputed. A common approach is to put the system prompt, tool JSON schemas, and retrieved fixed documents first, and put volatile content like the user's question and timestamps last.

Cache writes refer to the cost of placing a new prefix into the cache for the first time, usually billed at the standard input rate or slightly higher; cache hits are the discounted reads. For scenarios with very long prefixes but few reuses, write costs can exceed the hit savings — something that especially needs empirical verification in usage-billed APIs.

Testing Muse Wonder API in Apidog

A shared Apidog project keeps keys out of chat threads and keeps everyone on the same request configuration.

1. Create an environment, name it Meta Model API, set base_url to https://api.meta.ai/v1, and add MODEL_API_KEY as a secret variable so the value is masked in the UI and excluded from exports.
2. Add three requests, one per endpoint, each with Authorization: Bearer {{MODEL_API_KEY}}. Duplicate the Responses request three times, using low, medium, and max effort to compare costs side by side.
3. Assert on usage. Add JSONPath assertions on $.usage.output_tokens_details.reasoning_tokens and $.usage.input_tokens_details.cached_tokens. Zero cached-tokens on a request where you expected a cache hit signals a prefix design bug and can be caught before it reaches production.
4. Simulate 429. Meta's docs recommend exponential backoff with jitter starting around 500 ms, and honoring Retry-After. Point the client at an Apidog mock that returns a 429 with that header, and validate retry logic before sharing the 3,000-requests-per-minute limit across the team.
5. Run in CI via the Apidog CLI, so a model or price change fails the pipeline rather than crashing the client.

Frequently Asked Questions

Is there a free tier for the Muse Wonder API? No. It is billed per token with no minimum spend, so a few test calls cost only cents, but there is no free allowance.

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

Can I access Muse Wonder Full through the API? No. There is no callable model ID and no per-token pricing. 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 for the team. Meta's pricing page lists no tiers or increase process.

Next steps

Run low, medium, and max effort once each on a real task from your product, compare reasoning_tokens, and then pick a default. That number — not the $4 headline price — is what your bill will track.