🐸 KeyFrog API

AI infrastructure for production applications.

KeyFrog is a unified API gateway that provides developers and businesses with access to 58+ AI models from 14+ providers through a single, OpenAI-compatible endpoint. No vendor lock-in. One API key for everything.

🔗

OpenAI Compatible

Drop-in replacement. Use existing OpenAI SDKs with zero changes.

🔑

One API Key

Access all 58+ models with a single key. No per-provider setup.

💰

Pay as You Go

Only pay for tokens you use. No subscriptions, no minimums.

🏢

Enterprise Ready

High availability, automatic failover, and SLA support.

Quick Start

Make your first API call in under 5 minutes.

Create API Key

Copy Base URL

Use https://api.keyfrog.top/v1 as your API endpoint.

Send Your First Request

Make a chat completion call. See the code example →

💡 Tip: Start with gpt-4o-mini or deepseek-v4-flash — they're fast and cheap, perfect for testing.

Authentication

Authenticate all requests with a Bearer token.

Include your API key in the Authorization header of every request:

Authorization: Bearer kf-your-api-key

Best practices

Never expose keys in client-side code. Use environment variables or a backend proxy.
Rotate keys periodically. Generate new keys from the Dashboard.
Use separate keys for development and production environments.

⚠️ Security: If you suspect a key is compromised, revoke it immediately from the Dashboard.

Base URL

All API requests use a single endpoint.

https://api.keyfrog.top/v1

All endpoints are fully compatible with the OpenAI API specification. You can use any OpenAI SDK or HTTP client by simply changing the base URL.

Available endpoints

Endpoint	Method	Description
/v1/chat/completions	POST	Create chat completions
/v1/models	GET	List all available models

Chat Completion

POST/v1/chat/completions

Create a model response for a conversation. Compatible with OpenAI's Chat Completions API.

Request body

Parameter	Type	Description
model REQUIRED	string	Model ID (e.g., `gpt-4o-mini`, `deepseek-v4-pro`)
messages REQUIRED	array	Array of message objects with `role` and `content`
temperature OPTIONAL	number	Sampling temperature (0–2). Default: 1
max_tokens OPTIONAL	integer	Maximum tokens in the response
stream OPTIONAL	boolean	Enable SSE streaming. Default: `false`

Message roles

system — Sets the assistant's behavior and instructions
user — The user's input message
assistant — Previous assistant responses (for multi-turn conversations)

Streaming

POST/v1/chat/completions

Get real-time token-by-token responses via Server-Sent Events (SSE).

Set "stream": true in your request. The server sends data: chunks. The stream ends with data: [DONE].

How it works

Set "stream": true in the request body
The server responds with text/event-stream content type
Each chunk contains a delta field with incremental content
The stream ends with data: [DONE]

💡 Tip: Streaming dramatically improves perceived latency. Recommended for all interactive applications.

Models

GET/v1/models

List all available models. Currently serving 58+ models from 14+ providers.

Models are loaded dynamically from our backend. Use the id field in your chat completion requests.

Available Models

Loading models from backend...

Pricing

Pay-as-you-go. No subscriptions. No hidden fees.

All prices are in USD per 1 million tokens. Pricing data is synced from our backend in real time.

💰 Formula: Cost = (Input tokens + Output tokens) × Unit price ÷ 1,000,000

Price List

ModelVendorInputOutput

Loading pricing data...

* All prices in USD per 1M tokens. See full pricing page for details.

Error Codes

KeyFrog uses standard HTTP status codes with OpenAI-compatible error responses.

Code	Status	Description
401	Unauthorized	Invalid or missing API key
403	Forbidden	API key doesn't have permission, or key has been revoked
404	Not Found	The requested model or endpoint does not exist
429	Rate Limited	Too many requests. Implement exponential backoff
500	Server Error	Internal server error. Retry with backoff

Error response format

All errors return a JSON body with an error object containing message, type, and code.

Rate Limits

Rate limits protect the platform and ensure fair usage for all users.

If you exceed the rate limit, you'll receive a 429 Too Many Requests response.

Best practices

Implement exponential backoff. Wait 1s, 2s, 4s, 8s between retries.
Batch requests when possible to reduce call volume.
Use streaming to reduce the number of API calls needed.
Cache responses for identical prompts when appropriate.

Need higher limits? Contact us at support@keyfrog.top for enterprise rate limits.

SDKs

Use KeyFrog with your favorite language. All OpenAI SDKs work out of the box.

Python

Install: pip install openai

The official OpenAI Python SDK works with KeyFrog by changing the base_url.

Node.js

Install: npm install openai

The official OpenAI Node.js SDK works identically.

Go

Use any HTTP client. The API is standard REST with JSON.

cURL

Works with any HTTP client. No SDK required.

FAQ

How do I get an API Key?

How does billing work?

Pay-as-you-go. You're charged per token based on the model's unit price. No subscriptions or minimums. Check your usage in the Dashboard.

How do I switch models?

Simply change the model field in your request. All models share the same endpoint and API key. See the Models section for available models.

Is KeyFrog OpenAI compatible?

Yes, 100%. Just change the base_url to https://api.keyfrog.top/v1 and use your KeyFrog API key. All OpenAI SDK methods work — chat completions, models list, streaming, etc.

What models are available?

58+ models from 14+ providers including DeepSeek, Qwen, GLM, Kimi, MiniMax, Llama, Mistral, and more. See the Models section or Models page for the full list.

Are there free models?

Yes. Models like glm-4-flash are completely free. Great for prototyping and low-cost applications.

Do you support streaming?

Yes. Set "stream": true in your request. All models support SSE streaming. See the Streaming section.

How do I get support?

Email us at support@keyfrog.top. We typically respond within a few hours.

API Overview
// Base URL
https://api.keyfrog.top/v1

// 58+ models, 14+ providers
// OpenAI-compatible API
// One API key for everything

// Providers include:
• DeepSeek    • Qwen
• GLM         • Kimi
• MiniMax     • Llama
• Mistral     • xAI
• Cohere      • NVIDIA
• Amazon      • Microsoft
First Request

curl https://api.keyfrog.top/v1/chat/completions \
  -H "Authorization: Bearer $KEYFROG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "user", "content": "Hello!"}
    ]
  }'
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.keyfrog.top/v1"
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user",
               "content": "Hello!"}]
)
print(response.choices[0].message.content)
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "your-api-key",
  baseURL: "https://api.keyfrog.top/v1",
});

const res = await client.chat
  .completions.create({
    model: "gpt-4o-mini",
    messages: [{role:"user", content:"Hello!"}],
  });

console.log(res.choices[0].message.content);
Authentication

# Include your API key in the header
curl https://api.keyfrog.top/v1/models \
  -H "Authorization: Bearer $KEYFROG_API_KEY"
import os
from openai import OpenAI

# export KEYFROG_API_KEY="kf-..."
client = OpenAI(
    api_key=os.environ["KEYFROG_API_KEY"],
    base_url="https://api.keyfrog.top/v1"
)
import OpenAI from "openai";

// KEYFROG_API_KEY=kf-...
const client = new OpenAI({
  apiKey: process.env.KEYFROG_API_KEY,
  baseURL: "https://api.keyfrog.top/v1",
});
Configuration
// OpenAI Python SDK
client = OpenAI(
    base_url="https://api.keyfrog.top/v1"
)

// OpenAI Node.js SDK
const client = new OpenAI({
  baseURL: "https://api.keyfrog.top/v1"
})

// Raw HTTP
POST https://api.keyfrog.top/v1/chat/completions
GET  https://api.keyfrog.top/v1/models
Request

curl https://api.keyfrog.top/v1/chat/completions \
  -H "Authorization: Bearer $KEYFROG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role":"system","content":"You are helpful."},
      {"role":"user","content":"Capital of France?"}
    ],
    "temperature": 0.7
  }'
r = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role":"system", "content":"You are helpful."},
        {"role":"user", "content":"Capital of France?"},
    ], temperature=0.7)
print(r.choices[0].message.content)
const r = await client.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [
    {role:"system", content:"You are helpful."},
    {role:"user", content:"Capital of France?"},
  ], temperature: 0.7,
});
console.log(r.choices[0].message.content);
package main
import ("bytes";"encoding/json";"net/http")
func main() {
  body, _ := json.Marshal(map[string]any{
    "model": "gpt-4o-mini",
    "messages": []map[string]string{
      {"role":"user", "content":"Hello!"},
    },
  })
  req, _ := http.NewRequest("POST",
    "https://api.keyfrog.top/v1/chat/completions",
    bytes.NewBuffer(body))
  req.Header.Set("Authorization",
    "Bearer "+os.Getenv("KEYFROG_API_KEY"))
  resp, _ := http.DefaultClient.Do(req)
  defer resp.Body.Close()
}
Response
{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "The capital of France is Paris."
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 28,
    "completion_tokens": 8,
    "total_tokens": 36
  }
}
Streaming

curl https://api.keyfrog.top/v1/chat/completions \
  -H "Authorization: Bearer $KEYFROG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o-mini",
    "stream": true,
    "messages": [
      {"role":"user","content":"Haiku about frogs"}
    ]
  }'

# data: {"choices":[{"delta":{"content":"Green"}}]}
# data: {"choices":[{"delta":{"content":" frog"}}]}
# data: [DONE]
stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"user",
               "content":"Haiku about frogs"}],
    stream=True)

for chunk in stream:
    d = chunk.choices[0].delta
    if d.content:
        print(d.content, end="", flush=True)
const stream = await client.chat
  .completions.create({
    model: "gpt-4o-mini",
    messages: [{role:"user",
                content:"Haiku about frogs"}],
    stream: true,
  });

for await (const chunk of stream) {
  process.stdout.write(
    chunk.choices[0]?.delta?.content || "");
}
List Models

curl https://api.keyfrog.top/v1/models \
  -H "Authorization: Bearer $KEYFROG_API_KEY"
models = client.models.list()
for m in models.data:
    print(m.id, m.owned_by)
const models = await client.models.list();
for (const m of models.data)
  console.log(m.id, m.owned_by);
Response
{
  "object": "list",
  "data": [
    {"id":"gpt-4o-mini",
     "object":"model",
     "provider":"OpenAI",
     "categories":["fast"]},
    {"id":"deepseek-v4-pro",
     "object":"model",
     "provider":"DeepSeek",
     "categories":["chinese"]}
    // ... 58+ models
  ]
}
Cost Calculator
// Estimate cost for a request
function estimateCost(model, inTok, outTok) {
  const prices = {
    "gpt-4o-mini":       {in:0.15, out:0.60},
    "deepseek-v4-flash": {in:0.126, out:0.252},
    "qwen-turbo":        {in:0.05, out:0.16},
    "glm-4-flash":       {in:0, out:0},
  };
  const p = prices[model];
  return (inTok*p.in + outTok*p.out) / 1e6;
}

// 1M input + 100K output → gpt-4o-mini
estimateCost("gpt-4o-mini", 1e6, 1e5);
// → $0.21
Error Response
{
  "error": {
    "message": "Invalid API key provided.",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}
Error Handling

from openai import APIError, RateLimitError

try:
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role":"user","content":"Hi"}])
except RateLimitError:
    print("Rate limited. Retry with backoff.")
except APIError as e:
    print(f"Error {e.status_code}: {e.message}")
try {
  const r = await client.chat.completions
    .create({model:"gpt-4o-mini",
      messages:[{role:"user",content:"Hi"}]});
} catch (err) {
  if (err.status === 429)
    console.log("Rate limited");
  else
    console.error(`Error ${err.status}`,
                  err.message);
}
Exponential Backoff

import time

def call_with_retry(func, retries=5):
    for i in range(retries):
        try: return func()
        except RateLimitError:
            time.sleep(2 ** i)  # 1,2,4,8,16s
    raise Exception("Max retries")
async function callWithRetry(fn, n=5) {
  for (let i=0; i<n; i++) {
    try { return await fn(); }
    catch (e) {
      if (e.status===429)
        await new Promise(r=>
          setTimeout(r, 2**i*1000));
      else throw e;
    }
  }
}
Python
# pip install openai
from openai import OpenAI

client = OpenAI(
    api_key="kf-your-key",
    base_url="https://api.keyfrog.top/v1"
)
r = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role":"user","content":"Hello!"}])
Node.js
// npm install openai
import OpenAI from "openai";
const c = new OpenAI({
  apiKey:"kf-your-key",
  baseURL:"https://api.keyfrog.top/v1"});
const r = await c.chat.completions.create({
  model:"gpt-4o-mini",
  messages:[{role:"user",content:"Hello!"}]});
Go
package main
import ("bytes";"encoding/json"
        "fmt";"net/http";"os")
func main() {
  body,_:=json.Marshal(map[string]any{
    "model":"gpt-4o-mini",
    "messages":[]map[string]string{
      {"role":"user","content":"Hello!"}}})
  req,_:=http.NewRequest("POST",
    "https://api.keyfrog.top/v1/chat/completions",
    bytes.NewBuffer(body))
  req.Header.Set("Authorization",
    "Bearer "+os.Getenv("KEYFROG_API_KEY"))
  resp,_:=http.DefaultClient.Do(req)
  defer resp.Body.Close()
  fmt.Println(resp.Status)
}
cURL
curl https://api.keyfrog.top/v1/chat/completions \
  -H "Authorization: Bearer $KEYFROG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini",
    "messages":[{"role":"user",
                 "content":"Hello!"}]}'
Resources
// Quick Links
Dashboard:  https://keyfrog.top/dashboard
Models:     https://keyfrog.top/models
Pricing:    https://keyfrog.top/pricing
Support:    support@keyfrog.top

// API
Base URL:   https://api.keyfrog.top/v1
Models:     GET  /v1/models
Chat:       POST /v1/chat/completions

// Quick test
curl https://api.keyfrog.top/v1/models \
  -H "Authorization: Bearer YOUR_KEY"