Grok 4 API pricing: xAI direct vs gateway access

The decision between Grok 4 API pricing xAI direct vs gateway isn’t just about the per-token rate. Direct access gives you a single vendor relationship and the exact published price; a gateway adds routing, failover, and unified metering at the cost of an extra network hop and possibly a small margin. For engineers shipping LLM features, the total cost of ownership includes retry logic, multi-provider abstraction, and invoice reconciliation—not just the model line item.

Direct xAI access

Capabilities

xAI’s own endpoint exposes Grok 4 with full feature parity: streaming, function calling, JSON mode, and any provider-specific extensions such as reasoning step traces. The API surface mirrors the OpenAI chat completions contract, hosted at api.x.ai/v1. If xAI ships a Grok-4-only parameter (e.g., a custom sampling flag), you get it first.

Price/cost model

xAI publishes token prices for Grok 4 on its developer dashboard. You pay exactly that rate, billed to your xAI account, with no intermediary markup. Input and output tokens are metered separately. Cache hits get a discount if you send cache_control hints using xAI’s schema. There is no minimum commit; you pay as you go.

Latency/throughput

You connect straight to xAI’s inference fleet. No proxy buffer. In practice, p50 latency is governed by xAI’s region placement and your geographic proximity. Rate limits are enforced by xAI per API key, and burst capacity depends on your tier. If xAI’s Grok 4 pool is saturated, you absorb the 429s.

Ergonomics

You manage one API key, one base URL. If you already use the OpenAI SDK, you point it at https://api.x.ai/v1 and set the model to grok-4. That’s the entire integration. Rotating keys, tracking usage, and reading status all happen in one console.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.x.ai/v1",
    api_key="xai-...",
)
resp = client.chat.completions.create(
    model="grok-4",
    messages=[{"role": "user", "content": "Explain tail latency."}],
    stream=True,
)

Ecosystem

You’re locked to xAI’s status page, xAI’s SDK updates, and xAI’s support channel. For a shop already standardized on one model provider, that’s fine. You also avoid any translation layer that might drop a field.

Limits

Hard caps on requests per minute and tokens per day are set by xAI tier. If Grok 4 is degraded, your calls fail unless you build your own fallback to another provider. You own the circuit breaker.

Gateway access

Capabilities

A gateway fronts xAI alongside 200+ other models behind one OpenAI-compatible interface. You get the same Grok 4 capabilities, but the gateway may strip or pass through provider-specific fields depending on its translation layer. Some gateways normalize tool-call formats, which can subtly change behavior versus direct.

Price/cost model

Gateways resell xAI’s rate, often with a flat per-token margin or a volume discount. You receive a single invoice covering all models. For example, n4n.ai provides per-token usage metering across its 240+ model catalog, so Grok 4 spend appears next to your other model lines without custom accounting. You trade a few percent of token cost for zero billing glue code.

Latency/throughput

Your request traverses the gateway before xAI. Expect an added 10–30 ms overhead in same-region setups, more if the gateway normalizes the request schema. Throughput is capped by the lower of the two: gateway quota and xAI quota. A good gateway batches auth checks but cannot compress xAI’s compute time.

Ergonomics

One key, one base URL, many models. Routing directives let you pin Grok 4 or let the gateway choose. You write fallback logic once, not per provider. Client routing headers can force a provider; the gateway forwards cache-control hints so xAI’s discount still applies.

from openai import OpenAI

client = OpenAI(
    base_url="https://gateway.example/v1",  # OpenAI-compatible gateway
    api_key="gw-...",
)
resp = client.chat.completions.create(
    model="xai/grok-4",  # provider-qualified slug
    messages=[{"role": "user", "content": "Explain tail latency."}],
    extra_headers={"x-routing": "prefer=xai"},  # honor client routing directives
)

Ecosystem

You gain a unified observability plane, shared rate-limit pooling across providers, and sometimes automatic fallback. A gateway such as n4n.ai exposes one OpenAI-compatible endpoint that addresses 240+ models and handles automatic fallback when a provider is rate-limited or degraded. The tradeoff is dependency on the gateway’s compatibility shim.

Limits

The gateway imposes its own daily spend caps and per-key limits on top of xAI’s. If the gateway has an outage, you lose all models unless you code a direct fallback. You also depend on the gateway’s update cadence to expose new Grok 4 features.

Head-to-head comparison

Calling Grok 4: two concrete paths

Direct curl to xAI:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4",
    "messages": [{"role": "user", "content": "ping"}],
    "stream": false
  }'

Gateway call with provider cache hint forwarded:

curl https://gateway.example/v1/chat/completions \
  -H "Authorization: Bearer $GW_KEY" \
  -H "Content-Type: application/json" \
  -H "x-provider-cache: true" \
  -d '{
    "model": "xai/grok-4",
    "messages": [{"role": "user", "content": "ping"}]
  }'

The second example shows a gateway that forwards provider cache-control hints, preserving xAI’s discount semantics while keeping your client agnostic. In both cases the request body is identical aside from the model slug, which underscores how thin the gateway abstraction is.

Cost mechanics beyond the table

Grok 4 API pricing xAI direct vs gateway looks identical on the token line if the gateway charges zero margin, but that is rare. Most gateways take 1–5% on top, or they bundle volume discounts that beat direct at scale. The hidden line items are engineering hours: direct means you write the multi-provider switch, the 429 backoff, and the per-vendor usage aggregation. Gateway means you configure a header.

Caching behavior is another differentiator. xAI honors cache_control on supported models; a gateway must pass that through untouched or you pay full price for repeated prefixes. Verify the gateway’s docs before trusting it with long system prompts.

Latency reality check

We measured nothing here, but the physics is simple: every proxy adds at least one TLS handshake and one deserialization pass. In us-east, a gateway colocated with xAI adds low double-digit milliseconds. Cross-region, it can add hundreds. If your SLO is sub-200ms p99, direct is safer. If you already tolerate 500ms for multi-model routing, the gateway tax is invisible.

Which to choose

Solo developer or prototype

Go direct. Grok 4 API pricing xAI direct vs gateway is a wash at low volume; you avoid an extra dependency and read xAI’s docs directly. The OpenAI-compatible shape means you can switch later with a one-line base URL change.

Production with multi-model needs

Use a gateway. When your stack already calls Claude, Llama, and Grok, a single endpoint with automatic fallback when a provider is rate-limited or degraded cuts integration toil. The small margin is cheaper than your own abstraction layer. You also get one usage dashboard.

Cost-sensitive at scale

Negotiate with xAI for direct enterprise rates if your volume is Grok-only. Gateways monetize via margin; at six-figure monthly spend, that margin buys a lot of engineering time, but direct may win on raw cost. Run the numbers on your actual token mix.

Compliance or single-vendor mandate

Direct is mandatory. Some contracts forbid third-party proxying of prompts. Keep the data path inside xAI’s boundary and accept the burden of building your own resilience.

Grok 4 API pricing xAI direct vs gateway ultimately reflects a build-vs-buy trade on reliability and billing aggregation, not just the token line item. Pick the path that matches your operational surface area, not the one with the lowest headline number.