Getting started with Meta Muse in Python takes only a few lines of code, because Meta’s Model API speaks the same protocol as OpenAI’s. Knowing what you get for your money takes a bit longer. In this tutorial, you’ll call Muse Spark and the open-weights Muse Glimmer, stream a conversation, send an image, run a tool call, and parse typed output, with real timings and costs from the test runs.
The Muse models are Meta’s family of AI models for developers. Muse Spark is a reasoning large language model (LLM) that you call through the Meta Model API. Muse Glimmer is a 30-billion-parameter model whose weights you can download. Meta also uses the name Muse for a consumer app and a gadget, so the next section sorts out which is which.
By the end of this tutorial, you’ll understand that:
- Muse on its own is Meta’s consumer AI agent, which has no public API, while the Muse models are what you call from Python.
- You can reach Muse Spark through Meta’s own endpoint or through OpenRouter, which charges the same token prices.
- Reasoning is always on, but lowering the effort to
"minimal"cut latency by more than half and cost by about 60 percent in this tutorial’s test, without losing accuracy. - Muse Spark handles images, tool calls, and structured output through the standard OpenAI request format.
- Hosted Muse Glimmer answered the same test question for about one-eighth of Spark’s cost, and its Apache 2.0 license allows commercial use.
To decide where to start, find your situation in this table:
| Your situation | Recommendation |
|---|---|
Already use the openai package and want a hosted reasoning model with a 1M-token context |
Muse Spark through the Meta Model API or OpenRouter |
| Want open weights that you can host on your own hardware under a permissive license | Muse Glimmer with Ollama or a hosted provider |
| Want a personal assistant that sends emails and shops for you, and don’t plan to write code | The Muse app |
The next section untangles the Muse names.
Free Bonus: LLM APIs and MCP Cheat Sheet
Get an LLM APIs and MCP Cheat Sheet (PDF) and keep API calls, structured outputs, tool calling, agent loops, and MCP servers at hand on one page:
Take the Quiz: Test your knowledge with our interactive “Get Started With Meta Muse in Python: Spark and Glimmer” quiz. You’ll receive a score upon completion to help you track your learning progress:
Interactive Quiz
Get Started With Meta Muse in Python: Spark and GlimmerCheck your grasp of calling Muse Spark from Python, from reasoning tokens and images to tool calls, typed output, and the open Muse Glimmer.
Muse Models vs the Muse Agent and Muse Charm
Meta uses the name Muse for developer models, a consumer agent, and an upcoming gadget, and you access each one in a different way.
The Muse models are developer products: Muse Wonder, Muse Spark, Muse Ember, Muse Glimmer, Muse Code, Muse Image, and Muse Voice Transcribe. You call the hosted ones through the Meta Model API with an API key and pay for what you use. Glimmer is the exception, because Meta publishes its open weights instead of hosting it.
Muse on its own is Meta’s personal AI agent. Meta introduced it on September 8, 2026 as an agent that “proactively helps with people’s goals and suggests ideas.” You reach it through iOS and Android apps, the web at muse.ai, WhatsApp, and a Mac desktop app. For now, it’s available only in the US.
The agent sends emails, books travel, and shops through connectors such as Instacart. It’s free up to a weekly usage limit, and the Power and Maximum plans cost $20 and $100 a month. Meta says the agent is powered by “Muse Spark, Meta’s most capable model to date, built for real-world agentic work,” without naming a version.
Muse Charm is the gadget. Meta announced it at Connect on September 23, 2026, and promises only “more to share later this year” in its Connect recap. It hasn’t shipped and has no price. Press reports describe a keychain-sized device with a two-inch touchscreen and 5G, but sources disagree about its camera, so treat these specs as provisional.
Muse Gadgets lets you build your own hardware for Muse. On October 2, 2026, Meta open-sourced the Muse Gadget SDK under Apache 2.0, with firmware for ESP32 boards and a Linux SDK for machines such as a Raspberry Pi. To pair a device, you create an SDK token at gadgets.muse.ai and turn on Developer mode in the Muse app.
The Linux SDK is the part for Python developers. It’s a Python package called musegadget that needs Python 3.9 or newer. It isn’t on PyPI, so you install it with the repository’s install.sh script. Once your machine is paired, Muse can run commands on it, and you can add your own commands in Python. Scripts on the machine can also post into your Muse chat with musegadget send-user-msg.
The three products differ mostly in how you can reach them:
| Muse models | Muse agent | Muse Charm | |
|---|---|---|---|
| What it is | Hosted and open-weights models | Personal AI agent app | Pocket device for talking to Muse |
| Status | Model API generally available since Connect 2026, Glimmer and Muse Spark Open weights public | Live in the US since September 8, 2026 | Announced, not released |
| Account and billing | Model API team account, payment card, usage-based billing | Meta account, Free, Power, or Maximum plan | No price announced |
| Data terms | Data from the standard tier isn’t used for training | Not shared with ads systems, model training is opt-out | Not announced |
| Python access | Full API through the openai package |
No public API. Reviewed connectors, or a Muse Gadget paired to your own account | None, but you can build your own with Muse Gadgets |
The consumer agent has no public API that you can call with a key the way you call the Model API. A paired gadget only reaches your own Muse. To reach other people’s Muse agents, you submit an existing Model Context Protocol (MCP) server or an API to the Muse Connector Platform. Meta reviews it for “functional, security, and legal requirements” before it appears in Muse’s directory.
Meta’s developer documentation doesn’t tie a Power or Maximum plan to Model API usage, so expect to pay for the app and the API separately.
Older products called Muse, such as the InteraXon meditation headband, Microsoft’s gameplay model, and Google’s text-to-image research, are unrelated.
Get Started With Meta Muse in Python
As of November 2026, Meta’s developer lineup includes these products:
| Product | API ID | Weights | Price |
|---|---|---|---|
| Muse Wonder 1.0 (preview) | muse-wonder-1.0 |
Closed | $4.00 input and $20.00 output per 1M tokens |
| Muse Spark 1.3 | muse-spark-1.3 |
Closed | $1.25 input and $4.25 output per 1M tokens |
| Muse Spark Open | Not on the Model API | Open, Muse Model License | Free to self-host on a multi-GPU server, or through hosted providers |
| Muse Ember 1.0 | muse-ember-1.0 |
Closed | $0.10 input and $0.50 output per 1M tokens for requests up to 200K tokens |
| Muse Glimmer 30B | Not on the Model API | Open, Apache 2.0 | Free to self-host, or from $0.30 input and $1.10 output per 1M tokens hosted |
| Muse Code | Command-line tool muse |
Closed | API rates, or plans from $5 a month |
| Muse Image | muse-image-1.0 |
Closed | $0.01 per image |
| Muse Voice Transcribe | muse-voice-transcribe-1.0 |
Closed | $0.18 per hour of audio |
Meta’s models page recommends Spark 1.3 for new work, and it’s the model you’ll use in this tutorial. It has a 1M-token context window. The prices come from Meta’s pricing page and, for the hosted Glimmer, from OpenRouter.
Meta calls Muse Wonder its most capable model. Muse Ember is cheaper and meant for high-volume work, such as sub-agent tasks and routing. Both accept the same requests as Spark, so you can try either one on Meta’s endpoint by changing the model ID to muse-wonder-1.0 or muse-ember-1.0. Neither model was tested for this tutorial.
The direct route is a Meta Model API key from dev.meta.ai. You must be 18 or older, be in a supported country, and add a payment card before your first request. Billing is pay-as-you-go with no hard spending cap.
The second route is OpenRouter, which forwards Spark requests to Meta at the same token prices. This tutorial’s code ran through OpenRouter on October 5, 2026, because one key covers both Spark and a hosted Glimmer. At the end of this section, you’ll see how to switch to Meta’s endpoint.
To follow along, you need an OpenRouter API key and a little credit on the account. All the examples in this tutorial together cost well under a dollar. If you don’t have a key yet, then How to Use the OpenRouter API walks you through creating one. Next, create a virtual environment, install the pinned packages, and set your key. Select your operating system to see the matching commands:
Version 3.24.0 of openai requires Python 3.10 or newer, even though Meta’s Quickstart still lists Python 3.9.
Meta calls the Responses API “the recommended default for new work,” so your first request uses client.responses.create(). Create a file named first_call.py with the following content:
first_call.py
import os
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
response = client.responses.create(
model="meta/muse-spark-1.3",
input="In one sentence, what is a Python list?",
)
print(response.output_text)
usage = response.usage
details = usage.output_tokens_details
print(f"\nReasoning tokens: {details.reasoning_tokens}")
print(f"Total output tokens: {usage.output_tokens}")
print(f"Cost (USD): {usage.cost}")
You point the standard OpenAI client at OpenRouter’s base URL and prefix the model ID with meta/. The .usage attribute reports how many output tokens went into reasoning, and .cost is an OpenRouter extra with the price in US dollars. Go ahead and run the script:
(.venv) $ python first_call.py
A Python list is an ordered, mutable collection of items enclosed in square
⮑ brackets that can hold elements of different data types.
Reasoning tokens: 446
Total output tokens: 524
Cost (USD): 0.00224825
Congratulations, you’ve made your first Muse Spark call! Your wording and numbers will differ from run to run. Of the 524 output tokens, 446 were reasoning tokens that you never see. That’s about 85 percent of the output for a one-sentence answer.
Muse Spark always reasons before it answers, and those hidden tokens count toward the output limit you set with max_output_tokens on the Responses API or max_completion_tokens on Chat Completions. You pay for them at the output rate. Set the limit too low, and reasoning can use it up before any visible text appears.
You can’t switch reasoning off. An effort level of "none" returns an HTTP 400 error on Muse Spark, and the lowest level it accepts is "minimal". You’ll put "minimal" to the test in the next section.
Once you have a Meta Model API key, four changes in first_call.py move your request to Meta’s own endpoint:
first_call.py
client = OpenAI(
base_url="https://api.meta.ai/v1",
api_key=os.environ["MODEL_API_KEY"],
)
response = client.responses.create(
model="muse-spark-1.3",
input="In one sentence, what is a Python list?",
)
The highlighted lines swap in Meta’s base URL, your MODEL_API_KEY, and the model ID without its prefix. Remove the line that prints usage.cost as well, because that field only exists on OpenRouter. These changes follow Meta’s Quickstart, but they weren’t tested for this tutorial.
Stream Muse Spark and Tune Its Reasoning Effort
A chat app sends the whole conversation with every request, and streaming lets you show the reply while it arrives. The remaining Spark examples use the Chat Completions API. Meta supports it as a drop-in replacement for existing OpenAI code, and these examples were tested with it through OpenRouter. Create chat_stream.py:
chat_stream.py
1import os
2import time
3
4from openai import OpenAI
5
6client = OpenAI(
7 base_url="https://openrouter.ai/api/v1",
8 api_key=os.environ["OPENROUTER_API_KEY"],
9)
10
11messages = [
12 {"role": "system", "content": "You're a concise Python tutor."},
13 {"role": "user", "content": "What does enumerate() do?"},
14 {"role": "assistant", "content": "It pairs each item with its index."},
15 {"role": "user", "content": "Show me a three-line example."},
16]
17
18start = time.perf_counter()
19first_token_at = None
20stream = client.chat.completions.create(
21 model="meta/muse-spark-1.3", messages=messages, stream=True
22)
23for chunk in stream:
24 text = chunk.choices[0].delta.content if chunk.choices else None
25 if text:
26 first_token_at = first_token_at or time.perf_counter() - start
27 print(text, end="", flush=True)
28
29total = time.perf_counter() - start
30first = f"{first_token_at:.1f} s" if first_token_at else "none"
31print(f"\n\nFirst token: {first}, total: {total:.1f} s")
Here’s what the main parts of the script do:
- Lines 11 to 16 hold the conversation history, which you resend in full with every request. The system message sets the tone, and Meta treats
systemat the same level as its preferreddeveloperrole. - Lines 20 to 22 request a stream with
stream=True, so you get an iterator of chunks instead of one finished response. - Lines 23 to 27 print each piece of text as it arrives and record when the first one shows up.
Run the script and watch how long the first token takes:
(.venv) $ python chat_stream.py
items = ['a', 'b']
for i, x in enumerate(items):
print(i, x)
First token: 33.8 s, total: 34.1 s
Spark sometimes wraps the code in a Markdown code fence, so your output may include extra fence lines. Across four runs, the first token arrived after 11.5 to 33.8 seconds, with a median of about 15 seconds. The rest of the answer followed within half a second.
Spark finishes its reasoning before it streams any text, so streaming barely helps short answers at the default effort. In two runs of a shorter, single-question version with reasoning_effort="minimal", the first token arrived after 1.9 and 3.9 seconds.
To test how "minimal" affects accuracy, ask a question with one checkable answer. October 2026 has 22 weekdays. Save this script as effort.py:
effort.py
import os
import time
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
prompt = "How many weekdays are in October 2026? Reply with just the number."
for effort in ["minimal", None]:
options = {"reasoning_effort": effort} if effort else {}
start = time.perf_counter()
response = client.chat.completions.create(
model="meta/muse-spark-1.3",
messages=[{"role": "user", "content": prompt}],
**options,
)
elapsed = time.perf_counter() - start
usage = response.usage
print(
f"{effort or 'default':>8}: "
f"answer={response.choices[0].message.content!r} "
f"reasoning={usage.completion_tokens_details.reasoning_tokens} "
f"time={elapsed:.1f}s cost=${usage.cost:.5f}"
)
The loop sends the same prompt once with reasoning_effort="minimal" and once without it, which lets Spark pick its own level. On the Responses API, the same setting goes in reasoning={"effort": "minimal"}. Run the comparison:
(.venv) $ python effort.py
minimal: answer='22' reasoning=228 time=3.6s cost=$0.00104
default: answer='22' reasoning=526 time=6.2s cost=$0.00238
Spark answered correctly at both settings in all three runs, and the medians show the difference:
| Setting | Correct | Reasoning tokens | Latency | Cost |
|---|---|---|---|---|
"minimal" |
3 of 3 | 228 | 3.7 s | $0.00104 |
| Default | 3 of 3 | 585 | 8.3 s | $0.00270 |
On this prompt, "minimal" cut latency by more than half and cost by about 60 percent without losing accuracy. It still spent over 200 reasoning tokens, though. Test lower effort levels against your own prompts before you rely on them.
Add Vision, Tools, and Typed Output
Muse Spark can read images, ask your code to run functions, and return JSON that matches a schema. All three features use the standard OpenAI request format, so code you’ve written for other providers carries over with few changes. Each subsection below runs one short script against Muse Spark.
Ask Muse Spark About an Image
Save the bar chart below as downloads.png in the folder that you run the script from:

The chart shows made-up monthly downloads for a package, from 1,240 in January to 2,630 in June. The script sends it to Spark as a base64 data URL:
vision.py
import base64
import os
from pathlib import Path
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
image = base64.b64encode(Path("downloads.png").read_bytes()).decode()
question = (
"List each month's downloads as 'Mon: value', one per line. Then name"
" the month with the biggest increase over the previous month."
)
response = client.chat.completions.create(
model="meta/muse-spark-1.3",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": question},
{
"type": "image_url",
"image_url": {"url": f"data:image/png;base64,{image}"},
},
],
}
],
)
print(response.choices[0].message.content)
print(f"\nCost (USD): {response.usage.cost}")
The message’s content is a list that combines a text part with an image_url part. Run the script:
(.venv) $ python vision.py
Jan: 1,240
Feb: 1,580
Mar: 1,410
Apr: 2,050
May: 1,870
Jun: 2,630
Biggest increase: Jun
Cost (USD): 0.00641475
Spark read all six values and picked June, whose jump of 760 beats April’s 640. It was correct in all six runs, four on a 600-pixel version of the chart and two on the larger one shown above. Larger images used more tokens and cost about $0.006 per request instead of $0.004. Because each value is printed on its bar, this test mostly checks reading and arithmetic.
Let Muse Spark Call a Function
With tool calling, the model asks your code to run a function and then uses the result in its answer. Below, get_weather() returns canned data, so the weather never changes between runs. Start tools.py with the client, the function, and its schema:
tools.py
1import json
2import os
3
4from openai import OpenAI
5
6client = OpenAI(
7 base_url="https://openrouter.ai/api/v1",
8 api_key=os.environ["OPENROUTER_API_KEY"],
9)
10
11def get_weather(city):
12 """Return canned weather data so every run is reproducible."""
13 return {"city": city, "temperature_c": 18, "conditions": "light rain"}
14
15tools = [
16 {
17 "type": "function",
18 "function": {
19 "name": "get_weather",
20 "description": "Get the current weather for a city.",
21 "parameters": {
22 "type": "object",
23 "properties": {"city": {"type": "string"}},
24 "required": ["city"],
25 },
26 },
27 }
28]
29messages = [{"role": "user", "content": "Do I need an umbrella in Lisbon?"}]
The tools list describes get_weather() in the standard OpenAI format, and Spark decides on its own when to request a call. Add the request loop to the end of the file:
tools.py
30response = client.chat.completions.create(
31 model="meta/muse-spark-1.3", messages=messages, tools=tools
32)
33message = response.choices[0].message
34messages.append(message)
35
36for tool_call in message.tool_calls or []:
37 arguments = json.loads(tool_call.function.arguments)
38 result = get_weather(**arguments)
39 print(f"Tool call: {tool_call.function.name}({arguments})")
40 messages.append(
41 {
42 "role": "tool",
43 "tool_call_id": tool_call.id,
44 "content": json.dumps(result),
45 }
46 )
47
48final = client.chat.completions.create(
49 model="meta/muse-spark-1.3", messages=messages, tools=tools
50)
51print(final.choices[0].message.content)
In lines 30 to 34, you send the question with the tools and append Spark’s reply. Lines 36 to 46 run each requested function and append its result as a tool message. The or [] in line 36 covers replies without a tool call. The second request in lines 48 to 50 lets Spark write the final answer. Run the script:
(.venv) $ python tools.py
Tool call: get_weather({'city': 'Lisbon'})
Yes — you need an umbrella in Lisbon right now.
It's currently **18°C with light rain**, so I'd bring one if you're heading
⮑ out.
The full loop worked in all four runs. In one run, the tool-call message also carried text, so don’t assume that .content is empty when .tool_calls is set. Meta’s API accepts only tool_choice="auto", which means you can’t force Spark to call a specific tool.
Parse Typed Output With Pydantic
For structured output, you describe the shape you want as a Pydantic model and let the SDK turn it into a schema. Create structured.py:
structured.py
import os
from datetime import date
from openai import OpenAI
from pydantic import BaseModel
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
class Event(BaseModel):
name: str
city: str
start_date: date
attendees: int
topics: list[str]
text = (
"PyCon Lisboa runs from 12 to 14 March 2027. Organizers expect about"
" 850 people, with talks on typing, packaging, and free-threading."
)
completion = client.chat.completions.parse(
model="meta/muse-spark-1.3",
messages=[
{"role": "system", "content": "Extract the event details."},
{"role": "user", "content": text},
],
response_format=Event,
)
message = completion.choices[0].message
if message.parsed is None:
raise SystemExit(f"No event parsed: {message.refusal}")
event = message.parsed
print(repr(event))
print(event.start_date.strftime("%A, %B %d, %Y"))
The .parse() method converts Event into a JSON schema, sends it as response_format, and parses the reply into a validated Event object. If the model refuses, then .parsed is None, so the script stops with the refusal message. Meta’s documentation shows the older client.beta path, which 3.24.0 still accepts. Run the script:
(.venv) $ python structured.py
Event(name='PyCon Lisboa', city='Lisboa',
⮑ start_date=datetime.date(2027, 3, 12), attendees=850,
⮑ topics=['typing', 'packaging', 'free-threading'])
Friday, March 12, 2027
The .start_date attribute is a real datetime.date, so .strftime() works on it. All four runs printed identical output. Spark kept the Portuguese spelling “Lisboa” from the event name, so ask for normalized values in the system prompt if you need them.
AI Agent From Scratch Live Course: Curious what happens when you let the model keep calling tools until it has an answer? In Real Python’s Build an AI Agent From Scratch in Python live course, you write the agent loop by hand around a single tool call like this one, then recognize every piece of it in the tools you already use. Join the waitlist to hear about the next dates.
Run the Open-Weights Muse Glimmer
Muse Glimmer is a 30-billion-parameter dense model, which uses all its parameters for each token. It takes text and images as input and writes text. Meta publishes its weights on Hugging Face as Muse-Glimmer-30B under the Apache 2.0 license, and you don’t need approval to download them. Glimmer doesn’t run on the Meta Model API, so you either host it yourself or rent it from a provider.
Meta has also released Muse Spark Open, a version of Spark with downloadable weights and 816 billion parameters. Its smallest download, a mostly 4-bit build, is about 537 GB and runs on a server with four NVIDIA Blackwell GPUs.
OpenRouter serves Glimmer through three hosts, so you can try it with the same client as before. Create glimmer.py:
glimmer.py
import os
import time
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=os.environ["OPENROUTER_API_KEY"],
)
start = time.perf_counter()
response = client.chat.completions.create(
model="meta/muse-glimmer-30b",
messages=[
{"role": "user", "content": "In one sentence, what is a Python list?"}
],
)
elapsed = time.perf_counter() - start
print(response.choices[0].message.content or "")
details = response.usage.completion_tokens_details
reasoning = details.reasoning_tokens if details else None
print(f"\nServed by: {response.provider}")
print(f"Latency: {elapsed:.1f} s")
print(f"Reasoning tokens: {reasoning}")
print(f"Total output tokens: {response.usage.completion_tokens}")
print(f"Cost (USD): {response.usage.cost}")
The request matches your Chat Completions calls to Spark, apart from the model ID. The .provider attribute is another OpenRouter extra that names the host. The or "" and the check on details guard against hosts that leave out content or token details. Run it:
(.venv) $ python glimmer.py
A Python list is a built-in mutable ordered collection that can hold items of
⮑ any type and is accessed by index.
Served by: Phala
Latency: 4.8 s
Reasoning tokens: 158
Total output tokens: 187
Cost (USD): 0.00020864
Across four runs, Glimmer answered in 4.8 to 7.8 seconds at a median cost of $0.00029. In matching test runs through Chat Completions, Spark charged $0.0024 for the same question, so Glimmer was about eight times cheaper here, and its answer was as good.
Glimmer reasons too, at high strength by default. According to Meta’s Glimmer prompting guide, you can pick low, medium, high, or xhigh with a line such as Reasoning strength: low in the system prompt. That setting wasn’t verified through OpenRouter’s hosts.
You can run Glimmer on your own machine with Ollama, which provides a muse-glimmer model with an 18 GB default download. Meta measured its own 17 GB quantized build, which stores the weights at reduced precision, at 19.0 GiB of graphics memory with the full context, so a build of this size fits a 24 GB graphics card. Full precision needs about 64 GB. Once you’ve installed Ollama, download the model and chat with it in your terminal:
$ ollama run muse-glimmer
To call the model from Python, install the ollama package:
(.venv) $ python -m pip install ollama==0.6.3
The package talks to your local Ollama server. Save this script as glimmer_local.py:
glimmer_local.py
from ollama import chat
# Needs a running Ollama server and `ollama pull muse-glimmer` (about 18 GB)
response = chat(
model="muse-glimmer",
messages=[
{"role": "user", "content": "In one sentence, what is a Python list?"}
],
)
print(response.message.content)
The test machine had no GPU, so the local script wasn’t tested for this tutorial. For the complete local workflow, see How to Integrate Local LLMs With Ollama and Python.
Limitations to Know About
Spark handled every task here, and hosted Glimmer answered its test question well, but keep these limits in mind before you build with these models:
- Reasoning is always on: Spark reasons on every request, and the lowest effort is
"minimal". At the default effort, the first streamed token took about 12 to 34 seconds in these tests. - Some OpenAI parameters fail:
tool_choiceaccepts only"auto". The parametersstop,ngreater than one, andlogprobsreturn HTTP 400. - The contributor tier trains on your data: Model IDs ending in
-contributorcost $0.10 input and $0.20 output per 1M tokens because Meta may train on your prompts and completions. Only the model ID tells the tiers apart, so check it before every request. Meta’s terms forbid sending sensitive, confidential, or personal information to the contributor tier. - There’s no hard spending cap: The Model API offers an emailed spend alert, but you still pay for any usage above it.
- Some regions are excluded: Meta’s Geographic Use Policy blocks access in about 20 territories, including China, Russia, and Iran. Muse Image isn’t available in India.
- Spark’s open weights need a server: Muse Spark Open runs on four or more data center GPUs. Glimmer fits on a single graphics card.
- Spark trails the top models: On the Artificial Analysis leaderboard on October 5, 2026, Spark 1.3 scored 48 at
maxeffort and 45 atxhigh. Six other models scored higher, led by one at 58. Glimmer scored 17, well above the median of 8 for open-weights models of its size.
None of these limits blocks a prototype. Before production, plan around the slow first token, the missing spending cap, and the contributor tier model IDs.
Conclusion
Muse Spark is a good fit if you already work with OpenAI-style APIs and want a reasoning model with a 1M-token context, vision, tools, and typed output. It works best when your app can wait 10 seconds or more for a reply, or when "minimal" effort is good enough for your prompts. Muse Glimmer is the better pick if you want an Apache 2.0 model that you can host yourself or rent cheaply.
Keep the names apart, too: Muse is Meta’s consumer agent and Muse Charm its unreleased gadget, and neither has a public API.
In this tutorial, you’ve learned how to:
- Tell the Muse models apart from Meta’s consumer Muse agent and its gadgets
- Call Muse Spark with the
openaipackage through OpenRouter or Meta’s endpoint - Cut latency and cost with reasoning effort
- Send images, run tool calls, and parse structured output with Pydantic
- Try the open-weights Muse Glimmer through OpenRouter and set it up locally with Ollama
To keep going, browse Meta’s Model API documentation. To compare Meta Muse with another provider, read How to Use the Claude API in Python. For typed agents, try Pydantic AI. The LLM application development learning path ties these topics together.
Will you start with the hosted Spark or run Glimmer on your own GPU? Share what you plan to build in the comments below.
Free Bonus: LLM APIs and MCP Cheat Sheet
Get an LLM APIs and MCP Cheat Sheet (PDF) and keep API calls, structured outputs, tool calling, agent loops, and MCP servers at hand on one page:
Frequently Asked Questions
Now that you have some experience with Meta Muse in Python, you can use the questions and answers below to check your understanding and recap what you’ve learned.
These FAQs are related to the most important concepts you’ve covered in this tutorial. Click the Show/Hide toggle beside each question to reveal the answer.
No. Muse is Meta’s consumer AI agent with its own apps and subscription plans, and it has no public API that you can call with a key. The Muse models, such as Muse Spark and Muse Glimmer, are the developer products that you call from Python through the Meta Model API or run as open weights.
Yes. The Meta Model API is OpenAI-compatible, so you create an OpenAI client with Meta’s base URL or OpenRouter’s and pass a Muse model ID. Meta recommends the Responses API with client.responses.create() for new projects, and Chat Completions works too.
Muse Spark always reasons before it writes any visible text, and you can’t turn reasoning off. Passing reasoning_effort="minimal" shortens that thinking phase, which cuts both the wait for the first token and the cost of each request.
The contributor tier is a much cheaper version of Muse Spark that you select with a model ID ending in -contributor. Under its terms, Meta can train on the content you send, so keep private and customer data away from these model IDs.
Take the Quiz: Test your knowledge with our interactive “Get Started With Meta Muse in Python: Spark and Glimmer” quiz. You’ll receive a score upon completion to help you track your learning progress:
Interactive Quiz
Get Started With Meta Muse in Python: Spark and GlimmerCheck your grasp of calling Muse Spark from Python, from reasoning tokens and images to tool calls, typed output, and the open Muse Glimmer.