Cursor

Connect Cursor to Mixen — pay from your balance in roubles, with a catalog of 105+ models.

Installation

Cursor is a VS Code-based IDE. Download the installer from cursor.com (macOS, Windows, Linux). No OpenAI or Anthropic accounts needed — all chat requests go through Mixen.

Configuration

1. Open Cursor Settings → Models (gear icon in the top-right corner of the window).
2. In the OpenAI API Key section, paste your Mixen key and enable Override OpenAI Base URL:

Base URL:       https://api.mixen.ai/v1
OpenAI API Key: your-api-key

3. Click Add model and add a model by its ID from the catalog — for example openai/gpt-5.6-sol — then enable its checkbox in the list.
4. Save the settings. If your version has a Verify button, it will call GET /v1/models and confirm the API endpoint is reachable (the request itself does not verify the key); in recent Cursor versions the button is gone — the first request does the check.

A key starting with mxn-… is issued in the dashboard.

Verifying the connection

Before setting up models, you can check the key and balance with a minimal generating request:

curl https://api.mixen.ai/v1/chat/completions \
  -H "Authorization: Bearer your-api-key" \
  -H "Content-Type: application/json" \
  -d '{"model":"z-ai/glm-5.3-flash","messages":[{"role":"user","content":"ping"}],"max_tokens":5}'

200 with a response — the key and balance work; 401 invalid api key — the key was copied incompletely or isn’t a Mixen API key; 402 — no funds on the balance.

GET /v1/models does not verify the key — it responds without one; use it only to check that the API is reachable.

Picking a model per task

An IDE agent resends nearly all accumulated context on every turn, so input price drives the bill more than you’d expect. Prices below are per 1M tokens, input/output; full tables including cache columns — in the catalog.

Task	Model	Input / output
Code questions, review, small edits	GLM 5.3 Flash (z-ai/glm-5.3-flash)	8.4 / 27.9 ₽
Multi-file edits in familiar code	GLM 5.3 (z-ai/glm-5.3)	156 / 490.2 ₽
Complex agentic tasks, unfamiliar codebase	GPT-5.6 Sol (openai/gpt-5.6-sol), Claude Sonnet 5 (anthropic/claude-sonnet-5)	213.9 / 1069.5 ₽

GLM 5.3 Flash is a cheap workhorse: discussing project structure, asking about a file, sketching a plan. Turn on the flagships GPT-5.6 Sol and Claude Sonnet 5 where multi-step edit accuracy matters. A useful habit is to keep both in the list and switch as the session goes.

The three main filters for agentic work are visible right in the model’s catalog card: context window size, allowed reasoning_efforts, and tool calling support.

Saving on sessions

Every agent turn pays for its input again — but Mixen caches the repeating context prefix (system prompt, rules, chat history, read files) automatically. Nothing to enable on your side.

• Repeated context costs ~10% of the input price. For GPT-5.6 Sol, input is 213.9 ₽ per 1M tokens and 21.4 ₽ from cache; for GLM 5.3 Flash — 8.4 and 1.7 ₽ respectively.
• The cache lives 5 minutes with sliding renewal: every subsequent request resets the timer. As long as you work without long pauses, the cache lives from the start of the session to its end.
• A pause longer than 5 minutes means the first turn after it pays the full input price; the cache then warms up again. This is normal, not a billing error.

Simple tactics follow:

• “Read and explain” turns are cheap: the context rides from cache and the output is short. Don’t skimp on them — skimp on the models you use for them.
• A streak of long edits is cheaper than it looks: full input is paid once at the start, then it ships from cache.
• Keep sessions compact — a run of consecutive turns costs less than the same turns spread across the day.

Responses stream as real per-symbol deltas, not one block at the end; this doesn’t affect the price.

What a typical session costs

Let’s size up an agent session on GPT-5.6 Sol: 30 turns, each sending about 50K tokens of context (rules, read files, history).

Scenario	Session input
Without cache	1.5M tokens × 213.9 ₽ ≈ 321 ₽
With cache	first turn in full, then the prefix at 21.4 ₽ ≈ 70 ₽

The difference is input-only: the output (the edits themselves) is identical in both scenarios. The longer the session and the more stable its beginning — rules, the plan, and read files don’t change from turn to turn — the bigger the share the cache takes. The numbers are indicative: real volumes depend on project size and the number of open files.

How much came from cache specifically is visible in the API response — the usage.prompt_tokens_details.cached_tokens field (with streaming, in the final chunk, if the client requested usage). Cursor doesn’t show this field, but when reconciling the bill with the dashboard it answers the “where did the money go” question.

Reasoning depth

Our API accepts the reasoning_effort parameter: off, low, medium, high, xhigh, or max — the set depends on the model. Allowed values are listed in GET /v1/models → capabilities.reasoning_efforts, and the can_disable_reasoning flag shows whether the model accepts off.

Two caveats:

• Reasoning is billed as output tokens and eats into the max_tokens budget — long answers need headroom, or they get cut off.
• Custom-model settings in Cursor don’t expose a depth parameter — the model runs at its default. Pick the model for the depth you need in advance: use the card in the catalog as a reference.

Custom key limitations

Per Cursor’s docs, your own key is about chat models, and three things are worth knowing upfront:

• Tab autocomplete doesn’t go through Mixen — it always runs on Cursor’s built-in models, regardless of key settings (details in “Troubleshooting”).
• Requests pass through Cursor’s servers: final prompt assembly happens on Cursor’s side. The key is transmitted encrypted and isn’t stored, but traffic technically doesn’t go from the editor straight to Mixen.
• Cursor’s Zero Data Retention doesn’t apply to requests made with your own key — data handling follows the policy of the provider Cursor talks to, i.e. Mixen.

Tips for agentic work

• Your key applies to Cursor’s chat models: plain chat and the agent mode (composer) pick the model from the same list in Cursor Settings → Models.
• Put a tool-calling model with a large context on agent duty — Mixen supports tools on all chat endpoints, so the only limit is what the model itself can do.
• Split a long agentic task between two models: a cheap one for reconnaissance (questions, code search), a flagship for the edits themselves. Switching the model in chat is one click, and the context stays.

Frugal session checklist

• Questions, review, and search — on GLM 5.3 Flash; edits — on a flagship. Switching mid-session is one click.
• Don’t let the session cool down: the cache window is 5 minutes, and every turn extends it.
• A finished task means a new chat: a bloated history gets paid for on every turn (even at cache prices).
• A reasoning model only where depth is needed: thinking is billed as output.
• Re-check model IDs against the catalog after updating the list.

Useful documentation

• API Keys in Cursor — what exactly works with your own key.
• Agent in Cursor — how the agent mode works.
• Mixen catalog — model IDs, prices, and cache columns.

Recommended models

Model	ID
GPT-5.6 Sol	openai/gpt-5.6-sol
Claude Opus 5	anthropic/claude-opus-5
GLM 5.3	z-ai/glm-5.3
DeepSeek V4 Pro	deepseek/deepseek-v4-pro
Kimi K3	moonshotai/kimi-k3

The ID is entered manually and must match the catalog character for character, including the provider prefix (openai/…, anthropic/…). Full list — in the catalog.

Troubleshooting

• 401 / Invalid API Key — the key was copied incompletely or isn’t an API key; issue a new one in the dashboard, it starts with mxn-.
• Model doesn’t respond or missing from the list — check the ID in the catalog: it must match character for character with the provider prefix, and the model’s checkbox must be enabled.
• Tab autocomplete doesn’t go through Mixen — by design: per Cursor’s docs, a custom key and overridden base URL apply to chat only, while Tab keeps using Cursor’s built-in models.
• The first turn after a break is noticeably pricier — that’s the cache: a pause longer than 5 minutes drops it, and the turn pays the full input price. The price drops again afterwards.
• The bill grows faster than expected — check whether a reasoning model runs where a cheap one would do: thinking is billed as output. For questions and review, GLM 5.3 Flash is enough.