Apply your own routing policies, reduce token costs automatically, and see every routing decision in real time with Merge Gateway.
What Moonshot V1 8K costs to run
| Vendor | Input / 1M tokens | Output / 1M tokens | Zero data retention |
| --- | ---: | ---: | --- |
| Moonshot | $0.2000 | $2.00 | Yes |
Test Moonshot V1 8K
with Gateway’s Simulator
See a prompt's output, token spend, latency, and more with Moonshot V1 8K.
Route requests to Moonshot V1 8K in minutes
To get started in seconds, add our Gateway Implementation skill to your project, or pick your preferred SDK below. Check out our other quick start skills here.
Install the Merge Gateway SDK
Python
1$ pip install merge-gateway-sdkSend a request
Python
1from merge_gateway import MergeGateway
2
3client = MergeGateway(api_key="YOUR_API_KEY")
4
5response = client.responses.create(
6 model="openai/gpt-5.2",
7 input=[
8 {"type": "message", "role": "system", "content": "You are a helpful programming tutor. Explain the concepts clearly with practical examples."},
9 {"type": "message", "role": "user", "content": "Explain the concept of recursion in programming with a simple set of examples."},
10 ],
11)
12
13print(response.output[0].content[0].text)Try a diffrent model
Swap the model string to route to a different provider. No other code changes needed.
Anthropic
1response = client.responses.create(
2 model="anthropic/claude-sonnet-4-20250514",
3 input=[
4 {"type": "message", "role": "system", "content": "You are a helpful programming tutor. Explain the concepts clearly with practical examples."},
5 {"type": "message", "role": "user", "content": "Explain the concept of recursion in programming with a simple set of examples."},
6 ],
7)Point to Gateway
Python
1from openai import OpenAI
2
3client = OpenAI(
4 api_key="YOUR_API_KEY",
5 base_url="https://api-gateway.merge.dev/v1/openai",
6)Send a request
Use the standard chat.completions.create method. No provider prefix needed on the model name.
Python
1response = client.chat.completions.create(
2 model="gpt-5.2",
3 messages=[
4 {"role": "system", "content": "You are a helpful programming tutor. Explain the concepts clearly with practical examples."},
5 {"role": "user", "content": "Explain the concept of recursion in programming with a simple set of examples."},
6 ],
7)
8
9print(response.choices[0].message.content)Install packages
1npm install merge-gateway-ai-sdk-provider aiCreate the provider
TypeScript
1import { createMergeGateway } from "merge-gateway-ai-sdk-provider";
2
3const gateway = createMergeGateway({
4 apiKey: "YOUR_API_KEY",
5});Send a request
Use generateText to send a request. Model names use the provider/model format.
TypeScript
1import { generateText } from "ai";
2
3const { text } = await generateText({
4 model: gateway("openai/gpt-4o"),
5 prompt: "Explain the concept of recursion in programming with a simple set of examples.",
6});
7
8console.log(text);If you already have @ai-sdk/openai installed, point it at Gateway with a base URL change:
TypeScript
1import { createOpenAI } from "@ai-sdk/openai";
2
3const gateway = createOpenAI({
4 apiKey: "YOUR_API_KEY",
5 baseURL: "https://api-gateway.merge.dev/v1/ai-sdk",
6});
7
8// All generateText/streamText calls work unchangedInstall the Merge Gateway SDK
Anthropic SDK
1from anthropic import Anthropic
2
3client = Anthropic(
4 api_key="YOUR_API_KEY",
5 base_url="https://api-gateway.merge.dev/v1/anthropic",
6)
7
8message = client.messages.create(
9 model="claude-sonnet-4-20250514",
10 max_tokens=1024,
11 messages=[
12 {"role": "user", "content": "Explain the concept of recursion in programming with a simple set of examples."},
13 ],
14)
15
16print(message.content[0].text)Explore other models available in Merge Gateway
Moonshot V1 8K FAQ
If you have additional questions about Moonshot V1 8K, we've addressed several more below. Keep in mind that this information was written in July, 2026 and may change over time.
Heading
What other models does Moonshot AI offer?
Moonshot AI runs two lines: the older Moonshot V1 API tiers and the newer Kimi K2 generation. Here are some other models Moonshot AI supports:
- Moonshot V1 32K: the mid-context tier of the V1 family, with a 32,768-token window at
$1input and$3output per million tokens
- Moonshot V1 128K: the long-context V1 tier at 131,072 tokens, priced at
$2input and$5output per million tokens for larger documents and histories
- Moonshot V1 Auto: picks the right V1 context tier per request automatically, so you don't have to size the window yourself
- Kimi K2.6: the newer K2-generation model with a 262K-token context, a stronger general-purpose option than the V1 line
- Kimi K2.7 Code: a K2 variant tuned for coding and agentic tool use
- Kimi K2 Thinking: a reasoning-focused K2 model for harder multi-step problems
How does Moonshot V1 8K differ from Moonshot AI's other models?
Moonshot V1 8K is the smallest, cheapest entry point in the older V1 family.
- Context window: 8,192 tokens, the smallest in the lineup, versus 32K and 128K on the other V1 tiers and 262K on the Kimi K2 models
- Pricing: the cheapest option at
$0.20input and$2output per million tokens, below Moonshot V1 32K and Moonshot V1 128K
- Generation: it's part of the older V1 series; the Kimi K2 models are Moonshot's newer generation and are stronger on coding, agentic, and reasoning tasks
- Use case fit: best for short, well-scoped prompts rather than long documents or extended multi-turn context
Moonshot V1 8K is the right pick for short, high-volume, cost-sensitive tasks like classification, extraction, or brief completions, where an 8K window is plenty and price per request is the priority.
What models should I consider using alongside Moonshot V1 8K?
No single model is optimal for every task. Here are models worth pairing with Moonshot V1 8K depending on what your product needs:
- Gemini 3 Flash: route here when a request needs a much larger context window than 8K but you still want low cost and fast responses
- DeepSeek V4 Pro: for mid-to-hard reasoning tasks that exceed what an 8K entry-tier model can handle, at still-competitive pricing
- Codestral: for code generation and completion, where a code-specialized model outperforms a general short-context model
- Claude Opus 4.8: for the hardest reasoning or long-context work, when quality matters more than cost
What are the challenges of using Moonshot V1 8K in my product?
Like any production LLM, Moonshot V1 8K comes with tradeoffs worth planning for:
- Small context window: at 8,192 tokens, long documents, large prompts, or extended chat histories won't fit, which is its sharpest limitation
- Older generation: V1 predates the Kimi K2 line, so for coding, agentic, and reasoning quality the newer K2 models will usually outperform it
- Output-heavy cost: output is
$2per million tokens against$0.20input, so generation-heavy workloads cost more than the low input price suggests
- Provider dependency: relying on Moonshot alone means an outage or a deprecated version disrupts your traffic
- Cost at scale: even a cheap model compounds at high request volume without active budget controls
Why should I use Merge Gateway to route LLM requests with Moonshot V1 8K and every other model?
Using Moonshot V1 8K through Merge Gateway gives you access to the model itself and the infrastructure layer around it:
- One API, every provider: reach Moonshot V1 8K and every other major LLM through a single endpoint and API key, switching models by swapping the model string with no application code changes
- Intelligent routing and automatic failover: Merge routes around Moonshot outages automatically, and routing on cost, latency, or quality can hold cheap requests on Moonshot V1 8K while escalating harder ones, cutting spend by 40 to 60% without code changes
- Cost governance: set hard or soft project budgets so spend stays in plan, with every request attributed to a model, project, and tag in one billing dashboard across providers
- Build Your Own Router: define what "best" means with curated ML benchmarks or your own eval scores, so short cheap tasks land on Moonshot V1 8K and everything else routes where it should, with an explanation per decision
- Security and compliance controls: apply DLP rules and prompt injection protection before any request reaches Moonshot, and enforce per-project model and region policies outside your application
How can I start routing requests to Moonshot V1 8K via Merge Gateway?
Getting Moonshot V1 8K running through Merge Gateway takes a few minutes:
1. Create an account and get your API key from the dashboard.
2. Install the Merge Gateway SDK: run pip install merge-gateway-sdk (Python) or npm install merge-gateway-sdk (Node). Alternatively, if you're already using the OpenAI SDK, set base_url = "https://api-gateway.merge.dev/v1/openai" and your existing code works as-is.
3. Make your first request using the provider/model format. For Moonshot V1 8K, the model string is moonshot/moonshot-v1-8k. Swap the model string to route to any other provider without changing anything else.
4. Configure a routing policy in the dashboard to set failover behavior, cost limits, and optimization strategy. Your first policy can be as simple as naming Moonshot V1 8K as primary with one fallback.
Full setup instructions and SDK references are in the Merge Gateway docs.
Try Moonshot V1 8K through Merge Gateway
Route, observe, and control AI requests across providers from one API.
