Meta Model API Guide

Meta launched its first frontier model API on July 9, 2026. The Meta Model API provides developer access to Muse Spark 1.1, a multimodal reasoning model built for agentic tasks. It is the first time Meta has offered a frontier model to developers for pay-as-you-go use (Meta).

Muse Spark 1.1 is a 1M-token-context agentic model that rivals GPT-5.5 and Opus 4.8 on agent benchmarks. It is strong on tool use, computer use across desktop and browser, coding on real codebases, and multimodal understanding. Meta positioned it as one-quarter the cost of flagship models from OpenAI and Anthropic (Meta).

This guide walks you through accessing the Meta Model API, authenticating your app, integrating via REST or SDK, and building agentic workflows. We cover pricing, rate limits, supported features, and the code you need to get started. By the end, you will be able to call the model and build agents using tool calling and structured output.

What Is the Meta Model API?

The Meta Model API is Meta's new developer platform for accessing Muse Spark 1.1, launched July 9, 2026, in public preview (Meta). It is Meta's first frontier model available to developers via a paid API.

The API is self-serve, with no waitlist or vetting. You sign up on the Meta Developer Console, claim $20 free credits, and start building immediately. The API supports standard HTTP calls and provides SDKs for popular languages.

Muse Spark 1.1 is designed for agentic work — tasks where the model needs to reason, call tools, and solve multi-step problems. It is strong on computer use, tool calling, parallel subagent delegation, and multimodal input (Meta).

• Platform: Meta Model API (public preview, US-only).
• Model: Muse Spark 1.1, a multimodal reasoning model for agentic tasks.
• Launched: July 9, 2026 by Meta.
• Pricing: $1.25 input / $4.25 output per million tokens, $20 free credits at signup.
• Access: self-serve, no waitlist, REST API and SDK support.
• Features: tool calling, structured output, computer use, parallel subagents, multimodal input.

Models Available on the Meta Model API

Muse Spark 1.1 is the primary model available on the Meta Model API as of July 2026 (Meta). It is the first and currently only frontier model Meta has released to developers.

Muse Spark 1.1 comes as a single model, not multiple tiers. You call the same model for all tasks and pay the same per-token rate: $1.25 input / $4.25 output (Meta).

Meta has not announced other models coming to the API in the near term. If you need multiple tiers or fallback options, you would use multiple APIs (Muse Spark 1.1 + Claude + GPT-5.6).

• Muse Spark 1.1: the primary model, available now via Meta Model API.
• No other models announced: Muse Spark 1.1 is the only frontier model available.
• Context window: 1 million tokens (Meta).
• Pricing: $1.25 input / $4.25 output per million tokens.
• Other models: use additional APIs if you need fallback models.

How to Access the Meta Model API

Access is straightforward and self-serve. Go to the Meta Developer Console, sign up with your email, and create an API key (Meta). You will receive $20 free credits at signup.

You need an active Meta developer account. Meta does not require vetting or approval — signup is immediate.

Once you have your API key, you can call the model via REST API or SDK. The API is compatible with OpenAI and Anthropic request formats for easier migration.

• Step 1: Go to the Meta Developer Console (developer.meta.com).
• Step 2: Sign up with your email (self-serve, no vetting).
• Step 3: Create an API key in the console.
• Step 4: Claim your $20 free credits at signup.
• Step 5: Start making API calls via REST or SDK.
• Requirement: US-based access only (public preview).

Authentication: API Key Management

The Meta Model API uses standard API key authentication. You create an API key in the Meta Developer Console and pass it in the Authorization header of every API request (Meta).

Keep your API key secret. Do not commit it to version control. Use environment variables or a secrets manager to store it securely.

Keys can be rotated or revoked in the console at any time. There is no automatic expiration date listed in the preview documentation.

• Authentication: Bearer token in the Authorization header.
• Format: Authorization: Bearer YOUR_API_KEY
• Creation: generate keys in the Meta Developer Console.
• Storage: use environment variables or a secrets manager, never hardcoded.
• Rotation: revoke old keys and create new ones anytime.
• Expiration: not documented in public preview (likely indefinite until revoked).

REST API: Making Your First Call

The Meta Model API uses standard HTTP POST requests. The endpoint is https://api.meta.ai/v1/messages (Meta).

The API is compatible with OpenAI's chat completions format, so the request body is familiar. You send an array of messages and receive a completion back.

Here is a minimal example to get started: a simple chat request to Muse Spark 1.1 asking it to explain a concept.

• Endpoint: https://api.meta.ai/v1/messages
• Method: POST
• Content-Type: application/json
• Authentication: Bearer token in Authorization header
• Request body: model name, messages array, and optional parameters (temperature, max_tokens, etc.).
• Response: JSON with the model's reply.

SDKs and Client Libraries

Meta provides OpenAI-compatible and Anthropic-compatible SDKs. This means you can use the familiar OpenAI Python client, JavaScript client, or Anthropic Python SDK with minimal changes (Meta).

The easiest path: use the OpenAI SDK by changing the base URL and model name. This works because Meta matched the API contract to OpenAI's format.

If you prefer Anthropic's format, the API supports that too. Use whichever SDK you are most comfortable with.

• OpenAI Python: pip install openai, then point to Meta's endpoint.
• OpenAI JavaScript: npm install openai, same setup.
• Anthropic Python: pip install anthropic, use the Anthropic SDK.
• Custom requests: use requests or any HTTP library for full control.
• No official Meta SDK: use the compatibility layer instead.

Tool Calling and Agentic Workflows

Muse Spark 1.1 excels at tool calling and agentic workflows. You define tools (functions), and the model decides when to call them and with what arguments. It can also call multiple tools in parallel (Meta).

Tool calling is central to agent design. The model reasons about what needs to be done, calls the right tools, uses the results, and decides the next step — all in one request.

Parallel tool calling is new: Muse Spark 1.1 can delegate to multiple subagents at once, speeding up complex workflows (Meta).

• Tool calling: define functions, let the model call them.
• Format: tools parameter in the API request with function definitions.
• Parallel execution: Muse Spark 1.1 can call multiple tools at once.
• Structured output: use tool calling combined with schemas for deterministic output.
• Computer use: tool calling works with browser automation and desktop control.
• Example tools: web search, database queries, code execution, file operations, APIs.

Structured Output and Response Formats

Muse Spark 1.1 supports structured output via JSON schema. This lets you force the model to return JSON in a specific format, which is useful for parsing and validation (Meta).

Instead of free-form text, you provide a schema and the model adheres to it. For example, you can ask the model to always return a JSON object with specific fields.

Structured output is especially useful for extracting data from text, parsing forms, or building workflows where downstream code expects predictable output shapes.

• Structured output: provide a JSON schema, get JSON back.
• Use cases: data extraction, form parsing, API response generation.
• Validation: the model ensures the output matches your schema.
• Format: response_format parameter in the API request.
• Reliability: the model will not hallucinate fields not in the schema.

Computer Use: Desktop, Browser, and Mobile Workflows

Muse Spark 1.1 can understand and interact with computer screens. You feed it a screenshot, and it can describe what it sees, click buttons, type text, and navigate applications (Meta).

Computer use works across desktop, browser, and mobile. The model can operate a web app, a desktop tool, or interact with a mobile interface.

This is designed for automating complex workflows that humans would normally do manually — filling out forms, navigating multi-step processes, scraping visual data.

• Input: screenshots (base64-encoded images in the API request).
• Output: actions (click, type, navigate, scroll) or observations.
• Platforms: desktop, web browser, mobile.
• Use cases: form filling, data scraping, workflow automation, visual inspection.
• Accuracy: the model improves over multiple interaction steps.

Multimodal Input: Text, Images, Audio, and Code

Muse Spark 1.1 is multimodal — it reads text, images, audio transcripts, and code. You can send any mix of these in a single request (Meta).

Images: send base64-encoded images or URLs. The model reads diagrams, charts, screenshots, and photographs.

Code: paste code blocks, and the model understands syntax, context, and best practices. This is useful for code review and debugging.

Audio: not natively supported, but you can send transcripts as text. This is useful for analyzing podcast content or meeting notes.

• Text input: standard prompt text.
• Images: base64-encoded or URL-based in the messages array.
• Code blocks: paste code, and the model provides context-aware analysis.
• Audio: send transcripts as text (not native audio files).
• Combined: mix all types in a single message for rich reasoning.

Rate Limits and Usage Quotas

The Meta Model API enforces rate limits to prevent abuse. Public preview rate limits are conservative but have not been fully detailed in the developer documentation as of July 2026 (Meta).

Token limits: your monthly usage is tracked. Once you use your credits or reach a usage threshold, you can still make calls — they are billed to your account.

Request rate: there is likely a per-minute or per-second limit on the number of requests, but the exact number is not published in the public preview docs.

Best practice: implement exponential backoff and respect 429 (rate limit) responses.

• Token usage: tracked in real-time in the console.
• Billing: starts after $20 free credits are exhausted.
• Rate limits: not fully documented in public preview.
• Error handling: implement retry logic with exponential backoff.
• Monitoring: check the console for real-time usage stats.

Regional Availability and Access Restrictions

The Meta Model API is available to US developers only in public preview (Meta). Non-US access is not available as of July 2026.

If you are based outside the US, you cannot create an account or access the API during public preview. Meta will likely expand availability over time.

This restriction is temporary and specific to the preview period. Once the API exits preview, availability may expand.

• Availability: US-only in public preview.
• Non-US access: not available as of July 2026 (Meta).
• Planned expansion: likely after preview ends, but not officially announced.
• Workaround: use Muse Spark 1.1 through the Meta AI app instead (available in more regions).

Getting Started: Code Example

Here is a working Python example to call Muse Spark 1.1 via the Meta Model API. Install the OpenAI SDK (Meta uses the OpenAI-compatible format), then run the code.

This example sends a simple text request to the model and prints the response. You can build on this to add tool calling, structured output, or images.

• Install: pip install openai
• Authenticate: set your MUSE_SPARK_API_KEY environment variable
• Call the model: use the OpenAI client with Meta's endpoint
• Handle responses: the response object matches OpenAI's format

Best Practices and Recommendations

Keep API keys secure: use environment variables or a secrets manager. Never hardcode or commit keys.

Use structured output for deterministic results: if you need JSON in a specific format, provide a schema and the model will adhere to it.

Implement retry logic: network calls can fail. Use exponential backoff and respect rate-limit responses.

Monitor token usage: check the console regularly to track spend and avoid surprise bills.

Test with the free $20 credits first: use them to pilot your workflow before committing spend.

Consider tool calling for agents: instead of asking the model to generate text, give it tools and let it solve multi-step problems.

• Security: API keys in environment variables, never hardcoded.
• Structured output: use schemas for predictable, parseable responses.
• Retries: implement exponential backoff for transient failures.
• Monitoring: track token usage and cost in the console.
• Testing: use the $20 free credits to pilot before production.
• Agents: use tool calling and structured output for multi-step workflows.