Grok 4.7 API Setup: 12 Steps, $2/$6 per 1M Tokens [2026]

xAI shipped Grok 4.7 to the public API on September 21, 2026, and the model listing now sits behind documentation that carries a new “SpaceXAI Docs” header at docs.x.ai. If you have not touched the Grok API since Grok 4.5 or Grok 4.6, the pricing, the context window, and the reasoning controls have all shifted enough to trip up an existing integration. This tutorial walks through account setup, key generation, your first request in Python and Node.js, cost control through reasoning effort, function calling, vision input, streaming, and a small working project you can run today. Every step below reflects what is live in the Grok API as of late September 2026, not what shipped a year ago.

Why the Grok API Matters for Developers Right Now

Grok 4.7 is xAI’s frontier model for coding, agentic tasks, and knowledge work, and it replaced Grok 4.6 as the default recommendation on the API within weeks of release. The model ships with a 500,000-token context window, accepts both text and image input, and returns text-only output with no stated output length cap. Pricing sits at $2 per million input tokens and $6 per million output tokens for prompts under 200,000 tokens, a rate that carried over unchanged from Grok 4.6 rather than climbing with the new release. xAI’s own Grok 4.7 model page lists a knowledge cutoff of May 2026, so treat anything after that date as something the model has to be told about explicitly rather than something it already knows.

What actually changed between generations is harder to see from the pricing page alone. xAI’s release notes describe Grok 4.7 as an upgrade to reasoning quality and agentic tool use rather than a jump in raw context size or token cost, which is unusual in a market where competing labs have been racing to cut prices. We covered the Grok 4.7 pricing and benchmark story when it launched, and this guide picks up where that story left off: the actual mechanics of wiring the API into a project. Independent tracking from Artificial Analysis confirms the same context window and pricing figures published in xAI’s own documentation, which is a useful cross-check before you commit a production budget to a new model.

Grok 4.7 also introduced a companion coding-focused variant called Grok 4.7 Fast, but that variant is restricted to xAI’s own Cursor and Grok Build integrations. It does not appear as a selectable model ID on the public API, which trips up developers who read about it in release notes and then go looking for it in their own code. Keep that distinction in mind as you work through the steps below.

It also helps to know why the documentation looks slightly different if you last read it a year ago. The developer portal at docs.x.ai now displays a “SpaceXAI Docs” header at the top of every page, a branding change that showed up alongside the Grok 4.7 release notes. The API endpoints, model IDs, and authentication scheme have not changed because of it, so do not let the new header make you second-guess a working integration.

Prerequisites: What You Need Before You Start

This tutorial assumes a working terminal and basic comfort running pip or npm commands. You do not need prior experience with the Grok API, but you do need the following in place before Step 1.

• Python 3.10 or newer, or Node.js 18 or newer (either works, and the examples cover both)
• The official openai Python package (1.x line) or the openai npm package, since xAI’s Grok API mirrors the OpenAI Chat Completions request and response format
• A valid payment method to add to the xAI Console, since the Grok API requires billing to be configured before it issues live traffic beyond any trial credit
• An X (Twitter) account or email address to register your xAI developer account
• curl, for the quick connectivity tests in Steps 4 and 5
• About 90 minutes if you work through every step, including the CLI project at the end

One prerequisite worth flagging separately: xAI’s billing documentation does not publish a fixed minimum prepay amount that applies to every account, so check the current figure on your own Billing page in the console before you assume a specific dollar minimum. Budgets vary by account type and region.

If you are deciding between the Python and Node.js examples in this guide, pick whichever matches your existing stack rather than treating one as objectively better. Both SDKs wrap the same underlying REST API, so a function-calling example in Python and a streaming example in Node.js will behave identically against Grok 4.7 once the request bodies match. Data scientists and backend teams already using pandas or FastAPI will find the Python path faster to wire in, while teams building a browser-facing tool or an Electron app will get more value from the Node.js client since it shares a runtime with the rest of the frontend.

Step 1: Create Your xAI Developer Account

Go to the xAI Console and sign in with either your X account or a work email. New accounts land on a dashboard that lists API keys, billing, usage, and the model catalog. If you already have a personal Grok subscription through the X app, note that it is a separate product from API access. A Grok Premium+ subscription does not automatically unlock API credits, so you still need to complete billing setup separately inside the console.

Once you are logged in, take a minute to look at the Models page in the console. It lists every model your account can currently call, including grok-4.7, the previous-generation grok-4.6, and lighter variants. This page is the fastest way to confirm a new model has actually rolled out to your account rather than relying on release-note dates alone.

Step 2: Add Billing and Generate a Grok API Key

Open the Billing tab in the console and attach a payment method. The Grok API will not serve production traffic on an account with no billing method attached, even if your account shows trial credit. Once billing is confirmed, move to the API Keys tab and click Create Key. Give the key a descriptive name tied to the project that will use it, since the console lets you track spend and revoke access per key rather than per account.

Copy the key immediately. xAI, like most model providers, shows the full key value exactly once. Store it in a password manager or a local secrets file that is excluded from version control, never in a script you plan to commit.

Securing and Rotating Your Key

Treat a Grok API key the same way you would treat a database password. Set it as an environment variable rather than hardcoding it, scope separate keys to separate environments (development, staging, production), and rotate any key that has touched a public repository, a shared Slack channel, or a support ticket. The console lets you revoke a single key without affecting others tied to the same account, which is the whole point of naming keys clearly in the first place.

# macOS/Linux
export XAI_API_KEY="your-key-here"

# Windows PowerShell
setx XAI_API_KEY "your-key-here"

Step 3: Install the SDK and Configure Your Environment

xAI built the Grok API to match OpenAI’s Chat Completions schema closely enough that you can reuse the official openai Python package instead of installing a separate xAI-specific library. That means the fastest path to a working integration is pointing the existing openai package at xAI’s base URL and swapping in your Grok API key. xAI’s own quickstart guide walks through the same pattern if you want a second reference alongside this tutorial.

# Python
pip install --upgrade openai

# Node.js
npm install openai

With the package installed, create a client object that targets xAI’s global endpoint instead of OpenAI’s own servers. The base URL is the one setting that makes this whole approach work, so double-check it before you move on.

from openai import OpenAI
import os

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

Step 4: Send Your First Grok 4.7 API Request

With the client configured, call chat.completions.create and pass grok-4.7 as the model string. The request and response shapes match what you already know from OpenAI’s API, which is the entire appeal of the compatibility layer.

response = client.chat.completions.create(
    model="grok-4.7",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what changed in Grok 4.7 in two sentences."},
    ],
)

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

A healthy response returns a JSON object with a choices array, a usage block reporting prompt and completion token counts, and a model field confirming which model actually served the request. If you want to sanity-check connectivity before writing any code, curl works just as well.

curl https://api.x.ai/v1/chat/completions 
  -H "Content-Type: application/json" 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -d '{
    "model": "grok-4.7",
    "messages": [{"role": "user", "content": "Say hello in five words."}]
  }'

Expect a response body with an id field starting with something like chatcmpl-, a choices[0].message.content string with the model’s reply, and a usage object showing prompt_tokens, completion_tokens, and total_tokens. If those fields come back, your key, endpoint, and model string are all correct.

Step 5: Understand Grok 4.7 Pricing and the 200K-Token Threshold

Grok 4.7 uses a two-tier pricing structure based on prompt length, and missing this detail is one of the fastest ways to get an unpleasant billing surprise. Prompts under 200,000 tokens bill at the standard rate. Once a single prompt crosses 200,000 tokens, xAI switches to a long-context rate that roughly doubles input and output pricing. This is a per-request threshold, not an account-wide setting, so a single long document search can jump into the higher tier while the rest of your traffic stays on the standard rate.

Endpoint / Tier	Input (per 1M tokens)	Cached Input (per 1M tokens)	Output (per 1M tokens)
Global, under 200K tokens	$2.00	$0.50	$6.00
Global, 200K+ tokens	$4.00	$1.00	$12.00
US regional, under 200K tokens	$2.20	$0.55	$6.60
US regional, 200K+ tokens	$4.40	$1.10	$13.20

The US regional endpoint adds a flat 10% premium across every rate, which explains the numbers in the bottom two rows. That premium buys you data residency guarantees for regulated workloads, not extra performance, so most projects outside a compliance requirement should default to the global endpoint. Cached input pricing matters more than it looks at first glance: repeated system prompts, few-shot examples, or long documents that get reused across a session bill at a quarter of the standard input rate once xAI’s cache picks them up.

Grok 4.7’s pricing carried over unchanged from Grok 4.6, according to the model catalog published in xAI’s own pricing documentation. If you were already budgeting for Grok 4.6 traffic, migrating to Grok 4.7 should not move your monthly bill on its own, only your usage patterns will.

A useful habit here is logging the prompt token count of every request before it goes out, not just after the response comes back. Since the 200K-token threshold applies per request rather than as a running account total, the only reliable way to catch a prompt about to cross into long-context pricing is to measure it client-side before you send it. A document-heavy retrieval pipeline that concatenates several source chunks into one prompt is the most common place this bites teams, since adding one more search result can silently double that request’s cost without any error or warning from the API.

Step 6: Tune Reasoning Effort to Control Cost and Depth

Grok 4.7 exposes four reasoning effort levels, and picking the wrong one is the single most common reason developers either overpay or get shallow answers on hard problems. Reasoning tokens are billed as part of your total completion usage, so a higher effort setting costs more per call even though the per-token rate does not change.

Effort Level	Best For	Relative Latency
low	Simple classification, short factual lookups, chat UI autocomplete	Fastest
medium	General assistant replies, summarization, routine coding help	Moderate
high (default)	Multi-step reasoning, agentic tool use, non-trivial code generation	Slower
xhigh	Hard math, long planning chains, cases where being wrong is expensive	Slowest

Set the level explicitly with the reasoning_effort parameter rather than trusting the default in a cost-sensitive production path.

response = client.chat.completions.create(
    model="grok-4.7",
    reasoning_effort="low",
    messages=[
        {"role": "user", "content": "Is 'Colour' the British spelling of 'Color'? Answer yes or no."},
    ],
)

A quick way to see the impact: run the same prompt at low and xhigh and compare the usage.completion_tokens field in each response. For anything beyond a trivial lookup, expect the gap to be significant, since reasoning tokens accumulate before the model produces its visible answer.

xAI’s own reasoning documentation confirms that reasoning tokens are billed as ordinary completion tokens rather than as a separate line item, which means there is no hidden fee structure to reverse-engineer. The only thing that changes across effort levels is how many of those completion tokens the model spends thinking before it writes a visible answer. A practical pattern for a customer-facing product is to expose effort as an internal routing decision rather than a user-facing toggle: classify incoming requests by apparent complexity, default routine ones to medium, and only escalate to high or xhigh when a request matches patterns you have identified as genuinely hard, such as multi-step calculations or requests that reference several earlier messages in a long conversation.

Step 7: Add Function Calling and Structured Outputs

Grok 4.7 supports both function calling and structured outputs, which is what turns a chat model into something you can wire into an actual application rather than a demo. Function calling lets the model request that your code run a specific tool with specific arguments, while structured outputs force the model’s final answer into a JSON schema you define.

Function Calling Example

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_stock_price",
            "description": "Get the latest price for a stock ticker",
            "parameters": {
                "type": "object",
                "properties": {
                    "ticker": {"type": "string", "description": "Stock ticker symbol"}
                },
                "required": ["ticker"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="grok-4.7",
    messages=[{"role": "user", "content": "What is AMD trading at?"}],
    tools=tools,
)

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

Note that tool costs are not just tokens. xAI’s tools documentation states that requests involving tool calls are priced on both token usage and tool invocation counts, since a single query can trigger the model to call multiple tools before it answers. Budget for that if you are building an agent that chains several tool calls per user turn.

Structured Outputs Example

response = client.chat.completions.create(
    model="grok-4.7",
    messages=[{"role": "user", "content": "Extract the name and role from: 'Elena Petrova, Lead Backend Engineer'"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person_extraction",
            "schema": {
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "role": {"type": "string"},
                },
                "required": ["name", "role"],
            },
        },
    },
)

Structured outputs remove an entire category of bugs where a model wraps valid JSON in explanatory prose or drops a required field. Use them anywhere downstream code parses the model’s answer programmatically, which in practice is most production integrations.

Step 8: Send Image Input for Vision Tasks

Grok 4.7 accepts image input alongside text, but it only returns text output, so do not build a workflow that expects the model to generate or edit images directly through this endpoint. For that, xAI’s separate Grok Imagine product handles generation. To send an image, pass a base64-encoded payload or a public URL inside the message content array.

response = client.chat.completions.create(
    model="grok-4.7",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is misconfigured in this architecture diagram?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/diagram.png"}},
            ],
        }
    ],
)

Image tokens count toward the same 500,000-token context window as text, and image pricing is billed at the same per-token rate as text input on Grok 4.7, so a handful of screenshots in a long-running conversation add up faster than plain text would.

Step 9: Stream Responses for Real-Time Output

For chat interfaces or command-line tools where users expect to see tokens appear as they generate, set stream=True and iterate over the response chunks instead of waiting for the full completion.

stream = client.chat.completions.create(
    model="grok-4.7",
    messages=[{"role": "user", "content": "Write a short haiku about debugging."}],
    stream=True,
)

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

Streaming does not change your total token cost, it only changes when you receive the tokens. If your application logs usage for billing reconciliation, pull the final usage object from the last chunk in the stream rather than trying to sum partial deltas yourself.

Step 10: Choose a Regional Endpoint and Track Rate Limits

Beyond the global endpoint at api.x.ai/v1, xAI runs a US regional endpoint at us.api.x.ai/v1 that keeps traffic inside US infrastructure at the 10% price premium covered in Step 5. As of late September 2026, Grok 4.7 and Grok 4.6 are the only two models available on that regional endpoint, so if you need regional guarantees on a different model, check the console’s models list before committing to an architecture.

On rate limits, xAI’s published catalog for Grok 4.7 lists a request cap of 150 requests per second, 7,200 requests per minute, and 50 million tokens per minute at the account’s default tier. Those numbers scale with your account’s usage tier, so a brand-new account and a high-spend enterprise account will not see identical limits. Watch for HTTP 429 responses, which signal you have hit one of these caps rather than an authentication or malformed-request problem. Full details on how regional routing and its pricing premium work are in xAI’s regional endpoints documentation, including the note that Grok 4.7 and Grok 4.6 are currently the only two models exposed on the US endpoint.

import time
from openai import RateLimitError

def call_with_backoff(client, **kwargs):
    delay = 1
    for attempt in range(5):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError:
            time.sleep(delay)
            delay *= 2
    raise RuntimeError("Grok API rate limit exceeded after 5 retries")

If your workload processes large batches asynchronously rather than serving live users, look at xAI’s Batch API. It offers reduced per-token pricing and higher effective rate limits in exchange for asynchronous processing, which fits report generation, bulk document analysis, and offline evaluation runs far better than a synchronous request loop.

What Actually Changed From Grok 4.6 to Grok 4.7

Before you migrate an existing Grok 4.6 integration, it helps to know exactly what moved and what stayed flat. Pulling the model catalog directly from xAI’s documentation shows that Grok 4.7 kept the same context window, the same rate limits, and the same per-token pricing as Grok 4.6. The two generations are, on paper, priced and throttled identically. What xAI actually shipped in the newer release is better reasoning and tool-use quality at the same infrastructure cost, which is a different kind of upgrade than developers are used to seeing from a version bump.

Model	Context Window	Requests/Min	Tokens/Min	Input Price (per 1M)
grok-4.5	500,000	7,200	50,000,000	$2.00
grok-4.6	500,000	7,200	50,000,000	$2.00
grok-4.7	500,000	7,200	50,000,000	$2.00

That flat line across three model generations is worth sitting with for a second. In a market where Gemini, DeepSeek, and Claude have all cut prices repeatedly through 2026, xAI held its Grok pricing steady while shipping quality improvements underneath the same numbers. For a team already running Grok 4.6 in production, that makes the migration decision almost entirely about output quality and reasoning behavior, not about a fresh cost-benefit spreadsheet. Swap the model string, rerun your existing eval suite, and compare outputs directly since nothing else in your integration needs to change.

One caveat: do not assume every account sees identical rate limits regardless of tier. The figures above reflect the default tier published in xAI’s model catalog, and accounts with higher historical spend or enterprise agreements can see different request and token ceilings. Check your own account’s usage page rather than treating this table as a universal guarantee.

Building a Complete Project: A Grok 4.7 Research CLI Tool

To tie every piece together, here is a small but complete command-line tool that accepts a research question, queries Grok 4.7 with high reasoning effort, streams the answer to the terminal, and prints a running token cost estimate using the pricing from Step 5. Save it as grok_research.py.

import os
import sys
from openai import OpenAI

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

INPUT_RATE = 2.00 / 1_000_000
OUTPUT_RATE = 6.00 / 1_000_000

def ask(question: str, effort: str = "high"):
    stream = client.chat.completions.create(
        model="grok-4.7",
        reasoning_effort=effort,
        messages=[
            {"role": "system", "content": "You are a research assistant. Cite specifics and flag uncertainty."},
            {"role": "user", "content": question},
        ],
        stream=True,
    )

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

def estimate_cost(prompt_tokens: int, completion_tokens: int) -> float:
    return round(prompt_tokens * INPUT_RATE + completion_tokens * OUTPUT_RATE, 5)

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python grok_research.py "your question here"")
        sys.exit(1)

    question = " ".join(sys.argv[1:])
    print(f"Asking Grok 4.7: {question}n")
    answer = ask(question)
    approx_tokens = len(answer.split()) * 1.3
    print(f"n---nApprox completion tokens: {int(approx_tokens)}")
    print(f"Approx cost (output only): ${estimate_cost(0, int(approx_tokens))}")

Run it from the terminal with a question as the argument.

python grok_research.py "What are the tradeoffs of the 200K-token pricing threshold for a document-heavy RAG pipeline?"

You should see the answer stream token by token in your terminal, followed by an approximate output-token count and dollar estimate. This is a rough estimate rather than exact billing, since the script does not call the API’s own usage field in streaming mode. Extend it by capturing the final chunk’s usage data if you need precise numbers for a production cost dashboard, or by swapping the effort argument to compare answer quality at different reasoning levels on the same question.

Monitoring Cost and Usage Before You Ship

Every response from the Grok API includes a usage object with exact prompt, completion, and total token counts, which is the only reliable source of truth for what a given call cost. Do not estimate cost from word counts or character counts in production code. Use the numbers the API actually reports. A simple logging wrapper around every call gives you a running record you can reconcile against your monthly xAI invoice.

import csv
import datetime

def log_usage(response, log_path="grok_usage.csv"):
    usage = response.usage
    row = [
        datetime.datetime.utcnow().isoformat(),
        response.model,
        usage.prompt_tokens,
        usage.completion_tokens,
        usage.total_tokens,
    ]
    with open(log_path, "a", newline="") as f:
        csv.writer(f).writerow(row)

Call log_usage(response) right after every completion and you get a plain CSV file you can load into a spreadsheet or a dashboard to catch cost spikes before they show up on an invoice. This matters more for Grok 4.7 than for a flat-rate model, since the 200K-token long-context threshold means two requests with similar-looking prompts can cost very different amounts depending on which side of that line they land on. Reviewing the log weekly during early development is enough to catch a runaway prompt template before it reaches production traffic.

Common Pitfalls When Setting Up the Grok API

Most Grok API setup problems trace back to a handful of repeat offenders, and nearly all of them show up in the first hour of integration rather than later in production. Here is the list to check against before you consider your setup finished.

• Assuming grok-4-7-fast is a public model ID. It is only available inside Cursor and Grok Build, not the general API, so calling it directly returns a model-not-found error.
• Forgetting the long-context pricing threshold. A single 210,000-token prompt bills at double the standard rate on both input and output, which can blow a budget that assumed flat pricing.
• Hardcoding the API key in application code. Keys committed to a public or even private repository get scraped by automated scanners within hours in most reported incidents across the industry.
• Leaving reasoning_effort at the default in a latency-sensitive path. The default of high is tuned for quality, not speed, and it will feel slow in a live chat UI compared to low or medium.
• Mixing up the global and US regional base URLs. A key created and billed against one region will not silently work against the other endpoint’s URL if your account setup does not match.
• Ignoring tool invocation costs in agentic workflows. Function calling costs scale with both tokens and the number of tool calls the model makes, so a chain of five tool calls per user turn adds up differently than a single completion.
• Not handling streaming’s partial usage data. Summing token deltas yourself during a stream is unreliable, so pull the final usage object once the stream closes instead.

Troubleshooting: 8 Grok API Setup Issues and Fixes

When something breaks, resist the urge to regenerate your API key as a first response. Most failures are configuration or logic errors rather than a bad key, and swapping the key just adds an extra step to your debugging process without fixing anything. Work through the table below in order, starting from the HTTP status code your client actually received.

Symptom	Likely Cause	Fix
HTTP 401 Unauthorized	Missing, expired, or malformed API key	Regenerate the key in the console and confirm the Authorization header uses a “Bearer” prefix
HTTP 429 Too Many Requests	Exceeded RPS, RPM, or TPM limit for your tier	Add exponential backoff and check your current tier limits on the console’s usage page
HTTP 400 model not found	Typo in model string, or requesting an API-restricted model like grok-4.7-fast	Confirm the exact model ID against the console’s live Models page
Billing error on first request	No payment method attached to the account	Add a payment method under the Billing tab before generating traffic
Unexpectedly high invoice	Prompts silently crossed the 200K-token long-context threshold	Log prompt token counts per request and alert above 190K tokens
Empty or truncated response	Output cut off by a client-side timeout during a high reasoning_effort call	Increase client timeout or switch to streaming for long-running responses
Function call never triggers	Tool description too vague or missing required parameter schema	Write explicit, specific tool descriptions and mark required fields
Image input rejected	Malformed base64 payload or unreachable image URL	Validate the image loads in a browser and re-encode base64 without line breaks

Advanced Tips for Production Grok API Use

Once the basic integration works, a few details separate a fragile prototype from something that holds up under real traffic. First, take advantage of cached input pricing deliberately. If your application reuses a long system prompt or a static knowledge document across many requests, keep that content in the same position across calls so xAI’s caching layer can recognize and discount it at roughly a quarter of standard input pricing.

Second, if your workload involves multi-step agentic reasoning where you want to carry the model’s internal reasoning trace into a follow-up call rather than just its final answer, Grok 4.7 supports encrypted reasoning content. Requesting it does not expose readable chain-of-thought text, but it lets you pass the encrypted reasoning state back into a follow-up call so the model does not have to redo earlier reasoning from scratch.

response = client.chat.completions.create(
    model="grok-4.7",
    messages=[{"role": "user", "content": "Plan a three-step migration for a legacy auth system."}],
    reasoning_effort="xhigh",
    extra_body={"include": ["reasoning.encrypted_content"]},
)

Third, build a routing layer rather than hardcoding a single model everywhere in your codebase. If Grok 4.7 is one option among several models your product uses, a lightweight router that falls back to a different provider during an outage or rate-limit spike keeps your application resilient. We walked through exactly that pattern in our multi-model AI router guide, which pairs well with the Grok setup covered here.

Finally, treat reasoning effort as a per-request decision, not a global setting. A support chatbot answering a simple question should rarely run at xhigh, while an agent verifying a financial calculation should rarely run at low. Building that branching logic into your prompt router up front saves real money at scale, and it is a similar lesson to what we found writing the Claude Fable 5.1 API setup guide and the Gemini API key walkthrough, both of which expose comparable effort or thinking controls under different names.

If Grok 4.7 is one model in a wider evaluation, it is worth reading how it stacks up against dedicated inference hardware providers, since Groq’s chip-based serving approach targets a different bottleneck (raw token throughput) than xAI’s own model quality improvements.

Frequently Asked Questions

What is the exact model ID for Grok 4.7 on the API?
Use grok-4.7 in the model field of your chat completions request. There is no separate “latest” alias documented for this release as of late September 2026, so pin the exact string in production code.

Is the Grok API free to use?
No. The Grok API requires a billing method attached to your xAI Console account. Any trial credit that may appear on a new account is limited and does not represent ongoing free access.

How large is the Grok 4.7 context window?
500,000 tokens, covering both text and image input combined. Prompts that exceed 200,000 tokens move into the long-context pricing tier described in Step 5.

Can Grok 4.7 generate images?
No. Grok 4.7 accepts image input for analysis but only produces text output. Image generation runs through xAI’s separate Grok Imagine product and API.

Does the OpenAI Python SDK actually work with Grok, or do I need a separate library?
The official openai package works directly against Grok’s API once you set the base_url to xAI’s endpoint and swap in your Grok API key, since the request and response schema mirrors OpenAI’s Chat Completions format.

What is the difference between the global and US regional endpoints?
The US regional endpoint at us.api.x.ai/v1 keeps traffic within US infrastructure and costs a flat 10% more across input, cached input, and output pricing than the global endpoint. Choose it only if you have a specific data residency requirement.

Why does my Grok 4.7 request return a 429 error?
You have hit your account’s requests-per-minute, requests-per-second, or tokens-per-minute cap. Grok 4.7’s published default limits are 150 requests per second, 7,200 requests per minute, and 50 million tokens per minute, though your account’s actual tier may differ. Add retry logic with exponential backoff rather than retrying immediately.

Should I always use the highest reasoning effort for the best answers?
No. Higher reasoning effort increases both latency and cost, since reasoning tokens count toward your completion token usage. Reserve xhigh for genuinely hard, high-stakes tasks and use low or medium for routine requests.

Can I see Grok 4.7’s chain-of-thought reasoning directly?
Not as plain readable text. Grok 4.7 supports encrypted reasoning content that your application can pass back into a follow-up call so the model does not repeat earlier reasoning, but xAI’s documentation does not describe an option to expose that reasoning as human-readable text through the public API.

Do I need a different API key for the US regional endpoint?
No, the same API key authenticates against both the global endpoint and the US regional endpoint. What changes is the base URL you point your client at and the per-token price, which carries a 10% premium on the US endpoint.

Related Coverage

• Hy Image 3.5 API Setup: 12 Steps, $0.024/Image [2026]
• Gemini 3.8 Flash API: Full Setup Tutorial in 10 Steps [2026]
• Computer-Use AI Agent Setup: 13 Steps, 90 Min [2026]
• AI Red Teaming Setup: garak & PyRIT in 13 Steps [2026]
• Set Up Claude Fable 5.1 API: 12 Steps, 90 Min [2026]