XUSS AI API

XUSS होस्टिंग प्लेटफ़ॉर्म के ऊपर एक प्रोडक्शन OpenAI-संगत API। किसी भी OpenAI SDK, एडिटर या चैट क्लाइंट को XUSS की ओर इंगित करें — कोई वेंडर लॉक-इन नहीं, एक कुंजी, XUSS बैलेंस से उपयोग के अनुसार भुगतान।

• बेस URL: https://xuss.us/v1
• प्रमाणीकरण: Authorization: Bearer xsk-… (पैनल में कुंजी बनाएं)
• पैनल: https://xuss.us/panel/api
• फ़ॉर्मैट: OpenAI Chat Completions (स्ट्रीमिंग, टूल्स, विज़न, JSON मोड)

त्वरित शुरुआत

1. API कुंजी बनाएं पैनल में: API → API कुंजियाँ → कुंजी बनाएं। इसे कॉपी करें — यह केवल एक बार दिखाई जाती है। कुंजियाँ xsk- से शुरू होती हैं।

2. API कॉल करें किसी भी भाषा से — एक टैब चुनें:

curl https://xuss.us/v1/chat/completions \
  -H "Authorization: Bearer xsk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "xuss/kitsune",
    "messages": [{"role": "user", "content": "नमस्ते!"}]
  }'

from openai import OpenAI

client = OpenAI(base_url="https://xuss.us/v1", api_key="xsk-YOUR_KEY")

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "नमस्ते!"}],
)
print(r.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://xuss.us/v1", apiKey: "xsk-YOUR_KEY" });

const r = await client.chat.completions.create({
  model: "xuss/kitsune",
  messages: [{ role: "user", content: "नमस्ते!" }],
});
console.log(r.choices[0].message.content);

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
)

func main() {
	body := []byte(`{"model":"xuss/kitsune","messages":[{"role":"user","content":"नमस्ते!"}]}`)
	req, _ := http.NewRequest("POST", "https://xuss.us/v1/chat/completions", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer xsk-YOUR_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	fmt.Println(string(out))
}

<?php
$ch = curl_init('https://xuss.us/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer xsk-YOUR_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'xuss/kitsune',
        'messages' => [['role' => 'user', 'content' => 'नमस्ते!']],
    ]),
]);
$res = json_decode(curl_exec($ch), true);
echo $res['choices'][0]['message']['content'], PHP_EOL;

बस इतना ही — XUSS बैलेंस से प्रति टोकन शुल्क लिया जाता है, कोई सदस्यता आवश्यक नहीं।

प्रमाणीकरण

हर अनुरोध को bearer टोकन चाहिए:

Authorization: Bearer xsk-YOUR_KEY
Content-Type: application/json

कुंजियाँ पैनल → API में बनाई और रद्द की जाती हैं। नियम:

• कुंजी xsk- के बाद एक लंबी रैंडम स्ट्रिंग जैसी होती है। प्रदर्शन के लिए केवल शुरुआती अक्षर संग्रहीत होते हैं; पूरा मान निर्माण के समय एक बार दिखाया जाता है।
• प्रति खाता अधिकतम 10 सक्रिय कुंजियाँ।
• प्रत्येक कुंजी में वैकल्पिक समाप्ति तिथि और वैकल्पिक खर्च सीमा (USD) हो सकती है। कुंजी के समाप्त होने या सीमा तक पहुँचने पर, उससे किए गए अनुरोध 401 (key_expired) या 402 (key_spend_limit_reached) के साथ विफल होते हैं, जब तक आप नई कुंजी न बनाएँ या सीमा न बढ़ाएँ।
• पैनल में कुंजी बनाना Cloudflare Turnstile (कैप्चा) से सुरक्षित है, इसलिए स्क्रिप्ट से कुंजियाँ नहीं बनाई जा सकतीं।
• कुंजी रद्द करना तुरंत प्रभावी होता है।
• कुंजियाँ आपके खाते की AI API तक पहुँच विरासत में लेती हैं। यदि आपके खाते के लिए API सक्षम नहीं है, तो अनुरोध 403 लौटाते हैं।

कुंजी को कभी क्लाइंट-साइड कोड या सार्वजनिक रिपॉज़िटरी में उजागर न करें। कुंजी लीक हो जाए तो उसे पैनल में रद्द करें और नई बनाएं।

एंडपॉइंट्स

सभी Authorization: Bearer xsk-… स्वीकार करते हैं।

मॉडल

GET /v1/models API में मौजूद मॉडलों को कॉन्टेक्स्ट विंडो, विज़न समर्थन और प्रति-टोकन मूल्य के साथ लौटाता है:

{
  "object": "list",
  "data": [
    {
      "id": "xuss/kitsune",
      "object": "model",
      "owned_by": "xuss",
      "context_window": 1048576,
      "vision": true,
      "pricing": {
        "prompt": 0.00000029,
        "completion": 0.00000129,
        "input_cache_read": 0.0000000099
      }
    }
  ]
}

मूल्य USD प्रति टोकन में हैं। पैनल में दिखाई गई प्रति-मिलियन दर पाने के लिए 1,000,000 से गुणा करें।

मॉडल रूटिंग। एक ही मॉडल आइडी के पीछे, XUSS सेवा को तेज़ और उपलब्ध रखने के लिए अनुरोधों को अलग-अलग क्षमताओं पर भेज सकता है। यह आपके लिए अदृश्य है: अनुरोध किया गया model हमेशा वही होता है जो प्रतिक्रिया में लौटता है, और मॉडल अपना नाम जानता है। /v1/models में दिखाए मूल्य वही हैं जो आपसे लिए जाते हैं।

चैट कम्पलीशन्स

POST /v1/chat/completions

अनुरोध बॉडी

messages OpenAI स्कीमा का पालन करता है (system, user, assistant, tool रोल; मल्टीमॉडल कंटेंट ऐरे)।

प्रतिक्रिया

{
  "id": "chatcmpl-3f9c1a...",
  "object": "chat.completion",
  "created": 1791000000,
  "model": "xuss/kitsune",
  "choices": [
    {
      "index": 0,
      "message": {"role": "assistant", "content": "नमस्ते! कैसे मदद करूँ?"},
      "finish_reason": "stop",
      "logprobs": null
    }
  ],
  "usage": {"prompt_tokens": 12, "completion_tokens": 7, "total_tokens": 19},
  "system_fingerprint": "xuss"
}

finish_reason stop, length या tool_calls होता है।

Messages

मानक OpenAI संदेश ऐरे। न्यूनतम एकल-टर्न अनुरोध:

{"model": "xuss/kitsune", "messages": [{"role": "user", "content": "नमस्ते"}]}

बहु-टर्न बातचीत — हर बार पूरा इतिहास भेजें:

{
  "model": "xuss/kitsune",
  "messages": [
    {"role": "system", "content": "तुम एक संक्षिप्त सहायक हो।"},
    {"role": "user", "content": "XUSS क्या है?"},
    {"role": "assistant", "content": "XUSS एक होस्टिंग प्लेटफ़ॉर्म है।"},
    {"role": "user", "content": "क्या इसमें AI API है?"}
  ]
}

स्ट्रीमिंग

Server-Sent Events पाने के लिए "stream": true सेट करें। प्रत्येक पंक्ति data: {json} है; स्ट्रीम data: [DONE] के साथ समाप्त होती है।

चंक्स ऐसे दिखते हैं:

data: {"id":"chatcmpl-…","object":"chat.completion.chunk","created":…,"model":"xuss/kitsune","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"system_fingerprint":"xuss"}

data: {"id":"chatcmpl-…","choices":[{"index":0,"delta":{"content":"शांत "},"finish_reason":null}]}

data: {"id":"chatcmpl-…","choices":[{"index":0,"delta":{"content":"सर्वर "},"finish_reason":null}]}

data: {"id":"chatcmpl-…","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":9,"total_tokens":23}}

data: [DONE]

किसी भी भाषा में स्ट्रीम पढ़ें:

curl -N https://xuss.us/v1/chat/completions \
  -H "Authorization: Bearer xsk-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"xuss/kitsune","stream":true,
       "messages":[{"role":"user","content":"सर्वरों पर एक हाइकु लिखें"}]}'

stream = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "सर्वरों पर एक हाइकु लिखें"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content if chunk.choices else None
    if delta:
        print(delta, end="", flush=True)

const stream = await client.chat.completions.create({
  model: "xuss/kitsune",
  messages: [{ role: "user", content: "सर्वरों पर एक हाइकु लिखें" }],
  stream: true,
});
for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content || "");
}

package main

import (
	"bufio"
	"bytes"
	"fmt"
	"net/http"
	"strings"
)

func main() {
	body := []byte(`{"model":"xuss/kitsune","stream":true,"messages":[{"role":"user","content":"सर्वरों पर एक हाइकु लिखें"}]}`)
	req, _ := http.NewRequest("POST", "https://xuss.us/v1/chat/completions", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer xsk-YOUR_KEY")
	req.Header.Set("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()

	sc := bufio.NewScanner(res.Body)
	for sc.Scan() {
		line := sc.Text()
		if !strings.HasPrefix(line, "data: ") || strings.HasSuffix(line, "[DONE]") {
			continue
		}
		fmt.Println(line[6:]) // parse JSON, read choices[0].delta.content
	}
}

<?php
$ch = curl_init('https://xuss.us/v1/chat/completions');
curl_setopt_array($ch, [
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer xsk-YOUR_KEY',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'xuss/kitsune',
        'stream' => true,
        'messages' => [['role' => 'user', 'content' => 'सर्वरों पर एक हाइकु लिखें']],
    ]),
    CURLOPT_WRITEFUNCTION => function ($ch, $chunk) {
        foreach (explode("\n", $chunk) as $line) {
            if (str_starts_with($line, 'data: ') && !str_contains($line, '[DONE]')) {
                $j = json_decode(substr($line, 6), true);
                echo $j['choices'][0]['delta']['content'] ?? '';
            }
        }
        return strlen($chunk);
    },
]);
curl_exec($ch);

जब मॉडल तर्क (reasoning) का समर्थन करता है, तो स्ट्रीम चंक्स में delta में अतिरिक्त reasoning_content फ़ील्ड हो सकता है। मानक SDK इसे अनदेखा करते हैं और इसे आउटपुट के रूप में संभालना आवश्यक नहीं है।

सिस्टम प्रॉम्प्ट और पहचान

आपके system संदेशों का सम्मान किया जाता है। मॉडल अपना प्रदर्शित नाम भी जानता है और पूछे जाने पर कि यह कौन-सा मॉडल है, केवल उसी नाम से उत्तर देता है — यह कभी कोई अपस्ट्रीम प्रोवाइडर या रूट प्रकट नहीं करता।

{
  "model": "xuss/kitsune",
  "messages": [
    {"role": "system", "content": "तुम एक संक्षिप्त DevOps सहायक हो। बिंदुओं में उत्तर दो।"},
    {"role": "user", "content": "systemd सेवा को पुनः आरंभ कैसे करूँ?"}
  ]
}

विज़न (छवियाँ)

छवियों को OpenAI image_url कंटेंट भागों के रूप में भेजें (data URL या सार्वजनिक http(s) URL)। /v1/models में "vision": true वाले मॉडल ही छवियाँ स्वीकार करते हैं; बिना विज़न वाले मॉडल को छवि भेजने पर एक टेक्स्ट नोट लौटता है और मॉडल केवल टेक्स्ट पर उत्तर देता है।

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "इस छवि में क्या है?"},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,iVBORw0KGgo..."}},
        ],
    }],
)

सीमाएँ: अधिकतम 8 छवि भाग, प्रत्येक अधिकतम ~6 MB; छवियाँ टेक्स्ट बजट में नहीं गिनी जातीं।

फ़ंक्शन कॉलिंग

OpenAI-शैली tools भेजें। जब मॉडल कोई फ़ंक्शन कॉल करने का निर्णय लेता है, तो finish_reason tool_calls होता है और संदेश में tool_calls होता है।

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

r = client.chat.completions.create(
    model="xuss/kitsune",
    messages=[{"role": "user", "content": "ताशकंद में मौसम?"}],
    tools=tools,
)

call = r.choices[0].message.tool_calls[0]
print(call.function.name, call.function.arguments)

फिर परिणाम को tool संदेश के रूप में वापस भेजें:

messages = [
    {"role": "user", "content": "ताशकंद में मौसम?"},
    r.choices[0].message,
    {"role": "tool", "tool_call_id": call.id, "content": '{"temp_c": 24, "sky": "clear"}'},
]
final = client.chat.completions.create(model="xuss/kitsune", messages=messages)

सर्वर टूल्स (वेब + कौशल)

प्रति अनुरोध ऑप्ट-इन। "xuss_tools": true (सभी) या जो चाहिए उनका ऐरे जोड़ें। तब XUSS इन टूल्स को सर्वर पर आपके लिए चलाता है — मॉडल उन्हें कॉल करता है, सर्वर निष्पादित करके आगे बढ़ता है, और आपको उसी प्रतिक्रिया में अंतिम उत्तर मिलता है। क्लाइंट-साइड लूप की आवश्यकता नहीं।

r = client.chat.completions.create(
    model="xuss/kitsune",
    xuss_tools=True,                       # या ["web_search", "read_skill"]
    messages=[{"role": "user",
               "content": "वेब पर Python का नवीनतम रिलीज़ खोजें और सारांश दें।"}],
)
print(r.choices[0].message.content)

{
  "model": "xuss/kitsune",
  "xuss_tools": true,
  "messages": [{"role": "user", "content": "https://example.com खोलें और पृष्ठ शीर्षक बताएँ।"}]
}

ये केवल-पढ़ने योग्य हैं: फ़ाइलों, डेटाबेस, होस्टिंग या आपके खाते तक कोई पहुँच नहीं। चीज़ें बदलने वाले टूल्स (फ़ाइल प्रबंधन, DNS, डेटाबेस, आदि) आपके ही हाथों में रहते हैं और जान-बूझकर उपलब्ध नहीं कराए गए हैं।

• नॉन-स्ट्रीमिंग: सर्वर टूल लूप (अधिकतम 6 राउंड) चलाता है और अंतिम उत्तर लौटाता है; usage (और बिलिंग) हर राउंड को कवर करता है।
• स्ट्रीमिंग ("stream": true): टूल्स सर्वर पर चलते हैं, फिर अंतिम उत्तर सामान्य रूप से SSE के रूप में स्ट्रीम होता है।
• यदि आप अपने tools भी भेजते हैं, तो मॉडल दोनों को कॉल कर सकता है — XUSS अपने चलाता है और आपकी टूल कॉल को चलाने के लिए tool_calls के माध्यम से आपको लौटा देता है (मानक व्यवहार)।
• रनटाइम पर उन्हें खोजें: GET /v1/tools (परिभाषाएँ) और GET /v1/skills (नीचे सूची)।

उपलब्ध कौशल

read_skill इनमें से किसी का भी पूरा संदर्भ दस्तावेज़ कॉन्टेक्स्ट में लोड करता है — मॉडल को बस बताएँ कि कौन-सा (जैसे "product-design कौशल इस्तेमाल करें")।

संरचित आउटपुट (JSON मोड)

response_format को {"type":"json_object"} पर सेट करें और मॉडल से JSON निकालने को कहें। उत्तर का content एक JSON स्ट्रिंग होता है।

r = client.chat.completions.create(
    model="xuss/kitsune",
    response_format={"type": "json_object"},
    messages=[{"role": "user",
               "content": "a और b कुंजियों वाला JSON लौटाएँ, a=1, b=2"}],
)
import json
print(json.loads(r.choices[0].message.content))  # {'a': 1, 'b': 2}

हमेशा सुरक्षात्मक रूप से पार्स करें और प्रॉम्प्ट में वांछित सटीक आकार बताएँ।

बिलिंग और टोकन गणना

• शुल्क आपके XUSS बैलेंस से काटे जाते हैं (पैनल में टॉप-अप करें)।
• प्रति टोकन मॉडल की API कीमत पर बिल होता है: इनपुट (कैश मिस), कैश हिट (जहाँ समर्थित हो वहाँ सस्ता), और आउटपुट।
• प्रत्येक अनुरोध का usage prompt_tokens, completion_tokens और total_tokens बताता है।
• पैनल का API पृष्ठ खर्च, अनुरोध, टोकन, प्रति-मॉडल व प्रति-कुंजी विवरण और हालिया कॉल लॉग दिखाता है, चयनित श्रेणियों के साथ (आज, 7/30/90 दिन, इस/पिछले महीने, सभी समय)।
• बैलेंस अपर्याप्त होने पर अनुरोध 402 के साथ अस्वीकृत होते हैं।

लागत सूत्र (प्रति अनुरोध):

cost = cache_miss_tokens × price_in
     + cache_hit_tokens  × price_cache
     + completion_tokens × price_out

(कीमतें प्रति टोकन; प्रति-मिलियन के लिए 1,000,000 से विभाजित करें।)

रेट लिमिट और कोटा

सीमा से अधिक होने पर 429 लौटता है, Retry-After अर्थ के साथ (पीछे हटें और पुनः प्रयास करें)। अनुरोध बॉडी की सीमा 25 MB है।

त्रुटियाँ

त्रुटियाँ OpenAI त्रुटि प्रारूप का पालन करती हैं:

{
  "error": {
    "message": "Model 'xuss/foo' not found",
    "type": "invalid_request_error",
    "param": "model",
    "code": "model_not_found"
  }
}

param तब सेट होता है जब त्रुटि किसी विशिष्ट अनुरोध फ़ील्ड से संबंधित हो। मानक SDK सीधे error.message (और error.code) पढ़ते हैं।

यदि स्ट्रीम पहले ही शुरू हो चुकी हो, तो अस्थायी विफलताएँ "The model is temporarily unavailable…" से शुरू होने वाले सामान्य असिस्टेंट संदेश के रूप में भी दी जाती हैं।

OpenAI-संगत टूल्स के साथ उपयोग

कोई भी क्लाइंट जो कस्टम OpenAI बेस URL का समर्थन करता है, काम करता है। सेट करें:

• बेस URL: https://xuss.us/v1
• API कुंजी: आपकी xsk-… कुंजी
• मॉडल: जैसे xuss/kitsune

उदाहरण:

# open-webui / LibreChat / Cursor / Cline / Continue / LangChain:
#   set the OpenAI base URL to https://xuss.us/v1 and paste your key

पर्यावरण-चर शैली (कई टूल इनका पालन करते हैं):

export OPENAI_BASE_URL="https://xuss.us/v1"
export OPENAI_API_KEY="xsk-YOUR_KEY"

LangChain (Python):

from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="xuss/kitsune", base_url="https://xuss.us/v1",
                 api_key="xsk-YOUR_KEY")
print(llm.invoke("नमस्ते").content)

उन्नत पैरामीटर

जब समर्थित हों तो स्वीकार किए जाते हैं और मॉडल को पास किए जाते हैं: top_p, stop, seed, presence_penalty, frequency_penalty, logit_bias, user, n, parallel_tool_calls, tool_choice.

सामान्य प्रश्न

क्या मुझे अलग सदस्यता चाहिए? नहीं। आप XUSS बैलेंस से प्रति टोकन भुगतान करते हैं।

कौन-से मॉडल आइडी उपयोग करूँ? बिल्कुल वही जो GET /v1/models में हैं (जैसे xuss/kitsune)। "Kitsune" जैसे प्रदर्शित नाम पैनल में दिखाए जाते हैं।

क्या मैं छवियाँ भेज सकता हूँ? हाँ, "vision": true वाले मॉडलों को।

क्या मेरा डेटा प्रशिक्षण के लिए उपयोग होता है? नहीं — अनुरोध आपका उत्तर बनाने के लिए मॉडल को प्रॉक्सी किए जाते हैं और प्रशिक्षण के लिए उपयोग नहीं होते।

यदि कोई प्रोवाइडर धीमा या बंद हो तो क्या होगा? अनुरोध पारदर्शी रूप से वैकल्पिक क्षमता पर पुनः प्रयास किया जाता है; मॉडल आइडी और मूल्य वही रहते हैं।

कुंजी कैसे बदलूँ? नई कुंजी बनाएं, अपने ऐप्स उस पर स्विच करें, फिर पुरानी को पैनल में रद्द करें।

सहायता

• पैनल: https://xuss.us/panel/api
• अपने पैनल डैशबोर्ड से टिकट और Telegram सहायता
• ईमेल: support@xuss.us