Grok 4.6 vs 4.5: Cache Prices, API Limits and NSFW Tests

A newer version matters only if it changes the result or the cost of the work you do. For a fiction app that resends a character bible, cached-input pricing is a concrete difference; for an occasional fresh prompt, it is not.

Grok 4.5 and 4.6 have the same uncached-input and output prices on SpicyAPI. Grok 4.5 cached input is 40% cheaper. Both expose a 500,000-token input ceiling, the same reasoning choices, images, JSON and tools. Both completed all 22 scored requests in our September 2026 content tests. Start with 4.5 for a repeatedly cached character bible; consider 4.6 for multi-step coding or tool work, where its published agent benchmarks improved.

Exact rates, including the long tier

SpicyAPI prices in USD per million billed tokens:

Exactly 200,000 total input tokens uses the higher tier. Cached tokens count toward that threshold, and the selected tier applies to the whole request. The short-tier figures are not marginal rates for the first 199,999 tokens of a longer request.

A cold request with 100,000 uncached input tokens and 2,000 billed output tokens costs $0.212 on either route. If the input is instead 10,000 uncached and 90,000 cached, with the same output, it costs $0.059 on 4.5 versus $0.077 on 4.6. That difference is $18.00 across 1,000 identical usage patterns.

The cached example assumes 90,000 reported cache-hit tokens. Budget at the uncached rate until returned usage shows a hit; count each input token in only one category and use the settled charge for the final bill.

There is no separate “below 200K” model to select. Keep xai/grok-4.5/chat or xai/grok-4.6/chat; total input selects the tier. If a character bible grows from 190K to 200K after adding tool definitions and recent dialogue, that call enters the higher tier with the same model ID. Lowering the output budget does not bring its input back below the boundary.

What 4.6 changes beyond the rate table

The improvement target is long-running agent work. In xAI’s release evaluation, at High effort on both versions, 4.6 scored 69.9% versus 66.7% on CursorBench 3.2 and 65.9% versus 54.0% on DeepSWE 1.1. That gives a coding or multi-step tool application a reason to consider 4.6 even with the higher cache rate.

Start routine tasks at low or medium effort. More reasoning, tool turns and resent history can outweigh the token-rate difference, so compare the total cost of finishing the task.

The controls are largely the same

Set max_tokens for the requested deliverable. It caps visible text, not reasoning tokens. Reasoning is still billed as output, so this setting alone is not a total-output spending cap; reduce effort and use key spend limits when controlling cost.

Do not copy reasoning_effort: "none" from Grok 4.3. If your requirement is no reasoning plus a million-token input ceiling, 4.3 is a distinct option, rather than a setting you can switch on in these two routes.

What we know about adult-content support

The Grok 4.5 review and Grok 4.6 review record the content tests: 22 of 22 scored requests completed on each, including all 7 higher-intensity L4 requests. This supports either route for adult-fiction work.

Try it in Playground first

1. Open Grok 4.5 and switch to Playground.
2. Paste the reunion brief below, set Low reasoning and request the short scene.
3. Repeat on 4.6 with the same brief and compare the character voices and prop ownership.

Copyable request for a non-graphic adult scene

This example asks for romantic dialogue between fictional adults, with bounded length and a prop-continuity constraint. The exact same request shape is valid for either version; change only model when trying the alternative.

curl --fail-with-body https://api.spicyapi.ai/v1/chat/completions \
  -H "Authorization: Bearer $SPICY_API_KEY" \
  -H 'Content-Type: application/json' \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "xai/grok-4.5/chat",
    "reasoning_effort": "low",
    "max_tokens": 3000,
    "temperature": 0.7,
    "messages": [
      {"role": "system", "content": "Write non-graphic romantic dialogue between fictional adults. Preserve the supplied prop ownership. Keep the scene under 250 words."},
      {"role": "user", "content": "Mara, 32, and Jon, 35, meet at the last train. Mara owns a copper thermos; Jon owns a red case. They have not seen each other for a year. Write a warm reunion ending with a shared smile. Do not swap the props."}
    ]
  }' --output grok-scene.json

python3 - <<'PY'
import json
from pathlib import Path

def read_scene(reply: dict) -> str:
    choices = reply.get("choices") or []
    if reply.get("error") or not choices:
        raise RuntimeError("no successful reply")
    choice = choices[0]
    text = choice.get("message", {}).get("content")
    if choice.get("finish_reason") != "stop" or not isinstance(text, str) or not text.strip():
        raise RuntimeError("empty or incomplete scene")
    return text

print(read_scene(json.loads(Path("grok-scene.json").read_text())))
PY

Check that Mara still owns the thermos and Jon the red case, and that the reunion ends as requested. The current chat endpoint is synchronous and uses OpenAI-compatible response fields.

For structured continuity checks, add response_format: {"type":"json_object"} and instruct the model to return explicit keys such as prop_owners and conflicts. Parse the object and compare its owners against the supplied facts. For tool use, preserve the complete assistant tool-call message and return each application result with its matching tool_call_id.

Let an Agent prepare the call

For repeated fiction requests, ask your coding Agent to use the SpicyAPI Skill: “Read xai/grok-4.5/chat, then adapt the example to my input; show the request before running it.” The CLI lookup is spicyapi models get xai/grok-4.5/chat --json; the MCP lookup is spicyapi_model_get with model: "xai/grok-4.5/chat". Chat calls use a compatible client or the chat API; the media task commands do not generate chat replies.

Adult-fiction quality is a different question from acceptance

The 22-of-22 records answer whether those prompts were fulfilled at the tested content levels. A scene can pass that check and still have flat dialogue, inconsistent viewpoint or a character making a decision the author never intended. None of those writing differences can be settled by the matching acceptance totals.

For the reunion sample, a useful response preserves Mara's thermos and Jon's case, gives the year of separation emotional consequences and ends at the requested shared smile. A less useful response narrates an entire reconciliation, gives both speakers identical voices and explains every feeling before they have spoken. The second may contain more polished sentences while being less usable for the intended beat.

Make the next revision specific: “Keep Jon guarded for the first two exchanges. Let Mara notice the repaired handle on his case; she remembers it was broken when they parted. End before either character promises to stay.” This is a proposed writing instruction, not a finding that either Grok version produced the weak answer. It supplies something the model can change without inventing a wholesale plot.

Community comparisons also need a task boundary. A September 16 Cursor discussion contains users preferring 4.5 on UI work and users happy with 4.6. Those are experiences in a coding application, not matched evidence about adult fiction through this API. They help explain why a version number is a weak purchase shortcut; they do not contradict or replace the content trials above.

For a cold scene request, the listed input and output rates give neither version a price advantage. For many replies reusing a stable character bible, the cached-input difference can matter. If there are no reported cached reads, the advertised cached discount contributes nothing to that call. Choose 4.5 for the documented cache-rate advantage when it applies, and choose 4.6 when an actual task result gives you another reason. This article has no prose-quality result establishing that reason in advance.

Choose from the actual requirement

• Repeated brief plus many short replies: 4.5 is the lower-rate option for the cached part of input. Keep stable source text first and inspect actual usage.

• Mostly cold requests: neither has a token-rate advantage. Consider 4.6 for coding and multi-step tools; for fiction, choose the voice and instruction following you prefer.

• A very large source packet: both stop at 500,000 input tokens. If the packet exceeds that, reduce it or consider the different 4.3 contract. Neither 4.5 nor 4.6 accepts a PDF file to bypass the input limit.

• Sequential operations: set parallel_tool_calls: false when one tool result must precede another. Validate arguments in your application before carrying out a booking, write or other external action.

• Strict cost budget: explicitly set effort and max_tokens, then inspect actual usage.

Migration fixes

Open 4.5 for cached-history fiction, or 4.6 for a multi-step agent. The request above works on either.

FAQ

Is Grok 4.6 more expensive than 4.5?

Only cached input has a higher rate in this comparison: $0.50 versus $0.30 per million below 200K input, and $1.00 versus $0.60 at or above it. Cold-input and output rates are identical. Different reasoning usage can still change the total bill.

Does sending the same character bible guarantee cheaper cached input?

No. A stable prefix makes reuse possible; check the returned usage for an actual cache hit.

Which version should I use for uncensored roleplay?

Both completed the seven L4 requests in their scored sets. Start with 4.5 for repeated cached history; keep 4.6 if it gives a concrete improvement in characterization or instruction following in your workflow.