Skip to content

What is Keln

Keln is an inference platform for open-weight LLMs: one OpenAI-compatible endpoint, one published price per model, one SLA, backed by a pool of independent, contracted GPU providers, continuously quality-verified and routed for speed.

Get an API key Quickstart →

Your first request

from openai import OpenAI

client = OpenAI(
    base_url="https://api.keln.ai/v1",
    api_key="YOUR_KELN_KEY",
)

stream = client.chat.completions.create(
    model="deepseek-ai/deepseek-v4-flash",
    messages=[{"role": "user", "content": "Say hello from Keln."}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.keln.ai/v1",
  apiKey: process.env.KELN_API_KEY,
});

const stream = await client.chat.completions.create({
  model: "deepseek-ai/deepseek-v4-flash",
  messages: [{ role: "user", content: "Say hello from Keln." }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

curl https://api.keln.ai/v1/chat/completions \
  -H "Authorization: Bearer $KELN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Say hello from Keln."}],
    "stream": true
  }'

Coming from OpenAI or OpenRouter? The migration guide covers the base-URL change and the behavioral differences worth knowing.

Building agents or want to connect your coding harness? Keln also serves the Responses API (Codex) and an Anthropic-compatible API (Claude Code).

What Keln does for you

Each capability below is always on, with nothing to configure:

  • Routing & failover → Keln predicts each route's time-to-first-token for your prompt size and hedges or reroutes the moment a route falls outside its own predicted window. Streams survive node failures mid-generation.

  • Quality verification → Every serving route is continuously verified two ways: statistical fingerprints against trusted references, and scored synthetic tasks against its peers. Quantization downgrades and degraded output get caught and routed around.

  • Request normalization → Standard OpenAI parameters are honored or translated per model. Parameter behavior is documented per field in the API reference.

  • Reasoning control → reasoning_effort controls thinking on every model. The reasoning trace is returned in the reasoning_content field, on streaming and non-streaming responses.

  • Structured outputs & tools → JSON mode, JSON schema, and tool calling are supported. Structured responses are validated, and requests route to capacity verified for the requested mode.

  • Images (vision) → Models with the Vision badge accept images in the OpenAI content-parts format. Image input to a text-only model returns a 400.

  • Caching discount → Repeated prompt prefixes are billed at the per-model cached rate. No cache_control configuration is needed.

  • Reliability & SLOs → Speed targets, and delivered latency measured on your own traffic, shown in the usage dashboard.

  • Zero data retention → Prompts and completions are not stored and not used for training.

Pricing

Prices are per million tokens and published on the rate card. Rates are fixed: they do not vary by user, load, or serving capacity. Cached input is billed at the per-model cached rate.

Where to go next