Muse Spark 1.1 is Meta's multimodal reasoning model, built for agentic tasks. It accepts an unusually broad range of inputs — text, images, video, audio, and PDF documents — and returns text, reasoning natively across modalities within a 1M-token context window. It supports configurable reasoning effort and native tool calling, making it well suited for multimodal agents, deep research over mixed media, and long-context analysis. With efficient inference and a broad input surface, Muse Spark 1.1 targets workloads that combine documents, screenshots, recordings, and video with text — from analyzing long reports and media libraries to driving multi-step agentic pipelines that must reason over more than just text.
Meta Muse Spark 1.1 is a multimodal large language model from Meta that can process text, images, video, files, and audio in a single context. Its context window is 1,048,576 tokens – roughly 1…
Muse Spark 1.1’s main strength is its ability to process and reason over a very long context (1,048,576 tokens) that includes multiple media types. It can analyze a 500-page PDF with embedded images, or a 2-hour video together with its audio transcript, in one go. This eliminates the need for chunking or separate models. The model is also capable of following detailed instructions and performing complex reasoning tasks such as summarization, question answering, and entity extraction across mixed-media inputs.
Use Muse Spark 1.1 when your task genuinely benefits from a large context window and multiple input modalities. If you only need short text generation (e.g., 1,000 tokens) and no images or audio, a cheaper text-only model with smaller context is more cost-effective. However, for end-to-end multimodal understanding – like summarizing a video with its visual details and audio – Muse Spark 1.1 can reduce system complexity and latency by avoiding multiple model calls.
Best use cases include legal document review with scanned PDFs and audio depositions, medical record analysis combining images and notes, video content moderation (analysing frames and audio), and academic research paper comprehension with figures and tables. Any scenario where a single prompt must cover a long, heterogeneous input benefits from this model. It also works well for building multimodal RAG pipelines where the context window can hold entire documents plus relevant images.
The model is not optimized for extremely fast, low-latency responses – large contexts increase processing time. It also does not support streaming output (at the time of writing). For tasks that require real-time interaction (e.g., chatbots), smaller models are preferable. Additionally, the cost per token is higher than many text-only models, so for pure text tasks it may be overkill. The model’s performance on benchmark tasks has not been disclosed; users should evaluate on their own data.
Meta has not publicly released benchmark scores for Muse Spark 1.1. Users are advised to run their own evaluations on representative tasks. The model’s large context and multimodal input suggest it should perform well on document understanding and visual QA, but no standardized numbers exist in the provided facts. OrcaRouter does not provide additional benchmarking data; performance is as delivered by Meta.
Processing 1,048,576 tokens of multimodal data is computationally expensive. Latency depends on input length, the number of images or video frames, and output token count. For very long contexts, expect minutes rather than seconds. OrcaRouter does not publish latency benchmarks for this model. Users should test with realistic workloads to determine acceptable response times for their application.
The main limitation is the lack of publicly available performance data, making it hard to compare against alternative models without custom testing. The model also does not support output modalities beyond text – it cannot generate images or audio. Additionally, the 1M token context is theoretical; real-world accuracy may degrade at maximum length for some tasks. As with all large models, results can be inconsistent across different prompt styles.
Due to the potential for high latency when processing large multimodal contexts, this model is not recommended for real-time applications like interactive chatbots or live transcription. It is better suited for batch processing, offline analysis, and asynchronous workflows where a few seconds to minutes of processing time is acceptable. For low-latency needs, consider smaller, faster models available through OrcaRouter.
Pricing is $1.25 per 1 million input tokens and $4.25 per 1 million output tokens. Tokens are counted according to the model’s tokenizer; input tokens include all text, image tokens (typically 170 tokens per image), video frames, audio, and file content. Output tokens are generated text. OrcaRouter passes through the provider rate with zero markup, so the cost is exactly these figures. There are no additional platform fees.
Because the model supports up to 1M input tokens, a single call with a long document can cost $1.25 or more in input tokens alone. For short inputs (e.g., a few thousand tokens), the cost is much lower – around $0.0013 for 1,000 input tokens. The trade-off is that for tasks requiring only a small context, cheaper models with lower per-token rates are more economical. For large-context multimodal tasks, this model may be more cost-effective than splitting work across several models.
OrcaRouter does not currently offer caching or volume discounts for Muse Spark 1.1. Pricing is pay-as-you-go per token. There is no tiered pricing based on usage volume. Users should monitor their token consumption, especially for large multimodal inputs, to manage costs. The zero-markup policy ensures that the cost reflects the underlying provider price exactly.
No. OrcaRouter charges only for token consumption at the provider rate with zero markup. There are no request fees, no monthly minimums, and no surcharges for streaming (though the model does not currently support streaming). The only cost is input tokens at $1.25/1M and output tokens at $4.25/1M. Users are responsible for any costs associated with encoding or transmitting media to the API (network bandwidth).
Use the OpenAI-compatible chat completions endpoint. Set base_url to https://api.orcarouter.ai/v1. In request body, set model to "meta/muse-spark-1.1". Include messages in standard OpenAI format. For multimodal content, use a message with role "user" and content as an array of parts: text, image_url, etc. Authentication is via API key provided by OrcaRouter. Example in Python using openai library: client = OpenAI(base_url='https://api.orcarouter.ai/v1', api_key='your-key').
The API supports standard parameters: max_tokens (output token limit), temperature (0-2, default 1), top_p (0-1), frequency_penalty, presence_penalty, stop sequences, and seed for deterministic outputs. The model does not support streaming or function calling at this time. The n parameter (number of completions) is also not supported – only one completion per request. The context window limit is 1,048,576 tokens total for input and output combined.
If you currently use another provider, change the base URL to https://api.orcarouter.ai/v1 and the model name to "meta/muse-spark-1.1". Obtain an OrcaRouter API key from the dashboard. The request body format is identical to OpenAI's API. Multimodal content (images, videos, files, audio) uses the same format as OpenAI’s vision endpoints. No other code changes are required. Test with a small request to confirm tokenization and costs.
At present, Muse Spark 1.1 does not support streaming. Requests are synchronous; the response is returned once generation completes. For long-context prompts, this may take a significant time. OrcaRouter may add streaming support in the future, but as of now only non-streaming is available. Asynchronous processing can be achieved by sending requests in parallel from your application.
Muse Spark 1.1’s context window of 1,048,576 tokens is among the largest available, competing with models from other providers. However, being a multimodal model, it is specifically designed to handle mixed inputs. Purely text-based large-context models may be cheaper per token for text-only tasks. The provided facts do not specify benchmark comparisons, so users should evaluate based on their own multimodal needs.
Smaller multimodal models (e.g., with 128K context) are faster and cheaper but cannot process as much information in a single call. Muse Spark 1.1 sacrifices speed and cost for the ability to ingest entire documents or long videos. For tasks that can be chunked, using a smaller model may be more efficient. The right choice depends on whether your application truly requires a one-shot processing of very large inputs.
Use a text-only model when your inputs contain no images, video, or audio. Text-only models with comparable context sizes are often cheaper per token. For example, if your task is summarising a 1M-token text document without any visual elements, a pure text model costing less than $1.25/1M input would be more cost-effective. Muse Spark 1.1’s pricing is competitive for multimodal tasks, but not for pure text.
OrcaRouter provides a unified OpenAI-compatible interface, while Meta’s direct API may use its own protocol. OrcaRouter adds zero markup, so the token cost is the same (assuming Meta charges the same rate). OrcaRouter may offer additional features like API key management, usage tracking, and load balancing across providers. The choice depends on whether you prefer a consistent API abstraction across multiple models.
OpenAI-compatible — keep the SDK you already use
https://api.orcarouter.ai/v1import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.orcarouter.ai/v1",
api_key=os.environ["ORCAROUTER_API_KEY"],
)
response = client.chat.completions.create(
model="meta/muse-spark-1.1",
messages=[{"role": "user", "content": "Hello"}],
)
print(response.choices[0].message.content)include_reasoningmax_tokensreasoningreasoning_effortrepetition_penaltyresponse_formatstructured_outputstemperaturetool_choicetoolstop_ktop_p| Input / 1M tokens | $1.25 |
| Output / 1M tokens | $4.25 |
| Cache read / 1M | $0.150 |
| Currency | USD |
Estimate based on list price
Estimate only — actual token counts depend on the provider's tokenizer.
What developers are saying this week
GET /api/public/models/meta/muse-spark-1.1Open @misc{orcarouter_muse_spark_1_1,
title = {Muse Spark 1.1 API},
author = {Meta},
year = {2026},
howpublished = {OrcaRouter},
url = {https://www.orcarouter.ai/models/meta/muse-spark-1.1}
}Meta. (2026). Muse Spark 1.1 API. OrcaRouter. https://www.orcarouter.ai/models/meta/muse-spark-1.1