> ## Documentation Index
> Fetch the complete documentation index at: https://docs.kodus.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Moonshot (Kimi) - OpenAI-Compatible Inference

> Learn how to connect Moonshot AI's Kimi K2.6 models to Kodus — via the Moonshot Developer API or the Kimi Code Plan.

## How Moonshot works

Moonshot AI publishes the **Kimi** family of models (K2, K2.5, K2.6, K2.6 Coding). Kimi is particularly strong on long-context code understanding and agentic workflows, and the API is fully OpenAI-compatible — Kodus can talk to it via the **OpenAI-compatible** provider. Kodus also has a dedicated **Moonshot** provider, which connects over Moonshot's Anthropic-compatible endpoint (`https://api.moonshot.ai/anthropic`).

Moonshot offers **two paths** to the same model family, each with its own endpoint:

* **Developer API** (`platform.moonshot.ai`) — pay-per-token, billed per usage. Concurrency scales with your recharge tier.
* **Kimi Code Plan** (`kimi.com/code`) — subscription with a **dedicated coding endpoint**. Flat pricing, capped concurrency (30 concurrent).

<Note>
  Moonshot's consumer Kimi.com chat subscriptions (Andante, Moderato, etc.) are separate from both API paths. Chat subscriptions do **not** grant API access. Kimi Code Plan is the API-specific subscription.
</Note>

Moonshot also operates a China-only platform (`platform.moonshot.cn`, base URL `https://api.moonshot.cn/v1`) billed in CNY. Use that only if you operate inside mainland China.

## Plans at a glance

### Kimi Code Plan (subscription)

| Attribute | Value |
| - | - |
| **Endpoint** | `https://api.kimi.com/coding/v1` |
| **Concurrency** | Capped at 30 concurrent requests |
| **Billing** | Flat-rate subscription |
| **Keys from** | [kimi.com/code](https://www.kimi.com/code) |

### Developer API (pay-per-token)

| Model | Pricing (1M input / output tokens) | Context Window | Notes |
| - | - | - | - |
| **Kimi K2.6 Coding** `recommended` | \~$0.60 / $2.50 | \~256k tokens | Latest, tuned for code review. |
| **Kimi K2.5** | $0.60 / $2.50 | \~256k tokens | Previous generation, still capable. |
| **Kimi K2 (0905)** | lower tier | \~128k tokens | Stable general-purpose model. |

Developer API endpoint: `https://api.moonshot.ai/v1` (international). Concurrency scales with recharge tier — Tier 1 (\$10 recharge) starts at \~50 concurrent, up to \~1000 concurrent on Tier 5.

## Creating an API Key

<Warning>A Moonshot account is required to create an API key.</Warning>

<Tabs>
  <Tab title="Kimi Code Plan subscriber">
    1. Go to [kimi.com/code](https://www.kimi.com/code) and subscribe to the plan.
    2. Open the key management area for your subscription.
    3. Create a Kimi Code key and copy it.

    <Note>
      Kimi Code keys only work against `https://api.kimi.com/coding/v1`. They will return 401 if sent to `api.moonshot.ai`.
    </Note>
  </Tab>

  <Tab title="Developer API (pay-per-token)">
    1. Sign in at [platform.moonshot.ai](https://platform.moonshot.ai) (or [platform.moonshot.cn](https://platform.moonshot.cn) if you operate inside mainland China).
    2. Add a payment method — Moonshot may grant a small starter balance when you first add billing.
    3. Open the **API Keys** section at [platform.moonshot.ai/console/api-keys](https://platform.moonshot.ai/console/api-keys).
    4. Click **Create API Key**, give it a descriptive name (e.g. `kodus-prod`), and copy the key immediately.

    <Note>
      Developer API keys only work against `api.moonshot.ai/v1` (international) or `api.moonshot.cn/v1` (China). Keys are **not** portable between regions.
    </Note>
  </Tab>
</Tabs>

## Configure Moonshot in Kodus

The primary flow is the **AI providers** page on Kodus Cloud. Self-hosted users who prefer fixing the provider at the process level can use environment variables instead.

### Option 1 — Moonshot provider on Kodus Cloud (recommended for the Developer API)

<Steps>
  <Step title="Open AI providers and pick Moonshot">
    In the sidebar, open **AI providers** ([app.kodus.io/byok](https://app.kodus.io/byok)). On the **Providers** tab, click the **Moonshot** tile (under **Connect your first provider**, or **Add another provider** if you already connected one).
  </Step>

  <Step title="Paste your API key and pick the model">
    Paste your Developer API key from [platform.moonshot.ai](https://platform.moonshot.ai/console/api-keys) in the **API key** card. The **Model** picker then loads Moonshot's models — pick one (e.g. `kimi-k2.6`) or choose **Type model manually**. Kodus fills in the `https://api.moonshot.ai/anthropic` endpoint for you; this tile has no plan selector and no base URL field, so for a Kimi Code Plan key (or the China platform) use Option 2 below.
  </Step>

  <Step title="Test & save">
    Click **Test & save**. Kodus tests the connection and saves the config on success. 401 means the key doesn't match the endpoint.
  </Step>
</Steps>

### Tuning reasoning (optional)

**Thinking / Reasoning** is under **Advanced (optional)**. For Kimi, any level other than Off emits `thinking: { type: "enabled" }`. To override it, switch **Thinking / Reasoning** to **Custom** and paste one of these:

* **Disable thinking** for faster/cheaper reviews on small PRs:

  ```json theme={null}
  {
    "thinking": { "type": "disabled" }
  }
  ```

* **Force a specific token budget** (if Moonshot adds support for `budget_tokens` on your tier):

  ```json theme={null}
  {
    "thinking": { "type": "enabled", "budget_tokens": 25000 }
  }
  ```

<Note>
  No namespace wrapping needed — Kodus wraps the options under the active provider's namespace before sending. See the [main BYOK doc → Custom JSON override](/en/how_to_use/byok#custom-json-override) for details.
</Note>

### Tuning concurrency

* **Kimi Code Plan**: set **Max concurrent requests** (under **Advanced (optional)**) to `30` (the documented cap). Going higher returns 429.
* **Developer API**: start empty (no cap). Your actual limit scales with your recharge tier — Tier 1 (\~$10 recharge) allows ~50 concurrent; Tier 5 (~$3000) allows \~1000. Lower it explicitly if you see 429s at review time.

<Note>
  On the **Routing** tab, set Kimi as **Model for all tasks** and an OpenAI or Anthropic model as **Fallback (optional)** — if Moonshot returns 429 or 402, Kodus fails over automatically.
</Note>

### Option 2 — OpenAI-compatible endpoint

For the Kimi Code Plan, the China platform, or Moonshot's OpenAI-compatible endpoint, open **AI providers**, pick **OpenAI-compatible** under **Custom** on the **Providers** tab, and fill:

| Field | Value |
| - | - |
| **Base URL** | `https://api.moonshot.ai/v1` (Developer API)<br />`https://api.kimi.com/coding/v1` (Kimi Code Plan)<br />`https://api.moonshot.cn/v1` (mainland China only) |
| **Model** | `kimi-k2.6`, `kimi-k2.6`, `kimi-k2.5`, `kimi-k2-0905`, `kimi-k2` |
| **API key** | your Moonshot or Kimi Code key (matching the base URL above) |
| **Max concurrent requests** (under **Advanced (optional)**) | `30` on Kimi Code Plan; leave empty on Developer API (scales with recharge tier) |

### Option 3 — Self-hosted (environment variables)

If you run Kodus in Fixed Mode (single global provider, no per-org BYOK), configure Moonshot in the `.env` of your API + worker containers:

```env theme={null}
# Moonshot (Kimi) configuration (Fixed Mode)
API_LLM_PROVIDER_MODEL="kimi-k2.6"
API_OPENAI_FORCE_BASE_URL="https://api.moonshot.ai/v1"    # or https://api.kimi.com/coding/v1 for Kimi Code Plan
API_OPEN_AI_API_KEY="your-moonshot-or-kimi-code-api-key"
```

<Note>
  This path is only needed for self-hosted Kodus installs that deliberately disable BYOK. If BYOK is enabled on your self-hosted instance, prefer **Option 1** or **Option 2** — the **AI providers** page works the same as on Cloud.
</Note>

Restart the API and worker containers after editing `.env`, then verify the integration:

```bash theme={null}
docker-compose logs api worker | grep -iE "moonshot|kimi"
```

For the full self-hosted setup (domains, security keys, database, webhooks, reverse proxy), follow the [generic VM deployment guide](https://docs.kodus.io/en/how_to_deploy/deploy_kodus/generic_vm) and only swap the LLM block for the one above.

## Choosing between Kimi Code Plan, Developer API, and aggregators

* **Kimi Code Plan** — predictable flat-rate cost, 30-concurrent cap, dedicated `api.kimi.com/coding/v1` endpoint optimized for coding workflows. Best for steady-state teams with predictable PR volume.
* **Moonshot Developer API** — pay-per-token, concurrency scales with recharge tier, largest flexibility. Best for bursty workloads.
* **OpenRouter proxy** — if you want one billing relationship across many providers, OpenRouter exposes Kimi models with a small routing markup. Pick this when Kimi is part of a mixed-provider fleet, not a primary workload.

## Troubleshooting

<AccordionGroup>
  <Accordion title="401 after Test — key doesn't match endpoint">
    * Kimi Code Plan keys only work against `api.kimi.com/coding/v1`.
    * Developer API keys from `platform.moonshot.ai` only work against `api.moonshot.ai/v1`.
    * Developer API keys from `platform.moonshot.cn` only work against `api.moonshot.cn/v1`.
    * The **Moonshot** tile always uses `https://api.moonshot.ai/anthropic`, so it needs a `platform.moonshot.ai` key. Connect Kimi Code Plan or `platform.moonshot.cn` keys through **OpenAI-compatible** with the matching **Base URL**.
  </Accordion>

  <Accordion title="Insufficient balance">
    * Developer API bills pay-per-token. If balance runs out, requests return HTTP 402.
    * Add funds in the billing section of the console or set a monthly cap to avoid surprises.
    * Kimi Code Plan has flat pricing but is bound by its 30-concurrent cap and quota windows — 429 means you've hit one.
  </Accordion>

  <Accordion title="Model not found">
    * Confirm the model name matches the catalog (`kimi-k2.6`, `kimi-k2.6`, `kimi-k2.5`, `kimi-k2-0905`, `kimi-k2`).
    * Check [platform.kimi.ai/docs](https://platform.kimi.ai/docs) for the current list — new versions ship regularly.
  </Accordion>

  <Accordion title="Slow first response">
    * First call after idle periods may cold-start on Moonshot's side.
    * If latency matters, `kimi-k2-0905` is generally faster than the K2.6 variants for routine reviews.
  </Accordion>

  <Accordion title="Region / connectivity">
    * Users outside China should always use `api.moonshot.ai` or `api.kimi.com`. `api.moonshot.cn` may be unreachable or rate-limited from outside mainland China.
    * Confirm outbound HTTPS to the chosen endpoint is allowed from your Kodus deployment.
  </Accordion>
</AccordionGroup>

## Related

* [Moonshot platform (international)](https://platform.moonshot.ai)
* [Kimi Code Plan](https://www.kimi.com/code)
* [Kimi API documentation](https://platform.kimi.ai/docs)
* [BYOK overview](/en/how_to_use/byok)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.