Forem: Owen

Grok API: Pricing, Setup & Access Guide (2026)

Owen — Thu, 23 Apr 2026 11:07:34 +0000

Grok API: Pricing, Setup & Access Guide (2026)

TL;DR — Three Grok models are worth knowing: Grok 4.1 Fast ($0.20/M input, 2M context) for high-volume work, Grok 4.20 ($2.00/M input) for deep reasoning, and Grok Code Fast 1 ($0.20/M input, 256K context) for coding agents. All three are OpenAI-compatible. Getting to a working API call is a two-line config change in your existing OpenAI SDK setup.

Grok 4.1 Fast gives you a 2-million-token context window at $0.20/M input — that's 5x more context than GPT-5.4 Mini at a lower price, with real-time X search built in.

What the Grok API Actually Offers

xAI's API covers three distinct use cases: a cost-efficient general model with an unusually large context window, a flagship reasoning model with a built-in multi-agent architecture, and a coding-specific model optimized for agentic workflows.

Function calling, structured output, image input, and streaming all follow the same schema as the OpenAI Chat Completions API. If you're already using any OpenAI-compatible SDK, switching to Grok is a two-line change.

Pricing: Every Model Compared

All prices verified via ofox.ai/models, April 2026.

Model	Model ID	Input / 1M	Output / 1M	Context
Grok 4.1 Fast	`grok-4-1-fast`	$0.20	$0.50	2M
Grok 4.20	`grok-4.20`	$2.00	$6.00	2M
Grok 4.20 Multi-Agent	`grok-4.20-multi-agent`	$2.00	$6.00	2M
Grok Code Fast 1	`grok-code-fast-1`	$0.20	$1.50	256K

Prompt caching is automatic — no configuration needed. Cache hit prices vary by model: Grok 4.1 Fast drops to $0.05/M (75% off), Grok 4.20 drops to $0.20/M (90% off from $2.00), and Grok Code Fast 1 drops to $0.02/M (90% off from $0.20). For long, repeated system prompts, this makes the effective cost significantly lower than the sticker price.

Built-in tool fees (web search, X search, code execution): $2.50–$5.00 per 1,000 successful tool calls. These are charged separately from token costs.

How Grok Pricing Compares

Model	Input / 1M	Output / 1M	Context
Grok 4.1 Fast	$0.20	$0.50	2M
Grok Code Fast 1	$0.20	$1.50	256K
DeepSeek V4	$0.30	$0.50	1M
Gemini 3.1 Flash	$0.30	$1.50	1M
GPT-5.4 Mini	~$0.75	$4.50	400K
Claude Sonnet 4.6	$3.00	$15.00	200K
Grok 4.20	$2.00	$6.00	2M

Sources: ofox.ai/models, docs.x.ai/docs/models, April 2026.

Grok 4.1 Fast and Grok Code Fast 1 both land at $0.20 input, same tier as DeepSeek V4. Grok 4.1 Fast has a 2M context window vs DeepSeek's 1M; Grok Code Fast 1 has 256K, tuned for large codebases. For a full cross-model cost breakdown, see our AI API cost reduction guide.

The Three Models Worth Knowing

Grok 4.1 Fast — the everyday workhorse

At $0.20/M input, Grok 4.1 Fast is cheaper than GPT-5.4 Mini per token, but with 5x more context. The 2M token window means you can load an entire codebase, a long document collection, or a multi-day conversation history without truncating.

Two things set it apart from other $0.20-tier models: real-time web search via X (no knowledge cutoff for current events), and automatic prompt caching that requires zero configuration. Reasoning and non-reasoning modes are both available — toggle based on whether the task needs deliberate step-by-step thinking or fast pattern matching.

Grok 4.20 — multi-agent reasoning

Grok 4.20 is the only model currently available via API that exposes a multi-agent architecture at the call level. One request dispatches four internal agents — Grok, Harper, Benjamin, and Lucas — that cross-check each other's reasoning and actively debate conclusions to reduce hallucinations.

At $2.00/M input, it's 10x more expensive than Grok 4.1 Fast. For most tasks, that premium isn't justified. For high-stakes analysis — technical due diligence, research synthesis, complex decision support — the multi-perspective output is meaningfully better than a single-model call. The grok-4.20-multi-agent model ID explicitly routes to this architecture.

Grok Code Fast 1 — for coding agents

Grok Code Fast 1 (grok-code-fast-1) is purpose-built for agentic coding workflows. The 256K context window holds large codebases in memory across multi-step tool calls. At $0.20/M input and $1.50/M output, it's priced for high-volume use in CI pipelines, code review agents, and IDE integrations.

It supports function calling, structured output, and streaming — the full toolkit for building coding agents. For a comparison of how it stacks up against Claude and GPT on actual coding benchmarks, see our best AI model for coding guide.

Setup: Two Ways to Access the Grok API

Option 1: Through ofox.ai (recommended for most developers)

ofox.ai exposes the full Grok model family through an OpenAI-compatible endpoint. One API key covers Grok, Claude, GPT, Gemini, and 100+ other models — no separate xAI account needed.

Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.ofox.ai/v1",
    api_key="your-ofox-api-key"
)

response = client.chat.completions.create(
    model="grok-4-1-fast",
    messages=[{"role": "user", "content": "Explain prompt caching in one paragraph."}]
)
print(response.choices[0].message.content)

JavaScript/TypeScript:

import OpenAI from "openai";

const client = new OpenAI({
    baseURL: "https://api.ofox.ai/v1",
    apiKey: "your-ofox-api-key"
});

const response = await client.chat.completions.create({
    model: "grok-4-1-fast",
    messages: [{ role: "user", content: "Explain prompt caching in one paragraph." }]
});

If you're already using any model through ofox.ai, switching to Grok is changing one string. For a full walkthrough of migrating from OpenAI SDK to ofox.ai, see our OpenAI SDK migration guide.

Option 2: Through xAI directly

xAI's official endpoint is https://api.x.ai/v1. New accounts receive free credits to get started — check x.ai/api for current amounts. Enrolling in xAI's Data Sharing Program adds additional monthly free usage.

client = OpenAI(
    base_url="https://api.x.ai/v1",
    api_key="your-xai-api-key"
)

The direct route gets you the fastest access to new model releases and exclusive features like Live Search and X Search. The tradeoff: a separate billing relationship, and payment requires an international credit card.

When to Use Which Model

Context size and cost tolerance drive most of this decision:

High-volume pipelines, RAG, long-document tasks → Grok 4.1 Fast. The 2M context and $0.20 input price are hard to beat at this tier.
Coding agents, IDE integrations, code review → Grok Code Fast 1. The 256K window and coding-specific tuning make it the right fit.
Complex analysis, research, high-stakes decisions → Grok 4.20 or Grok 4.20 Multi-Agent. The 10x price premium is only worth it when output quality genuinely matters more than cost.
Real-time information → Any Grok model. The X integration gives you current data that models with fixed knowledge cutoffs can't match.

For a broader comparison of how Grok fits into the current model landscape, see our LLM leaderboard and model comparison guide.

Practical Notes

Prompt caching is automatic. Unlike Anthropic's explicit cache control headers, Grok caches repeated prefixes without any configuration. Cache hit rates differ by model: Grok 4.1 Fast saves 75% ($0.05/M), Grok 4.20 saves 90% ($0.20/M), and Grok Code Fast 1 saves 90% ($0.02/M). If your system prompt is long and consistent across requests, you're already paying well below the sticker price.

Tool call pricing is separate. The $2.50–$5.00/1,000 fee applies to built-in tools (web search, X search, code execution). Standard function calling with your own tools is charged at normal token rates.

The 2M token window is real, but very long contexts can affect output quality on complex reasoning tasks. For most practical workloads — codebases, document collections, long conversations — you won't hit the ceiling.

New xAI accounts have conservative rate limits. If you're building production workloads, plan for this or use an API gateway like ofox.ai that manages rate limits across multiple upstream providers.

Getting Started

Get an API key at ofox.ai (covers Grok + all other models) or x.ai/api (xAI direct, free credits for new accounts)
Set base_url to https://api.ofox.ai/v1 or https://api.x.ai/v1
Use model ID grok-4-1-fast for general tasks, grok-code-fast-1 for coding, grok-4.20 for deep reasoning

The Grok API's real unlock for developers isn't just the pricing — it's a 2M context window at the $0.20 tier that makes whole-codebase and whole-document reasoning practical without the cost math falling apart.

For teams already using an API gateway, adding Grok is a one-line model ID change. For teams evaluating whether to consolidate API providers, our AI API aggregation guide covers the tradeoffs.

Originally published on ofox.ai/blog.

OpenAI Just Named It Workspace Agents. We Open-Sourced Our Lark Version Six Months Ago

Owen — Thu, 23 Apr 2026 08:50:31 +0000

Hero image: from OpenAI's Workspace Agents announcement (April 22, 2026).

TL;DR — OpenAI shipped Workspace Agents on April 22: shared, cloud-resident AI agents that live in Slack and ChatGPT, built to do the work your team already does. That's the same shape as Marvin, the Lark/Feishu bot we open-sourced six months ago — but MIT-licensed, model-agnostic via the Ofox gateway, MCP-extensible, and running on your own hardware. Here's what Workspace Agents confirmed, and why the open-source version matters.

A 30-second Lark conversation

"Which blog post drove the most conversions last week?"

A teammate asked this in a Lark group chat. Within a minute, a bot card appeared: the top five posts ranked by paid conversions, anomalies flagged, with a throwaway line at the end: "This one is 3x the runner-up. Probably worth a follow-up piece."

Doing this manually: open GA4, pick a report template, add dimensions, add filters, export CSV, paste into a spreadsheet, compare. Ten minutes minimum. Marvin (our in-house Lark bot) did it in the time it took to type the question.

This isn't a new technique. It's just putting the agent where the work actually happens — the chat your team is already in — instead of making people walk over to the agent's UI.

OpenAI just made this a product category

Yesterday (April 22, 2026) OpenAI announced Workspace Agents. The shape:

Codex-powered, built for "work you're already doing" — preparing reports, writing code, responding to messages
Runs in the cloud, keeps going when you're offline
Shared across the org — build once, team reuses via ChatGPT or Slack
Schedules + approval flows
Free until May 6, credit-based pricing after
Framed as "the evolution of GPTs"

The most striking part of the launch isn't a feature — it's the repeated framing that the agent should come to the system the team already works in, not the other way around.

The industry has been converging on this for a while

The past two years have moved AI from "chat UI" toward "agent inside a workflow":

Claude Code put the agent in your terminal
Cursor / Windsurf / Zed put it in your IDE
Linear's Ask Agent put it in your issue tracker
Workspace Agents now puts it in your team IM

The consensus is clear: no one should have to leave where they work to use AI. The correct place for AI is wherever you already are.

For many teams, that place is Lark/Feishu. Real collaboration, real decisions, real feedback happen there. If an agent can't meet the team there, it might as well not exist.

The open-source reference implementation: Marvin

We open-sourced Marvin six months ago — a TypeScript Lark/Feishu bot framework built on the Claude Code CLI. Named after the depressive-but-terrifyingly-capable robot from The Hitchhiker's Guide to the Galaxy.

Feature-by-feature against Workspace Agents:

Workspace Agents promise	Marvin's implementation
Always running	Sessions persisted to disk, auto-resumes interrupted tasks on restart
Shared in the team IM	Live progress cards in Lark/Feishu groups, ⬜ → 🔄 → ✅
Schedule + event triggers	Built-in cron + WebSocket event listener
Ask for approval	Admin can interrupt mid-task with a message; Claude resumes with full context
Org permissions / safety	Output filter strips API keys, tokens, internal IDs, internal IPs

The architecture is smaller than you'd guess: Lark WebSocket in → Claude Code CLI → real-time progress card renderer out. Full diagram in the README.

What Marvin actually does for us

1. Take a task from Lark, ship it to production.

Someone flags a copy issue in chat, or @-mentions Marvin with "take this." Marvin greps the repo to find the code, opens a feature branch, pushes a PR, waits for CI, merges to dev, opens the second PR to master, merges that, confirms the deploy, reports back in chat, and closes the task. Human input: one sentence.

2. A GA4 question, answered in under a minute.

The opening anecdote. Marvin calls GA4 through its MCP server, cross-references dimensions, flags anomalies, returns a structured summary. Ten minutes of human work, done in 30 to 60 seconds.

The underrated part here isn't speed — it's that the cost of asking a data question drops to zero. Before, you'd think "is this worth opening GA4 for?" and often skip. Now you just ask. Question volume goes up, decisions get more evidence-based.

3. Everything else you plug in.

Marvin's capability surface equals the MCP servers you connect. Firecrawl for research, freee for accounting, Context7 for docs, your own internal services. Add an MCP server today; Marvin uses it tomorrow. That's the real ceiling.

Four ways the choices differ

A side-by-side parameter table isn't the point. The philosophy differences are:

Dimension	OpenAI Workspace Agents	Marvin
Agent ↔ model	Locked to Codex	Pluggable via the Ofox gateway — swap models anytime
Data boundary	Runs on OpenAI's cloud	Runs on your machine / your server
IM decoupling	Primarily Slack (and ChatGPT)	`lark.ts` is an adapter — swap Slack/Discord without touching the core
Tool ecosystem	Codex + OpenAI preset integrations	Any MCP server
Modifiability	Closed SaaS	Persona, rules, pipeline are all files in your repo

For many teams, data boundary and modifiability are the decisive ones. What's in your team chat, your repo, your GA4 property, your accounting — that's core organizational information, and you probably don't want it flowing through someone else's cloud.

Marvin runs on your own hardware. Ours lives on a Mac mini in the office, managed by launchd, with no external cloud services involved.

Running it

Repo: github.com/ofoxai/lark-claude-bot

If you have Claude Code installed, paste this at it and it'll walk you through setup:

Clone and configure https://github.com/ofoxai/lark-claude-bot for me:
1. Clone the repo and cd into it
2. Run npm install
3. Copy .env.example to .env
4. Ask me for Lark App ID, App Secret, and Encrypt Key, fill them in
5. If I don't have a Lark app yet, walk me through creating one on open.larksuite.com or open.feishu.cn
6. Once configured, run npm run dev to start the bot

A few minutes later there's a Marvin in your team chat.

Wrapping up

OpenAI has made "workspace agent" a product category. That's a net good — more teams will take this form seriously. But the future of agents shouldn't be "one SaaS vendor, one model, one IM they picked for you."

Marvin is one reference implementation of the opposite: open, model-agnostic, MCP-extensible, locally hosted. It's also the workflow-side incarnation of the Ofox gateway philosophy — one API for every model, one bot shape for every IM.

Code is here: github.com/ofoxai/lark-claude-bot.

Originally published on ofox.ai/blog.

LLM Leaderboard: Best AI Models Ranked (April 2026)

Owen — Thu, 23 Apr 2026 07:33:09 +0000

There is no single best model in April 2026 — the leaderboard has fractured by task.

Claude Opus 4.7 dominates coding benchmarks at 82% on SWE-bench Verified and ranks first on LM Arena with 1504 Elo rating. Three models tie at the top of the Artificial Analysis Intelligence Index (score of 57): Claude 4.7, Gemini 3.1 Pro Preview, and GPT-5.4. DeepSeek V3.2 offers optimal pricing at $0.29 per million input tokens.

How These Rankings Work

Three independent benchmarking systems:

LM Arena — Blind human preference voting across 339 models with 5.7M+ votes. The largest human-preference dataset in existence, using chess-style Elo ratings.
SWE-bench Verified — Evaluates whether models can resolve actual GitHub issues through agent-based testing.
GPQA Diamond — Graduate-level science questions where human PhD experts typically score 65-70%.
Artificial Analysis Intelligence Index — Combines multiple benchmarks into composite scoring.

Overall Leaderboard (LM Arena Top 10)

Rank	Model	Elo Score
1	claude-opus-4-7-thinking	1504
2	claude-opus-4-6-thinking	1502
3	claude-opus-4-7	1497
4	claude-opus-4-6	1496
5	muse-spark (Meta)	1493
6	gemini-3.1-pro-preview	1493
7	gemini-3-pro	1486
8	grok-4.20-beta1	1482
9	gpt-5.4-high	1482
10	grok-4.20-beta-0309-reasoning	1480

Anthropic holds four of the top five spots. The 24-point gap between first and tenth is statistically meaningful but not a blowout.

Best for Coding: SWE-bench Rankings

Model	Score	Notes
Claude Opus 4.7	82.0%	Released April 16, 2026
Gemini 3.1 Pro Preview	78.8%	Best price among top-3
Claude Opus 4.6 (Thinking)	78.2%	Cheaper alternative
GPT-5.4	78.2%	Tied with Opus 4.6
GPT-5.3 Codex	78.0%	Coding-tuned variant

The spread between #1 and #5 is roughly 4 percentage points. Differences appear in edge cases — complex multi-file refactors, ambiguous specs, long-running tasks.

Best for Reasoning: Composite Intelligence Index

Model	AA Score
Claude Opus 4.7	57
Gemini 3.1 Pro Preview	57
GPT-5.4	57
Kimi K2.6	54
Claude Opus 4.6	53

The three-way tie at 57 points indicates the current frontier is a plateau. Selection depends on cost, context window, and task-specific requirements rather than performance differentiation.

Best Value: Price-Performance Comparison

Model	Input $/M	Output $/M	Context	SWE-bench
DeepSeek V3.2	$0.29	$0.43	164K	—
Kimi K2.6	$0.60	$2.50	256K	vendor-reported
Gemini 3.1 Pro Preview	$2.00	$12.00	1M	78.8%
GPT-5.4	$2.50	$15.00	1M	78.2%
Claude Opus 4.7	$5.00	$25.00	1M	82.0%
Claude Opus 4.6	$5.00	$25.00	1M	78.2%

DeepSeek V3.2 is 17x cheaper than Claude Opus 4.7 on input tokens. Kimi K2.6 offers roughly 8x cheaper access with an Intelligence Index score only 3 points below the frontier band.

Best Open-Source Model

Kimi K2.6 from Moonshot AI — 1-trillion-parameter Mixture-of-Experts architecture with 32B active parameters, 256K context window. Scores 54 on the Intelligence Index, ahead of Claude Opus 4.6 (53).

Which Model Should You Pick?

For Coding: Claude Opus 4.7 leads at 82% SWE-bench. Cost-conscious teams should evaluate Kimi K2.6.
For Long-Context Work: Gemini 3.1 Pro Preview — 1M-token window with tied frontier performance.
For High-Volume Production: DeepSeek V3.2 as cost-effective alternative.
For General Chat: Claude Opus 4.7 (thinking mode) leads, but gaps are negligible for most apps.
For Self-Hosted: Kimi K2.6 — the only open-weight model that belongs in this conversation.

Originally published at ofox.ai