GuidesOneMux

Estimating Muse Spark 1.2 Contributor Costs for JSON Extraction

A reproducible way to estimate Muse Spark 1.2 Contributor API costs for schema-validated extraction, with explicit token assumptions, published prices, and cache caveats.

AI

Summary · TL;DR

For a simple uncached extraction estimate, multiply total input and output tokens by their per-million-token prices. This guide works through a 10,000-request example, explains what the estimate leaves out, and shows how to validate returned JSON locally.

Key Takeaways

  • The supplied model source lists Muse Spark 1.2 Contributor at $0.10 per million input tokens and $0.20 per million output tokens, with separate cache prices.
  • In the illustrative workload of 10,000 requests averaging 2,000 input and 300 output tokens, the estimate is $2.60 at those listed prices, before caching or other provider-specific billing behavior.
  • OneMux’s published catalogue lists $0.0559 input and $0.1118 output per million tokens; its published price ratio is 0.5589999999999998.
  • Treat schema compliance as something to validate in your application unless the endpoint and parameters you use explicitly document structured-output support.
On this page (6)

Estimate the workload before choosing a route

For structured extraction, the useful first estimate is not “cost per document” in isolation. It is the expected input and output token volume for the number of documents you will process. Include the instructions, schema, and source text in input; include the returned JSON in output. Then calculate each category separately.

Muse Spark 1.2 Contributor is listed with text and image input, reasoning support, and a context window of 1,048,576 tokens. Those are documented model details, not evidence of extraction accuracy or a guarantee that a particular API accepts every structured-output parameter. The source lists pricing in USD per million tokens. The model’s source listing also gives separate cache-read and cache-write rates.

Published prices and billing caveats

The table compares the supplied official listing with OneMux’s published catalogue snapshot captured on 2026-11-08. The prices are shown per million tokens to match the source’s stated units. The published price ratio is reproduced as supplied; it is not a measured performance comparison.

Price categoryOfficial listed priceOneMux published price
Input, per 1 million tokens$0.10$0.0559
Output, per 1 million tokens$0.20$0.1118
Cache read, per 1 million tokens$0.002$0.001118
Published price ratio (OneMux / official)—0.5589999999999998

The official source states that a tier is selected using the total input tokens in each request and applies to that entire request; its listed rate table shows one “All requests” rate. The source also lists cache-write pricing at $0. Cache eligibility, retention, rounding, and billing details can vary by provider, so do not assume that every repeated token qualifies for the cache-read rate. The OneMux catalogue snapshot provides input, output, and cache-read prices, but does not specify additional tier or cache conditions here. Check the current OneMux prices and model details before budgeting a live workload.

OneMux is the publisher of the OneMux prices in this comparison. It provides access to models through one OpenAI-compatible API, with routing, keys, spend visibility, and credit top-ups. Compatibility with a particular model’s endpoint and parameters is conditional on documented support; verify the integration requirements rather than assuming every provider-specific feature is available.

Worked example: 10,000 extraction requests

Illustrative assumptions, not measured usage: each request contains 2,000 input tokens, including the prompt, schema, and source document, and returns 300 output tokens of JSON. The workload has 10,000 requests, no cache reads or writes, and no images. It stays within the listed context window per request. These averages should be replaced with token counts from a representative sample of your own documents.

  1. Input volume: 10,000 × 2,000 = 20,000,000 tokens, or 20 million.
  2. Output volume: 10,000 × 300 = 3,000,000 tokens, or 3 million.
  3. At the official listed rates: 20 × $0.10 + 3 × $0.20 = $2.60.
  4. At the OneMux published rates: 20 × $0.0559 + 3 × $0.1118 = $1.4534.

This comparison uses the same token volumes and input/output categories on both sides. It is arithmetic from published rates, not a quote, invoice prediction, benchmark, or guarantee of savings. The example excludes retries, tool calls, image-token usage, cache treatment, and any provider-specific billing adjustments. A schema that grows from a few fields to a large nested definition can also increase input volume on every request if it is sent each time.

To make the estimate reproducible, record the request count, average input tokens, average output tokens, and whether cache reads are expected. Measure token counts on a representative sample, including unusually long documents. If requests vary substantially, estimate short, typical, and long cases rather than multiplying one average across the whole workload.

Validate extracted JSON in your application

A model response that looks like JSON is not automatically valid against your schema. Validate it before storing or acting on extracted fields. The following Python example checks a parsed response with the jsonschema package; it does not call the model or rely on an undocumented structured-output feature.

from jsonschema import validate

schema = {
    "type": "object",
    "properties": {
        "invoice_number": {"type": "string"},
        "total": {"type": "number"}
    },
    "required": ["invoice_number", "total"],
    "additionalProperties": False
}

# Parse the model's returned JSON string before validation.
extracted = {"invoice_number": "INV-1042", "total": 125.50}
validate(instance=extracted, schema=schema)

In production, handle JSON parsing errors and schema-validation errors separately. Decide whether an invalid result should be retried, sent for review, or rejected. Retries add requests and therefore can change the cost estimate. Also test nulls, missing fields, unexpected keys, and values with the wrong type against your actual schema.

Practical budgeting checklist

  • Count schema and instructions as input whenever they are sent with a request.
  • Estimate returned JSON tokens separately from input tokens.
  • Model retries and unusually long documents instead of assuming every request matches the average.
  • Keep cache-read estimates separate until you know whether your chosen route makes those reads billable at the listed rate.
  • Validate JSON locally and monitor actual token usage after launch; update the estimate with observed volumes.

For the stated example, the uncached arithmetic is $2.60 at the official listed rates or $1.4534 at the dated OneMux catalogue rates. Your actual spend depends on request sizes, route behavior, caching, and applicable billing terms.

Published price snapshot

Captured 2026-11-08T23:00:05.457Z from the OneMux published catalogue. Prices retain website billing units; this is not a live benchmark. Tiered, cached or time-based billing may differ. Unknown values are not zero.

ModelOfficial inputOfficial outputOneMux inputOneMux outputPublished price ratio
Muse Spark 1.2 Contributor$0.1$0.2$0.0559$0.11180.5589999999999998

Current OneMux prices. Compare workload costs only when input/output and billing units match; see each model page for tier conditions.

FAQ

How much does Muse Spark 1.2 Contributor cost for JSON extraction?

The supplied source lists $0.10 per million input tokens and $0.20 per million output tokens, plus separate cache rates. For 10,000 illustrative requests averaging 2,000 input and 300 output tokens, the uncached estimate is $2.60 at those listed rates.

Does Muse Spark 1.2 Contributor guarantee valid JSON?

The supplied source documents text and image input, reasoning support, and pricing, but does not establish a guarantee of schema-valid JSON. Validate parsed output against your schema in your application and confirm endpoint support for any structured-output parameters you plan to use.

How should I account for cached tokens?

Keep cache reads separate from uncached input and use the cache-read rate only when the relevant provider route and request qualify. The source lists $0.002 per million cache-read tokens, while cache eligibility, retention, and billing behavior can vary.

Are the OneMux prices a measured discount?

No. They are published catalogue prices captured on 2026-11-08. The listed ratio is 0.5589999999999998 relative to the official prices shown, using matching input and output units. It does not compare model quality or measured workload performance.

Related articles