Grok 4.3 API: The 200K Boundary, Context and Cost

A long script review needs the scenes that establish who knows or owns what. Sending more of the script can help expose a missing connection, but it also changes the bill—especially at the 200,000-token boundary.

Grok 4.3 is the long-context option in the current Grok chat lineup: it accepts up to 1,000,000 input tokens and offers reasoning_effort: "none", which the current 4.5, 4.6 and 4.7 contracts do not. Watch the billing boundary: 200,000 total input tokens already selects the higher tier, and that tier applies to the entire request.

Exact prices and limits

The current SpicyAPI contract for xai/grok-4.3/chat supports text and image parts, up to 256 messages and 128 tool definitions. It does not accept file/PDF or audio parts.

The input ceiling is 1,000,000 tokens. max_tokens defaults to 4,096 and accepts up to 900,000, the visible-reply ceiling. Reasoning tokens are billed separately within output usage and are not limited by this cap. Available efforts are none, low, medium, high and xhigh; default is low.

For a simple exact extraction, start with none. For a difficult continuity question involving many separated scenes, try low or higher if the initial response misses a specific connection. Reasoning consumes billed output too, so visible answer length alone cannot reconstruct the bill.

What happens at 199,999 versus 200,000 tokens

With 4,000 billed output tokens and no cache:

The difference is a tier change, not the cost of one extra token at the old rate. Cached input also contributes to the threshold. At 50,000 uncached plus 149,000 cached input and 4,000 output, the estimate is $0.1023. Raising the cached portion to 150,000 makes total input 200,000 and raises the estimate to $0.205.

Do not count the cached part again as uncached. The request formula is:

cost = uncached_input × input_rate / 1,000,000
     + cached_input × cached_rate / 1,000,000
     + billed_output × output_rate / 1,000,000

Before sending, load the complete messages and settings in the Grok 4.3 Playground and inspect its price estimate and tier. Include system instructions, tool definitions, images and resent history; a character count is not an exact token count. Afterward, inspect usage.prompt_tokens, which already includes cached input. Do not add usage.prompt_tokens_details.cached_tokens again. Compare total input with 200,000, then use the settled charge for the final bill.

Keep the reusable script and character bible first and the changing question last. A stable prefix can enable reuse, but apply the cached rate only to tokens reported as cache hits.

The tier is selected using total input, including the history sent with this call. An initial balance hold does not necessarily reflect final cache savings. Use the returned usage and settled charge to assess a real request; all totals here are illustrative arithmetic.

The million-token window is a limit for one API request. It is separate from a Grok app subscription's weekly message allowance. With this chat endpoint, send the history and source text the model needs on each call; it does not acquire your app's earlier conversations merely because the model name is familiar.

Try it in Playground first

1. Open Grok 4.3 and switch to Playground.
2. Set the System prompt to the instruction in the example below. In the message box paste the two scenes (SCENE12 and SCENE18) and ask for missing prop transfers. Choose the none reasoning option and press Run model.
3. Check that the answer names both the thermos and red case, then inspect the price estimate before sending a full script.

A practical long-script use case

A fictional adult romance script uses a red leather case and a copper thermos with a blue band. The continuity problem is ownership: who carried each prop before and after a scene? Send the script as text with scene labels and ask for explicit handoffs or missing ones, rather than asking the model to “review everything.”

Illustration of the fictional props. It is not Grok output or evidence of visual accuracy; the call below receives their written descriptions.

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.3/chat",
    "reasoning_effort": "none",
    "max_tokens": 2000,
    "response_format": {"type": "json_object"},
    "messages": [
      {"role": "system", "content": "Return JSON with missing_handoffs: a list of objects containing prop, missing_step and evidence_scene_ids (a nonempty list of supplied scene labels). Do not invent a handoff."},
      {"role": "user", "content": "Fictional adults: Mara, 32, Jon, 35. SCENE_12: Mara leaves her copper thermos with a blue band on the bench. Jon carries a closed red leather case. SCENE_18: Jon gives Mara the thermos; Mara opens the red case. Find ownership changes without an explicit handoff."}
    ]
  }' > response.json

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

resp = json.loads(Path("response.json").read_text())
print(json.dumps({"usage": resp.get("usage")}, indent=2))
choices = resp.get("choices") or []
if resp.get("error") or not choices or choices[0].get("finish_reason") != "stop":
    raise RuntimeError("no complete continuity report")
text = choices[0].get("message", {}).get("content")
if not isinstance(text, str) or not text.strip():
    raise RuntimeError("empty report")
report = json.loads(text)
if not isinstance(report, dict) or not isinstance(report.get("missing_handoffs"), list):
    raise RuntimeError("missing_handoffs must be a list")
for item in report["missing_handoffs"]:
    if not isinstance(item, dict):
        raise RuntimeError("each finding must be an object")
    for key in ("prop", "missing_step"):
        if not isinstance(item.get(key), str) or not item[key].strip():
            raise RuntimeError(f"missing {key}")
    ids = item.get("evidence_scene_ids")
    if not isinstance(ids, list) or not ids or any(
        not isinstance(i, str) or i not in {"SCENE_12", "SCENE_18"} for i in ids
    ):
        raise RuntimeError("unsupported scene reference")
print(json.dumps(report, indent=2))
PY

There are two expected gaps: Jon needs to retrieve the thermos from the bench, and the red case needs to pass from Jon to Mara. Neither action is impossible; neither transfer is stated in the supplied scenes. A correct answer identifies both gaps using SCENE_12 and SCENE_18, rather than inventing a scene that resolves them.

For a programmatic check, give the model a concrete output shape: missing_handoffs is a list of objects with prop, missing_step and evidence_scene_ids. The single example checks that shape before printing the report.

The checker validates the report structure and scene references. Compare the two findings with the scene text before accepting the edit; valid JSON alone cannot establish that the continuity analysis is right.

For a full script, replace the user message with the text exported from your current draft, retaining the same scene labels.

For a long script, use the streaming interface. Export PDF text first and retain the scene labels used in your findings.

Give the long script a useful question, not an invitation to summarize

For prop continuity, keep a compact sequence with scene labels and visible actions: who brought the item, where it was left and who next uses it. A character bible establishes the ordinary owner; it does not forbid another character borrowing the item. Ask for changes lacking a stated transfer, rather than every appearance that differs from the owner table.

In the sample, Jon handing Mara the thermos implies he retrieved or received it after scene 12. Mara opening the red case implies she can access Jon's item. Those are gaps to inspect. A human-written fix might add Jon collecting the thermos as they leave the platform and offering the case for Mara to open. Another legitimate fix keeps the distance between the characters and has each handle only their own item. Choose according to the scene's relationship beat; the continuity report cannot make that creative decision for you.

For an adult companion application, the equivalent packet contains stable fictional character facts, a short account of the current relationship and the conversation needed for the next reply. Keep the distinction between an established fact and a participant's claim. If a character says “we met last summer” but the approved history says they met yesterday, the assistant should not silently rewrite the character record. The statement may be a joke or deliberate fiction inside the scene.

Why fifty short replies can cost more than one long review

Every call can resend the context. At a cold 100,000 input tokens and 2,000 billed output tokens, Grok 4.3's short-tier calculation is $0.13 per reply, or $6.50 for fifty replies at the same usage. A focused 10,000-input packet with the same output is $0.0175, or $0.875 for fifty. These arithmetic cases do not assume cache hits or equal quality.

The tenfold smaller input is useful only if it preserves the information the next reply needs. Keep the complete script for a whole-script question; carry a concise approved history for a local exchange. When a summary omits the fact that a promise remains unfulfilled, the cheaper prompt can produce a worse continuation. Check the important relationship and continuity facts before replacing a source packet with its summary.

The supported none option is a reasonable starting point for literal extraction. It does not make every difficult narrative inference equally easy. If the missing handoff spans several scenes, first ensure those scenes were supplied, then try more effort on that defined question. Increasing effort before supplying the evidence only makes a more elaborate guess possible.

Add a reference image with the correct message shape

Image tokens count toward the same input ceiling and pricing threshold. Add the image only when the question depends on prop appearance.

For a visual question, replace the user message's string content with typed parts (the chat API docs list which parts each model accepts):

{
  "role": "user",
  "content": [
    {"type": "text", "text": "Describe the visible case and thermos. Do not infer an unseen handoff."},
    {"type": "image_url", "image_url": {"url": "https://cdn.spicyapi.ai/blog/authored/seo-next-twenty-2026-10-01/grok-4-3-context-budget-guide/body-1-gpt-image-66b06646fd526c4c.webp"}}
  ]
}

The image shows prop appearance; ownership changes still require the relevant scene text. Supply both when a continuity question depends on a visual detail.

Let an Agent prepare the call

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

Adult-content observations and model choice

The Grok 4.3 review reports 8 of 9 higher-intensity adult-scene requests completed in the September 2026 tests, with one softened response. For an adult script, state the fictional editing assignment in the system message and supply the passages to preserve.

For an adult creator who needs a large character bible plus script, the practical attractions are its input ceiling, lower output rate and genuine none effort option. Grok 4.5 and 4.6 and Grok 4.7 share a smaller 500,000-token ceiling and cost $2.00 per million uncached input and $6.00 per million output below 200K input, against $1.25 and $2.50 on Grok 4.3. Cached input costs $0.30 on 4.5 and $0.50 on 4.6 and 4.7, against $0.20 on Grok 4.3.

Fixes for common surprises

Which setup to start with

Use Grok 4.3 with none for a bounded continuity report when cost and a large source packet matter. Start with scene evidence rather than a whole-script rewrite. Keep the packet below 200,000 tokens when the task permits it; when the missing connection depends on distant scenes, pay for the necessary context rather than dropping the scene that proves the answer.

FAQ

Is the million-token API window the same as Grok app memory?

No. Anything the model should know must be in the request: paste the earlier scenes or a summary of them. Your Grok app history and message allowance do not carry over to API calls.

Does cached input count toward the 200,000-token threshold?

Yes. Cached tokens and resent history all count, so a long chat can cross the line even when most of it is cached. The higher rates then apply to the whole request, so trim old turns before the final call if you are close.

Does none guarantee the cheapest answer?

It removes the exposed reasoning mode, which makes it a useful starting point for a small extraction. The bill still depends on input, cache categories, visible output and the selected tier; a longer answer or larger packet costs more.

Can the model find every continuity mistake in a million-token script?

The window is capacity, not a perfect-recall guarantee. Label scenes, ask a specific continuity question and verify cited passages. After finding the missing transfer, request a local repair instead of regenerating the entire script.