Principles

MyIP OpenRouter is a small, opinionated gateway. It is easier to use if you know which promises it makes and which ones it refuses to make. This page is that list.

What we guarantee

One base URL, no code changes

We speak the OpenAI Chat Completions protocol. Point an existing OpenAI client at https://openrouter.myip.co.kr/api/v1, swap the key, and your code keeps working. Response bodies keep OpenAI's field names, nesting and encodings — including the habit of encoding prices as strings.

Fields we add (provider, usage.cost, pricing.currency) are additive. SDKs ignore unknown fields, so adding them cannot break a client that was written against the original protocol.

Prices are in won, and nowhere else

Every amount we return is KRW. One credit is one won. We do not convert to USD for display, because a display currency that differs from the billing currency guarantees that someone eventually reconciles the wrong number.

Three things state this explicitly so a client cannot misread it:

• X-MyIP-Currency: KRW on every /api/v1 response
• pricing.currency: "KRW" inside each model in GET /api/v1/models
• usage.cost and X-MyIP-Cost-KRW, both in won

The model we bill is the model that answered

We run the fallback chain ourselves rather than delegating it to the upstream router, and the upstream is configured with retries and fallbacks disabled. If a hidden layer silently re-routed your request, the model you were charged for and the model that answered could diverge — and there would be no way for you to detect it.

So X-MyIP-Model and X-MyIP-Provider are answers, not guesses, and GET /api/v1/generation lists every attempt in provider_responses.

Cost is auditable per request

usage.cost, X-MyIP-Cost-KRW, and total_cost from GET /api/v1/generation are the same number: the amount actually deducted from your credits. It is computed once, at settle time, and stored — not recomputed at read time from prices that may have changed since.

The formula is public. See How costs are calculated.

Failed calls are free

If no candidate produced a response, the request is recorded with a cost of zero and the credit ledger is not touched. A cancelled stream is different: tokens the upstream already produced are billed, because otherwise disconnecting would be a way to use the service for free.

Local first

If a model runs on our own GPU, that slot is tried before any external provider — it is cheaper and the prompt never leaves our network. This is the default, not an opt-in. Local-first routing explains exactly when local loses.

Errors are specific

One error shape, one status-to-error_type table, no invented codes:

{"error":{"code":404,"message":"…","metadata":{"error_type":"no_endpoints_found"}}}

error.code always equals the HTTP status. An unimplemented path returns 404 not_supported with the path in metadata, rather than a bare 404 that leaves you guessing whether you typed the URL wrong. The full table is in Errors and debugging.

What we deliberately do not do

We are not a superset of every AI API

We implement chat completions, legacy completions, the model catalog, generation lookup, key management, credits, providers, and a few dataset endpoints. That is the whole surface; it is listed in API overview.

We do not implement embeddings, image/video/audio generation, speech, the Responses API, the Batch API, presets, workspaces, guardrails, BYOK, OAuth PKCE, SCIM, observability broadcast, containers, or classifiers. Those paths return 404 not_supported. See Unsupported endpoints.

No magic routers

There is no auto-router that picks a model for you, no cost/quality frontier selection, no model fusion. Routing is exactly what you asked for: your models[] chain, expanded by provider priority, filtered by your provider{} preferences. Nothing else reorders it.

No model variants

There are no :free, :nitro, :floor or similar suffixes. A model id is vendor/name and it means one thing. If you want the cheapest candidate, ask for it explicitly with provider: { "sort": "price" }.

No silent parameter emulation

Parameters we do not consume are forwarded to the upstream unchanged. If the upstream does not understand one, it is dropped there — we do not emulate it in the gateway and then bill you for the emulation. The practical consequence is that you should check supported_parameters on the model, or set provider: { "require_parameters": true } to restrict the chain to candidates that advertise support.

No hidden prompt rewriting

We do not compress, truncate, or reorder your messages. transforms and plugins are accepted for wire compatibility and then discarded — see Message transforms. What you send is what the model sees, minus the routing-only fields (models, provider, route, transforms, plugins).

No cookie auth on the API surface

/api/v1/* accepts Authorization: Bearer only. Mixing session cookies into an SDK-facing surface opens a CSRF hole for no benefit. The dashboard uses a separate, session-authenticated API.

Consequences you should design for

1. A cold local model can make the first request slow, or return 503 model_loading. Handle Retry-After, or give the request a fallback chain. See Local GPU models.
2. A long prompt can change which provider serves you. Local candidates whose context window is smaller than your prompt are removed from the chain before dispatch. Read X-MyIP-Provider if this matters to you.
3. Running out of credit suspends your keys. Requests return 402 insufficient_credits with metadata.balance_krw; topping up restores them automatically. An admin suspension is 403 key_suspended and topping up does not clear it — the two are different codes on purpose. See Limits and 402.