How to Use Muse Wonder API: A Step-by-Step Guide

What Is the Meta Muse Wonder API?

Muse Wonder is Meta’s model for complex software engineering, technical reasoning, and sustained agent work. Meta lists muse-wonder-1.0 in preview, with text, image, video, audio, and PDF input, text output, and a native 1,048,576-token context window. This guide focuses on text requests through GPT Proto’s Muse Wonder 1.0 API.

Muse Wonder and Muse Spark are both available through Meta Model API. Wonder targets longer, more demanding tasks; Spark serves cost-sensitive and latency-sensitive workloads, including coding and agent loops. Spark is not restricted to a consumer app or excluded from API access.

Muse Wonder Full is a separate higher-capability variant available only in eligible Muse Code subscription plans. It is not an additional public API model ID, and setting Wonder’s reasoning effort to max does not switch to Full. Meta’s model documentation distinguishes these access paths.

A hosted model provides responses and tool-call instructions. Your application supplies the tools, execution environment, scheduling, and conversation state; a model call alone does not create a complete autonomous agent.

How to Get Muse Wonder API Access on GPT Proto

GPT Proto lists Muse Wonder 1.0 in its model catalog. Access uses a GPT Proto account, a platform API key, and the balance and permissions applicable to that account; it does not require putting a Meta-issued key into the GPT Proto request.

1. Sign in to your GPT Proto account.

2. Create a key in the dashboard’s API Keys section.

3. Add credits to the shared balance and confirm Muse Wonder 1.0 is available to the account.

4. Configure the documented GPT Proto endpoint and model string for the request.

GPT Proto’s published authentication guide describes platform key creation. The Muse Wonder model page identifies the current listing and rates.

Direct Meta access is a separate integration with a Meta Model API account and key. Muse Code subscriptions are another product, not a universal prerequisite for calling Wonder’s API. Availability remains subject to each service’s account permissions and terms; gateway access is not a guarantee of worldwide availability or a way to override regional restrictions.

How to Obtain and Secure Your GPT Proto API Key

1. Sign in to GPT Proto.

2. Open the dashboard’s API Keys section.

3. Generate a new key and give it a name that identifies the application or environment.

4. Copy the value and store it securely.

The key is a GPT Proto platform credential, not a separate Meta-issued Muse Wonder key. Descriptive names help track use; separate keys for development and production provide independent revocation, while the account can still use a shared credit balance.

For a terminal session, expose the key through an environment variable:

export GPTPROTO_API_KEY='your-gptproto-key-here'

The value above is a placeholder. Production services can load the key from their deployment’s secret store. A local .env file must be explicitly loaded by the application or shell and excluded from version control; Python’s os.environ does not load that file automatically.

Keys belong on the server, not in browser or mobile source code. The API key guide explains the distinction between client-visible and private credentials.

For routine rotation, create and deploy a replacement key before revoking the old one. If a key is exposed in a repository, log, or public client, revoke it immediately and replace it in affected deployments. Key names alone do not create model-specific permissions or isolate billing.

Authentication and Base Endpoint Setup

For GPT Proto Chat Completions, the request URL is:

https://gptproto.com/v1/chat/completions

The equivalent OpenAI-compatible SDK base URL is https://gptproto.com/v1. Authentication uses your GPT Proto-issued key:

POST /v1/chat/completions HTTP/1.1
Host: gptproto.com
Authorization: Bearer <GPTPROTO_API_KEY>
Content-Type: application/json

GPT Proto’s public Muse Wonder page configuration identifies the chat model as muse-wonder-1.0. The request examples below use that identifier with the platform’s documented Chat Completions structure. GPT Proto’s quickstart documents the endpoint and response shape; its authentication guide specifies Bearer authentication.

Direct Meta requests use a different host and credential: https://api.meta.ai/v1 with a Meta Model API key. Meta’s Responses format uses input; Chat Completions uses messages. The API endpoint guide explains how a base URL, route, and HTTP method combine into a request.

A key from one platform is not interchangeable with a key from another. Switching between Responses, Chat Completions, and Messages also changes the request fields and response parsing, even when the same model is available on more than one protocol.

Your First Muse Wonder API Request: curl and Python

With GPTPROTO_API_KEY set in the environment, a text request uses the documented GPT Proto Chat Completions endpoint:

curl --fail-with-body --request POST \
  'https://gptproto.com/v1/chat/completions' \
  --header "Authorization: Bearer $GPTPROTO_API_KEY" \
  --header 'Content-Type: application/json' \
  --data '{
    "model": "muse-wonder-1.0",
    "messages": [
      {"role": "user", "content": "Explain three risks in a database migration."}
    ]
  }'

This example sends the key at runtime rather than embedding its value in the source. --fail-with-body makes curl report HTTP errors while retaining the response body for diagnosis.

The equivalent Python example uses requests:

import os
import requests
api_key = os.environ["GPTPROTO_API_KEY"]
response = requests.post(
    "https://gptproto.com/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json",
    },
    json={
        "model": "muse-wonder-1.0",
        "messages": [
            {
                "role": "user",
                "content": "Explain three risks in a database migration.",
            }
        ],
    },
    timeout=60,
)
response.raise_for_status()
data = response.json()
print(data["choices"][0]["message"]["content"])

The example requires the requests package. A missing environment variable raises KeyError; an HTTP error raises an exception before the program attempts to read a successful chat response. The 60-second timeout is an example client setting, not a platform response-time guarantee.

Request Fields

• model selects the model; this example uses muse-wonder-1.0 from GPT Proto’s public chat configuration.

• messages contains the conversation. Each item has a role and content.

• Additional output-budget, reasoning, tool, or streaming fields depend on the selected route. They are not universal prerequisites for the minimal request above.

Reading the Response

A non-streaming Chat Completions response has the following illustrative shape. IDs, generated content, finish reasons, and usage values vary by request:

{
  "id": "chatcmpl-example",
  "object": "chat.completion",
  "model": "muse-wonder-1.0",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Example assistant output."
      },
      "finish_reason": "stop"
    }
  ]
}

The generated text is in choices[0].message.content, not choices[0].text. A stop finish reason describes how generation ended; it does not prove factual accuracy or task completion. Where the response includes usage, it records token consumption rather than a guaranteed final charge across every processing mode.

Pricing, Rate Limits, and Billing

GPT Proto’s current Muse Wonder 1.0 listing shows $3.20 per million input tokens and $16.00 per million output tokens. The Muse Wonder pricing page is the model-specific reference; platform usage is deducted from a shared credit balance with no required subscription, as described in GPT Proto’s billing details.

For comparison, Meta’s official Standard API rates are $4.00 per million input tokens, $20.00 per million output tokens, and $0.20 per million cached input tokens. Muse Wonder is available in Standard mode on Meta Model API; Contributor mode is not available for Wonder on pay-as-you-go. These are Meta rates, not a quote for every GPT Proto charge. Meta’s pricing documentation defines the native billing modes.

Model API pricing and Muse Code subscriptions are separate products. A promotion or trial credit is separate from ongoing API pricing; Muse Code subscription allowances are not Model API free-tier quotas.

Request and token limits depend on the service and account. Meta’s published team-level limits are not automatically GPT Proto limits. A 429 response can indicate rate limiting; the response body and any retry headers identify the applicable limit.

Total agent cost includes input, output and billed reasoning, cache behavior, retries, and any tool charges. The affordable LLM APIs for AI agents guide covers cost per successful task and the effect of recovery calls, rather than token price alone.

Common Use Cases for the Muse Wonder API

Coding Assistants and Agents

Muse Wonder can generate implementations, investigate errors, review changes, and work through technical requirements. In a coding agent, the application supplies repository access, permitted tools, and test feedback. The model’s native large context is capacity for relevant material, not a guarantee that any repository fits or that a refactor is correct.

Document and Content Workflows

Text requests can summarize supplied material, reformat documents, and produce structured drafts. The workflow still controls input selection, output budgets, validation, and editorial review. This text-to-text tutorial does not establish support for every file or multimodal field on every GPT Proto route.

Classification and Background Processing

An application can call the model from a scheduled job to classify tickets, extract fields, or prepare a response. The application runs the schedule and handles results; the model does not execute cron jobs or external actions by itself. Tool calls require an execution layer, permissions, and validation.

Muse Wonder Full is not a public API option for any of these examples. The guide uses Muse Wonder 1.0, while the application’s request limits and acceptance criteria determine the size of each job.

Troubleshooting Requests

Invalid Key or Authentication Error

A 401 response commonly indicates a missing, invalid, or revoked credential. A GPT Proto endpoint requires a GPT Proto key in the Bearer header; a Meta-issued key is not a substitute. Missing environment variables and malformed headers are separate client-side configuration problems.

Invalid Request or Model Access

For validation errors, inspect the error body for the named field. A Chat Completions request uses messages, not a plain prompt; its chat response parser also differs from Responses. Permission errors depend on the account and endpoint. Muse Wonder Full access belongs to Muse Code, not to a public API plan upgrade.

Rate Limiting

For a 429 response, use bounded exponential backoff with random jitter. When Retry-After is present, wait at least that long. A retry policy needs a maximum attempt count and delay, not an infinite loop. Sending retries consumes capacity and can increase cost.

Timeout and Server Errors

Client timeouts, gateway timeouts, and backend failures have different causes. Long reasoning requests can exceed a client’s chosen timeout. A supported streaming or background mode can change request handling, but those features depend on the selected endpoint. Retrying a generation request does not automatically make it idempotent and may create another billable attempt.

Account or Regional Availability

Service terms, account permissions, and availability restrictions still apply. The public model listing does not guarantee access in every jurisdiction or remove regional restrictions. Diagnosis comes from the actual service response and account status, not from an assumed waitlist-bypass mechanism.

Using Muse Wonder with an OpenAI-Compatible SDK

GPT Proto’s documented Chat Completions interface can be used with an OpenAI-compatible client. The SDK version of the text request is:

import os
from openai import OpenAI
client = OpenAI(
    api_key=os.environ["GPTPROTO_API_KEY"],
    base_url="https://gptproto.com/v1",
)
response = client.chat.completions.create(
    model="muse-wonder-1.0",
    messages=[
        {"role": "user", "content": "Explain three risks in a database migration."}
    ],
)
print(response.choices[0].message.content)

The example requires the openai package. The key is passed explicitly because GPTPROTO_API_KEY is a custom environment-variable name; the OpenAI SDK’s default key variable is not the one used here.

A same-protocol compatible text call retains the core messages structure. A move from Meta Responses to GPT Proto Chat Completions also changes input to messages and changes output parsing. Provider-specific reasoning, tool, streaming, and multi-turn state features can require additional handling.

GPT Proto’s shared key and balance consolidate supported model access. They do not guarantee identical feature coverage, immediate account approval, worldwide access, or a public Muse Wonder Full route.

Muse Wonder on GPT Proto: Integration and Billing

GPT Proto brings Muse Wonder 1.0 into a shared model catalog for coding, reasoning, and agent applications. The same platform key and credit balance can access supported models from multiple providers, without maintaining a separate GPT Proto balance for each model.

The Muse Wonder model page connects model capabilities to its platform listing. GPT Proto pricing describes shared-balance billing and current platform terms. Hosted access does not include downloadable weights or on-premises deployment.