Muse Spark 1.2 API Pricing

Muse Spark 1.2 API pricing follows the two-tier structure Meta announced 2026-08-05. Standard is $1.25 input / $0.15 cached input / $4.25 output per million tokens. Contributor is $0.10 input / $0.002 cached input / $0.20 output.

This page focuses on the API-caller view: full rate card, SDK compatibility notes, and the practical patterns for keeping API spend predictable.

For a general pricing overview, see the Muse Spark 1.2 pricing guide. This page is for teams writing integration code.

API Rate Card, Both Tiers

Muse Spark 1.2 API pricing is identical to the pricing published for Muse Code (which uses the same backing model).

Standard tier: $1.25 per million input tokens, $0.15 per million cached input tokens, $4.25 per million output tokens. Meta does not use Standard data.

Contributor tier: $0.10 per million input tokens, $0.002 per million cached input tokens, $0.20 per million output tokens. Meta uses Contributor prompts and outputs to improve their products.

• Standard: $1.25 in / $0.15 cached / $4.25 out per M
• Contributor: $0.10 in / $0.002 cached / $0.20 out per M
• Same model, tiers differ only in data-use
• Tier is a request-time choice

SDK and Library Compatibility

SDK compatibility details were not documented at launch — verify at https://developer.meta.com/ai/products/muse-code/. Do not assume OpenAI-SDK compatibility until Meta confirms it.

The install command for Muse Code (curl -fsSL https://dev.meta.ai/install.sh | bash) is the only formally documented client at launch. Direct HTTP API examples were not published in the announcement.

Teams building on Muse Spark 1.2 today should design a thin vendor abstraction so a future SDK swap is a one-file change.

• SDK details: not published — verify at vendor page
• Muse Code CLI is the documented client
• Do not assume OpenAI-SDK compatibility
• Vendor-abstract your client for easy swaps

Cost-Control Patterns

Cache-friendly prompts save real money. Cached input is $0.15 (Standard) or $0.002 (Contributor) per million tokens, so structure prompts with the shared context at the top.

Send only the diff or delta, not the full file, when a prior request has already cached the base context. Muse Code does this automatically; direct API callers do not.

For batch workloads, split traffic by sensitivity: sensitive requests go to Standard, non-sensitive requests go to Contributor. Route at your gateway, not at the caller.

• Cache-friendly prompt structure
• Send deltas, not full files, on cached-base requests
• Route sensitive vs non-sensitive at the gateway
• Meter and alert on tier-mismatched requests

Forecasting API Spend

A team of 5 engineers running Muse Spark 1.2 for 200 PR reviews and 400 targeted edits per month, on Standard, spends roughly $30-$80/month depending on cache hit rate.

The same workload on Contributor spends roughly $2-$6/month. The gap is why the Contributor tier will pull open-source contributors first.

When we run our own trend-pass routine across the portfolio, we forecast API spend before we ship, not after. Do the same before flipping any team over.

• 5-eng team, 200 PRs + 400 edits/mo
• Standard: ~$30-$80/mo (cache-dependent)
• Contributor: ~$2-$6/mo
• Forecast before flipping teams, not after

How to use Muse Spark 1.2

You do not host Muse Spark 1.2 yourself — you use it through a tool, so "getting started" really means choosing the right one.

The fastest way to put Muse Spark 1.2 to work day to day is inside an AI IDE, and Cursor is the most popular — it supports it directly, so you can be working in minutes. Prefer a different editor? Windsurf, Zed, and GitHub Copilot drive these models too.