One key, every model, automatic failover

The simplest way to call powerful AI models from one API key

KJP.AI is a single OpenAI-compatible API platform that routes your requests across a pool of backend keys, retries automatically when one hits its limit, and streams responses back token by token.

Free plan included · No credit card required · Gmail sign-up only

Product

Built for developers who ship

Every plan gets the same reliable API platform — the only thing that changes is how many calls you get each month.

Multi-provider routing

Call kjp-alpha, kjp-alpha-mini, or any custom model an admin publishes — all through one consistent endpoint.

Automatic key failover

If one backend key hits a rate limit, your request seamlessly retries on the next healthy key — no dropped requests.

Real token streaming

Add "stream": true and get an OpenAI-shaped SSE stream, so replies feel instant in your app.

Live usage tracking

Watch your call count against your plan's monthly limit in real time from your dashboard.

Secure by design

Your secret key is scoped to your account only — generate as many as you need, and revoke any of them instantly.

Text, image & file input

Send inline base64 images or upload larger files — multimodal requests work out of the box on supported models.

Pricing

Simple, honest pricing

Start free. Upgrade when you outgrow it. Yearly billing saves roughly two months on every paid plan.

Integration

One request. Any model.

Example Request

curl -X POST "https://your-domain.com/v1/chat/completions" \
  -H "Authorization: Bearer kjp-secret-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kjp-alpha",
    "messages": [{"role":"user","content":"Explain AI in a few words"}]
  }'

Need API access?

company@kjp.pro.bd KJP AI on Facebook

Dashboard

Generate your API key, watch your usage, and start calling the KJP.AI API platform.

This Month's Usage 0 / 200 calls

My Generated API Keys

Free

Current Plan

Total Calls (All Time)

Quick Links

Step 1

Generate Your API Key

Create your personal secret token (kjp-secret-...).

Step 2

Pick a Model

See which models are available: kjp-alpha and kjp-alpha-mini.

Step 3

Get cURL & SDK Code

Copy working integration code for your chatbot or app.

Anytime

Upgrade Your Plan

Need more calls? Compare plans and request an upgrade.

My API Keys

Generate secret keys to authenticate requests from your app.

Secret API Key	Created On	Action

Available Models

Model aliases you can call from your API key. The admin manages which underlying provider model each one points to.

Multimodal AI

kjp-alpha

Routes through the primary multimodal AI key pool. Supports complex text prompts and multi-file uploads.

• Inputs: Text, Images, Files
• Automatic failover across the admin's key pool

Ultra Fast Chat

kjp-alpha-mini

Routes through the fast AI chat pool. Ideal for rapid conversational bots and quick queries.

• Inputs: Text Prompt
• Automatic failover across the admin's key pool

Billing & Plan

See your current plan and usage, or request an upgrade — an admin activates it on their end.

Current Plan: Free

0 / 200 calls this month

API Integration Code Examples

Use these code snippets to connect your app to the KJP.AI API platform.

Base Endpoint: https://your-domain.com
Send POST requests using your generated key Authorization: Bearer kjp-secret-xxxx and set model to kjp-alpha, kjp-alpha-mini, or any custom model name listed on the Available Models page.

⚡ Feels instant: add "stream": true to the request body and read the response as Server-Sent Events (see example 2 below).
⚡ Faster images: send the image inline as base64 directly in the message (see example 4) instead of a separate upload step.

1. cURL Request

curl -X POST "https://your-domain.com/v1/chat/completions" \
  -H "Authorization: Bearer kjp-secret-YOUR_GENERATED_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kjp-alpha",
    "messages": [
      {"role": "user", "content": "Explain AI in a few words"}
    ]
  }'

2. JavaScript / Node.js — Streaming (fastest, replies as they arrive)

async function sendToChatbot(promptMessage, onToken) {
  const API_URL = "https://your-domain.com/v1/chat/completions";
  const API_KEY = "kjp-secret-YOUR_GENERATED_KEY";

  const response = await fetch(API_URL, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      model: "kjp-alpha-mini",
      stream: true,
      messages: [{ role: "user", content: promptMessage }]
    })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let fullText = "";
  let buffer = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split("\n");
    buffer = lines.pop();
    for (const line of lines) {
      const trimmed = line.trim();
      if (!trimmed.startsWith("data:")) continue;
      const payload = trimmed.slice(5).trim();
      if (payload === "[DONE]") continue;
      const json = JSON.parse(payload);
      const delta = json.choices?.[0]?.delta?.content || "";
      if (delta) { fullText += delta; onToken?.(delta); }
    }
  }
  return fullText;
}

// Usage: sendToChatbot("Hello!", (chunk) => process.stdout.write(chunk));

3. Python Integration (non-streaming)

import requests

url = "https://your-domain.com/v1/chat/completions"
headers = {
    "Authorization": "Bearer kjp-secret-YOUR_GENERATED_KEY",
    "Content-Type": "application/json"
}
payload = {
    "model": "kjp-alpha",
    "messages": [{"role": "user", "content": "Hello world!"}]
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

4. Sending an Image (fast path — inline base64)

const response = await fetch(API_URL, {
  method: "POST",
  headers: { "Authorization": `Bearer ${API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "kjp-alpha",
    messages: [{
      role: "user",
      content: [
        { type: "text", text: "What is in this image?" },
        { type: "image_url", image_url: { url: "data:image/jpeg;base64,BASE64_IMAGE_DATA" } }
      ]
    }]
  })
});