Grok Complete Guide: Plans, Models, Imagine, the xAI API, and Privacy Settings

How to Read This Guide

This is a continuously updated reference document, not a one-off tutorial. The information was checked on 2026-11-06, and facts follow the official pages of xAI (officially referred to as SpaceXSI in its documents), including x.ai, grok.com, docs.x.ai, the X Help Center, and the App Store and Google Play listings. Where the official sources have no answer, or where official pages contradict each other, this guide says “not published by the official source” or “official pages are inconsistent” and does not fill the gap with third-party numbers.

Grok was repackaged across the board in 2026: the company it belongs to, the subscription plans, the mode menu, and the way usage is counted have all changed. If your picture of Grok is still the 2025 one, with SuperGrok, DeepSearch, and the Think button, most of it no longer matches. Start with the comparison table below.

What Grok is

Grok is an AI assistant and model family developed by xAI. On the user side, the entry points are grok.com, the iOS and Android apps, and Grok built into X (formerly Twitter). On the developer side there are the API and tools such as Grok Build. The main features the official sources describe are:

• It can search the web and public X posts during a conversation and attach citations.
• One app brings together voice, image and video generation (Grok Imagine), file upload, Connectors, Skills, Automations, and Build.
• The paid plans bundle Grok, Grok Bot, Cursor, and X Premium into a single subscription (Chapter 3).

How xAI, SpaceX, and X relate

This section covers only what the official pages can verify:

The official naming is not consistent either: the website footer reads © 2026 SpaceX Super Intelligence LLC, and the Terms and AUP refer to the company as SpaceXSI, but the App Store copyright line still reads © xAI Inc., and the developer field shows X Corp. The first time this guide mentions the company it writes “xAI (officially referred to as SpaceXSI in its documents)”. After that, “xAI” means the company and “Grok” means the product.

Grok is not Groq

Grok is xAI’s chatbot and model family, at grok.com. Groq (spelled with one fewer o) is a different company, Groq Inc., which makes LPU inference chips and a cloud inference service and has no relationship with xAI. The names are similar, so check the domain when you search, buy a subscription, or connect an API:

This guide covers only the former.

Major changes this year

The table below compares what was commonly believed in 2025 with the official state on the check date:

How to read this guide

Suggested order:

1. Read this chapter and Chapter 2 first to confirm your entry point and sign-in method.
2. Chapters 3 and 4 explain the plans, usage, and the mode and model names in the app.
3. Everyday chat, Imagine, workflows (Connectors, Skills, Automations, Build), and Grok Bot each have their own chapter.
4. Everyone should read the privacy and data chapter, especially the “Improve the model” switch and Private Chat.
5. Developers should read the chapters on the API and Grok Build.

Every chapter ends with its sources and the check date. If a number or name differs from what you see in the interface, trust the interface and the official pages. That is also why this guide needs to be kept up to date.

The items most likely to go out of date

The following items can change within a month or two. Check the official pages again before you act:

A note on prices: USD prices come from the official pages. NT$ prices are the reference prices shown on grok.com/plans for Taiwan on the check date. Promotions and in-app purchase prices may differ. See Chapter 3 for details.

Sources: xAI joins SpaceX, Terms of Service, Privacy Policy, Consumer FAQs, X Subscription announcement, Grok 4.5 everywhere, Grok 4.7, Grok Automations, Introducing Grok Bot, Grok Connectors, Grok Skills, Grok Imagine Image 2.0, Grok Imagine Video 1.5, Grok FAQ, About Grok (X Help Center) (checked 2026-11-06)

Access, Installation, and Sign-in

Grok has more than one entry point. The web, the mobile apps, and Grok built into X are the three most common, and there are further entry points such as Grok Bot, Grok Build, and the Office add-ins. First work out which one you want to use, because the privacy policy, plans, and features that apply are not exactly the same for each.

Entry points at a glance

The official sources also mention that Grok Voice 3.0 powers in-car voice conversations in Tesla vehicles, and that third-party tools such as OpenClaw, OpenCode, Kilo Code, Warp, and Hermes Agent can sign in with a SuperGrok or X Premium subscription. Both lean toward automotive and developer scenarios and are outside this chapter.

Web: grok.com

Just open grok.com. A few key points:

• You can chat without signing in. The banner on the home page states that these conversations do not appear in your history and are not used to train models. The official consumer FAQ describes signed-out use as “may be collected and retained anonymously”, and in most regions (except the EU and the UK) you cannot opt out of training. The two statements are inconsistent. If privacy matters to you, read the privacy and data chapter first and rely on the settings after you sign in.
• The mode menu in the input box (Fast, Auto, Expert, Heavy) is visible without signing in, and there is also a “Premium” item that requires signing in. See Chapter 4 for what the modes mean.
• Make sure the domain is grok.com. The official FAQ mentions that using the wrong domain (for example grok.x.ai) means features such as Projects are missing.

Mobile apps

The two store pages are not consistent: the App Store copyright line is © xAI Inc. and its developer field shows X Corp., while the Google Play developer field shows SpaceX Super Intelligence. This is a result of the official naming still being in transition. When you download, check the store name “Grok” against the identifiers in the table above.

In addition, the official x.ai/grok marketing page says “30+ languages”, which differs from the number of languages listed on the App Store. The languages that actually work depend on the interface and the conversation, so do not treat the number as a guarantee.

Grok in X

Tap the Grok icon in the X navigation to use it, at x.com/i/grok. The official X Help Center states “Grok is available in all countries where X is available”, and Grok 4.5, announced on 2026-07-22, also launched on X at the same time. X subscribers have a Grok tab on X.

Two things are easy to mix up:

• Different rules apply: using Grok on X falls under X’s privacy policy and terms; grok.com and the apps fall under SpaceXSI’s. The way to turn off training data use is also different; see the privacy and data chapter.
• The About Grok page in the X Help Center has no date, and its content still refers to xAI, so it may not be the latest version.

Sign-in methods

The official FAQ lists the following ways to sign in to grok.com:

How to link your X account: Settings → Account → Connect your X Account. If your Grok entitlement comes from an X subscription (The X Subscription or the old X Premium), link the same X account so that the subscription status stays in sync.

When signing in, keep in mind:

• The official pages do not explain the account-merging rules between different sign-in methods. It is best to always sign in the same way, so your conversation history and subscription do not get split.
• Manage the subscription on the platform where you bought it: if you bought on the web, manage it on the web; if you bought through Apple or Google Play, cancel it in the store.
• The minimum age is 13 (or the legal minimum age in your country), and users 13 to 17 need the consent of a parent or guardian.

Can you use it in Taiwan?

The official sources do not publish a complete list of unsupported regions that could be cited. The following three items are the evidence that could be verified directly on the check date:

1. grok.com/plans shows prices in NT$ from a Taiwan network, which indicates that the page treats Taiwan as a region where you can buy (see Chapter 3 for prices).
2. The Taiwan App Store lists Grok, with a Chinese listing named “Grok - AI Assistant”.
3. The X Help Center states that Grok is available in every country where X is available.

The official AUP says only that you may not offer the service in regions where we do not provide it, and the Terms have a separate sanctions clause. The complete list of regions is not published by the official source.

Practical reminders:

• Taiwan’s NT$ prices and promotions are shown based on your connection region. If you use a VPN or an overseas network, the page may switch to another currency.
• Features may open at different times in different regions. For example, Imagine’s reference images and voice references were first offered only in the US and on specific plans, and were pushed to all tiers within a few days.
• Australia has additional terms (age assurance and restrictions on certain content); see the privacy and data chapter.

Sources: Grok FAQ, Grok on the App Store (US), Grok - AI Assistant (Taiwan App Store), Grok on Google Play, About Grok (X Help Center), Grok 4.5 everywhere, Introducing Grok Bot, Grok Build for everyone, Terms of Service, Acceptable Use Policy, grok.com/plans, Grokipedia (checked 2026-11-06)

Plans and Pricing

Since 2026-10-12, all new Grok subscribers go through The X Subscription, which bundles Grok, Grok Bot, Cursor, and X Premium into one subscription with five tiers: Free, Plus, Premium, Super, and Ultra. The old SuperGrok and X Premium plans can still be renewed, but switching to the new plans is optional and irreversible. First confirm which generation of plan you are on, so the usage rules later on line up.

USD pricing

A few details:

• Prices exclude tax (for example VAT).
• You can cancel at any time, at least 24 hours before renewal.
• The official sources say Premium is equivalent to what SuperGrok, Cursor Pro, and X Premium+ cost together, $90/month.
• The official recommendation: start with Premium if you are new, choose Super if you use agents every day, and choose Ultra for heavy use; Plus is for social media creators with lighter usage.
• “Grok API access” is listed from Plus upward, but the official FAQ says API usage is billed separately at standard rates and does not draw from the plan’s usage pool. See the API chapters later for API pricing.
• Third-party models used inside Cursor (such as Claude and GPT) are not included in the plans and are billed separately at API list prices.

Teams and enterprise

Teams and Grok Business are described separately on the official pages. The official pages do not explain how the two differ or whether they are the same product line, so read x.ai/pricing and x.ai/grok/business separately according to your needs.

Reference prices shown in Taiwan

The table below shows the prices that grok.com/plans displayed for Taiwan on 2026-11-06. NT$ prices are reference prices: the official page says they exclude tax and other fees, promotions and in-app purchase prices may differ, and the actual amount is whatever the checkout screen shows. The direct pricing page x.ai/pricing showed only USD at the same time.

Notes:

• USD and NT$ are not at a fixed exchange rate: $8 corresponds to NT$249, $30 to NT$990, $100 to NT$3,390, and $200 to NT$6,690.
• On the monthly view, the text “NT$249/year” also appears below Plus, which does not match the annual NT$2,490. The official page is internally inconsistent; this guide treats NT$249/month as correct, but check the screen again before checkout.
• The 50% off for the first month is a promotion shown on the page at that moment and will change, so do not treat it as a long-term price.
• The official sources do not publish a separate price for in-app purchases on the Apple App Store or Google Play. Check the subscription screen in the store.

Are the old plans still available?

They can still be renewed, but the current official pages already direct new subscribers to The X Subscription.

USD prices of the old plans: the current official pages do not list a price table for SuperGrok or SuperGrok Heavy. The only thing that can be cited is the description on x.ai/pricing (Premium replaces SuperGrok, Cursor Pro, and X Premium+, which together cost $90/month), so this guide does not state prices for the old plans. To find out what you are paying now, check the billing record on the platform where you subscribed.

The weekly usage pool and top-up

The usage mechanism for paid users, based on the official Grok FAQ and X Subscription documents:

• The new mechanism is a single shared weekly usage pool that you can allocate freely across Chat, Imagine, Voice, Build, and Bot; the FAQ says it has been rolling out gradually since June 2026.
• Under Settings → Usage you can see your progress, each product’s share, and the reset time.
• Grok and Cursor share the same weekly pool, which resets every week.
• Once it is used up, paid features pause; the free tier’s Chat and Voice quotas can still be used (counted separately).
• To keep going, you can buy Extra Usage Credits (minimum $5, currently purchasable on the web only, expiring after one year, at a higher unit price than what is included in the plan) or turn on Auto Top Up (with a custom amount and a monthly cap).
• When 720p video exceeds the plan’s limit, it automatically drops to 480p.

Grok Bot usage has two versions of the rules, and the official pages are inconsistent, because they belong to different plan generations:

What to know before switching

According to the official X Subscription documentation:

1. Switching is permanent, and customer support cannot undo it.
2. The old subscription is cancelled at checkout and refunded pro rata.
3. If the old subscription was bought through Apple or Google Play, you must cancel it in the store yourself, and the refund is decided by the store.
4. The subscription is sold directly only by X Subscription Corp. and no resellers are authorized.
5. The usage rules of the old and new plans differ (for example Grok Bot in the table above), so read the new plan’s rules carefully before switching.

Before switching, check these yourself: the platform of your current subscription, the renewal date, whether you have an annual balance remaining, and whether you need Grok Bot (Plus does not include it).

Sources: The X Subscription announcement, x.ai/pricing, X Subscription pricing, X Subscription overview, X Subscription usage, Grok FAQ, grok.com/plans, Grok Bot more plans, Grok Business, X Premium (X Help Center) (checked 2026-11-06)

Modes and Models

Grok’s “modes” and “models” are two different things, and they are the easiest to confuse: the app’s input box lets you choose a mode (Fast, Auto, Expert, Heavy), while official announcements talk about models (Grok 4.5, 4.6, 4.7). The mapping between the two is not publicly explained on the official pages. This chapter treats them separately and marks clearly where the official sources are not explicit.

The mode menu in the app

On 2026-11-06, the mode menu in the grok.com input box was tested to have four items, visible even when signed out. The four modes are Fast, Auto, Expert, and Heavy. The public official pages do not explain the purpose of each mode one by one.

There is also a “Premium — Unlock extended capabilities” item that requires signing in.

What can and cannot be confirmed about this menu:

Practical advice: go by the options you see in the interface of your own account. To check whether a mode is available, first try selecting it in the menu after signing in, then watch how usage changes in Settings → Usage.

The x.ai/grok product page also mentions “Deep reasoning — Step-by-step thinking you can follow and verify”, as well as Multi-agent capabilities in which several agents work in parallel and the reasoning can be audited, but the official sources do not say which mode or plan in the list above they correspond to.

Model timeline

The table below collects public information from x.ai/news and docs.x.ai. Dates follow the official pages:

The official assessments of its own models (“most intelligent”, “most powerful”) are vendor claims, and this guide does not compare them further.

Where Grok 4.5, 4.6, and 4.7 stand

The key point is that the original text of the Grok 4.7 announcement says “available today in Cursor and Grok Build … Grok API, third-party coding harnesses” and does not mention grok.com. The other scattered clues cannot be pieced together into a conclusion:

• The model column on x.ai/grok/business lists Grok 4.7 (Business plan).
• x.ai/pricing describes Premium as “Latest Grok models”.
• Whether the default model for consumer chat is 4.5 or 4.7 is not stated directly on the official pages.

Therefore, this guide does not say “Grok 4.7 has reached grok.com”, and does not say it has not. To confirm, check the mode menu in your signed-in account, or look at x.ai/news and docs.x.ai/developers/release-notes for new announcements.

Grok 5 has no announcement at all in the official news or docs, and this guide does not discuss rumored release dates.

Old names and features that disappeared

Names that were common in 2025 are handled differently on the current official pages as of the check date:

If you find an article online that still teaches you to press DeepSearch or Think, check it against your own interface first. If you do not see it, it does not exist, so do not be misled by old tutorials.

API models in brief

Grok’s API models and the app’s modes are two independent systems, and billing is separate too (what a plan includes is app usage, while the API is billed separately at its own rates). The table below lists only the basics of each model. The full call methods, pricing, rate limits, and the retirement mapping are in the API chapters later. Prices are in USD per 1 million tokens, at the standard price for input tokens up to 200k:

A few additional points:

• When the prompt reaches 200k tokens or more, the whole request uses the higher unit price.
• The official sources say Grok 4.7 Fast (the same model, 2x speed, 2x price) is only in Cursor and Grok Build and is not in the public API.
• Since 2026-05-15, older slugs such as grok-4-1-fast-*, grok-4-fast-*, grok-4-0709, and grok-3 have been retired, and requests are automatically redirected to grok-4.3 and billed at its prices.
• Image, video, and voice have their own models such as grok-imagine-image-2.0, grok-imagine-video-1.5, and grok-voice-3.0; the details are left to the API chapters.

Sources: Grok 4.7, Grok 4.6, Grok 4.5, Grok 4.5 everywhere, Grok 4.1, Grok 4, Grok 3, Grok Voice 3.0, Grok Skills, Grok Automations, x.ai/grok, x.ai/pricing, Grok Business, Grok FAQ, Models (API), Release notes, May 15 retirement, Grok on the App Store (checked 2026-11-06)

Everyday Chat: Search, Files, Voice, and Personalization

This chapter covers the chat features Grok users reach for most often on grok.com and in the iOS and Android apps. The check date is 2026-11-06. Details the official pages do not state explicitly are marked “not published by the official source” and are not filled in from old tutorials.

Search and live X data

The most obvious difference between Grok and other chatbots is that the official sources list searching public X posts as a built-in capability. How the official sources say it works:

• Grok decides on its own whether to search public X posts and live web results, then answers using what it finds.
• The x.ai/grok product page states that answers come with source citations, and that you can ask follow-up questions on the same topic.
• The search scope is public posts. X’s help pages state that once an account is set to “protect posts”, its posts are not used to train models and are not cited when answering other users’ questions.

In practice, you can simply ask Grok in natural language to look at X, for example:

The App Store description also phrases this kind of use as “advanced searches on X”. Answers can still be wrong. The Consumer FAQ states plainly that Grok sometimes provides inaccurate or inappropriate content and advises users to verify for themselves.

The mode menu in the input box

The signed-out grok.com input box shows four modes, Fast, Auto, Expert, and Heavy, plus a “Premium” item that you can expand only after signing in. Which model each mode maps to and which plans can use it is not explained directly on the official pages. See the chapter on models and modes, or confirm inside the app after signing in.

Tutorials from 2025 often mention names such as DeepSearch, DeeperSearch, Think, and Big Brain. As of the check date, none of the current official pages (x.ai, docs.x.ai, the App Store description) use these names. The App Store description now says “deep research on the web” for in-depth web research, and x.ai/grok says “Deep reasoning” and “Multi-agent”. Whether these names were changed or merged into some mode is not published by the official source.

x.ai/grok describes Multi-agent as several agents working on sub-problems in parallel, with each agent’s reasoning auditable, and the results merged into one answer with citations. That page puts it under SuperGrok; which tier it corresponds to in the new plan system is not published by the official source.

File upload

Press + next to the chat input box and choose files on your device; on the web you can also drag and drop. A single message can have several files attached, and Grok confirms the upload succeeded before answering.

The official sources note that support differs slightly between platforms. The web version usually has the most complete document format support, and limits may be adjusted slightly by platform or subscription plan. When a limit is exceeded, Grok shows an error message.

What you can do

The official description groups use cases into five types: synthesizing multiple files, transforming (summarizing, rewriting, turning a slide deck into an outline), extracting (tables, quotations, metadata), analyzing (charts, code, data visualization of CSV and XLSX, and transcription of audio and video), and multimodal reasoning across text and images.

Limits and tips

• Images embedded in non-PDF files are not necessarily treated as images, and Grok mainly extracts the text.
• Audio and video can be uploaded, but transcription quality is inconsistent.
• For PDFs over 100 pages, Grok focuses on text and key images; when you ask, specify the range using actual page numbers, or split the document into smaller ones.
• For image analysis, images of 1000 x 1000 pixels or larger are recommended.
• Mixed uploads (TXT, PDF, PPTX, images, code) can be handled together; for very complex requests, split them into follow-up questions.

Common errors

Uploaded files can be managed and deleted on the web at grok.com/files. Deleted conversations and files are removed from the system within the standard retention period, except where they must be retained for legal, compliance, or safety reasons; see the privacy and data chapter for details.

Voice mode

A few points in the official description of voice can be confirmed:

• The App Store description lists Grok Voice Mode: natural voice conversation with Grok, real-time replies, a personalizable way of interacting, and a choice of conversation styles. The same description also mentions that you can generate images by voice alone.
• x.ai/grok describes voice as a back-and-forth conversation with “sub-second latency”.
• The Grok overview on docs.x.ai lists voice as one of Grok’s features (hands-free), without explaining it platform by platform.
• On 2026-07-15 the official announcement added 21 flagship voices and improved the naturalness of the original five. This announcement belongs to the Grok Voice product line; whether the voice menu in the consumer app is in sync with it is not published by the official source.
• Grok Voice 3.0 (2026-10-14) is a voice model, and the official description says it powers Grok Bot’s voice mode and Grok in Tesla vehicles. Which model version the consumer app’s voice currently runs on is not published by the official source.

On languages, the official figures are inconsistent in two places: the App Store lists English plus 38 languages, while x.ai/grok says more than 30 languages. The details of Traditional Chinese voice support are not published by the official source; if you need it, test it directly in the app.

When using Grok voice inside X, X’s help pages state that the transcription or translation of voice input may be shared with xAI for personalization and training. The location of the switch is in the privacy and data chapter.

Custom instructions, memory, and personalization

This area needs a clear split between what the official sources “state explicitly” and what appears only on marketing pages:

Custom instructions and Memory appear only on the product page and have no corresponding documentation, so this guide does not give an operating path. If you want Grok to consistently follow a certain format or process, the approach with complete official documentation is Skills (see the next chapter).

Grok Bot’s memory is a separate mechanism: each Bot keeps its own preferences, role, and a summary of past work, unrelated to the conversation memory on grok.com.

On Projects, the FAQ on docs.x.ai mentions only that grok.com has Projects (using the wrong domain such as grok.x.ai means the feature is missing), and the team plan announcement mentions that Collection Search is available through Projects; the detailed usage and plan restrictions are not published by the official source.

Chat history and sharing

• View history: on iOS, tap your avatar in the top left to open your chat history; on grok.com, click the history icon in the top right (three lines and a magnifying glass).
• Share a conversation: on the web, press Share, or click the share icon below the conversation, which creates a public link. The official sources warn that if the link is posted on a social platform, it may be indexed by search engines.
• Revoke a share: go to grok.com/share-links and press Remove next to the link.
• Team plans: in a Grok Business team workspace, share links can be opened only by authorized members.
• Moving conversations from another AI: the App Store description says “Easily transfer your conversations and context to Grok”; the transfer mechanism and supported sources are not published by the official source.

After you use up your usage

Paid users share one weekly usage pool, and Chat is deducted from it too. When it is used up, paid features pause, but the free tier’s Chat and Voice quotas can still be used, counted independently and reset separately. See the chapter on plans and pricing for plan and usage rules.

Grok Imagine: Image and Video Generation

Grok Imagine is Grok’s image and video generation feature. There are three entry points: grok.com/imagine, the iOS app, and the Android app. You can also ask Grok in an ordinary conversation to draw an image or make a video, and then modify it with follow-up prompts. The official product page (x.ai/grok) describes it as text-to-image and text-to-video in the same conversation thread, where you can keep editing with follow-up requests after generation.

The check date is 2026-11-06. The official pages are inconsistent about video resolution and length, so this chapter lists what each source says side by side.

Images: Imagine Image 2.0

On 2026-08-07, the official sources announced Imagine Image 2.0 as the Quality Mode of grok.com/imagine and the iOS and Android apps. The official positioning is “images you can use directly for work”, with the following key points.

On resolution, the x.ai/grok product page says images go up to 2K.

The App Store description also mentions several common edits: removing objects, replacing backgrounds, applying artistic styles, turning photos into moving video, and generating images using voice commands alone.

How to get started

Below the input box on the grok.com home page there are shortcuts such as “Create an image” that start an image-generation conversation; you can also go directly to grok.com/imagine to use Quality Mode and the templates. After generation, use follow-up prompts to describe what to change, or use the magic wand to specify a region, so you do not have to rewrite the whole prompt.

Image generation on the API side

If a developer wants to generate images in code, the model for the xAI API image endpoint is grok-imagine-image-2.0. The official documentation specifies: n can be set from 1 to 10; the response defaults to a temporary URL that you need to download promptly; editing takes up to 5 source images; and the 21:9 and 5:2 ratios are also available. The following is the official example from the docs.x.ai image generation page:

curl -X POST https://api.x.ai/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-imagine-image-2.0",
    "prompt": "A collage of London landmarks in a stenciled street‑art style"
  }'

Templates

Image 2.0 launched with a set of templates that package common image workflows into ready-made starting points, so users only need to provide the material. The templates listed in the official announcement are as follows (names are the official originals):

The official announcement also showed a “one world, many images” approach: generate characters, scenes, and props separately, keep one consistent style, and then use them as reference material for video.

Video: Imagine Video 1.5

The timeline of the video model:

• 2026-06: Imagine Video 1.5 was announced, described by the official source as having better motion, physics, and audio.
• 2026-07-31: Added text, image, and voice references, and support for text-prompt-only video generation (text-to-video) and native 1080p.

The key points of the late-July update:

Image references and voice references were first available only in the US and only to SuperGrok Heavy and SuperGrok Plus; the official sources said they would reach all plans within days. The App Store description also mentions that videos can carry sound.

Resolution and length: official pages are inconsistent

Putting these together, the reasonable reading is that each plan has a different video limit, but the official sources do not list a per-plan table of 480p, 720p, 1080p, and length. The resolutions and durations you can actually choose depend on the options shown in the app on your own account, and this guide does not hard-code numbers for each plan.

So that you know the model’s own range of capability, here are the API documentation’s specifications for comparison (these are not the app’s limits):

Usage

Imagine shares the paid plan’s weekly usage pool with Chat, Voice, Build, and Bot. The official sources explain that different products consume different amounts: a chat message uses very little compute, while generating a high-quality video uses far more. You can see each product’s share under Usage in Settings. When usage runs out, paid features pause and the free tier’s Chat and Voice quotas are unaffected; for Imagine’s free quota, the official sources say only “limited”, and the number is not published.

Watermarks and usage rules

Watermarks

• Generated images and videos both carry a Grok watermark that marks the content as AI-generated.
• The official sources state explicitly that there is no setting to turn off the watermark.
• The official sources also point out that some jurisdictions legally require AI-generated content to be labeled.
• The Terms state that users may be required to add, or SpaceXSI may automatically add, an AI-generated disclosure label.
• The Acceptable Use Policy prohibits “stripping, altering, or circumventing embedded provenance metadata or watermarks”. Removing or covering the watermark is a violation and may lead to suspension.

Rights to outputs

The wording in the official Consumer FAQ is that users own their inputs and outputs (including generated images) and may use them as they see fit, including for commercial purposes. The official sources also require that you credit the work as generated by Grok in line with the Brand Guidelines. Before commercial use, read the terms in full yourself.

Content rules

The prohibitions in the Acceptable Use Policy that relate directly to images and video:

• “Undressing” or nudifying real people, or altering a real person’s image or likeness so that it shows an intimate or sexual situation.
• Depicting a real person’s likeness in a pornographic way.
• Deceptively impersonating real people.
• Depicting someone in a defamatory or false manner.
• Sexualizing or exploiting children. The official sources say that suspected child sexual exploitation content is reported to NCMEC.

In Australia, the Terms have dedicated rules: you may not upload or attempt to generate content involving child sexual exploitation, advocacy of terrorism, advocacy of crime or violence, advocacy of drug-related crime, or content on specific fetish themes.

Violations may lead to account suspension or termination, and content may be deleted. When you see violating content, you can tap ”⋯” in Grok and choose Report Issue, or email [email protected]. For adult content display settings and age restrictions, see the privacy and data chapter.

Workflows and Grok Bot

From May to August 2026, Grok added Connectors, Skills, Automations, Build, and a standalone Grok Bot in succession. The names are similar, but they belong to two different products: the first four are features inside grok.com and the apps, while Grok Bot is a separate app. The check date is 2026-11-06.

Connectors (including custom MCP)

Connectors let Grok access external tools and data directly in a conversation: search email, browse cloud files, and check the calendar, without copying and pasting back and forth.

Three kinds of connectors

docs.x.ai divides connectors into three types:

• Built-in connectors: maintained by SpaceXSI; sign in once with OAuth.
• Connector directory: preconfigured third-party services, again requiring only a sign-in. The full list is at grok.com/connectors.
• Custom MCP connectors: connect to your own Model Context Protocol server.

The launch announcement of 2026-05-06 lists slightly different items: SharePoint, Outlook, OneDrive, Google Workspace, Notion, GitHub, and Linear, plus custom MCP. Notion, GitHub, and Linear do not appear in the current built-in table in the docs, and whether they fall under the directory is not itemized by the official source, so go by the list you actually see at grok.com/connectors.

How to add one

• Web: go to grok.com/connectors, press New Connector, choose a service, and complete OAuth. You can also press + in the chat input box, choose Connectors, and then press Add connector.
• iOS, Android: Settings, then Connectors.
• The official sources explain that Grok requests only the permissions it needs; once connected, Grok automatically uses the corresponding tool whenever a question relates to that service.
• Taking SharePoint as an example, the announcement explains that by default it can search and read; only after you enable write permission can it create and modify documents, lists, and pages.
• The privacy policy states that Google content connected through Google OAuth is not used for SpaceXSI’s AI training.

Custom MCP

At grok.com/connectors press New Connector, choose Custom, enter the MCP server URL, and complete authentication, and Grok automatically reads the tools the server exposes. There is one condition to watch: the server must be reachable from the public internet. Private addresses such as localhost, 127.0.0.1, 10.x.x.x, 172.16.x.x, and 192.168.x.x are rejected; a server running locally needs a tunneling service to be exposed (the Custom MCP Tunneling page on docs.x.ai explains this).

Grok Business and Enterprise

For team plans, an admin must first go to Grok Business, then Connectors in console.x.ai, and use Add Connector to add one from the directory or Other to enter an MCP URL, before members can connect their own accounts at grok.com/connectors. Adding and removing require Team Read-Write permission. After an admin removes a connector, members can no longer use it, and index data related to that connector may be removed.

MCP on the API side

If a developer wants to use MCP in the API, the xAI API has a Remote MCP tool, in which xAI’s servers connect to the MCP server on your behalf, supporting only Streamable HTTP and SSE. The following example comes from the Remote MCP page on docs.x.ai:

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
  "model": "grok-4.7",
  "input": [
    {
      "role": "user",
      "content": "What can you do with https://github.com/xai-org/xai-sdk-python?"
    }
  ],
  "tools": [
    {
        "type": "mcp",
        "server_url": "https://mcp.deepwiki.com/mcp",
        "server_label": "deepwiki"
    }
  ]
}'

Skills

Skills are the mechanism of “teach Grok once and it remembers in every later conversation”, and they are available on grok.com, iOS, and Android. The official announcement explains that every account has built-in skills provided by xAI by default, with no setup needed:

• There are three ways to build a custom skill: describe it in a conversation, upload a file, or write it from scratch. You can also finish a task and ask Grok to save what it just learned as a skill.
• Your own version takes priority over the built-in one, so you can override it directly.
• The announcement explains that Grok can produce Word, PowerPoint, Excel, and PDF files that are ready to share, and can also restructure existing files you upload.
• The announcement states that Skills ran on Grok 4.3 when they launched.

For how custom skills are shared and how teams manage them, the official announcement says only that they “can be shared”, and the details are not published.

Automations

Automations are work that Grok carries out by itself: describe it once, choose when to run it, and Grok reports back when done. The entry point is grok.com/automations, and it is also inside the iOS and Android apps.

You can also say directly in a conversation “check the news every morning and flag anything related to pricing”, and Grok will set it up for you. Scheduling is open to everyone; email triggers were described at the time of the announcement as “included with SuperGrok”. Which tier they correspond to under the new plans (The X Subscription) is not published by the official source.

Build

Build lets you describe a website, app, game, or dashboard in a conversation, and Grok builds a working version live in the conversation, which you can keep modifying afterward.

• Plans: on 2026-07-28 it opened as an Early Beta to SuperGrok Heavy only; since 2026-08-19, all plans can use it, on the web and on mobile (iOS, Android).
• Publishing: each published app gets its own *.grok.me URL; access can be set to “only you”, “anyone with the link”, or “public”; you can also bind your own domain.
• Other features: Remix (lets others copy your published app and modify it), export to GitHub, Secrets (store third-party service keys outside the app code), and using Connectors to turn business data into a filterable live dashboard.
• Apps that call Grok: you can enable SpaceXSI APIs for a single app so that the app itself can call Grok for chat, images, and voice, with no need to create or paste a key; permissions are per app and can be revoked at any time.
• Note: docs.x.ai explains that Build on grok.com retains the conversation and the build session (so that apps can be published across sessions) and does not offer Private Chat.

Do not confuse it with the terminal Grok Build CLI: the CLI is a separate coding agent, with its own documentation for installation and usage. Grok Studio is no longer supported, and the official sources direct you to use Grok Build instead.

Microsoft 365 and Google Workspace add-ins

The official consumer announcement for Grok 4.5 also mentions that Grok can work directly inside Word, Excel, PowerPoint, and Outlook. Installation methods and the required plans are covered in the announcement list only by the summaries above, and no further details are published.

Grok Bot

What it is

Grok Bot is “an AI teammate with its own computer”. The official sources explain that each Bot works on a persistent cloud computer (with a browser, file system, and terminal): you assign tasks by message, it finishes them in real tools, and it comes back to you only when approval is needed.

• Work in the cloud continues even if you close the app or your computer.
• You can have several Bots at once, which message each other, share context, and can be placed in group chats.
• You can ask a Bot to watch the next time you do something and save the process as a repeatable routine.
• Each Bot keeps its own preferences, role, and a summary of past work; all your Bots share the same cloud computer, and the official sources warn against treating different Bots as a security boundary.
• When a Bot signs in to a website, passwords go through the Vault or a Secure Form and the Bot itself cannot see them; for steps that only a person can handle, such as SSO, passkeys, and CAPTCHA, it hands the computer back to you.

How it differs from grok.com

The FAQ on docs.x.ai states directly: Grok Bot is not the same thing as grok.com or the Grok mobile app, and a paywall or “Weekly SuperGrok Limit” you see in the Grok app has nothing to do with Grok Bot.

Which plans include it

New plans (The X Subscription, the default for new customers since 2026-10-12)

• Premium, Super, and Ultra include Grok Bot, for both individual and team seats.
• Plus and Free do not include it.
• The official documentation explains that Bot usage is deducted from that seat’s weekly shared usage pool (shared with Grok and Cursor) and is not an additional quota on top.
• Usage can be viewed under Usage at grok.com/dashboard; once exceeded, it is topped up with prepaid credits.

Old plans (can still be renewed)

• Eligible users in the 2026-08-11 beta announcement: SuperGrok, SuperGrok Plus, SuperGrok Heavy; Cursor Pro, Pro+, Ultra; and Cursor Teams Standard and Premium. The 2026-08-26 announcement says that all SuperGrok, Cursor Pro, and Cursor Teams plans include Grok Bot.
• Both announcements say Grok Bot “has its own usage”, counted separately from the plan usage of Grok and Cursor, so work handed to the Bot does not consume the original plan’s usage.
• The Grok Bot FAQ on docs.x.ai explains that under the old plans, usage is recorded to your Cursor account, not Grok or X; after you reach the Weekly usage limit, if on-demand is turned on, the excess is billed through Cursor.
• Rules for linking SuperGrok or X Premium+: you can link individual SuperGrok, SuperGrok Plus, SuperGrok Heavy, and X Premium+; SuperGrok Lite and Grok Enterprise cannot be linked; linking is permanent and you cannot unlink it yourself; a Cursor plan and SuperGrok do not add up, and instead the larger usage amount of the two is taken.
• If you later switch to The X Subscription, Bot usage is supplied from the new shared usage pool instead, and the switch is irreversible.

“Separate usage” and “drawing from the shared pool” are different rules for two plan generations, not a contradiction in the documents; before subscribing, check which side you belong to.

Platforms

The announcement of 2026-08-11 says “desktop and iOS”, and the download button on the announcement page is also macOS. The current docs.x.ai pages list more supported platforms: desktop on macOS, Windows, and Linux, plus iOS (iOS 18 and later) and Android (Android 9 and later). The official pages are inconsistent, so go by the download options you actually see at x.ai/bot and in the stores. For how Enterprise plans are opened up, contact official sales.

Approvals and X integration

• Actions are judged by Auto Review by default, and most actions run on their own; when your consent is needed, the Bot shows an approval card in the conversation, where you can choose to allow once, always allow, or deny. The official recommendation is to state boundaries in your request, for example always ask first before sending email, publishing, deleting, or purchasing.
• Approvals triggered by a routine or another Bot while you are not present expire after about 30 minutes.
• Since 2026-08-29 you can connect an X account so the Bot can search posts, read the timeline, and check mentions; paid users get free X API credits to get started.
• Tagging @bot in an X post or reply hands the post to your primary Bot as a task. The condition is that your Grok account is linked to an X account; X accounts in Australia, the UK, the EU, Iceland, Liechtenstein, and Norway currently do not support tagging.
• When chatting with Grok Bot inside X Chat, Cursor’s privacy policy applies, along with X’s privacy policy.

Grok Bot’s privacy settings are a separate set; see the privacy and data chapter.

Privacy and Data Controls

I recommend that everyone read this chapter. It has three main points: content from consumer accounts may be used to train models by default, and you have to turn that off in the settings yourself; using Grok inside X falls under X’s settings, which are a separate set from grok.com; and the official text is inconsistent about the training rules for signed-out use.

The lookup date is 2026-11-06. The Consumer FAQ page shows a date of 2025-05-12, but its footer and brand name have been updated to 2026, so this guide treats it as current. A few of its sentences (for example, that voice is available only on iOS) are clearly out of date and are not cited.

First, work out which service you are using

The official privacy policy states plainly that SpaceXSI and X Corp. are different companies.

Turning off Improve the model

The official default wording is that SpaceXSI may use your content and interactions (prompts, searches, and other data you submit) together with Grok’s responses to train models, and it says you can control this. To turn it off:

A few details to note:

• After you turn it off, only new conversations are excluded from training. Conversations that already exist are not affected.
• Even with it turned off, feedback you volunteer (for example, a thumbs up or thumbs down with an explanation) may still be used for training.
• The official Private Chat is a separate path: content from Private Chat is not used for training.
• For Business and Enterprise customers, the official text says their content is not used to improve models.

Private Chat

In the upper-right corner of the Grok screen there is a ghost icon. Tap it to enter Private Chat.

• Conversations do not appear in your history.
• Content and interactions are not used for model training.
• Conversations are deleted from SpaceXSI systems within 30 days. The official exceptions are data that has been de-identified or pseudonymized and is no longer linked to your account, and data that must be kept for safety, security, or legal reasons.

Two limitations: the official text says “where available,” which means it is not offered in every situation; and docs.x.ai says that Build on grok.com keeps conversations and build sessions and does not offer Private Chat.

Signed-out use: the official statements are inconsistent

You can chat on grok.com without signing in, but three pieces of official text do not agree on how data is handled in that case:

The official text does not say which of the three takes precedence. The more conservative approach is to not enter personal data, work secrets, or customer data while signed out. To handle that kind of content, sign in first and turn off Improve the model, or use Private Chat.

Personalization: Personalize Grok using X

Grok can use your X data and interactions to personalize its answers. The switch is here:

• Grok app: Settings, Data Controls, Personalize Grok using X
• grok.com: Settings, Data, Personalize Grok using X

If you sign in with an X account, the Terms state that you agree SpaceXSI may bring in your X profile (including your birthday), account and location information, preferences, post history, usage data, and your conversation history with Grok inside X. To connect your X account to Grok, go to grok.com Settings, Account, Connect your X Account.

Deleting and downloading data

• After you submit a deletion request, the data is removed from SpaceXSI systems within 30 days at most, except for data that must be kept for legal, safety, or security reasons.
• If you sign in again and confirm within 30 days of deleting your account, it can be restored.
• The official source does not publish the exact format or waiting time for data downloads. The FAQ says only that you can download or delete your data under Data Controls in Settings.
• For other data rights requests (access, deletion, and so on), use x.ai/privacy-portal. General support is [email protected], and the privacy contact is [email protected].
• The official text states that it does not sell your data.

Human review and data use

• The official text says SpaceXSI uses automated classifiers and safety tools to monitor for violations, and that a limited number of authorized personnel may view conversations to improve models, investigate security incidents and abuse, and meet legal obligations.
• The official guidance is not to enter personal or sensitive information in your prompts.
• The Terms of Use state that you own your inputs and outputs, and that you also grant SpaceXSI a broad license to use them for providing the service, improving products and models, and meeting legal and safety requirements.
• When you use Grok’s autonomous actions (agentic actions, such as browsing the web, running code, sending messages, or modifying files), the Terms state that you are responsible for those actions.

Grok inside X: a separate set of settings

When you tap the Grok icon in X’s navigation bar (x.com/i/grok), X’s privacy policy applies, not SpaceXSI’s. The key points from X’s help page are below.

• The X help page says X may share your public X data and your interactions with Grok inside X with xAI to train and fine-tune models. Public data includes public posts and their interactions, public Spaces, and public profiles.
• Voice input counts too: transcribed or translated content may be shared.
• After you turn off training, you can still use Grok. However, for Grok-powered X features (such as recommendations), turning it off does not stop the deployed models from learning through normal use.
• Likewise, feedback from thumbs up or thumbs down may still be used for training even after you opt out.
• When you use Grok Bot inside X Chat, opting out of training goes through the same X settings page. Grok Bot data is kept until you delete your Grok Bot account, and you can delete it in Grok Bot settings.
• This X help page carries no date and still refers to the company as xAI, so it may not be current. Go by what the X settings page actually shows.

Age limits and content settings

Age

• You must be at least 13 years old (or the minimum age in your country) to use Grok. Ages 13 to 17 require consent from a parent or legal guardian, and the guardian must agree to the Terms of Service.
• The iOS App Store age rating is 16+.
• The official text states that, depending on the features you choose and what you enter, the output may include profanity, crude humor, sexual situations, or violence. The FAQ gives an example: asking Grok to answer in an “unhinged” style may produce offensive or inappropriate responses. The official text also asks parents who supervise teenagers’ use to take advantage of the data control options in the app settings.

Settings for adult content

The Australia-specific terms state that SpaceXSI uses age assurance to determine whether an Australian user is under 18, and until the user is confirmed to be 18 or older, access to 18+ adult content may be unavailable. The same passage also says users can restrict their own exposure to media that may contain 18+ adult content under Settings > Data Control. This sentence appears in the Australian terms, and the official text does not say whether other regions are the same.

What the policy prohibits

The prohibitions listed in the Acceptable Use Policy (effective 2026-08-14) that relate directly to data and content include:

• Undressing or nudifying real people, altering images of real people into intimate or sexual situations, depicting real people’s likenesses in a pornographic way, and deceptive impersonation of real people.
• Sexualizing or exploiting children; the official text says suspected child sexual exploitation content is reported to NCMEC.
• Jailbreaking, adversarial prompting, and prompt injection.
• Stripping or circumventing embedded provenance metadata or watermarks.
• Using the output or the service to develop machine learning models that compete with SpaceXSI.

Violations may lead to suspension or termination of the account. To report one, tap ”⋯” in Grok and choose Report Issue, or email [email protected]. The email address for safety-related reports is [email protected], and security vulnerabilities go through HackerOne.

Grok Bot and API data

• Grok Bot: it uses Cursor account authentication and data settings, and opting out of training depends on the corresponding Cursor account and privacy settings. It needs cloud data storage, so accounts still on the old Legacy Privacy Mode are asked to switch to Privacy Mode before getting started. All of your Bots share one cloud computer, and everything you put on it is accessible to every Bot.
• xAI API: API requests and responses are stored encrypted for 30 days by default (for abuse auditing) and then deleted automatically. The official text says API inputs and outputs are not used to train models without your explicit consent. You can request Zero Data Retention if you need it, but the official source itself does not recommend it for most customers, because it disables stateful conversations, Files, Collections, Batch, and other features.

API Quickstart and Model List

This chapter goes from the xAI API account and API key to the first request, and then covers the text models currently available, their prices, and reasoning effort. The API and the Grok chatbot (grok.com, the app) are separate products with separate billing. Prices and the model list change every month. The numbers in this chapter are what docs.x.ai showed on 2026-11-06. Before you use them, check them again against docs.x.ai/developers/models and docs.x.ai/developers/pricing.

Getting an API key

The steps come from the docs.x.ai Quickstart (developers/quickstart):

1. Sign up for an account at console.x.ai.
2. Load it with credits first, which is required before you can start using the API.
3. Generate a key on the API Keys page.
4. Put the key in the XAI_API_KEY environment variable, or in a .env file in your project directory.

export XAI_API_KEY="your_api_key"

Source: docs.x.ai Quickstart, Step 2.

A few related facts, from the docs.x.ai Security FAQ (developers/faq/security):

• An API key is tied to a team, not to an individual.
• If a key leaks, xAI works with GitHub Secret Scanning: when a leak is detected, the key is disabled and an email notification is sent. You can also choose Disable key or Delete key for a key in the Console.
• The Management API (for managing keys, billing, and audit logs) uses a separate management key, and its base URL is https://management-api.x.ai, from developers/management-api-guide.

Base URL and authentication

GET /v1/models lists the models available to that key, including prices, aliases, and reasoning effort capabilities. There are also category endpoints: /v1/language-models, /v1/image-generation-models, and /v1/video-generation-models.

Your first request

The official Quickstart examples all use the Responses API (/v1/responses), not Chat Completions. The four approaches below all come from the same page, and the model in the examples is grok-4.7.

curl

curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "input": "Fix this function and explain the bug: function median(a){a.sort();return a[a.length/2]}"
  }'

Python, using the OpenAI SDK (pip install openai)

from openai import OpenAI

client = OpenAI(
    api_key="<YOUR_XAI_API_KEY_HERE>",
    base_url="https://api.x.ai/v1",
)

response = client.responses.create(
    model="grok-4.7",
    input="Fix this function and explain the bug: function median(a){a.sort();return a[a.length/2]}",
)

print(response.output_text)

JavaScript, using the OpenAI SDK (npm install openai)

import OpenAI from "openai";

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

const response = await client.responses.create({
  model: "grok-4.7",
  input:
    "Fix this function and explain the bug: function median(a){a.sort();return a[a.length/2]}",
});

console.log(response.output_text);

Python, using the official xai-sdk (pip install xai-sdk)

import os
from xai_sdk import Client
from xai_sdk.chat import user

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(model="grok-4.7")
chat.append(user("Fix this function and explain the bug: function median(a){a.sort();return a[a.length/2]}"))

print(chat.sample().content)

JavaScript, using the Vercel AI SDK (npm install ai @ai-sdk/xai zod)

import { xai } from "@ai-sdk/xai";
import { generateText } from "ai";

const { text } = await generateText({
  model: xai.responses("grok-4.7"),
  prompt:
    "Fix this function and explain the bug: function median(a){a.sort();return a[a.length/2]}",
});

console.log(text);

All four snippets above come from the docs.x.ai Quickstart (developers/quickstart).

SDKs and OpenAI compatibility

• OpenAI SDK: for both Python and JavaScript, you only need to change base_url (baseURL in JS) to https://api.x.ai/v1. Everything else follows OpenAI’s Responses API usage.
• xai-sdk (Python): the official SDK. The documentation says it uses gRPC and covers Collections, Voice, API key management, and more, and it can be mixed with the REST Responses API. On the lookup date, PyPI showed the latest version as 1.21.0 (uploaded 2026-10-23), and it requires Python 3.10 or later.
• JavaScript: the JS examples in the official documentation use only the OpenAI SDK and the Vercel AI SDK (@ai-sdk/xai). The documentation does not mention an official xAI JavaScript SDK.
• Anthropic SDK compatibility layer: the official legacy endpoint page (developers/rest-api-reference/inference/legacy) marks it as fully deprecated and asks you to use the Responses API or gRPC instead.

Model list and prices

The following are text and multimodal models. Input can be text plus images, and output is text. Prices are in USD per 1 million tokens, as of the lookup date 2026-11-06, from developers/models and developers/pricing (the numbers on the two pages match).

Long-context surcharge: the table above shows prices for prompts under 200k tokens. When the prompt reaches 200k tokens or more, all tokens in the whole request are billed at the higher price. Each model’s higher price is exactly 2 times every number in the table above (for example, grok-4.7 is $4.00 for input, $1.00 cached, and $12.00 for output).

Other details from the model pages:

• All eight models support function calling and structured outputs.
• The grok-4.7 model page says “No text output limit.”
• Alias rules: <model> points to the latest stable version, <model>-latest points to the latest version, and <model>-<date> is a pinned version. For example, grok-4.20-0309-reasoning can also be written as grok-4.20, and the aliases of grok-build-0.1 include grok-build-latest.
• Grok 4.7 Fast (the same model at 2 times the speed and 2 times the price; 1.5 times for very long context) is offered only in Cursor and Grok Build and is not in the public API. Source: developers/pricing.
• Image input supports jpg, jpeg, and png, with a limit of 20 MiB per image and no limit on the number of images. presencePenalty, frequencyPenalty, and stop cannot be used with reasoning models, and including them returns an error.

Image, video, and voice models are priced separately and are outside the scope of this chapter.

Reasoning effort

reasoning_effort controls how much effort the model spends thinking before it answers. Source: developers/model-capabilities/text/reasoning.

Reasoning tokens are billed the same way as output tokens and are reported as reasoning_tokens in the usage. The reasoning content is not provided in plain text, only in an encrypted version.

The syntax differs by interface: in the Responses API it is reasoning: {"effort": "high"}; in xai-sdk it is reasoning_effort="high"; in the Vercel AI SDK it is providerOptions.xai.reasoningEffort.

The official curl example from the reasoning page is below. The -m 3600 extends the timeout to 3600 seconds, which the official text recommends for reasoning models so the connection is not closed early.

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -m 3600 \
  -d '{
    "model": "grok-4.7",
    "reasoning": {"effort": "high"},
    "input": [
        {
            "role": "system",
            "content": "You are a highly intelligent AI assistant."
        },
        {
            "role": "user",
            "content": "Find all prime numbers p such that p^2 + 2 is also prime. Prove your answer."
        }
    ]
}'

Source: docs.x.ai Reasoning (developers/model-capabilities/text/reasoning).

Where the official pages disagree:

In practice, go by capabilities.reasoning_effort returned from GET /v1/models, or rely only on the settings where the two pages agree for grok-4.7 and grok-4.6. The reasoning.effort of grok-4.20-multi-agent does not control thinking depth. It controls the number of collaborating agents (4 or 16). That model is in beta, and its API surface may have breaking changes.

Retired models

The official source retired the following slugs at 2026-05-15 12:00 PT. After retirement, the slugs can still be called, and requests are redirected automatically and billed at the grok-4.3 price (input $1.25, output $2.50 per 1 million tokens), not the original model’s price. Source: developers/migration/may-15-retirement.

grok-code-fast-1 is also listed on the model page as an alias of grok-build-0.1. The official documentation does not mention the status of older slugs such as grok-3-mini and the grok-2 series, and the current model page does not list those models either.

Many tutorials online still use grok-3, grok-4, and grok-code-fast-1. If you copy them, you will be redirected to grok-4.3 and billed at a different price. For new projects, specify a current model directly.

How to choose a model

The differences below are compiled from the official model pages and Release Notes. They are not the official source’s model selection advice.

When each model went live, going by the month headings in the Release Notes: grok-4.20 in March 2026, grok-build-0.1 in May, grok-4.5 in July (opened to European users in the same month), grok-4.6 in August, and grok-4.7 in September.

Regions and data retention

The global endpoint https://api.x.ai does not guarantee in which region a request is processed. xAI may route across regions because of capacity. The Regions column on each model page lists the regions where it is served, for example us-east-1, us-west-2, and us-central-1 for grok-4.7 and grok-4.6, and us-east-1, eu-west-1, and us-west-2 for grok-4.3, but that is not a routing guarantee.

To limit processing to the US, you can use https://us.api.x.ai/v1 instead. This endpoint offers only grok-4.7 and grok-4.6, has no image, video, or voice, adds a 10% surcharge on token usage, and the official text states plainly that it is not a full data residency guarantee. If you have contractual requirements, contact [email protected] first. Source: developers/advanced-api-usage/regions.

On data retention, per the Security FAQ, all API requests and responses are by default stored in encrypted form on xAI servers for 30 days for abuse auditing and then deleted automatically. xAI does not train models on API inputs and outputs without your explicit consent. Zero Data Retention (ZDR) is enabled per team, but it disables stateful Responses, Files, Collections, Batch, and other features, and the official source does not recommend enabling it for most customers.

Price lookup date

The lookup date for every price in this chapter is 2026-11-06, and the source is the Models and Pricing pages on docs.x.ai. Most docs.x.ai pages do not show a last-updated date, and only the Release Notes are divided by month. During 2026, the text models grok-4.20, grok-build-0.1, grok-4.3, grok-4.5, grok-4.6, and grok-4.7 have been added one after another, so before you place an order, go by the Console’s Models page and what GET /v1/models returns.

API Usage Limits and Billing

xAI API limits are set per team, and teams are automatically placed in Tier 0 through Tier 4 based on cumulative spend. Billing comes in two forms: prepaid credits and monthly invoicing. The numbers in this chapter are what was found on 2026-11-06, from the docs.x.ai Rate Limits (developers/rate-limits), Pricing (developers/pricing), and Manage Billing (console/billing) pages.

How rate limits work

Each team has limits in two dimensions for each model:

• RPS: requests per second. The official text explains that the per-second limit is derived from the per-minute request budget (RPM divided by 48, with a minimum of 2), so you cannot send a whole minute’s worth of requests in a single second.
• TPM: tokens per minute.

Exceeding either one returns HTTP 429. What counts toward TPM includes prompt tokens (text, image, audio), completion tokens, reasoning tokens, and cached prompt tokens. Cached tokens are billed at a lower rate, but they still use up TPM.

Do not carry over the RPM numbers that older articles often cite. The units in the current documentation are RPS and TPM.

Tiers and upgrade thresholds

Tiers are decided by cumulative API spend since 2026-01-01, and you are upgraded automatically when spend reaches a threshold, with no application needed. The basis for the calculation is the amount of prepaid credits purchased, or invoices that have been paid. The official text states that teams are not downgraded after an upgrade.

Limits by tier

The table below gives the values for T0, T1, T2, T3, and T4, from developers/rate-limits.

Voice endpoints are limited by RPS and the number of concurrent connections (the official text calls them concurrent sessions), not by tokens:

Additional notes:

• The tier system applies to text, embedding, and voice models. To raise the limits for the Imagine API (image and video), email [email protected].
• You can see your team’s actual limits on the Console Models page.
• Batch API requests do not count toward rate limits.
• If you want higher limits without spending more, or need more than Tier 4, you can submit an adjustment request on the Console Models page. For enterprise-level capacity, contact [email protected].

Prepaid credits and monthly invoicing

The official Manage Billing page lists two billing methods:

A few behaviors that are easy to trip over:

• The invoiced billing limit defaults to $0. In that case only prepaid credits are used, and once the credits run out, API requests are rejected outright.
• After monthly invoicing is enabled, the system uses prepaid credits first, and the shortfall is charged to the default payment method at the end of the month. Once the invoice limit is reached, there are no more responses until you raise the limit.
• Auto top-up: the official text recommends turning it on to avoid service interruptions. You can set the balance threshold that triggers it, the amount per top-up (minimum $5), and the total monthly top-up cap. When 80% of the monthly cap has been used, the API spend management card shows a warning.
• For now, prepaid credits can be bought only through Guest Checkout, which the official text attributes to regulatory reasons. Buying by bank transfer takes 2 to 3 business days, and credits are issued only after the transfer arrives.
• The Billing page has a promo code field, so if you have a promotion code you can use it there.

SuperGrok and X consumer subscriptions are separate from API credits. Buying a subscription gives you no API quota, and the reverse is also true.

The official documentation has no free quota

Across the docs.x.ai Billing, Pricing, Rate Limits, and Quickstart pages, there is no mention of a “free quota” or of “credits in exchange for data sharing.” The first step of the Quickstart is to sign up and then load credits.

Claims such as “new accounts get free credits” and “agree to data sharing and receive credits every month” have circulated online. Different third-party pages contradict each other, and none of them appear in the official xAI documentation. Whether you have any credits at all, go by what the Console Billing page actually shows, and do not rely on third-party summaries.

Other billing rules

Batch API: -20% on text models

The Batch API is asynchronous batch processing, and most requests finish within 24 hours (not guaranteed by the official source). The discount applies to grok-4.7, grok-4.6, grok-4.5, grok-4.3, and the three grok-4.20 models, and it is applied to input, output, cached, and reasoning tokens. grok-build-0.1 does not support Batch. Images and video can go through Batch, but they are billed at regular prices. Source: developers/pricing, developers/advanced-api-usage/batch-api.

Limits listed in the official documentation: the JSONL upload file is capped at 200 MB; a single request payload is capped at 25 MB; each team can create at most 2 batches per second; add-requests can be called at most 1000 times every 30 seconds; and batches with more than 100,000 requests may be throttled. Teams with ZDR (Zero Data Retention) enabled cannot use Batch.

A minimal example of creating a batch:

curl -X POST https://api.x.ai/v1/batches \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "name": "customer_feedback_analysis"
  }'

Source: docs.x.ai Batch API (developers/advanced-api-usage/batch-api). For adding requests and retrieving results afterward, see Step 2 through Step 4 on that page.

Priority Processing: 2x rate

Add service_tier: "priority" on text endpoints (Responses, Chat Completions) and the request gets higher scheduling priority, at 2 times the standard price, which applies to input, output, cached, and reasoning tokens; the cache discount is calculated first and then multiplied by 2. The service_tier field in the response tells you the tier actually used, and billing is at 2 times only when the response confirms priority. Images, video, and Batch are not supported.

response = client.responses.create(
    model="grok-4.7",
    input="Explain the Riemann hypothesis in one paragraph.",
    service_tier="priority",
)
print(response.output_text)
print(f"Tier used: {response.service_tier}")

Source: docs.x.ai Priority Processing (developers/advanced-api-usage/priority-processing). The client in the example is the OpenAI SDK client created in Chapter 9.

Violation fee: requests that violate the usage policy are still billed. In the Responses API, each request blocked before generation is charged a $0.05 violation fee. Source: developers/pricing.

US regional endpoint: when you use https://us.api.x.ai/v1, token usage carries a 10% surcharge (1.1x). Source: developers/advanced-api-usage/regions.

Cost estimate

Below is an arithmetic illustration based on the official prices. The actual amount is whatever usage.cost_in_usd_ticks in the response reports. Suppose you send a batch of requests on grok-4.7 with prompts under 200k tokens, totaling 1 million input tokens (no caching) and 100,000 output tokens:

Reasoning tokens are billed at the output price, so the higher you set the reasoning effort, the more output tokens there are, and the actual cost will be higher than in the table above. Tool call fees are charged separately; see Chapter 11.

Tracking the cost of each request

The usage.cost_in_usd_ticks in each response reports the actual cost of that request, where 1 USD equals 10,000,000,000 ticks, and it already includes cache discounts and tool fees. The official xai-sdk example:

import os
from xai_sdk import Client
from xai_sdk.chat import user

client = Client(api_key=os.getenv("XAI_API_KEY"))

chat = client.chat.create(
    model="grok-4.7",
    messages=[user("Say hello")],
)
response = chat.sample()

# Convenience property — ticks converted to dollars.
print(f"Cost: ${response.cost_usd:.6f}")

# Raw ticks for integer-precision accounting.
print(f"Cost (ticks): {response.usage.cost_in_usd_ticks}")

Source: docs.x.ai Cost Tracking (developers/cost-tracking).

Prompt caching happens automatically. The official text recommends setting prompt_cache_key in the Responses API (or the x-grok-conv-id header for Chat Completions) so that the same conversation lands on the same machine. The number of cached tokens can be read from usage.input_tokens_details.cached_tokens. Source: developers/advanced-api-usage/prompt-caching.

What to do about a 429

The official approach is simple: implement exponential backoff. The example waits 1, 2, 4, and 8 seconds in turn after each failure before retrying (2 to the power of attempt), and throws the error once the retry limit is reached. xai-sdk uses gRPC, and the corresponding error code is RESOURCE_EXHAUSTED.

The example from the official Rate Limits page is below. It calls the legacy chat.completions, and the backoff logic is exactly the same if you switch to client.responses.create.

import os
import time
from openai import OpenAI, RateLimitError

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

def request_with_backoff(messages, max_retries=5):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="grok-4.7",
                messages=messages,
            )
        except RateLimitError:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt
            time.sleep(wait)

Source: docs.x.ai Rate Limits (developers/rate-limits).

The official Debugging page (developers/debugging) recommends that for a 429 you reduce your request rate or raise your limits in the Console. When handling a 429, you can do the following based on the official documentation:

1. Check the Models page first to confirm your tier and the RPS and TPM for that model.
2. Remember that cached tokens also count toward TPM, so a long prompt uses up quota even when it hits the cache.
3. Move workloads that do not need immediate results to the Batch API, which does not count toward rate limits.
4. If you need higher limits, upgrade your tier through cumulative spend, submit an adjustment request on the Models page, or contact [email protected].

Also, the error code table on the Debugging page lists only 400, 401, 403, 404, 405, 415, 422, and 429. It has no entries for 5xx and no complete error body specification. For service status, see status.x.ai.

Text Generation, Structured Outputs, and Built-in Tools

This chapter covers the main features for generating text through the API: the Responses API, streaming, reasoning, structured outputs, function calling, image input, and the built-in tools that xAI’s servers run on your behalf. The examples all come from the matching docs.x.ai pages and always use the model grok-4.7; prices and limits are what was found on 2026-11-06.

Responses API and Chat Completions

The official documentation recommends the Responses API (/v1/responses), and the original Chat Completions (/v1/chat/completions) is marked as legacy. Source: developers/model-capabilities/text/comparison, developers/model-capabilities/legacy/chat-completions.

Parameter mapping:

The location of the response content also differs: in Chat Completions it is in choices[0].message.content, while in the Responses API it is in items of different types in the output array, and the SDK’s output_text is a convenience property for getting plain text.

The official documentation is inconsistent in how it words legacy: the table header on the comparison page says Deprecated, and the chat-completions page says “offered as a legacy endpoint.” The recommendation in both places is the same: migrate to the Responses API.

Server-side storage: by default the Responses API stores prompts, reasoning, and responses on the server for 30 days, and you can turn that off with store: false. When storage is off and you use a reasoning model, you can use include: ["reasoning.encrypted_content"] to get back the encrypted reasoning content and pass it back unchanged on the next turn; grok-4.7 returns it whether or not include is set.

The official multi-turn example is below. The original example on that page uses the retired grok-4, which is changed to grok-4.7 here.

# First request
response = client.responses.create(
    model="grok-4.7",
    input=[{"role": "user", "content": "What is 2+2?"}],
)

# Continue the conversation - no need to resend history
second_response = client.responses.create(
    model="grok-4.7",
    previous_response_id=response.id,
    input=[{"role": "user", "content": "Now multiply that by 10"}],
)

Source: docs.x.ai Comparison with Chat Completions API (developers/model-capabilities/text/comparison).

Streaming

All models with text output support streaming, and image generation models do not. Set "stream": true and the server returns incremental content over SSE (Server-Sent Events). The official text reminds you that for reasoning models, it is recommended to extend the request timeout manually so the connection is not closed early (the official example uses 3600 seconds). Source: developers/model-capabilities/text/streaming.

The official streaming page example uses Chat Completions. Streaming in the Responses API appears in Tools Overview (developers/tools/overview), which also brings in built-in tools:

import os
from openai import OpenAI

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

response = client.responses.create(
    model="grok-4.7",
    input=[
        {"role": "user", "content": "What are the latest updates from xAI?"}
    ],
    tools=[
        {"type": "web_search"},
        {"type": "x_search"},
        {"type": "code_interpreter"},
    ],
    stream=True,
)

for event in response:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Source: docs.x.ai Tools Overview. The original prompt in the official example asks about the company’s latest news, and here it is rewritten in a more general form.

Two practical notes:

• When streaming, a function call appears in full in a single chunk and is not streamed in pieces.
• The official source also has a WebSocket mode (a single long-lived connection; the official measurement is up to about a 20% drop in end-to-end latency for tool-heavy agent loops, and it is compatible with ZDR and store=false) and a Context Compaction API (to shorten the context of long conversations). See developers/advanced-api-usage/websocket-mode and developers/advanced-api-usage/context-compaction respectively.

Reasoning

reasoning.effort (Responses API) can be low, medium, high (default), or xhigh. For where the range each model supports disagrees with the official pages, see Chapter 9. Reasoning tokens are billed at the output price; reasoning content is provided only in an encrypted version.

Structured outputs

Structured outputs make the response strictly conform to the JSON Schema you provide. Source: developers/model-capabilities/text/structured-outputs.

• The Responses API uses text.format; Chat Completions uses response_format (json_schema, json_object, text).
• You can define the schema with Pydantic (Python) or Zod (JavaScript).
• Function calling parameters always follow the schema strictly (strict is implicitly true).
• It can be used together with built-in tools and function calling, giving results of the form “look things up with tools first, then return a fixed format.”

The supported JSON Schema is a subset:

The official example for Python with Pydantic and web search:

import os
from openai import OpenAI
from pydantic import BaseModel, Field

class ProofInfo(BaseModel):
    name: str = Field(description="Name of the proof or paper")
    authors: str = Field(description="Authors of the proof")
    year: str = Field(description="Year published")
    summary: str = Field(description="Brief summary of the approach")

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

response = client.responses.parse(
    model="grok-4.7",
    input="Find the latest machine-checked proof of the four color theorem.",
    tools=[
        {"type": "web_search"}
    ],
    text_format=ProofInfo,
)

proof = response.output_parsed
print(f"Name: {proof.name}")
print(f"Authors: {proof.authors}")
print(f"Year: {proof.year}")
print(f"Summary: {proof.summary}")

Source: docs.x.ai Structured Outputs, the Agentic Tools with Structured Output section. The official page splits the ProofInfo definition and the call into two blocks, which are merged into one here.

Function calling

Function calling lets the model ask your program to run a custom function. The flow comes from developers/tools/function-calling:

1. Define the function’s name, description, and JSON Schema parameters in tools.
2. The model returns a function_call item.
3. Your program runs the function and sends the result back using function_call_output plus previous_response_id.
4. The model produces the final response based on the result.

tool_choice can be set to auto (default), required, none, or a specific single function. Parallel calls are on by default, so the model can request multiple tool calls in one response; to turn that off, pass parallel_tool_calls: false. The Chat Completions reference notes a maximum of 128 functions. Function calling can be mixed with the server-side built-in tools.

Official example:

import os
import json
from openai import OpenAI

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

tools = [
    {
        "type": "function",
        "name": "get_temperature",
        "description": "Get current temperature for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"},
                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "default": "fahrenheit"}
            },
            "required": ["location"]
        },
    },
]

response = client.responses.create(
    model="grok-4.7",
    input=[{"role": "user", "content": "What is the temperature in San Francisco?"}],
    tools=tools,
)

# Handle function calls
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)
        result = {"location": args["location"], "temperature": 59, "unit": args.get("unit", "fahrenheit")}

        response = client.responses.create(
            model="grok-4.7",
            input=[{"type": "function_call_output", "call_id": item.call_id, "output": json.dumps(result)}],
            tools=tools,
            previous_response_id=response.id,
        )

for item in response.output:
    if item.type == "message":
        print(item.content[0].text)

Source: docs.x.ai Function Calling (developers/tools/function-calling).

Image input

In the Responses API content, put input_image and input_text. image_url can be a public URL, or base64 in the form data:image/jpeg;base64,.... jpg, jpeg, and png are supported, with a limit of 20 MiB per image and no limit on the number of images. Images are billed in tokens. Source: developers/model-capabilities/images/understanding.

response = client.responses.create(
    model="grok-4.7",
    input=[
        {
            "role": "user",
            "content": [
                {
                    "type": "input_image",
                    "image_url": image_url,
                    "detail": "high",
                },
                {
                    "type": "input_text",
                    "text": "What's in this image?",
                },
            ],
        },
    ],
)

Source: docs.x.ai Image Understanding. The official text reminds you that when sending images, it is recommended not to store the request and response on the server, or it may fail.

Built-in tools

Built-in tools run on xAI’s servers. You only need to set which tools to use in tools, and the API runs them automatically and returns the results with citation sources. The official processing flow is: analyze the question, decide whether to call a tool or answer directly, run the tool, consolidate the results and repeat until there is enough information, and finally return a response with citations. Source: developers/tools/overview.

Built-in tools became generally available (GA) in 2025-10. The citations property of a tool response is always returned by default and lists every source URL the agent encountered during its search; there are also inline citations embedded in the response text, see developers/tools/citations.

Cost = token usage + number of tool calls. The model decides for itself how many times to call tools, so the more complex the question, the higher the cost. Below are the tool prices from developers/pricing.

Additional notes:

• X Search is billed by the “number of items retrieved.” Every post returned from a search or thread retrieval (including parent posts and quoted posts) counts as one post, and each profile returned from a user search counts as one.
• Image Search is part of Web Search and is billed at the Web Search rate.
• xai-sdk (gRPC) does not support the aliases code_interpreter and file_search; use code_execution and collections_search.
• There are also regular token fees: input, reasoning, completion, image, and cached tokens are all priced by the model used for that request.

The xai-sdk and the Vercel AI SDK are written differently. The Vercel AI SDK example from the official Tools Overview is:

import { xai } from "@ai-sdk/xai";
import { streamText } from "ai";

const { fullStream } = streamText({
  model: xai.responses("grok-4.7"),
  prompt: "What are the latest updates from xAI?",
  tools: {
    web_search: xai.tools.webSearch(),
    x_search: xai.tools.xSearch(),
    code_execution: xai.tools.codeExecution(),
  },
});

for await (const part of fullStream) {
  if (part.type === "text-delta") {
    process.stdout.write(part.text);
  } else if (part.type === "source" && part.sourceType === "url") {
    console.log(`Citation: ${part.url}`);
  }
}

Source: docs.x.ai Tools Overview. The prompt is likewise changed to a general form.

Web Search

Searches and browses the web in real time. Available parameters: allowed_domains (up to 5), excluded_domains (up to 5, and cannot be used together with allowed_domains), enable_image_understanding (lets the agent analyze images it encounters during search), and enable_image_search (results can embed images). Source: developers/tools/web-search.

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
  "model": "grok-4.7",
  "input": [
    {
      "role": "user",
      "content": "What is xAI?"
    }
  ],
  "tools": [
    {
      "type": "web_search"
    }
  ]
}'

Source: docs.x.ai Web Search. The original prompt is a simple question asking for a company name, and it is rewritten here.

X Search

Searches posts, users, and threads on X. It supports keyword search (X advanced search operators can be used), semantic search, user search, and thread retrieval. Parameters include allowed_x_handles / excluded_x_handles (up to 20 each; 10 in the Vercel AI SDK), from_date / to_date (YYYY-MM-DD), enable_image_understanding, and enable_video_understanding (default false). Source: developers/tools/x-search.

import { xai } from "@ai-sdk/xai";
import { generateText } from "ai";

const { text, sources } = await generateText({
  model: xai.responses("grok-4.7"),
  prompt: "What are people saying about xAI on X?",
  tools: {
    x_search: xai.tools.xSearch(),
  },
});

console.log(text);
console.log("Citations:", sources);

Source: docs.x.ai X Search. The company name in the original prompt is different, and it is rewritten here.

Code Execution

Lets Grok write Python and run it in a sandbox, used for exact calculation, data analysis, and verification. Common packages such as NumPy, Pandas, Matplotlib, and SciPy are preinstalled. The sandbox has no external network, a restricted file system, and keeps no state across requests, and large datasets may hit memory limits; the official page does not publish specific execution time or memory numbers. Source: developers/tools/code-execution.

The tool name differs by interface: code_execution in the xAI SDK, code_interpreter in the Responses API, and xai.tools.codeExecution() in the Vercel AI SDK.

response = client.responses.create(
    model="grok-4.7",
    input=[
        {
            "role": "user",
            "content": "Calculate the compound interest for $10,000 at 5% annually for 10 years",
        },
    ],
    tools=[
        {
            "type": "code_interpreter",
        },
    ],
)

print(response)

Source: docs.x.ai Code Execution, the Basic Calculations section. The client is created the same way as in the Responses example above.

Collections and Files

Both let the model read your own documents, but they serve different purposes. Source: developers/files, developers/files/collections, developers/pricing.

Files requires a model that supports agentic tools. The official text lists grok-4.20, grok-4.5, grok-4.6, and grok-4.7, and supported formats include text, code, csv, json, and pdf. Teams with ZDR enabled cannot use Files and Collections. The tool for querying Collections is called collections_search (the Responses API also accepts file_search), and the call fee is $2.50 per 1000 calls. For the full flow of creating a collection, uploading, and querying, see developers/tools/collections-search.

Remote MCP

xAI’s servers connect to an external MCP server on your behalf so that Grok can use its tools. Source: developers/tools/remote-mcp.

The OpenAI Responses API parameters require_approval and connector_id are currently not supported. Remote MCP can also be used in the Speech to Speech API. The tool call itself is not billed separately and only tokens are counted.

curl https://api.x.ai/v1/responses \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
  "model": "grok-4.7",
  "input": [
    {
      "role": "user",
      "content": "What can you do with https://github.com/xai-org/xai-sdk-python?"
    }
  ],
  "tools": [
    {
        "type": "mcp",
        "server_url": "https://mcp.deepwiki.com/mcp",
        "server_label": "deepwiki"
    }
  ]
}'

Source: docs.x.ai Remote MCP Tools.

Where Live Search stands

The 2025-05 Release Notes state that Live Search went live in the API, which is the search_parameters parameter of Chat Completions (mode, sources, from_date, to_date, max_search_results, return_citations). The API reference for Chat Completions still keeps this parameter today, but the navigation no longer has a Live Search page, and what the official source promotes is the web_search and x_search tools described above. The official documentation does not explicitly say “Live Search is deprecated,” so for new projects I recommend using the built-in tools directly and treating the old search_parameters as a parameter on a legacy endpoint. Source: developers/release-notes, developers/rest-api-reference/inference/chat-completions.

Image, Video, and Voice APIs

Grok’s media capabilities are split into two groups of APIs: the Imagine API handles image and video generation, and the Voice API handles real-time voice conversation (Speech to Speech), text to speech (TTS), and speech to text (STT). Both use the same XAI_API_KEY, but each has its own models, endpoints, and pricing. The content of this chapter is based on the docs.x.ai pages of 2026-11-06. Models and prices are updated quickly, so check the official pages before you start.

Two prerequisites:

• The US regional endpoint (us.api.x.ai) does not offer image, video, or voice. These three can only use the global endpoint https://api.x.ai. The regional endpoint is explained in the next chapter.
• When Zero Data Retention (ZDR) is on, images and videos cannot be stored by xAI on your behalf, and you must supply your own upload URL. See the “Image generation” and “Video generation” sections of this chapter.

Imagine API overview

Source: docs.x.ai “Imagine Overview” (/developers/model-capabilities/imagine).

Image generation

Source: docs.x.ai “Image Generation” and “Imagine Overview”. The main model today is grok-imagine-image-2.0, and the older grok-imagine-image (1.0) is still available.

A minimal request:

curl -X POST https://api.x.ai/v1/images/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-imagine-image-2.0",
    "prompt": "A collage of London landmarks in a stenciled street-art style"
  }'

Common parameters:

A few behaviors that are easy to miss:

• The returned URL is temporary, so download it promptly.
• When quality is auto, generation uses low and editing uses medium, and billing follows the quality actually served.
• The official 2026-11 announcement says the names grok-imagine-image-quality and grok-imagine-image-pro have been retired, and requests are automatically handled by grok-imagine-image-2.0 with quality: "low", so you do not need to change your code.
• When you want several versions of the same prompt, the official text recommends using n, which is more efficient than sending repeated requests.

Image editing

Source: docs.x.ai “Imagine Overview”. A source image can be a public URL or a base64 data URI, up to 5 per request, and can be used to composite subjects, convert styles, or combine scenes.

curl -X POST https://api.x.ai/v1/images/edits \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-imagine-image-2.0",
    "prompt": "Render this as a pencil sketch with detailed shading",
    "image": {
      "url": "https://docs.x.ai/assets/api-examples/images/style-realistic.png",
      "type": "image_url"
    }
  }'

Video generation

Source: docs.x.ai “Video Generation”. Video requests are asynchronous: you send the request and get a request_id, then poll until the status is done. The xAI SDK and the Vercel AI SDK poll automatically.

Request modes:

Setting ranges: duration is 1 to 15 seconds (default 8); resolution can be 480p, 720p, or 1080p, with a default of 480p; the supported aspect ratios are 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 21:9, and 5:2, with a default of 16:9. Videos come with an audio track by default, and passing generate_audio: false gets you a silent video.

The full polling approach (source: docs.x.ai “Imagine Overview”):

# Start the video generation request
REQUEST_ID=$(curl -s -X POST https://api.x.ai/v1/videos/generations \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{
    "model": "grok-imagine-video-1.5",
    "prompt": "Make the water crash down and slowly pan out the camera",
    "image": {"url": "https://docs.x.ai/assets/api-examples/video/waterfall-still.png"},
    "duration": 12
  }' | jq -r '.request_id')

# Poll until the video is ready
while true; do
  RESULT=$(curl -s https://api.x.ai/v1/videos/$REQUEST_ID \
    -H "Authorization: Bearer $XAI_API_KEY")
  STATUS=$(echo "$RESULT" | jq -r '.status')
  if [ "$STATUS" = "done" ]; then
    echo "$RESULT" | jq -r '.video.url'
    break
  elif [ "$STATUS" = "failed" ] || [ "$STATUS" = "expired" ]; then
    echo "Request $STATUS"; echo "$RESULT" | jq .
    break
  fi
  sleep 5
done

The error.code values on failure (source: Error Handling in “Video Generation”):

Imagine prices and limits

Source: docs.x.ai “Pricing”, “Rate Limits”, and the 2026-11 migration announcement.

Three additional points:

• The migration announcement lists grok-imagine-image-2.0 at low quality as $0.04 for 1K and $0.06 for 2K, with an extra $0.01 per input image when editing. The unit price for medium quality is not listed on the official pages, so go by the pricing page and usage.cost_in_usd_ticks in the response.
• The official Imagine overview says “video duration and resolution both affect cost,” but the pricing page lists only a single per-second price. The two statements do not fully agree, so the actual cost is whatever the usage fields in the response show.
• Imagine rate limits are not part of the automatic tier upgrades, so to raise the quota you need to email [email protected]. Baseline values (Tier 0 through Tier 4, requests per second): image models 6, 12, 25, 50, 100; video models 10, 20, 39, 79, 158.

Voice API overview

Source: docs.x.ai “Voice Overview”.

Speech to Speech: real-time voice agents

Source: docs.x.ai “Speech to Speech” and “Voice Overview”.

The connection URL is wss://api.x.ai/v1/realtime?model=grok-voice-latest. grok-voice-latest is an alias that now points to grok-voice-3.0; grok-voice-2.0 is marked deprecated, with the same API and the same price.

import asyncio
import json
import os
import websockets

async def voice_agent():
    async with websockets.connect(
        "wss://api.x.ai/v1/realtime?model=grok-voice-latest",
        additional_headers={"Authorization": f"Bearer {os.environ['XAI_API_KEY']}"}
    ) as ws:
        # Configure voice and enable tools
        await ws.send(json.dumps({
            "type": "session.update",
            "session": {
                "voice": "eve",
                "instructions": "You are a helpful customer support agent.",
                "turn_detection": {"type": "server_vad"},
                "tools": [{"type": "web_search"}]
            }
        }))

        # Stream audio and receive responses
        async for message in ws:
            event = json.loads(message)
            if event["type"] == "response.output_audio.delta":
                # Play audio: base64.b64decode(event["delta"])
                pass

asyncio.run(voice_agent())

Common fields of session.update:

Do not put the API key in browsers or on phones. The official text recommends Ephemeral Tokens: your server calls POST https://api.x.ai/v1/realtime/client_secrets to exchange for a short-lived token to hand to the client (source: docs.x.ai “Ephemeral Tokens”):

curl --url https://api.x.ai/v1/realtime/client_secrets \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  --data '{
    "expires_after": {
      "seconds": 300
    }
  }'

For phone scenarios, SIP can connect incoming PSTN or PBX calls to a session, and there are Twilio, WebRTC, and iOS sample projects in xai-cookbook. The number of concurrent connections depends on the tier: Tier 0 through Tier 4 are 10, 20, 50, 100, and 200 respectively.

Text to Speech

Source: docs.x.ai “Text to Speech”.

curl -X POST https://api.x.ai/v1/tts \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Welcome to our service. How can I help you today?",
    "voice_id": "eve",
    "language": "en"
  }' \
  --output welcome.mp3

(The text in the example has been changed to a general sentence; the other fields follow the official source.)

You can insert speech tags into the text to control tone: inline tags such as [pause] and [laugh], and wrapping tags such as <whisper>…</whisper>. The WebSocket streaming endpoint (wss://api.x.ai/v1/tts) has no text length limit, with at most 50 simultaneous sessions per team.

Custom Voices can clone a voice from reference audio of up to 120 seconds (source: docs.x.ai “Custom Voices”):

• The official text recommends a recording of 90 to 120 seconds, in a quiet environment, with a single speaker; material under 30 seconds may lack detail.
• In the Console you can create up to 30 custom voices for free; creating them through the API (POST /v1/custom-voices) is limited to the Enterprise plan.
• Official warning: Custom Voices are currently available only in the United States, except Illinois.

Speech to Text

Source: docs.x.ai “Speech to Text”. The default model is grok-voice-transcribe-2.0; the old 1.0 ended on 2026-10-02, and requests are automatically redirected to 2.0.

curl -X POST https://api.x.ai/v1/stt \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -F model=grok-voice-transcribe-2.0 \
  -F [email protected]

The order of multipart fields is specified: file must come last, or the options before it may be ignored. Streaming recognition goes through wss://api.x.ai/v1/stt, with audio sent as binary frames and settings placed in the URL parameters. Besides 400, 401, 413, and 429, the STT status codes also include 502 (downloading from a url failed) and 503 (the backend is temporarily unavailable).

Language support

The number of STT languages is inconsistent across the official pages: the STT page and Voice Overview say 38 or more, the launch announcement in the Release Notes says 25, and the x.ai/voice marketing page says 25 or more. The STT page has a table listing each code, which is newer and more complete, so go by that table for the languages actually available.

The parts relevant to Chinese-speaking users:

The level of support for Traditional Chinese is not published by the official source. The language tables for TTS and Speech to Speech list only Simplified, and the STT table lists only Mandarin. No page says whether the output will use Traditional characters, or whether Taiwanese accents or Taiwan-specific vocabulary are supported. Before using it in a production product, I suggest testing with your own Traditional Chinese scripts and recordings, and then deciding whether to go live.

Voice rate limits

Source: docs.x.ai “Rate Limits”, listed in order from Tier 0 to Tier 4.

Tiers are upgraded automatically based on cumulative API spend since 2026-01-01. For each tier’s spend threshold, see docs.x.ai “Rate Limits.”

Developer Tools, Error Codes, and Enterprise Features

This chapter has three parts: ways to connect Grok to developer tools and cloud platforms, API error codes, and the things enterprises ask about, such as data retention, regions, and compliance. The content is based on the docs.x.ai pages of 2026-11-06. The official documentation refers to the company as SpaceXSI, but the domain, environment variables, and SDKs still use xAI, so this chapter uses xAI throughout.

Developer tools overview

Tools like Cline, Roo Code, and Continue mostly support an OpenAI-compatible base URL, so in theory you can enter https://api.x.ai/v1. But this is speculation and not an official endorsement, and xAI provides no setup instructions for them.

Grok Build CLI

Source: docs.x.ai “Grok Build”, “CLI Reference”, “Headless & Scripting”. Grok Build is xAI’s coding agent. You can use it through an interactive TUI, in headless mode (scripts and bots), or embedded in other applications through the Agent Client Protocol (ACP). The Release Notes list it under 2026-05 and mark it as beta.

Install and launch:

curl -fsSL https://x.ai/cli/install.sh | bash

On Windows, use irm https://x.ai/cli/install.ps1 | iex. The third way is the npm package @xai-official/grok (npm install -g @xai-official/grok). The official enterprise deployment page points out specifically that in environments that restrict outbound connections, you can install through npm and do not need to open up x.ai. On 2026-11-06, a check of the npm registry showed the latest version as 1.0.77.

The first time you run grok, it opens a browser to sign in. In environments without a browser (SSH, containers), use grok login --device-auth, or set XAI_API_KEY.

cd your-project
grok

Headless mode:

grok -p "Explain this codebase"
grok -p "Explain the architecture" --output-format streaming-json

There are three output formats: plain, json, and streaming-json. To use it as an ACP agent inside an IDE or another program, the command is grok agent stdio. In CI, it is recommended to add --no-auto-update to avoid background update checks.

Common subcommands:

Reading Claude Code’s configuration

The official documentation has a section called “Claude Code compatibility,” which states that Grok Build needs no setup and automatically reads Claude Code’s marketplaces, plugins, skills, MCP, agents, and hooks, as well as CLAUDE.md, CLAUDE.local.md, and .claude/rules/, handling them together with .grok/. It also reads the AGENTS.md family of files, and Cursor’s rules, MCP, and hooks.

A few practical details:

• MCP settings are loaded from ~/.claude.json, .cursor/mcp.json, and the project’s .mcp.json, with lower priority than config.toml.
• To turn off a source, set skills, rules, agents, mcps, or hooks under [compat.claude] or [compat.cursor] in ~/.grok/config.toml to false. You can also use environment variables such as GROK_CLAUDE_SKILLS_ENABLED=0.
• Some Claude Code flag names work as aliases: --allowedTools, --disallowedTools, --append-system-prompt, --system-prompt, --dangerously-skip-permissions.
• If an enterprise deployment already distributes Claude Code’s managed-settings.json through MDM, Grok reads the permission rules, MCP allowlist, and marketplace restrictions in it. But disableBypassPermissionsMode is not applied to Grok. To lock down always-approve, you must set disable_bypass_permissions_mode = true in Grok’s own requirements.toml.
• This is “compatible reading,” not calling Grok from inside Claude Code. The official source has no documentation on “using Grok models in Claude Code.”

Models, MCP, and cost

• Models: the example ~/.grok/config.toml file sets the default model to grok-build. You can also use [model.<id>] with base_url and env_key to connect any compatible endpoint, then switch with grok -p "Hello" -m my-model or the TUI’s /model.
• MCP: grok mcp add --transport http linear https://mcp.linear.app/mcp adds a remote server; for a local server use grok mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/dir; adding --scope project writes to the project’s .grok/config.toml.
• Cost: Grok 4.7 Fast (the same model at twice the speed and twice the price) is offered only in Cursor and Grok Build and is not in the public API. The official text states that it is “not included in Grok Build’s free tier,” which means Grok Build has a free tier, but the quota and conditions of the free tier are not published on any official page. Paid usage goes through The X Subscription plans.

Cursor

Source: docs.x.ai “Grok 4.7” and “The X Subscription”. The official model page says grok-4.7 is available in Cursor on “all plans.” The X Subscription combines Grok, Cursor, and X into one subscription, and first-party usage of Grok and Cursor shares a weekly quota. Using third-party models inside Cursor (for example Claude or GPT) is not covered by the quota, and is billed at API list prices from the first use.

Vercel AI SDK

Source: docs.x.ai “Community Integrations”. The install command is npm install ai @ai-sdk/xai zod, and it reads the environment variable XAI_API_KEY by default.

import { xai } from '@ai-sdk/xai';
import { generateText } from 'ai';

const { text } = await generateText({
    model: xai.responses('grok-4.7'),
    prompt: 'Write a vegetarian lasagna recipe for 4 people.',
});

To specify a key or base URL, use createXai({ apiKey, baseURL }); for images, use generateImage with xai.image('grok-imagine-image-2.0').

LiteLLM

Source: docs.x.ai “Community Integrations”. Add the xai/ prefix to the model name:

from litellm import completion
import os

os.environ['XAI_API_KEY'] = ""
response = completion(
    model="xai/grok-4.7",
    messages=[
        {
            "role": "user",
            "content": "What's the weather like in Boston today in Fahrenheit?",
        }
    ],
    max_tokens=10,
    response_format={ "type": "json_object" },
    seed=123,
    temperature=0.2,
    top_p=0.9,
    user="user",
)
print(response)

This official example uses completion in the Chat Completions form. xAI’s main interface is the Responses API, and for whether LiteLLM supports it, see LiteLLM’s own xAI provider documentation.

Docs MCP Server

Source: docs.x.ai “Docs MCP Server”. xAI provides an MCP server that lets AI assistants look up documentation directly. Its URL is https://docs.x.ai/api/mcp, it uses Streamable HTTP and is stateless, and its tools include list_doc_pages, get_doc_page, and search_docs. The setup methods the official text lists cover Grok Build, Cursor, Zed, Windsurf, and OpenCode.

grok mcp add --transport http xai-docs https://docs.x.ai/api/mcp
grok mcp doctor xai-docs

In Cursor, add it under Settings → MCP, choose the type url, and enter the same URL.

Vertex AI, Foundry, and model gateways

Google Cloud Vertex AI (source: docs.x.ai “Google Cloud Vertex AI”): Grok is a partner model in Model Garden. You must first enable it in Model Garden and then call it through the OpenAI-compatible interface, which supports the Responses API and Chat Completions. The model name carries the publisher prefix, for example xai/grok-4.7; authentication uses Application Default Credentials. Data retention and handling follow Google Cloud’s policies, not xAI’s 30-day rule. The base URL in the official example must be filled in as given on the model card or in Google’s documentation, and the page gives no fixed value.

from openai import OpenAI

client = OpenAI()  # Uses ADC / env vars automatically

response = client.responses.create(
    model="xai/grok-4.7",
    input="Explain the advantages of using Grok for agentic workflows with parallel tool calling.",
    max_output_tokens=800,
)

print(response.output_text)

Microsoft Foundry (source: docs.x.ai “Microsoft Foundry”): first create a Foundry resource and project, then deploy a Grok model from the model catalog. The “deployment name” is the value of the model parameter and cannot be changed after creation. The deployment type can be Serverless (pay for what you use) or Provisioned Throughput Units. Billing goes through Azure Marketplace and your Azure subscription. The endpoint format is https://{resource-name}.services.ai.azure.com/api/projects/{project-name}/openai/v1, and the official text recommends Microsoft Entra ID authentication, with keys also supported.

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import OpenAI

project_endpoint = "https://YOUR-RESOURCE-NAME.services.ai.azure.com/api/projects/YOUR_PROJECT_NAME"
base_url = project_endpoint.rstrip("/") + "/openai/v1"

credential = DefaultAzureCredential()
token_provider = get_bearer_token_provider(
    credential,
    "https://ai.azure.com/.default",
)

client = OpenAI(
    base_url=base_url,
    api_key=token_provider,
)

response = client.responses.create(
    model="grok-4.3",  # your deployment name
    input="Explain the significance of Grok's tool-calling capabilities for building reliable agents. Be concise but insightful.",
    max_output_tokens=800,
)
print(response.output_text)

That page also mentions that Grok on Foundry can be used with azure-ai-projects, LangChain, Semantic Kernel, and LlamaIndex. This is what the Foundry page says, and it does not mean xAI has a separate LangChain page.

Model gateways: the grok-4.7 model page lists three gateways, OpenRouter, Vercel, and Cloudflare, with only the names and no setup instructions. The Security FAQ also reminds you that when sharing one key through a gateway such as OpenRouter, you should send a different safety_identifier for each end user, so that violations can be attributed to individual users.

Error codes

Source: docs.x.ai “Debugging Errors”. When an API call fails, it usually returns an HTTP status code and an error message, and in most cases the message itself explains the cause.

A few additional points:

• The official error code page has no 5xx entries and no complete specification of the error response body. To handle 5xx, the only reference is the individual endpoint pages. For example, the TTS and STT pages each list 500, 502, and 503 and recommend retrying with backoff; for video generation failure codes, see the previous chapter.
• 404 also means “the model does not exist, or your team does not have access to it,” and a body example is {"code":"not-found","error":"The model ... does not exist or your team <team_id> does not have access to it..."}. Requesting a model that is not on the list at the US regional endpoint (including retired slugs and grok-latest) also returns this 404.
• Calling https://api.x.ai/v1/models directly without a key returns 401, with the body {"code":"unauthenticated:no-credentials",...}.
• The xAI SDK uses gRPC, and 429 maps to RESOURCE_EXHAUSTED.
• For service status, see https://status.x.ai (there is also an RSS feed at https://status.x.ai/feed.xml). To report a bug, email [email protected] with the request, response, and related logs, or go to #help on the xAI API Developer Discord.

Data retention and no training

Source: docs.x.ai “Security” FAQ.

• Default: all API requests and responses are stored in encrypted form on xAI servers for 30 days, for abuse auditing, and then deleted automatically.
• No training: the official text states clearly that xAI does not use API inputs and outputs to train models without your explicit consent.
• The server-side conversation state of the Responses API is also kept for 30 days, and you can turn that off by passing store: false.
• Team admins can view operation records in the Console’s Audit Log. After ZDR is on, the records contain only management events (such as creating a key or changing the team), not request and response content.

ZDR trade-offs

Zero Data Retention (ZDR) makes prompts and outputs never written to disk. The official documentation is cautious about it: “not recommended for most customers,” because ZDR disables features that depend on storage, and content deleted under ZDR cannot be recovered or provided by xAI afterward.

Operational limits:

• ZDR works at the team level and cannot be turned on for a single key only.
• A team admin switches it on and off themselves in the Console’s Team Settings, and before turning it on you must first delete all existing Files and Collections.
• Once on, each response header carries x-zero-data-retention: "true", which your program can use to confirm it.
• If you do not see the ZDR option, it may be because you are not an admin, your environment has not yet opened up self-service ZDR, or your team has separate arrangements under a signed Enterprise contract. Contact [email protected].

In the Grok Build CLI, with ZDR on, no traces or code data are retained. With ZDR off, you can use /privacy or /settings to turn off retention of code data, and the first use also asks whether you allow data to be retained to improve products and models. Under ZDR, Grok Build’s video tool needs your own S3-compatible storage, set in ~/.grok/managed_config.toml, and until it is set the video tool reports an error.

Also, the Build mode on grok.com keeps conversations and build sessions in order to publish apps across sessions, and does not offer Private Chat. If “improve the model” is on, that data may be used for product and model improvement.

US regional endpoint

Source: docs.x.ai “Regional Endpoints”. The global endpoint https://api.x.ai does not guarantee the processing region, and xAI may shift traffic between regions for capacity or reliability. When you need request handling and inference to stay in the US, switch to https://us.api.x.ai/v1, which every team can use, and existing API keys work with it.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("XAI_API_KEY"),
    base_url="https://us.api.x.ai/v1",
)

response = client.responses.create(
    model="grok-4.7",
    input="Explain latency versus throughput in two sentences.",
)

print(response.output_text)

The official warning is blunt: the regional endpoint itself is not a full data residency guarantee, and if you have contract-level requirements for where data is processed or stored, contact [email protected] before relying on it. As for Europe, the API documentation has no dedicated page for an EU regional endpoint. The Regions column on some model pages lists nodes such as eu-west-1, but the official text states that this is not an API routing guarantee.

mTLS

Source: docs.x.ai “mTLS Authentication”. mTLS is an enterprise feature that ensures only machines presenting a valid client certificate can call the API on behalf of your team.

1. Email [email protected] with your team ID, a CA certificate in PEM format, and the Common Name of the client certificate.
2. Once enabled, change the URL from https://api.x.ai to https://mtls.api.x.ai. The API paths stay the same.
3. Attach the client certificate and private key to every request, and you still need to send your original API key.

curl https://mtls.api.x.ai/v1/chat/completions \
  --cert /path/to/client-cert.pem \
  --key /path/to/client-key.pem \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -d '{ ... }'

(The official example uses Chat Completions here; other API paths and features behave the same once mTLS is enabled. The request body is omitted.)

Compliance certifications

Source: docs.x.ai “Security” FAQ and the feature pages of each model.

For things like GDPR that need written proof, do not rely only on a single marketing line on a documentation page. I suggest requesting the DPA and Trust Center materials directly, or contacting [email protected] (custom pricing, monthly invoicing, and higher rate limits also go through this channel, and you can also fill out the form at https://x.ai/grok/business).

Grok Build’s enterprise deployment has several more controls: OIDC single sign-on (supporting Entra ID, Okta, and Auth0), settings enforced through the MDM-distributed /etc/grok/requirements.toml, force_login_team_uuid to lock the team used for sign-in, and a network allowlist (core features need cli-chat-proxy.grok.com and auth.x.ai), with TLS 1.2 or 1.3 used for the entire connection.

Government procurement: GSA OneGov

xAI’s docs.x.ai has no dedicated page for government plans. The primary-source information that can be confirmed comes from the US GSA (General Services Administration) press release of 2025-09-25, “GSA and xAI Partner on $0.42 per Agency Agreement to Accelerate Federal AI Adoption” (https://www.gsa.gov/node/166722), with the following content:

• Federal agencies can obtain Grok models at $0.42 per agency.
• The term is 18 months, valid through 2027-03, which GSA says is the longest term among the OneGov AI agreements.
• The models covered by the agreement are Grok 4 and Grok 4 Fast.
• xAI commits to assigning dedicated engineers to help agencies adopt it, and to providing onboarding training.
• The agreement provides a path to upgrade to a Grok enterprise subscription that meets FedRAMP and DoD Impact Level requirements, for more features and higher rate limits.

This press release describes the models at the time of signing. The API names for Grok 4 and Grok 4 Fast were retired on 2026-05-15, with requests redirected automatically to grok-4.3, and that GSA page does not say whether the models covered by the agreement were updated afterward. The current state of FedRAMP and DoD IL authorization is also not in xAI’s API documentation, so agencies that need it should confirm directly with xAI and GSA.

Positioning Compared with ChatGPT, Claude, and Gemini, and Sources

This chapter covers only differences in product structure and policy that can be verified on official pages. It does not judge which provider is more accurate, safer, or easier to use. The benchmarks and rankings that each provider publishes are self-published, and this guide does not use them for comparison. For Claude’s and Gemini’s plans, prices, and usage rules, check each provider’s official pages directly. This chapter does not cite their numbers, to avoid falling out of step with pages that are adjusted frequently.

What Grok’s official sources emphasize

Compared with ChatGPT: the price ladder

The US dollar prices come from each provider’s official pricing page, and the New Taiwan dollar figures are reference prices: the Grok figures are taken from what grok.com/plans showed on 2026-11-06, and the ChatGPT figures are taken from the official ChatGPT page checked on the same day. Promotions and in-app purchase prices may differ.

Grok’s official statement is that Premium is equivalent to the former combination of SuperGrok, Cursor Pro, and X Premium+ totaling $90 per month. This is the official source’s conversion of its own old plans, and it does not represent an equivalent comparison with other companies’ products.

A few observations with a basis

1. Grok ties its subscription to X and Cursor. The plans of The X Subscription include both the X-side benefits (the checkmark, ads, creator tools, and so on) and Cursor. This is a characteristic of Grok’s plan structure; when choosing, factor in “whether I need the X benefits” as well. Third-party models (such as Claude and GPT inside Cursor) are not included in the plans and are billed separately at API list prices.
2. Real-time X data is a selling point the official source states explicitly. Grok’s official pages describe “searching public X posts” as a feature and say answers include citations. That public X posts can be cited also means your own public posts may show up in Grok’s answers; to avoid that, the official method is to set your account to protect your posts.
3. Images and video share an entry point with chat. Imagine can be used from grok.com/imagine or inside a conversation thread, and video supports reference images and voice references. Generated output carries a watermark and removing it is prohibited, which you should accept before you use it.
4. Grok Bot and grok.com are two products. The official FAQ says plainly that the two are different, with different sign-in accounts (Cursor), different usage accounting (the new plans draw on the shared pool, the old plans are separate), and different model choice (Grok Bot has no model menu). When comparing “Grok” with other products’ agent features, first work out which one you are comparing.
5. Usage rules differ by provider, and all of them are changing. Grok’s weekly shared usage pool is a new scheme rolled out gradually starting in June 2026, so do not use the 2025 figures of “how many Chat messages per day and how many Imagine images per day” to calculate.
6. Training defaults. Content from consumer accounts may be used for training by default, which you can turn off in Data Controls; Private Chat is not used for training; Business and Enterprise do not use customer content for training. Whether other products have the same default, check against each one’s official privacy statement.
7. The official documentation openly acknowledges that output may be inappropriate. Grok’s official FAQ and terms state that output may include profanity, crude humor, sexual situations, or violence, and the Australian terms also mention a setting that can restrict access to 18+ media (see the section below).

Figures the provider reports about itself

The models and rankings published by Grok’s official source are the vendor’s own claims. This guide only relays them and does not endorse them:

• Grok 4.7 (2026-09-21): the official source calls it the “most powerful model for coding and knowledge work,” with a knowledge cutoff of May 2026 and a context of 500k.
• Grok 4.5 (2026-07): the official source calls it “our most intelligent model yet.”
• Imagine Image 2.0: the official announcement cites Arena’s Image Edit and Text-to-Image leaderboards (as of 2026-08-07) and says it ranked second in the world on both. The announcement also notes that xAI’s models are listed on Arena under the name “SpaceXAI.”

Whether Grok 4.7 is enabled by default in regular grok.com conversations is not covered: the official announcement says only that it is available in Cursor, Grok Build, and the API, and the grok.com side is not published by the official source. Sign in and check inside the app.

Content policy: official text only

Grok has had many content controversies in media coverage and community discussion. This chapter does not include media reports or third-party commentary, and lists only the policy text in the official documents that can be quoted directly:

These are policy texts and do not equal how they are enforced in practice. The official FAQ also acknowledges that Grok may produce inaccurate information or hallucinations, and advises users to verify.

How to choose

• You need to look up real-time discussion on X: this is a feature Grok’s official source states explicitly, and it is worth running a round with topics you actually care about.
• You already use Cursor or X Premium: The X Subscription bundles them together, so work out the combined cost and the rules for switching between old and new plans; switching is irreversible, and customer support cannot undo it.
• You want an agent that handles chores automatically for long stretches: first confirm whether what you want is Automations or Skills inside grok.com, or the standalone Grok Bot, because the usage and plans for the three differ.
• You care about your data not being used for training: turn off Improve the model first, and use Private Chat for sensitive content; if you use Grok inside X, also turn it off in the X settings. For enterprise use, look at the Business or Enterprise terms.
• You are making commercial images or video: accept the watermark rules first, and read the requirements on output rights and labeling.

Whichever provider you choose, quotas and plans can change within a month or two. Before you decide, go back to the official pages to confirm the current conditions.

Sources

All of the following are official pages, with a lookup date of 2026-11-06. Official pages keep being updated, and the content is whatever each page shows at the time.

Company and product announcements (x.ai/news)

• xAI joins SpaceX
• The X Subscription
• Grok 4.5, Grok 4.5 on grok.com, X, iOS, and Android
• Grok 4.6, Grok 4.7
• Introducing Grok Bot, Grok Bot expanded plans, Grok Bot and X
• Connectors, Skills, Automations
• Build Mode, Grok Build on web and mobile
• Imagine Image 2.0, Imagine Video 1.5 with References
• Grok Voice 3.0, Grok Business
• News list (Office add-in and other announcements)

Product and pricing pages

• x.ai/grok, x.ai/grok/business, x.ai/bot, x.ai/build
• x.ai/pricing
• grok.com/plans (shown in New Taiwan dollars)
• The X Subscription pricing details, overview

Help documentation (docs.x.ai)

• Grok overview, Grok FAQ, Business user guide
• Connectors
• Grok Bot overview
• Models, Release Notes

Legal and policy

• Terms of Service
• Privacy Policy
• Consumer FAQs
• Acceptable Use Policy
• Safety
• Privacy Portal

X and store pages

• About Grok (X Help Center)
• X Premium (X Help Center)
• Grok’s iOS App Store page
• Grok’s Google Play page

For comparison: ChatGPT

The ChatGPT plan and price comparison is taken from the official ChatGPT pricing page checked on the same day.