How to Use Grok 4.3 for Free: 4 Working Paths in 2026

Grok 4.3 is xAI’s flagship model as of May 2026. It supports a 1M-token context window, native video input, and pricing of $1.25 / $2.50 per million tokens. If you are prototyping, learning, or building a side project, you can use Grok 4.3 without paying upfront through three practical routes: xAI Console promotional credits, Puter.js user-paid calls, and the free chat surfaces on grok.com and X.

Try Apidog today

This guide walks through each option with setup steps, code, and trade-offs. For the full paid API guide, see How to use the Grok 4.3 API. For the voice equivalent, see How to use Grok Voice for free.

TL;DR

• Three free paths to Grok 4.3: xAI Console promotional credits, Puter.js, and the chat UIs at grok.com and X.
• Best for developers shipping a public web app: Puter.js. Your users cover their own usage.
• Best for backend/API prototyping: xAI Console credits.
• Best for no-code use: grok.com or the X app.
• Model IDs:
  • xAI direct API: grok-4.3
  • Puter.js: x-ai/grok-4.3
• Use Apidog to test equivalent requests across providers and compare responses, latency, and token usage.

Path 1: Use xAI Console promotional credits

Use this path when you want to test the real production API surface without paying upfront.

Step 1: Create an xAI Console account

Go to:

console.x.ai

Sign in with your X account. Account verification follows whatever X requires.

Step 2: Check your promotional credits

After signup, open the Billing tab.

xAI has run promotional windows that give new accounts free credits. These credits are usually enough for several days of integration testing, but the amount and eligibility window can change.

The key point: these credits are finite and do not auto-renew. Use them to validate your integration, then either move to paid usage or switch to another path.

Step 3: Call Grok 4.3 from the API

The xAI endpoint follows an OpenAI-compatible Chat Completions shape:

export XAI_API_KEY="xai-..."

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": "user",
        "content": "Explain prompt caching in three sentences."
      }
    ],
    "reasoning_effort": "low"
  }'

For early testing, start with:

"reasoning_effort": "low"

Use medium or high only when you need stronger reasoning, because they consume credits faster.

Pros and cons

Pros	Cons
Real production API behavior	Credit pool is finite
Supports Grok 4.3 capabilities such as 1M context, video, and function calling	Promotional terms can change
No migration cost when moving to paid usage	Limited to what fits inside the credit bucket

Use this path if: you need backend access, want to test the real API, or plan to move to paid xAI usage later.

For the full request schema, see How to use the Grok 4.3 API.

Path 2: Use Puter.js

Puter.js is the cleanest free path for developers building public browser-based apps.

How Puter.js works

Puter.js exposes a JavaScript client for calling LLMs such as Grok, GPT, Claude, Gemini, and DeepSeek.

The important billing difference:

The end user pays from their Puter account, not the developer.

You add the script and call the model from the browser. When users run the app, Puter handles authentication and charges the user for the cloud and AI usage their session consumes.

Step 1: Add Puter.js to your page

<script src="https://js.puter.com/v2/"></script>

No API key is required in your app.

Step 2: Call Grok 4.3

Use puter.ai.chat() with the Puter model ID:

<script src="https://js.puter.com/v2/"></script>

<script>
  puter.ai.chat(
    "Summarize the trade-offs between SQLite and Postgres in three bullets.",
    { model: "x-ai/grok-4.3" }
  ).then((response) => {
    document.body.innerText = response.message.content;
  });
</script>

The first time a user runs this, Puter prompts them to sign in or create a Puter account. After that, requests use the user’s Puter balance.

Step 3: Stream responses

Puter.js also supports streaming:

const stream = await puter.ai.chat(
  "Walk me through migrating a React app to Next.js.",
  {
    model: "x-ai/grok-4.3",
    stream: true,
    reasoning_effort: "medium",
  }
);

for await (const chunk of stream) {
  process.stdout.write(chunk?.text || "");
}

Pros and cons

Pros	Cons
Developer pays $0	User must sign in to Puter
No API key in your repo	Less suitable for backend-only systems
Supports multiple major LLM providers	Requires a browser context
Good fit for public tools and side projects	May add slightly more latency than direct xAI calls

Use this path if: you are building a public web app, demo, side project, or free tool where users can cover their own usage.

Avoid this path if: the user is not the person triggering the query, such as in internal automation, backend jobs, or bots.

For similar free-access patterns, see How to use the DeepSeek V4 API for free and How to use the GPT-5.5 API for free.

Path 3: Use grok.com or the X app

Use this path when you only need to chat with Grok and do not need API access.

Options:

• grok.com: web chat. Sign in with X.
• X app: Grok is available inside the X mobile and web apps under the Grok tab.

Free users get a limited daily quota that resets every 24 hours.

This path is useful for:

• One-off research.
• Prompt exploration.
• Checking whether Grok’s output style fits your use case.
• Manual testing before implementing API calls.

You cannot script or automate requests from these chat UIs.

The free tier on grok.com currently defaults to a smaller Grok variant. Premium subscriptions on X unlock Grok 4.3 in the chat UI with higher quotas.

Path 4: Use OpenRouter for cheaper Grok-class testing

OpenRouter is not a free Grok 4.3 path, but it is useful for testing Grok-class models behind one API key.

Grok 4.3 on OpenRouter costs the same as direct xAI pricing:

$1.25 / $2.50 per 1M tokens

However, OpenRouter also carries free variants for some Grok models, such as:

grok-4-fast:free

Use this when you do not specifically need Grok 4.3 but want a free Grok-family model for experimentation.

Example request:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "x-ai/grok-4-fast:free",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ]
  }'

Use this path if: you want free Grok-class output and do not require Grok 4.3 specifically.

Compare the options

Path	Cost to developer	Cost to end user	Best for
xAI Console credits	$0 within credit limit	n/a	Backend prototyping and learning the production API
Puter.js	$0	User pays usage	Public web apps, side projects, free tools
grok.com / X	$0	$0 within quota	Manual use and prompt testing
OpenRouter free model	$0	n/a	Free Grok-class output, not Grok 4.3 specifically

Test provider requests in Apidog

When you are comparing providers, keep the prompt and request body stable. Change only the base URL, auth key, and model name.

A practical Apidog setup:

1. Create an Apidog environment with these variables:
   • XAI_API_KEY
   • OPENROUTER_API_KEY
   • BASE_URL
2. Create one Chat Completions request.
3. Save provider-specific variants:
   • xAI direct
   • OpenRouter
4. Run both with the same prompt.
5. Compare:
   • Response quality
   • Token usage
   • Latency
   • Error behavior
6. When credits run out, switch environments instead of changing code.

Download Apidog and create a new collection.

Use these base URLs:

https://api.x.ai/v1
https://openrouter.ai/api/v1

Both use an OpenAI-compatible Chat Completions schema, so the request body can stay mostly identical except for the model value.

For more on cross-provider testing, see API testing tool for QA engineers.

What you give up by staying free

Free paths are useful for prototyping, but they come with trade-offs.

1. Tighter rate limits

Promotional credits do not remove rate limits. If you test at scale, expect 429 responses before your credit pool is exhausted.

Add basic throttling during tests:

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

for (const prompt of prompts) {
  await callGrok(prompt);
  await sleep(1000);
}

2. Less benefit from prompt caching

Prompt caching is most valuable when you send large repeated context, such as a stable 50k+ token system prompt.

For a small prototype with a few dozen calls, caching savings are less important.

3. Best-effort support

Free usage paths usually do not include production support. If you are debugging production traffic, move to a paid tier.

When to move to paid usage

Move off the free path when you see one of these signals:

1. You hit rate limits often.
   
   If rate limits block testing or usage more than a few times per week, paid usage is easier to operate.

2. You have large reusable prompts.
   
   Stable long prompts can benefit from prompt caching.

3. You need compliance or support.
   
   Free tiers are not the right place for SOC 2 audit trails, BAAs, regional data residency, or production support requirements.

Migration is usually small:

• For xAI Console, keep the same API surface and use paid billing.
• For OpenRouter, change the model or base URL.
• For Puter.js, keep the browser flow if user-paid usage still fits your product.

FAQ

Is Grok 4.3 truly free?

It depends on the path.

• xAI Console: free while promotional credits last.
• Puter.js: free for the developer because the user pays.
• grok.com: free within a daily message quota.

Can I use Grok 4.3 from a backend without paying?

Yes, while xAI Console credits last. After that, you need paid usage or a browser-based user-pays flow such as Puter.js.

Does Puter.js work in Node.js?

Puter.js is browser-first. The user-pays model is built around browser authentication and user handoff. For backend usage, use the xAI Console path while credits last.

What model ID should I use on Puter.js?

Use:

x-ai/grok-4.3

What model ID should I use with xAI directly?

Use:

grok-4.3

Do free credits cover function calling and video input?

Yes. Console credits apply to Grok 4.3 usage, including function calling, long context, video input, and reasoning effort. Watch token usage closely because video and long context can consume credits quickly.

How does this compare to Grok Voice?

Grok Voice has its own free-access pattern. For that walkthrough, see How to use Grok Voice for free.

Is there a free Grok 4.3 mini?

Not currently. xAI has not released a separate mini SKU for the 4.3 line. The closest free substitute mentioned here is grok-4-fast:free on OpenRouter, which is a smaller, faster Grok 4 variant.

Wrapping up

Use the path that matches your implementation:

• Use xAI Console credits if you need the real backend API.
• Use Puter.js if you are shipping a browser-based public app and want users to cover usage.
• Use grok.com or X if you only need manual chat.
• Use OpenRouter free Grok variants if you want free Grok-class output but do not need Grok 4.3 specifically.

If none of the free paths fit, Grok 4.3’s paid pricing is still low enough for many side projects.

For the full paid API walkthrough, see How to use the Grok 4.3 API. For the head-to-head against OpenAI, see Grok Voice vs GPT-Realtime.

Build the request once in Apidog, swap the base URL between providers, and ship on the option that fits your usage curve.