Bring Your Own Key is how Mesrai uses LLMs by default on every plan — Free, Pro, and Enterprise. You connect your own provider account, choose any compatible model, and the token bill lands on your provider’s dashboard, not ours. Mesrai never adds a margin to tokens and never stores your key in plain text.

Getting started

The BYOK settings page gives you two paths: pick a recommended model from the curated catalog (fastest, covers most cases), or configure any provider manually (used for custom endpoints or models we haven’t benchmarked).

1. 1

   Open BYOK Settings

   Go to app.mesrai.com/organization/byok.

2. 2

   Pick a recommended model

   The Main model section shows a grid of curated models we’ve benchmarked for code review. Click any card to start connecting it.

3. 3

   Paste your API key and test

   Each card expands inline with a single input — just the API key. Click Test to probe the provider, or Test & save to run the test and persist the config on success.

4. 4

   Add a Fallback (recommended)

   Once the Main model is configured, a Fallback model section appears. If your main provider hits rate limits or goes down, Mesrai falls back automatically.

Recommended Models

These six models are curated for code review. They all appear in the catalog on /organization/byok and come pre-tuned with sensible defaults (temperature, max output tokens, and reasoning effort set to medium).

Plan selector (GLM 5.1 and Kimi K2.6)

Z.ai and Moonshot both offer a subscription plan with a different endpoint than their pay-per-token Developer API. The curated card for each of these models shows a Plan selector so you can pick the right endpoint before pasting your key.

Configure manually

When the model you want isn’t in the curated list (custom endpoint, self-hosted LLM, or a provider we haven’t benchmarked), click Configure manually at the bottom of the catalog. This opens /organization/byok/manual?slot=main — a step-by-step wizard:

1. 1

   Pick a provider

   Choose from OpenAI, Anthropic, Google Gemini, OpenRouter, Novita, or OpenAI Compatible (for any OpenAI-format endpoint).

2. 2

   Enter the base URL (if required)

   OpenAI-compatible providers need an explicit base URL. The field only appears when you pick that provider.

3. 3

   Pick or type the model ID

   If Mesrai can list models from the provider, you get a dropdown. Otherwise (e.g. self-hosted or when platform keys aren’t configured), type the exact model ID manually.

4. 4

   Paste the API key

   The key field appears once provider and model are set.

5. 5

   Tune advanced settings (optional)

   Temperature, max tokens, reasoning effort, and max concurrent requests — all optional. Defaults are sensible for most providers.

6. 6

   Test and save

   Click Test & save to run the connection probe and persist on success.

Supported Providers

Reasoning / Extended Thinking

All six recommended models support reasoning. The BYOK form exposes a Thinking toggle (Off / Low / Medium / High / Custom) under Advanced settings, pre-filled to Medium for every recommended model.

Preset levels

When you pick Low / Medium / High, Mesrai translates the level to each provider’s native format automatically:

Custom JSON override

Picking Custom in the Thinking toggle reveals a JSON textarea. Paste the provider options directly — Mesrai auto-wraps them under the active provider’s namespace. You don’t need to know the Vercel AI SDK routing rules.

Use this when:

• You need a specific budgetTokens value for Claude (instead of the preset effort mapping)
• You want to enable/disable thinking on a per-model basis for OpenAI-compatible providers
• You want fields beyond reasoning — caching, service tier, safety settings, user tagging, etc. The override is merged into providerOptions, so any adapter field passes through
• The provider ships a new field Mesrai hasn’t wrapped yet

Examples (paste directly — no namespace needed)

{
  "thinking": { "type": "enabled", "budgetTokens": 20000 }
}

{
  "cacheControl": { "type": "ephemeral" }
}

Going manual with namespaces (power users)

If your JSON already contains a known namespace key at the top level (anthropic, google, openai, openrouter, openaiCompatible), Mesrai leaves it untouched. Useful if you want to mix multiple provider namespaces or be explicit:

{
  "openrouter": {
    "reasoning": { "effort": "high" },
    "provider": { "order": ["moonshot"], "allow_fallbacks": false }
  }
}

Under the hood, these are the namespace mappings Mesrai uses:

Gotchas

• Valid JSON only. Missing commas or trailing commas break the parse and Mesrai ignores the override.
• Precedence: the JSON override fully replaces the effort-preset’s namespace block — if you override anthropic.thinking but forget anthropic.outputConfig, that field won’t be sent. OpenRouter routing (Pin providers / Allow fallbacks) is the one exception: it deep-merges with your override under openrouter.
• Unknown provider = no wrap. If your BYOK provider isn’t in the namespace table above, Mesrai passes the JSON through as-is. Rare — only applies if you configure a provider Mesrai doesn’t recognize.

Pinning OpenRouter providers

OpenRouter is a router — when you request a model (e.g. moonshotai/kimi-k2.5), it forwards the call to one of several upstream providers (Moonshot direct, Together, Groq, Fireworks, Novita…). Each call can land on a different backend. That’s convenient, but it introduces silent variance:

• Quality drift — upstreams run different precisions (FP8, INT4, full) and give subtly different outputs for identical prompts
• Tool-calling inconsistency — some backends don’t support function calling the same way, leading to malformed tool use
• Reasoning format variance — one upstream honors reasoning_effort, another only thinking.enabled, another ignores both
• Latency swings — p50 can jump from 800ms to 4s between calls as routing changes
• Rate-limit surprises — you hit quota on a backend you didn’t explicitly choose

How to pin

When your BYOK provider is OpenRouter, the Advanced settings panel shows an OpenRouter routing section with two fields:

• Pin providers (in order) — comma-separated list of upstream names (e.g. moonshot, together). OpenRouter tries them in order and uses the first available.
• Allow fallbacks — when off, requests hard-fail if none of the pinned providers are available. When on (default), OpenRouter can fall back to any other upstream that serves the model.

Under the hood, Mesrai emits this into the Vercel AI SDK call:

{
  "openrouter": {
    "provider": {
      "order": ["moonshot", "together"],
      "allow_fallbacks": false
    }
  }
}

Advanced: raw JSON override

If you need fields beyond order and allow_fallbacks (e.g. ignore, data_collection, require_parameters), switch Thinking to Custom in Advanced settings and paste the full routing payload — it’s merged into providerOptions alongside any reasoning config:

{
  "openrouter": {
    "provider": {
      "order": ["moonshot"],
      "allow_fallbacks": false,
      "ignore": ["deepinfra"],
      "data_collection": "deny"
    },
    "reasoning": { "effort": "medium" }
  }
}

Concurrency and rate limits

The maxConcurrentRequests field (under Advanced settings) caps how many inflight requests Mesrai sends to your provider in parallel. Most of the time, the default is fine — but subscription plans with strict concurrency caps need it set explicitly.

Defaults Mesrai pre-fills

When to tune it

Best Practices

Security

Fallback Strategy

• Use a different provider for Main and Fallback (e.g. Anthropic main, Google fallback). Protects against provider-specific outages.
• Subscriptions with tight concurrency limits (GLM Coding Plan Lite/Pro, Kimi Code Plan) make poor solo configurations — pair them with a pay-per-token Fallback so bursty PRs don’t starve.

Troubleshooting

Frequently Asked Questions