xAI's platform is OpenAI-compatible, so if your code already calls OpenAI you swap two lines and you're on Grok. The differentiators: 1M-token context (2M on the fast model) and Live Search over the open web and X. This covers the free-credit mechanics, current pricing, your first call, and when to reach for a genuinely card-free API instead.

Everything below is sourced from xAI's docs at docs.x.ai and the console at console.x.ai. Pricing and credit programs change often — confirm current numbers in your own console before building a budget around them.

How the Data-Sharing Free Credits Work

The credit is tied to one toggle in team settings, usually labeled "Share API Inputs and Outputs for Model Training."

• You opt in. xAI may use your prompts and completions to improve future Grok models.
• You get credited. Up to $150 in free credits per month against your usage, refreshing monthly while active.
• It's region-gated. Limited to eligible countries; if your billing region isn't supported, the toggle won't grant credits.
• Promo credits. New accounts have at times received a small one-time signup credit (commonly reported ~$25). Promotional, comes and goes.

Verified 2026-09-01, and this is the important caveat: the data-sharing credit program is no longer documented anywhere on docs.x.ai. The pricing page has no free-credit section, and the Data & Privacy page describes only Zero Data Retention and a 30-day audit window — no training toggle, no credit grant. It may still exist in the console without being documented, so confirm the live figure at console.x.ai before planning around it. Treat the $150 below as historical until you have seen it on your own billing page.

Other caveats, because this program changes frequently:

• xAI has at points required a small one-time deposit (reported as low as $5) before the $150 unlocks — a fraud/identity gate, not a recurring charge.
• The ceiling, eligibility, and activation flow have all shifted across 2025–2026. Treat "$150/month" as the headline, then verify the live number in your console.
• Credits do not roll over — unused allowance at month-end is gone.

The key point: this is a data-for-credits trade, not a charity free tier. The "free" costs privacy rather than dollars.

Grok API Models and Pricing in 2026

The lineup is built around the Grok 4.x family, with Grok 4.3 as the recommended general-purpose and coding model. Per-token prices are USD per 1M tokens, from docs.x.ai:

xAI also exposes multimodal endpoints on the same platform: image generation (~$0.02–$0.05 per image), video generation (~$0.05–$0.08 per second), and voice modes. These count against the same balance — and the same $150 credit on the data-sharing program.

Two things make Grok distinctive: huge context windows (1M on the flagship, 2M on fast — Gemini-class, far beyond Groq's or Cerebras's ceilings), and Live Search, which pulls real-time data from the web and X via a search parameter (billed separately, per-source). No other major free-credit API ships first-party real-time X data. Model IDs move — hit GET /v1/models before hardcoding one in production.

What Can $150/Month Actually Buy?

Take a typical turn of 1,000 input + 500 output tokens. On grok-4.3 that's $0.0025 per turn, so $150 covers ~60,000 turns/month (~2,000/day). On grok-build-0.1 it's $0.0020 per turn — about 75,000 turns/month (~2,500/day).

For almost any side project, internal tool, or MVP, the credit is effectively "unlimited." You'd need a real product with thousands of daily users to exhaust it — and at that scale you shouldn't be on a program that trains on your traffic anyway.

Get Your Grok API Key

1. Sign in at console.x.ai (X account or email).
2. Create or select a team — billing and credits are scoped to the team.
3. For free credits, open team settings and enable "Share API Inputs and Outputs for Model Training." Confirm the $150 credit shows under billing.
4. Add a payment method if prompted (some regions require it, sometimes with a small one-time deposit).
5. Under API Keys, click Create API Key, copy it — shown once. Store it in a secret manager or .env, never commit it.

Your First Grok API Call (OpenAI-Compatible)

The single most useful fact: the Grok API is OpenAI-compatible. Base URL https://api.x.ai/v1, request/response shapes match OpenAI Chat Completions. Change the base URL and model name and you're calling Grok.

cURL

curl https://api.x.ai/v1/chat/completions 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "grok-4.3",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain the CAP theorem in three sentences."}
    ]
  }'

Python (OpenAI SDK)

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Write a Python function that returns the nth Fibonacci number iteratively."},
    ],
)

print(response.choices[0].message.content)

xAI also ships an official xai-sdk Python package, but the OpenAI SDK keeps your code provider-agnostic.

Node.js / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const response = await client.chat.completions.create({
  model: "grok-4.3",
  messages: [
    { role: "user", content: "Write a TypeScript type for a paginated API response." },
  ],
});

console.log(response.choices[0].message.content);

Streaming

stream = client.chat.completions.create(
    model="grok-4.3",
    messages=[{"role": "user", "content": "Explain async/await in JavaScript with one example."}],
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Structured JSON output

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": (
                "Extract as JSON with keys title, company, remote (boolean), salary (string or null): "
                "'Backend Engineer at NorthByte, fully remote, $130k-$160k.'"
            ),
        }
    ],
    response_format={"type": "json_object"},
)
# {"title": "Backend Engineer", "company": "NorthByte", "remote": true, "salary": "$130k-$160k"}

Live Search: Grok's Real Differentiator

Most LLM APIs are frozen at their training cutoff. Grok can query the live web and X by adding a search parameter to the request. Live Search is billed per source returned, separate from token costs — so it draws down your balance (and $150 credit) faster than plain completions.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[{"role": "user", "content": "What are the latest changes to the xAI API pricing this week?"}],
    extra_body={
        "search_parameters": {
            "mode": "auto"
        }
    },
)

Field names for non-standard features evolve — treat this as a pattern and confirm the current schema in the docs. First-party real-time access to X plus the open web is something neither Gemini's free tier, Groq, nor DeepSeek offers natively.

OpenAI SDK Quick Reference

Because Grok is OpenAI-compatible, it drops into LangChain, LlamaIndex, LiteLLM, OpenWebUI, and anything accepting a custom base URL.

With LiteLLM, switching a whole codebase to Grok is one model string:

from litellm import completion
import os

os.environ["XAI_API_KEY"] = "YOUR_XAI_API_KEY"

response = completion(
    model="xai/grok-4.3",
    messages=[{"role": "user", "content": "What are the SOLID principles?"}],
)

It also connects to OpenClaw, an open-source agent platform: run openclaw onboard, choose Custom OpenAI-compatible, enter https://api.x.ai/v1, paste your key, and select grok-4.3. Paired with the data-sharing credit, you get a frontier coding/reasoning agent at zero marginal cost — the 1M-token context holds a large codebase, and Live Search fetches current docs mid-task.

Grok vs Other Free AI APIs

The honest read: if you want "free" with no asterisks, Gemini and Groq are simpler — no payment method, no data-for-credits trade. Grok's pitch is different: a frontier model with a 1M-token window and real-time X/web access that happens to be free if you accept the data-sharing terms. You pick Grok for its capabilities and treat the credit as a bonus.

The Privacy Trade-Off: When NOT to Use the Credits

The $150/month is contingent on letting xAI train on your prompts and completions. That has real consequences:

• Never enable data sharing for proprietary or confidential data — customer records, internal source code, unreleased product details, legal/medical text.
• Be careful with user data. Forwarding end-user messages to Grok with sharing on may violate your privacy policy or regulations like GDPR.
• Separate environments. Keep one team with sharing on for non-sensitive experimentation (covered by the credit), and a separate paid team with sharing off for anything touching real data.

Turn data sharing off and the $150 credit goes away — back to standard pay-as-you-go, which is the correct setup for production with sensitive data.

Frequently Asked Questions

Is the Grok API free forever?

No. There's no permanent zero-cost tier. The closest thing is the data-sharing program's up-to-$150/month credit, which refreshes monthly while you remain opted in. Terms have changed repeatedly — confirm the current ceiling in console.x.ai.

Do I need a credit card to use the Grok API?

It depends on your region. Some regions start on the credit with little friction; others require a payment method and occasionally a small one-time deposit. Unlike Gemini or Groq, Grok is not guaranteed card-free.

Does enabling free credits mean xAI trains on my data?

Yes — that's the entire deal. The $150/month is granted in exchange for letting xAI use your inputs and outputs to improve its models. Turn data sharing off (and forgo the credit) for anything sensitive.

Is the Grok API OpenAI-compatible?

Yes. Point any OpenAI SDK at https://api.x.ai/v1, use your xAI key as the bearer token, and set the model to a Grok ID. No other code changes needed.

Final Thoughts

"Is the Grok API free?" has no one-word answer. By default it's paid, but the data-sharing program makes it effectively free up to $150/month — enough for tens of thousands of daily completions on a frontier model with a 1M-token context and real-time X/web search no other major API offers natively. The catch you should never ignore: that free tier trains on your inputs. Use it freely for non-sensitive prototyping, keep it off for anything confidential. Get your key at console.x.ai, point your OpenAI SDK at https://api.x.ai/v1, and pair it with OpenClaw for a fully free agent.

Related Reads

• Free AI APIs in 2026: We Tested 10, Four Now Want a Card
• Google Gemini Free API Tested: 34s to First Token
• Groq Free API Tested: ~525 tok/s + What You Can Build
• DeepSeek API Is No Longer Free: We Checked the Balance
• OpenRouter Free Tier Tested: 18 Free Models, One API Key