How to Get a Grok API Key: Setup, Pricing and Live X Data for the xAI API

These steps follow the xAI quickstart and billing docs as of 2026. Button labels in the console change from time to time; the page names below are the ones the docs link to.

1. Create an account. Sign up or sign in at console.x.ai. API access is organized by team: every key belongs to a team, and the team's credits and rate limits apply to all of its keys.

2. Add credits. Open Billing and buy prepaid credits (the docs call this "API spend management"). This is also where you enter a promo code if you have one. Card payments are credited right away; a bank transfer takes 2 to 3 business days. With the default $0 invoiced billing limit, requests are rejected once the prepaid balance reaches zero, so set an auto top-up (minimum $5) if your app must not stop.

3. Create the key. Open the API Keys page and create a key. The full key starts with xai- and is shown only at creation; afterwards the console and the API return a redacted form such as xai-...b14o. Keys can be limited to specific endpoints and models (ACLs), capped in requests per second, requests per minute or tokens per minute, and given an expiry time, so a key for a single feature does not need access to everything.

4. Store it as XAI_API_KEY. Export it in your shell or put it in a .env file that is not committed. Keep it on the server: a key in browser JavaScript or a mobile app bundle can be copied and spent by anyone.

Then check that the key works before writing any code. The account endpoint /api-key (under the same https://api.x.ai/v1 base URL) returns the key's name, its ACLs and whether the key or the team is blocked or disabled; /models lists the models this key can call.

Not as a standing tier in the current docs. The xAI billing docs describe two ways to pay, prepaid credits and monthly invoiced billing, plus a promo code field; they do not promise sign-up credits. Third-party guides still report $25 of sign-up credits or a $150-a-month data-sharing program, but neither appears in the current docs.x.ai pages, so treat them as unconfirmed and check the Billing page of your own console before you plan around them.

Credits from X API spend. One documented route to free xAI credits sits on the X side: X's own pricing docs (docs.x.com) say that teams paying for the official X API earn xAI API credits once their X API spend in a billing cycle reaches $200 (10% back, 15% from $500, 20% from $1,000), after linking the xAI team in the X developer console; the count resets each billing cycle. It only pays off if you already buy official X API reads at $0.005 per post. The docs.x.ai pages do not describe the program themselves.

What is free is the key itself: creating one costs nothing, you only pay for usage. A new team starts at rate-limit Tier 0 ($0 cumulative spend) and moves up automatically as it spends, and tiers never downgrade (see the table in the pricing section).

About "free Grok API" wrappers. Some GitHub projects offer a "free Grok API" by driving the consumer Grok web app with your logged-in session. They are not the xAI API, they break whenever the web app changes, and your prompts and session go through code you did not write. For anything you ship, use a real key from console.x.ai.

The xAI API is OpenAI-compatible: point the official OpenAI SDK at https://api.x.ai/v1 and pass your xAI key. xAI also publishes its own Python SDK, xai-sdk, which uses gRPC and covers xAI-only features such as Collections and key management.

The docs now recommend the Responses API (client.responses.create, input in input) for new code. Chat Completions (client.chat.completions.create, input in messages) still works but is labelled a legacy endpoint, and new features arrive in Responses first. If you are porting an OpenAI chat app, the change is the method name and messages to input.

Every response's usage object includes cost_in_usd_ticks, the exact charge for that request, where 1 USD = 10,000,000,000 ticks. Logging it per request is the simplest way to see what a feature costs before the monthly bill does.

Which model? The docs recommend grok-4.7 for code and chat. For high-volume summarizing or classification, grok-4.3 costs less per token (see the table below) and has a 1M-token context window. Model names without a date (grok-4.7) are aliases for the latest stable version; pin a dated name if you need identical behavior over time.

Prices below are copied from the xAI pricing page as of 2026, in USD per 1 million tokens. Requests whose prompt reaches 200k tokens are billed at a higher long-context rate for every token in that request (double the rates shown here for these models).

Worked example. A request with 10,000 input tokens and 1,000 output tokens on grok-4.7 costs 10,000 x $2.00/1M + 1,000 x $6.00/1M = $0.026. The same request on grok-4.3 costs $0.015. Reasoning tokens are billed too, so check usage on real requests.

Tools are billed on top of tokens. When Grok uses a server-side tool, you pay for the tokens it reads and writes plus a per-use fee:

Other price switches. The Batch API takes 20% off grok-4.3 and the grok-4.20 models (other models have no batch discount) and usually completes within 24 hours. Priority processing costs 2x standard rates. The US regional endpoint (https://us.api.x.ai/v1, grok-4.7 and grok-4.6 only) costs 1.1x. A request blocked before generation for violating the usage guidelines is charged $0.05.

Rate limits are set per model in requests per second and tokens per minute, and grow with your team's tier. The tier depends only on cumulative spend since January 1, 2026; exceeding a limit returns HTTP 429.

Your exact per-model limits are on the Models page of the console. Per-second limits are derived from the per-minute request budget (RPM divided by 48, minimum 2), so you cannot spend a whole minute's requests in one burst.

Grok and Groq are different companies with different keys. Grok is xAI's model family; its key comes from console.x.ai, starts with xai- and works against https://api.x.ai/v1. Groq is a separate inference provider that serves open models on its own hardware; its key comes from console.groq.com, is usually stored as GROQ_API_KEY, and works against https://api.groq.com/openai/v1. Both are OpenAI-compatible, which is why a mixed-up key or base URL fails with an authentication error instead of an obvious "wrong provider" message.

The mix-up is mostly a search problem: console.groq.com ranks for "grok api key". Among the posts in our study, only 0.3% of English posts about the Grok API mention Groq at all.

Most failures come from the key's permissions, the team's credit balance, or a wrong base URL. The /api-key check from step 4 answers the first two in one call.

Web Search and X Search are server-side tools: you list them in tools on a Responses API call, Grok decides when to call them, xAI runs the searches, and the answer comes back with source citations. They are the documented way to give the Grok API current information (see the X Search tool docs). Older tutorials describe "Live Search", which the release notes list from 2025; the current docs document these tools instead. Server-side tools are not available on Chat Completions, which supports only your own function calling.

Both counters are in usage.server_side_tool_usage_details on the response, which is how you reconcile a request against the fees. Because the model chooses how many searches to run, the cost of one question varies; max_turns limits the rounds of tool calls, and narrow handles, domains and dates limit what each search returns. Image understanding on either tool is billed as image tokens rather than a separate fee.

Grok models do not know about current events on their own. The xAI models page says so directly: there is no access to real-time events without search tools enabled. If your app needs today's X posts, there are two ways to get them into a Grok request.

Route A: Grok's built-in X Search tool. Add {"type": "x_search"} to tools (parameters in the table above). Grok writes its own searches, and you pay $5 per 1,000 posts fetched plus tokens. Every post returned counts, including parent and quoted posts, and the count is not de-duplicated: a post returned by two searches is billed twice.

Route B: fetch the posts yourself, then ask Grok. Call an X data API with the exact query you want, keep the fields you need, and pass them to Grok as input. With TwitterAPI.io, GET https://api.twitterapi.io/twitter/tweet/advanced_search takes the same advanced-search syntax as X (from:, since:, min_faves:, lang:, -filter:retweets and the rest of the Twitter search operators), returns 20 tweets per page with a cursor, and costs $0.15 per 1,000 tweets returned, with a minimum of 15 credits ($0.00015) per request. The full script is below.

On the fetch fee alone, $5 / $0.15 = about 33x per 1,000 posts. Route A is still the quicker build for one-off questions ("what are people saying about X today?"), where letting the model choose the searches is the point. Route B fits pipelines that run on a schedule, need the same query every time, store the raw posts, or feed hundreds of posts per run.

A month of hourly digests. Say an app summarizes 100 posts every hour for 30 days: 72,000 posts. On Route A, if Grok fetches 100 posts per run, the X Search fee is $360.00 before tokens. On Route B the TwitterAPI.io fetch is $10.80, and sending the slim 7-field posts to grok-4.7 adds about 14.4M input tokens, $28.80 at $2.00/1M. Both routes also pay for the summary output, and Route A's input tokens depend on how much of each post the model reads.

The script below does three things. It pages through advanced_search with queryType=Latest, keeps 7 fields per post (url, text, createdAt, author handle, and like, repost and reply counts), and sends them to Grok with a system prompt that treats post text as data. Posts are written by strangers, so never let their text act as instructions to the model.

Run it: pip install openai requests, export XAI_API_KEY and TWITTERAPI_IO_API_KEY (from your TwitterAPI.io dashboard), then python grok_x_summary.py. Three pages are 60 tweets, which costs $0.009 on TwitterAPI.io. We ran the fetch half against the live API while writing this page: two pages returned 40 posts with every url and author handle present.

Rate limits on the X side. TwitterAPI.io allows 0.2 requests per second (one every 5 seconds) before your first payment and 20 per second after it, so on free credits put a 5-second pause between pages. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card); it is one grant per person or network, repeat sign-ups from the same network within 30 days get $0.10, and free credits expire after 31 days.

Why slim the posts. The raw JSON for one post carries the whole author profile, entities, media and nested quoted posts. In our sample of 1,200 posts it averaged about 1,124 tokens per post, against 200 for the 7-field version (5.6x fewer). For 1,000 posts on grok-4.7 that is $2.25 of input tokens raw versus $0.40 slim; on grok-4.3, $1.41 versus $0.25.

Going further. Swap the query for from:handle to follow one account, add since: and until: for a date window, or keep the raw JSON in your database and send Grok only the slim view. For agent frameworks, the same endpoint is wrapped as tools in our guides for Claude, the OpenAI Agents SDK and the Vercel AI SDK (links below).

To see which problems people actually run into, we pulled the newest 1,200 public X posts matching ("grok api" OR "xai api" OR "grok api key") -filter:retweets through TwitterAPI.io advanced search (Latest), then tagged each post by keyword. 63.7% of the posts were in English, 11.2% Japanese and 10.4% Chinese; 51.7% were original posts, 29.3% replies and 19.0% quotes.

Cost is the main subject: 42.5% of English posts talk about prices, credits or plans, often new-model launch prices and the bundled consumer plans rather than the API itself. Keys and the console come up in 15.3%, and 9.6% describe errors, rate limits or outages. That is why this page leads with the key steps, the pricing table and the troubleshooting table.

The same sample gives the token side of Route B. We measured each post twice, as the raw API JSON and as the 7-field slim JSON from the script, and priced 1,000 posts at Grok input rates.

Medians are lower than the means (840 raw and 99 slim tokens per post) because a few long posts and quote chains pull the averages up. Output tokens are not included; they depend on how long you ask the summary to be, not on the route. Route A's token use is not in the table because the model decides how much of each fetched post it reads, so we could not measure it from the outside.

Collecting the whole sample took 60 requests and cost $0.18 in TwitterAPI.io credits.

Question. What do public X posts about the Grok API discuss, and how many Grok input tokens does one X post add? Query. ("grok api" OR "xai api" OR "grok api key") -filter:retweets, Latest, through GET https://api.twitterapi.io/twitter/tweet/advanced_search, 60 pages of 20 posts. Sample. The newest 1,200 matching posts, collected in 2026, spanning about 24 weeks.

Method. Topics are case-insensitive keyword matches on the post text (for example "pric", "cost", "credits" for pricing; "api key" or "console" for keys). Tokens are characters divided by 4, a model-agnostic estimate; Grok's own tokenizer will give somewhat different counts, and usage.input_tokens on a real request is the number that is billed. Prices are taken from docs.x.ai and twitterapi.io/pricing.

What the sample cannot show. It is one keyword query, so posts that discuss the API without these phrases are missing, and posts in other languages were not translated before tagging. Keyword tags miss sarcasm and text inside images, and a post can count under several topics. We did not run Route A at scale, so its token usage is not measured. Only aggregates are published; no individual posts or authors are shown or stored in the study files.