Use Kimi K3 in Your IDE Without a Subscription

The three connection values every client needs

Create one Novita API key, then use the endpoint format your coding client supports.

1. In Novita, open API Key Management and create a key. Copy it once and store it securely.
2. For an OpenAI-compatible client, use https://api.novita.ai/openai/v1 as the base URL.
3. For a client that accepts Anthropic-compatible providers, use https://api.novita.ai/anthropic as the base URL.
4. Use the exact model ID moonshotai/kimi-k3.
5. Paste the API key only into the client's provider or secret field, never into a project file.
6. Start with one small prompt and confirm it appears in Novita's usage dashboard.

Some clients ask for a base URL without /v1 and add that path themselves. Follow the matching setup below; a duplicated or missing /v1 is a common cause of 404 errors.

VS Code or JetBrains: use Continue

Novita publishes an official Continue integration for both VS Code and JetBrains IDEs.

1. Install Continue from the VS Code Marketplace or the JetBrains plugin marketplace.
2. Open Continue and choose Add Chat Model.
3. Select Novita AI as the provider.
4. Enter the API key from your Novita account.
5. Select Kimi K3 if it appears, or add moonshotai/kimi-k3 as the custom model ID.
6. Ask K3 to explain one file before granting broader agent or command permissions.

Continue supplies the editor experience; Novita supplies the K3 model. Chat, autocomplete, agent and tool features can use separate models or settings inside Continue.

OpenCode: use Kimi K3 in a terminal or desktop coding agent

Novita publishes an official OpenCode integration for custom models. OpenCode is useful when you want a coding agent without changing your main editor.

1. Install the current OpenCode command-line tool or desktop app from OpenCode's official site.
2. Open OpenCode settings and find Providers or Custom Provider.
3. Display name: Novita.
4. Base URL: https://api.novita.ai/openai/v1.
5. API key: use the key created in your Novita account.
6. Model ID: moonshotai/kimi-k3.
7. Save, select Kimi K3 via Novita and test a read-only project question before approving edits or commands.

Novita's OpenCode documentation confirms the custom-provider route and exact base URL. K3's model ID comes from Novita's Model Hub; context, price and capabilities remain model-specific.

Claude Code: use Novita's Anthropic-compatible endpoint

Novita publishes a Claude Code integration using its Anthropic-compatible API. This PowerShell setup applies only to the current terminal window.

1. Install the current Claude Code release and open PowerShell in a small test project.
2. Set ANTHROPIC_BASE_URL to Novita's Anthropic-compatible endpoint.
3. Set ANTHROPIC_AUTH_TOKEN to your Novita API key.
4. Set both model variables to moonshotai/kimi-k3 so background requests do not fall back to an unavailable Anthropic model.
5. Run claude and confirm a simple read-only request works before approving edits, commands or MCP tools.

$env:ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
$env:ANTHROPIC_AUTH_TOKEN="PASTE_YOUR_NOVITA_KEY"
$env:ANTHROPIC_MODEL="moonshotai/kimi-k3"
$env:ANTHROPIC_SMALL_FAST_MODEL="moonshotai/kimi-k3"
claude

Novita documents non-Claude models in Claude Code, but Anthropic does not support or guarantee third-party routing to non-Claude models. Claude Code updates can therefore affect tools or compatibility. Test the current versions before making it your main workflow.

Zed: add Novita as an OpenAI-compatible provider

Zed is one supported example, not the only way to use this offer.

1. In Zed, open the command palette and run agent: open settings.
2. Under LLM Providers, choose Add Provider and select an OpenAI-compatible provider.
3. Provider name: Novita. API URL: https://api.novita.ai/openai/v1.
4. Model ID: moonshotai/kimi-k3. Context window: 1048576.
5. Set reasoning effort to high, enter the Novita key when prompted and save.
6. Open Agent, select Kimi K3 via Novita and test one non-sensitive file.

K3 handles Agent and inline requests in this setup. Zed's separate Edit Prediction provider controls tab suggestions while you type.

Optional copyable Zed settings.json configuration

Add this inside your existing Zed settings object. If language_models already exists, merge the nested novita provider instead of duplicating the top-level key.

{
  "language_models": {
    "openai_compatible": {
      "novita": {
        "api_url": "https://api.novita.ai/openai/v1",
        "available_models": [
          {
            "name": "moonshotai/kimi-k3",
            "display_name": "Kimi K3 via Novita",
            "max_tokens": 1048576,
            "max_output_tokens": 131072,
            "reasoning_effort": "high",
            "capabilities": {
              "tools": true,
              "images": true,
              "parallel_tool_calls": false,
              "prompt_cache_key": false,
              "chat_completions": true,
              "interleaved_reasoning": false,
              "max_tokens_parameter": true
            }
          }
        ]
      }
    }
  }
}

After saving, enter the key through Zed's provider interface. The 131072 output setting is a conservative editor cap below the model's published maximum; it does not reduce the 1M context setting.

VS Code: use Cline or Roo Code

Cline officially supports custom OpenAI-compatible providers, and Roo Code offers a similar provider-based workflow.

1. Install Cline or Roo Code in VS Code.
2. Open the extension's provider settings and choose OpenAI Compatible.
3. Base URL: https://api.novita.ai/openai/v1.
4. API key: use the key created in Novita.
5. Model ID: moonshotai/kimi-k3.
6. Save, verify the connection and begin with read-only file access.
7. Test file edits and terminal tools separately before enabling automatic approvals.

The extension controls checkpoints, terminal access, MCP and approval rules. K3 is the model behind those features; the affiliate link does not install or configure the extension.

Neovim: use CodeCompanion

Novita publishes an official CodeCompanion.nvim integration for bringing its models into Neovim.

1. Install CodeCompanion.nvim using its current official installation instructions.
2. Create a Novita adapter in your Neovim configuration.
3. Use https://api.novita.ai/openai as the adapter base URL unless the current plugin version asks for the /v1 form.
4. Store your Novita key in an environment variable rather than directly in init.lua.
5. Set the model to moonshotai/kimi-k3.
6. Run :checkhealth codecompanion and test a small chat before editing code.

Neovim plugin configuration can change between releases. Compare this page with Novita's current CodeCompanion guide and the plugin's own adapter documentation.

Other IDEs and coding agents

A client does not need a dedicated Novita button if it supports a custom OpenAI-compatible or Anthropic-compatible provider.

1. Look for Provider, Custom Model, OpenAI Compatible, Anthropic Compatible or Base URL in the client's settings.
2. Use https://api.novita.ai/openai/v1 for an OpenAI-compatible connection or https://api.novita.ai/anthropic for an Anthropic-compatible connection.
3. Enter moonshotai/kimi-k3 as the model ID and add your Novita API key.
4. Confirm that the client uses a compatible chat or messages endpoint.
5. Test chat first, then file edits, tools, terminal access, MCP and autocomplete one feature at a time.

Do not describe this as literally working in every IDE. A client must support a compatible custom endpoint, and each client decides which agent features it exposes.

Quick API test before opening a large repository

A small test confirms that the key, endpoint and model ID work. Run it only in a secure terminal and remove the environment variable when finished.

$env:NOVITA_API_KEY="PASTE_YOUR_KEY_HERE"
$headers = @{
  Authorization = "Bearer $env:NOVITA_API_KEY"
  "Content-Type" = "application/json"
}
$body = @{
  model = "moonshotai/kimi-k3"
  messages = @(
    @{ role = "user"; content = "Return only: Kimi K3 connection works" }
  )
  max_tokens = 80
  reasoning_effort = "low"
} | ConvertTo-Json -Depth 5
Invoke-RestMethod `
  -Uri "https://api.novita.ai/openai/v1/chat/completions" `
  -Method Post `
  -Headers $headers `
  -Body $body

Do not save the real key in this command, screenshots, shell history, dotfiles or source control. Revoke and replace it immediately if it is exposed.