Kimicode in Cursor Alternative: Custom Endpoint Setup

What works and what to expect

Many code editors with built-in chat let you replace the OpenAI endpoint with your own. That one setting is what makes this possible. You give the editor three things: a base URL, an API key and a model name. Everything else is the editor's own behaviour.

The API here is a hosted, OpenAI-compatible service with one open-weight model, run by an independent provider and tuned to answer without content refusals for lawful adult use. It is not Kimi's own service and not a router across vendors, so there is no model picker. You get uncensored, and that is the only model ID.

Be realistic about the match. I am not claiming this model beats whatever your editor ships by default at writing code, and I have no benchmark to show you. What you gain is control: your own endpoint, per-token billing at $0.15 per 1M input and $0.50 per 1M output, and a model that does not refuse a request because of its topic. What you give up is whatever features the editor only enables for its own models.

Step by step: the base URL override

1. Sign in and open the API key page. Create a key. New users can claim the $0.50 trial there with one click, no card needed, valid for 7 days.
2. In your editor, open the model or API settings. Cursor, for example, has had an option to override the OpenAI base URL in its model settings. The name and location of that option change between releases, so check the editor's own documentation if you cannot find it.
3. Enter the base URL: https://api.kimicode.cc/v1. Do not add /chat/completions.
4. Paste your key into the OpenAI key field.
5. Add a custom model named uncensored and select it in the chat panel.
6. Run a small test question. If the editor shows an error, open the dev console or logs and look for the HTTP status. A 401 is a key problem, a 404 is a URL problem, and a 429 is a rate limit.

Some editors verify a key by calling a hosted model name that does not exist here. If verification fails but chat works, ignore the verification step. If the editor refuses to save without it, use another tool from the next section.

Keep your trial limits in mind while testing: 2 concurrent requests and 60 per minute. An editor that fires several background requests at once, such as autocomplete plus chat, can hit the concurrency cap. A full key allows 8 concurrent and 300 per minute.

Other editors and tools that take a custom endpoint

If your editor will not accept a custom base URL, several open-source tools will. Each takes the same three values. Check their docs for the current option names, since these change.

Aider reads standard OpenAI environment variables and takes an OpenAI-compatible model with an openai/ prefix:

Copyexport OPENAI_API_BASE="https://api.kimicode.cc/v1"
export OPENAI_API_KEY="YOUR_KEY"
aider --model openai/uncensored

Continue, an extension for VS Code and JetBrains, accepts a model entry with the provider set to openai and an API base. The file format differs by version, so this is the shape to look for:

Copy{
  "models": [
    {
      "title": "Kimicode API",
      "provider": "openai",
      "model": "uncensored",
      "apiBase": "https://api.kimicode.cc/v1",
      "apiKey": "YOUR_KEY"
    }
  ]
}

Cline offers an OpenAI-compatible provider in its settings, where you enter the same base URL, key and model ID. In all cases the pattern is the same: pick the OpenAI-compatible provider, never the one named after a vendor.

A system prompt that suits code work

Editors usually add their own instructions, but many let you add custom rules or a system prompt. A short, specific prompt beats a long one. Here is a starting point you can adjust:

You are a code assistant working in the user's project. Answer with the smallest change that solves the problem. Show diffs or the changed function, not the whole file. If a requirement is unclear, ask one question before writing code. State any assumption you make about versions or frameworks.

Why these lines? "Smallest change" cuts output tokens, which are the pricier side at $0.50 per 1M. "Show diffs" does the same and makes review easier. "Ask one question" prevents a long wrong answer. "State assumptions" gives you a place to catch an error before it reaches your code.

Keep temperature low for code. Values around 0.2 to 0.4 give steadier output, and you can pass a seed if you want repeatable results while debugging a prompt. Both are passed through to the model.

A script when the editor falls short

When an editor feature does not fit a custom endpoint, a twenty-line script covers the gap and gives you full control over what is sent. This one reads a file, asks for a review with your own system prompt, and prints the answer as it streams.

Copyimport os, sys
from openai import OpenAI

client = OpenAI(base_url="https://api.kimicode.cc/v1", api_key=os.environ["KIMICODE_KEY"])

SYSTEM = (
    "You are a careful code reviewer. List real bugs first, then risky spots. "
    "Quote the line you mean. Skip style comments."
)

path = sys.argv[1]
code = open(path, encoding="utf-8").read()

stream = client.chat.completions.create(
    model="uncensored",
    stream=True,
    temperature=0.3,
    messages=[
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": f"Review {path}:\n\n{code}"},
    ],
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

Run it as python review.py app/server.py. A 1,000-token file with a 600-token review costs $0.00015 + $0.0003 = $0.00045. You could review a few thousand files for under $2.

The same pattern works for commit messages, test generation and docstrings. Bind the script to a key in your editor and you have a custom command with no plugin at all.

Where this fits and where it does not

This setup is a good fit if you want your own endpoint, pay-per-token billing and a model that will not refuse a task because of its subject. It suits solo developers, small teams and people who build tools that talk to several providers through one client library.

It is a weaker fit if you depend on features that only work with an editor's own hosted models, such as tight inline autocomplete tuned to a specific model, or image-based features. If those are central to how you work, keep the default and use this API for the chat panel and for scripts. Mixing the two is common and costs nothing extra.

If you only want to see what it feels like, claim the trial on the API key page and ask your editor three questions from your current task. Compare the answers with what you get now. That test takes ten minutes and uses a fraction of a cent.

Honest limits of a text-only model

Three limits are worth knowing before you switch.

Text only. There are no image inputs and no embeddings endpoint. If your editor indexes a codebase with embeddings, that index needs another source or the feature stays off. Pasting a screenshot of an error will not work either; paste the error text.

100,000-token window. That is the prompt plus the completion. As a rough rule, code runs about three to four characters per token, so a big file of 40 KB is on the order of 10,000 to 13,000 tokens. Editors that attach many files can reach the ceiling quickly. When you see a context error, attach fewer files, not more.

No hidden routing. You get one model. If it misses on a task, there is no fallback model behind the scenes, so rephrase, add an example, or narrow the question.

On cost, a typical coding question with 20,000 input tokens and 1,000 output tokens is $0.003 + $0.0005 = $0.0035. Fifty of those in a day is $0.175. The pricing page lists top-ups from $20 to $500 with bonuses from $50, and credit never expires. Prompts are not used for training.

Checklist before you commit

• Test with the trial credit on a real task from your own project, not a toy prompt.
• Check that streaming works in your editor. If answers appear only at the end, the editor may be buffering.
• Confirm that tool calling is wired up if you use agent features. This API supports tools and streamed tool_calls, but the editor decides whether to send them.
• Read the docs quickstart once, including the section on error codes.
• Decide on a monthly top-up cap. Since billing is prepaid, the most you can spend is what you added.

The prepaid design is a safety net for editors that run agent loops. A loop that goes wrong stops when the credit does, rather than producing a surprise invoice.

More guides

• Kimi Code API Pricing vs Pay-as-You-Go Tokens
• Kimi Code API URL: Base URL Setup for OpenAI Clients
• Groq API: Myths vs Facts for Uncensored LLMs