ज्ञानधार / डेवलपर्स

बातचीत, प्रतिक्रियाएँ और संदेश

एक मॉडल से कुछ पूछने के तीन तरीके, तीन प्रारूपों में ग्राहक पहले से ही बोलते हैं, सभी एक ही मॉडल पर चलते हैं और एक ही तरह से बिल करते हैं।

सुविधा के लिए यह पृष्ठ मशीन-अनुवादित है। अंग्रेजी मूल संस्करण वह संस्करण है जो लागू होता है।

चैट पूरा करें

OpenAI चैट प्रारूप, और लगभग हर उपकरण का समर्थन करता है. अब तक की बातचीत भेजें और अगले संदेश वापस प्राप्त करें.

POST https://nymbot.ai/api/v1/chat/completions - एक एपीआई कुंजी की आवश्यकता है।

केवल model और messages एक नमूना लेने के पैरामीटर चुने हुए मॉडल को बिना किसी त्रुटि के फेंक दिया जाता है, इसलिए एक अनुरोध शरीर मॉडल पर काम करता है। supported_parametersक्या छोड़ने के बजाय अस्वीकार किया जाता है वह सब कुछ है जो मॉडल बिल्कुल नहीं कर सकता है: एक मॉडल के लिए चित्र जो नहीं देख सकता है, एक मॉडल के लिए उपकरण जो उन्हें कॉल नहीं कर सकता है।

जवाब एक सामान्य है। chat.completionइसके साथ ही लागत में usage.cost ($ में) और में nymbot वस्तु। model हल किया मॉडल आईडी है, इसलिए एक छोटा नाम पूर्ण के रूप में वापस आता है। यदि मॉडल उत्तर देने से पहले तर्क करता है, तो इसका तर्क है message.reasoning_content, उत्तर से अलग।

प्रतिक्रिया

{
  "id": "chatcmpl-5f1c0a9e27d84b3c",
  "object": "chat.completion",
  "created": 1790726400,
  "model": "anthropic/claude-sonnet-5",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "A Lightning invoice is a one-time payment request..."
      },
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 1240,
    "completion_tokens": 380,
    "total_tokens": 1620,
    "prompt_tokens_details": { "cached_tokens": 0 },
    "completion_tokens_details": { "reasoning_tokens": 0 },
    "cost": 0.01895
  },
  "nymbot": {
    "balance": "pro",
    "charged_credits": 0.162,
    "charged_sats": 16.2,
    "balance_credits": 412.425,
    "balance_sats": 41242.5
  }
}

finish_reason जो वापस आया है, से काम किया जाता है, क्योंकि प्रदाता इसे अलग तरह से रिपोर्ट करते हैं: tool_calls जब मॉडल ने उपकरण मांगे, length जब जवाब में हर टोकन का उपयोग किया गया था (या मॉडल ने उन्हें सभी तर्क देने के लिए खर्च किया और कोई जवाब नहीं लिखा), content_filter जब प्रदाता ने इनकार कर दिया, और stop अन्यथा। usage.completion_tokens_details.reasoning_tokens हमेशा 0 होता हैः छिपे हुए तर्क टोकन को गिना जाता है, और इसमें चार्ज किया जाता है। completion_tokens.

स्टेट कोड प्रत्येक एंडपॉइंट शेयरों में सूचीबद्ध हैं गलतियां.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [
      {"role": "system", "content": "Answer in one short paragraph."},
      {"role": "user", "content": "What is a Lightning invoice?"}
    ],
    "max_tokens": 400
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {"role": "system", "content": "Answer in one short paragraph."},
        {"role": "user", "content": "What is a Lightning invoice?"},
    ],
    max_tokens=400,
)
print(reply.choices[0].message.content)
print(reply.usage.cost)

JavaScript

import OpenAI from "openai";

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

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [
    { role: "system", content: "Answer in one short paragraph." },
    { role: "user", content: "What is a Lightning invoice?" },
  ],
  max_tokens: 400,
});
console.log(reply.choices[0].message.content);
console.log(reply.usage.cost);

स्ट्रीमिंग

के साथ "stream": true जवाब सर्वर द्वारा भेजी गई घटनाओं के रूप में आता है जबकि मॉडल इसे लिखते हैं। प्रत्येक घटना एक है chat.completion.chunk ए पर data: लाइन, और प्रवाह के साथ समाप्त होता है data: [DONE]. तर्क अंदर आता है delta.reasoning_content, जवाब में delta.content.

किसी भी चीज़ को स्ट्रीमिंग करें जो लगभग 100 सेकंड से अधिक समय ले सकती है, जैसे कि एक लंबी प्रतिक्रिया, एक बड़ी प्रतिक्रिया। max_tokens या एक तर्क मॉडल। एक अनुरोध जिसे स्ट्रीम नहीं किया जाता है, वह जवाब पूरा होने तक कुछ भी नहीं भेजता है, और आपके और निम्बॉट के बीच का नेटवर्क लगभग 100 सेकंड के बाद एक निष्क्रिय कनेक्शन को बंद कर सकता है; मॉडल अभी भी समाप्त हो जाता है और जो उसने लिखा है वह चार्ज हो जाता है, लेकिन जवाब खो जाता है। एक धारा कीप-अलाइव भेजती है, इसलिए यह मॉडल के लिखने तक खुला रहता है।

धारा

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{"content":"A Lightning invoice"},"finish_reason":null}]}

: keep-alive

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}

data: {"id":"chatcmpl-5f1c0a9e27d84b3c","object":"chat.completion.chunk","created":1790726400,"model":"anthropic/claude-sonnet-5","choices":[],"usage":{"prompt_tokens":1240,"completion_tokens":380,"total_tokens":1620,"cost":0.01895},"nymbot":{"balance":"pro","charged_credits":0.162,"charged_sats":16.2,"balance_credits":412.425,"balance_sats":41242.5}}

data: [DONE]

• लाइनों के साथ शुरू : वे हर 15 सेकंड में भेजे जाते हैं जबकि मॉडल सोच रहा है. एसएसई ग्राहक उन्हें छोड़ देते हैं.
• मांग लीजिए। "stream_options": {"include_usage": true} ऊपर अंतिम भाग प्राप्त करने के लिए, एक खाली के साथ choices, टोकन गिनती, लागत और nymbot वस्तु।
• चार्ज स्ट्रीम समाप्त होने के बाद समाप्त होता है. यदि आप कनेक्शन को जल्दी से बंद करते हैं, तो मॉडल बंद नहीं होता है: Nymbot अपने टोकन गिनने के लिए 25 सेकंड तक प्रदाता के शेष स्ट्रीम को पढ़ता है, और आप भुगतान करते हैं जो प्रदाता रिपोर्ट करता है।
• पहले भाग से पहले एक त्रुटि, जैसे कि 401 या 402, अपने स्टेट कोड के साथ सामान्य JSON के रूप में वापस आता है, एक स्ट्रीम के रूप में नहीं। data: {"error": {…}} घटना, और प्रवाह बिना समाप्त होता है [DONE].
• उपकरण के साथ अनुरोध, और ओपनएआई के प्रतिक्रिया परिवहन पर मॉडल, प्रदाता से प्रवाहित नहीं होते हैं। वे अभी भी एक वैध धारा के साथ उत्तर देते हैं, जो उत्तर पूरा होने के बाद भेजा जाता है।

cURL

curl -N https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nymbot/auto",
    "stream": true,
    "stream_options": {"include_usage": true},
    "messages": [{"role": "user", "content": "Write a haiku about sats."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

stream = client.chat.completions.create(
    model="nymbot/auto",
    stream=True,
    stream_options={"include_usage": True},
    messages=[{"role": "user", "content": "Write a haiku about sats."}],
)
for chunk in stream:
    if chunk.choices:
        print(chunk.choices[0].delta.content or "", end="", flush=True)
    elif chunk.usage:
        print("\ncost:", chunk.usage.cost)

JavaScript

import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "nymbot/auto",
  stream: true,
  stream_options: { include_usage: true },
  messages: [{ role: "user", content: "Write a haiku about sats." }],
});
for await (const chunk of stream) {
  if (chunk.choices.length) process.stdout.write(chunk.choices[0].delta.content || "");
  else if (chunk.usage) console.log("\ncost:", chunk.usage.cost);
}

टूल कॉल

कार्यों को वर्णन करें tools और मॉडल जवाब देने के बजाय एक को कॉल करने के लिए कह सकता है. आप फ़ंक्शन चलाते हैं, इसके परिणाम को एक के रूप में जोड़ते हैं tool उसी के साथ संदेश tool_call_id, और बातचीत को फिर से भेजें। निम्बॉट कभी भी आपके कार्यों को नहीं चलाता है; यह मॉडल के अनुरोध को आपको वापस भेजता है।

tool_choice लेता है "auto", "none", "required" या {"type": "function", "function": {"name": "…"}}. मॉडल सूची चिह्नित करता है कि मॉडल उपकरणों को कॉल कर सकते हैं (capabilities.tools) उपकरणों से इनकार किया जाता है 400 unsupported_tool है nymbot/auto और कुछ कैटलॉग मॉडलों पर जो ओपनएआई के प्रतिक्रिया परिवहन पर चलते हैं, जिन्हें निम्बॉट उपकरण नहीं दे सकता है।

के साथ "stream": true, उपकरणों के साथ एक अनुरोध एक टुकड़े में चला जाता है और फिर एक सामान्य टुकड़े अनुक्रम के रूप में भेजा जाता है: रोल, एक टुकड़ा जो प्रत्येक उपकरण कॉल को अपने सूचकांक, आईडी, नाम और तर्क के साथ ले जाता है, और अंतिम टुकड़ा।

जवाब में, कुछ

"choices": [
  {
    "index": 0,
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [
        {
          "id": "call_7d2e",
          "type": "function",
          "function": { "name": "get_invoice_status", "arguments": "{\"invoice_id\":\"a41f\"}" }
        }
      ]
    },
    "finish_reason": "tool_calls"
  }
]

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [{"role": "user", "content": "Has invoice a41f been paid?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_invoice_status",
        "description": "Look up whether an invoice is paid.",
        "parameters": {
          "type": "object",
          "properties": {"invoice_id": {"type": "string"}},
          "required": ["invoice_id"]
        }
      }
    }]
  }'

Python

import json, os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "get_invoice_status",
        "description": "Look up whether an invoice is paid.",
        "parameters": {
            "type": "object",
            "properties": {"invoice_id": {"type": "string"}},
            "required": ["invoice_id"],
        },
    },
}]
messages = [{"role": "user", "content": "Has invoice a41f been paid?"}]

reply = client.chat.completions.create(model="anthropic/claude-sonnet-5", messages=messages, tools=tools)
call = reply.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)

messages.append(reply.choices[0].message)
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps({"paid": True})})

final = client.chat.completions.create(model="anthropic/claude-sonnet-5", messages=messages, tools=tools)
print(final.choices[0].message.content)

JavaScript

import OpenAI from "openai";

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

const tools = [{
  type: "function",
  function: {
    name: "get_invoice_status",
    description: "Look up whether an invoice is paid.",
    parameters: {
      type: "object",
      properties: { invoice_id: { type: "string" } },
      required: ["invoice_id"],
    },
  },
}];
const messages = [{ role: "user", content: "Has invoice a41f been paid?" }];

const reply = await client.chat.completions.create({ model: "anthropic/claude-sonnet-5", messages, tools });
const call = reply.choices[0].message.tool_calls[0];
const args = JSON.parse(call.function.arguments);

messages.push(reply.choices[0].message);
messages.push({ role: "tool", tool_call_id: call.id, content: JSON.stringify({ paid: true }) });

const final = await client.chat.completions.create({ model: "anthropic/claude-sonnet-5", messages, tools });
console.log(final.choices[0].message.content);

अनुरोध में चित्र

मॉडल के साथ capabilities.vision चित्र पढ़ सकते हैं। एक जोड़ें image_url एक उपयोगकर्ता संदेश का हिस्सा, या तो एक सार्वजनिक संदेश के साथ https:// लिंक या ए data:image/…;base64, यू. आर. एल.। प्रति अनुरोध 20 चित्र तक। एस. वी. जी. चित्र अस्वीकार कर दिए जाते हैं, और इसी तरह 4,096 वर्णों से अधिक का लिंक या जिसमें उपयोगकर्ता नाम या पासवर्ड होता है (400 invalid_image_url) एक विकल्प detail है। auto, low या high.

के साथ nymbot/auto, इसमें एक छवि के साथ एक अनुरोध को एक मानक मॉडल के लिए निर्देशित किया जाता है जो देख सकता है। capabilities.vision उनके साथ तस्वीरें लेने से इनकार कर दिया 400 unsupported_content. चित्र केवल उपयोगकर्ता संदेशों में हो सकते हैं। एक लिंक को सार्वजनिक मेजबान को इंगित करना चाहिए; निम्बॉट चित्र को मॉडल के प्रदाता को भेजता है और इसे नहीं रखता है।

बाकी अनुरोध की तरह, प्रदाता द्वारा गणना किए जाने वाले इनपुट टोकन के रूप में एक तस्वीर का शुल्क लिया जाता है।

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "What is in this picture?"},
        {"type": "image_url", "image_url": {"url": "https://example.com/receipt.jpg"}}
      ]
    }]
  }'

Python

import base64, os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

with open("receipt.jpg", "rb") as f:
    data_url = "data:image/jpeg;base64," + base64.b64encode(f.read()).decode()

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this picture?"},
            {"type": "image_url", "image_url": {"url": data_url}},
        ],
    }],
)
print(reply.choices[0].message.content)

JavaScript

import { readFile } from "node:fs/promises";
import OpenAI from "openai";

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

const dataUrl = "data:image/jpeg;base64," + (await readFile("receipt.jpg")).toString("base64");

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  messages: [{
    role: "user",
    content: [
      { type: "text", text: "What is in this picture?" },
      { type: "image_url", image_url: { url: dataUrl } },
    ],
  }],
});
console.log(reply.choices[0].message.content);

तर्क करना

मॉडल के साथ capabilities.reasoning वे जवाब देने से पहले सोच सकते हैं। इसके बारे में कम या ज्यादा पूछें reasoning_effort ("minimal", "low", "medium" या "high") या "reasoning": {"effort": "high"}या जोड़ें :thinking मॉडल का नाम, जिसका अर्थ है उच्च प्रयास. बिना तर्क के मॉडल पर सेटिंग अनदेखा की जाती है. nymbot/auto, :thinking अनुरोध को मानक तर्क मार्ग पर भेजता है।

एंथ्रोपिक मॉडल पर प्रयास लगभग 1,000,2,000,8,000 या 16,000 टोकन का एक विचारशील बजट बन जाता है, जो कभी भी उससे अधिक नहीं होता है। max_tokens सोचना छोड़ दिया जाता है जब tool_choice एक उपकरण को मजबूर करने के लिए, और जब अनुरोध एक उपकरण लूप जारी करता है (इसके अंतिम संदेश एक उपकरण परिणाम है), क्योंकि एंथ्रोपिक को इसे फिर से शुरू करने के लिए पहले हस्ताक्षर किए गए सोच की आवश्यकता होती है।

तर्क वापस आता है message.reasoning_contentया delta.reasoning_content जब स्ट्रीमिंग, कभी भी जवाब में मिश्रित. तर्क आउटपुट है और इस तरह के रूप में चार्ज किया जाता है, अंदर completion_tokensकुछ प्रदाता बिल्कुल भी तर्क पाठ वापस नहीं करते हैं, और यह अभी भी शुल्क है।

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "reasoning_effort": "high",
    "messages": [{"role": "user", "content": "Is 2^61 - 1 prime? Show why."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    reasoning_effort="high",
    messages=[{"role": "user", "content": "Is 2^61 - 1 prime? Show why."}],
)
message = reply.choices[0].message
print(getattr(message, "reasoning_content", None))
print(message.content)

JavaScript

import OpenAI from "openai";

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

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  reasoning_effort: "high",
  messages: [{ role: "user", content: "Is 2^61 - 1 prime? Show why." }],
});
console.log(reply.choices[0].message.reasoning_content);
console.log(reply.choices[0].message.content);

मॉडल प्रत्यय

मॉडल नाम पर एक शेक्स बदलता है कि अनुरोध कैसे संसाधित किया जाता है, बिना किसी अन्य क्षेत्र के। anthropic/claude-sonnet-5:online.

किसी भी अन्य प्रत्यय को नजरअंदाज कर दिया जाता है। पूरे नाम को पहले आजमाया जाता है, इसलिए एक मॉडल जिसकी आईडी में वास्तव में एक कोलन होता है, अभी भी काम करता है; ऐसा न करने पर, प्रत्यय को एक बार में अंत से हटा दिया जाता है जब तक कि एक मॉडल मेल नहीं खाता। एक मॉडल का नाम अधिकतम 200 वर्ण लंबा हो सकता है जिसमें अधिकतम 4 प्रत्यय हो सकते हैं; एक लंबा नाम अस्वीकार कर दिया जाता है। 400 invalid_value.

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5:thinking",
    "messages": [{"role": "user", "content": "Plan a three-day trip to Lisbon."}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5:thinking",
    messages=[{"role": "user", "content": "Plan a three-day trip to Lisbon."}],
)
print(reply.choices[0].message.content)

JavaScript

import OpenAI from "openai";

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

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5:thinking",
  messages: [{ role: "user", content: "Plan a three-day trip to Lisbon." }],
});
console.log(reply.choices[0].message.content);

वेब खोज

कोई भी चैट मॉडल लाइव वेब से जवाब दे सकता है. Nymbot अंतिम उपयोगकर्ता संदेश (उसकी पहली 2,000 अक्षरों) के लिए खोज करता है, सर्वश्रेष्ठ पृष्ठों को पढ़ता है और उन्हें सवाल के साथ मॉडल को देता है, जो बाहरी सामग्री के रूप में चिह्नित है कि मॉडल से निर्देश नहीं लेना चाहिए. दो मोड हैं:

• हमेशा खोजें: "plugins": [{"id": "web", "max_results": 5}]या A :online मॉडल के लिए पर्याप्त।
• खोजें जब यह मदद करता है: "tools": [{"type": "web_search", "parameters": {"max_results": 5}}]के रूप में भी स्वीकार किया जाता है web_search_preview या openrouter:web_searchNymbot केवल तभी खोजता है जब प्रश्न को लगता है कि उसे वर्तमान जानकारी की आवश्यकता होती है, एक ही परीक्षण जो ऐप का उपयोग करता है।

max_results डिफ़ॉल्ट रूप से 5 है और अधिक से अधिक 10। स्रोत वापस आते हैं nymbot.web_search.sources, प्रत्येक एक के साथ title, snippet और url, और के रूप में url_citation संदेश पर टिप्पणियाँ।

प्रत्येक खोज जो चलाता है $ 0.008 की लागत है, जो टोकन के शीर्ष पर sats में परिवर्तित किया जाता है, और यह स्टॉक का हिस्सा है. यह पढ़ने वाले पृष्ठ भी इनपुट टोकन हैं, इसलिए वेब से एक जवाब ठंड से पूछे गए एक ही प्रश्न से अधिक खर्च करता है, कभी-कभी कई बार अधिक।

जवाब में, कुछ

"nymbot": {
  "balance": "pro",
  "charged_credits": 0.431,
  "charged_sats": 43.1,
  "balance_credits": 411.994,
  "balance_sats": 41199.4,
  "web_search": {
    "sources": [
      { "title": "Lightning Network - Wikipedia", "snippet": "The Lightning Network is a payment protocol...", "url": "https://en.wikipedia.org/wiki/Lightning_Network" }
    ]
  }
}

cURL

curl https://nymbot.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "plugins": [{"id": "web", "max_results": 5}],
    "messages": [{"role": "user", "content": "What changed in the latest Bitcoin Core release?"}]
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

reply = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[{"role": "user", "content": "What changed in the latest Bitcoin Core release?"}],
    extra_body={"plugins": [{"id": "web", "max_results": 5}]},
)
print(reply.choices[0].message.content)
for source in reply.model_extra["nymbot"]["web_search"]["sources"]:
    print(source["url"])

JavaScript

import OpenAI from "openai";

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

const reply = await client.chat.completions.create({
  model: "anthropic/claude-sonnet-5",
  plugins: [{ id: "web", max_results: 5 }],
  messages: [{ role: "user", content: "What changed in the latest Bitcoin Core release?" }],
});
console.log(reply.choices[0].message.content);
for (const source of reply.nymbot.web_search.sources) console.log(source.url);

प्रतिक्रिया एपीआई

OpenAI के नवीनतम प्रारूप, OpenAI एजेंट एसडीके और कोडेक्स द्वारा उपयोग किया जाता है. यह चैट पूर्णता के समान मॉडल, बिलिंग और सुविधाओं पर चलता है.

POST https://nymbot.ai/api/v1/responses - एक एपीआई कुंजी की आवश्यकता है।

प्रतिक्रिया

{
  "id": "resp_8c1e4b0f9a2d4e61",
  "object": "response",
  "created_at": 1790726400,
  "status": "completed",
  "model": "anthropic/claude-sonnet-5",
  "output": [
    {
      "type": "message",
      "id": "msg_2b7f",
      "role": "assistant",
      "status": "completed",
      "content": [{ "type": "output_text", "text": "A Lightning invoice is...", "annotations": [] }]
    }
  ],
  "output_text": "A Lightning invoice is...",
  "usage": {
    "input_tokens": 1240,
    "input_tokens_details": { "cached_tokens": 0 },
    "output_tokens": 380,
    "output_tokens_details": { "reasoning_tokens": 0 },
    "total_tokens": 1620
  },
  "incomplete_details": null,
  "error": null,
  "instructions": null,
  "store": false,
  "previous_response_id": null,
  "metadata": {},
  "nymbot": { "balance": "pro", "charged_credits": 0.162, "charged_sats": 16.2, "balance_credits": 412.425, "balance_sats": 41242.5 }
}

एक उपकरण अनुरोध में दिखाई देता है output ए के रूप में function_call के साथ बिंदु call_id, name और argumentsपरिणाम को a के रूप में वापस भेजें function_call_output एक ही चीज के साथ call_id. तर्क, जब मॉडल इसे वापस करता है, एक है reasoning के साथ बिंदु reasoning_text पहले सूचीबद्ध, पहले सूचीबद्ध status है। incomplete जब जवाब आया max_output_tokens या फिर उसने नकार दिया। incomplete_details.reason सेट करें max_output_tokens या content_filterप्रतिक्रिया अनुरोध की सेटिंग्स (तापमान, उपकरण, उपकरण विकल्प आदि) को भी प्रतिध्वनित करती है जैसा कि ओपनएआई करता है, और इसमें अनुरोध का विवरण होता है। nymbot वस्तु की लागत

स्ट्रीमिंग, हर घटना एक है event: लाइन और A data: एक के साथ लाइन sequence_number, इस क्रम मेंः response.created, response.in_progress, response.output_item.added, response.content_part.addedकिसी भी संख्या में response.output_text.delta, response.output_text.done, response.content_part.done, response.output_item.done, और अंत में response.completed उपयोग और लागत के साथ. एक जवाब के साथ छोटे अंत response.incomplete इसके बजाय, और धारा के शुरू होने के बाद एक विफलता response.failedअपने-अपने वस्तुओं के रूप में ध्वनियों को तर्क देना response.reasoning_text.delta और .doneटूल कॉल संदेश के बाद आते हैं, प्रत्येक के साथ एक वस्तु के रूप में response.function_call_arguments.delta और .done.

cURL

curl https://nymbot.ai/api/v1/responses \
  -H "Authorization: Bearer $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5",
    "instructions": "Answer in one short paragraph.",
    "input": "What is a Lightning invoice?"
  }'

Python

import os
from openai import OpenAI

client = OpenAI(base_url="https://nymbot.ai/api/v1", api_key=os.environ["NYMBOT_API_KEY"])

response = client.responses.create(
    model="anthropic/claude-sonnet-5",
    instructions="Answer in one short paragraph.",
    input="What is a Lightning invoice?",
)
print(response.output_text)

JavaScript

import OpenAI from "openai";

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

const response = await client.responses.create({
  model: "anthropic/claude-sonnet-5",
  instructions: "Answer in one short paragraph.",
  input: "What is a Lightning invoice?",
});
console.log(response.output_text);

मानव संदेश

एंथ्रोपिक एसडीके और क्लाउड कोड के लिए एंथ्रोपिक का प्रारूप। यह कैटलॉग में हर मॉडल के साथ काम करता है, न केवल क्लाउडः अनुरोध का अनुवाद किया जाता है, उसी पाइपलाइन के माध्यम से चलाया जाता है, और वापस अनुवाद किया जाता है।

POST https://nymbot.ai/api/v1/messages - एक API कुंजी की आवश्यकता होती है, जैसे कि x-api-key या Authorization: Bearer.

द. anthropic-version और anthropic-beta हेडर स्वीकार किए जाते हैं और नज़रअंदाज़ किए जाते हैं। एंथ्रोपिक मॉडल के नाम कैटलॉग से मेल खाते हैं, इसलिए क्लाउड कोड और एसडीके उन नामों के साथ काम करते हैं जो वे पहले से ही उपयोग करते हैंः

• एक नाम जो कैटलॉग जानता है, जैसे claude-sonnet-5 या anthropic/claude-opus-5जिस तरह से इस्तेमाल किया जाता है।
• अन्यथा एक तारीख (-20260514), -latest, एक संस्करण टैग जैसे कि -v1जैसा कि एक ब्रैकेटेड टैग [1m] और एक anthropic/ या anthropic. उपसर्ग हटा दिए जाते हैं, और संस्करण में डॉट्स और डैश दोनों तरीकों से आज़माए जाते हैं (claude-haiku-4-5 ढूँढें claude-haiku-4.5).
• यदि वह अभी भी कुछ भी मेल नहीं खाता है, तो परिवार (ओपस, सॉनेट या हाइकू) का उपयोग किया जाता है, जब तक कि कैटलॉग का संस्करण वही है या मांगे गए संस्करण से नया है।
• एक नाम जो कुछ भी मेल नहीं आता वापस आता है 404 not_found_error.

प्रतिक्रिया

{
  "id": "msg_01c7a2f93e5b4d08",
  "type": "message",
  "role": "assistant",
  "model": "anthropic/claude-sonnet-5",
  "content": [{ "type": "text", "text": "A Lightning invoice is..." }],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 1240,
    "output_tokens": 380,
    "cache_read_input_tokens": 0,
    "cache_creation_input_tokens": 0
  },
  "nymbot": { "balance": "pro", "charged_credits": 0.162, "charged_sats": 16.2, "balance_credits": 412.425, "balance_sats": 41242.5 }
}

content पकड़ भी सकते हैं। tool_use ब्लॉक और A thinking ब्लॉक, जिसका signature खाली है। stop_reason है। end_turn, max_tokens, tool_use या refusal, उसी तरह काम किया जैसे finish_reason है चैट पूरा करें; stop_sequence हमेशा होता है null, तब भी जब एक विराम अनुक्रम उत्तर को समाप्त कर देता है। input_tokens केवल नए इनपुट को गिना जाता है; कैश किए गए इनपुट दो कैश क्षेत्रों में है। लागत में है nymbot वस्तु और X-Nymbot-Cost-Sats हेडर।

प्रवाहित, घटनाएँ एंथ्रोपिक की हैंः message_start, content_block_start, ping, content_block_delta (text_delta, input_json_delta या thinking_delta), content_block_stop, message_delta रुकने के कारण, उपयोग और nymbot मूल्य वस्तु, और message_stop. ए. ping यह भी हर 15 सेकंड में भेजा जाता है जबकि मॉडल काम कर रहा है. उपकरण कॉल पाठ के बाद आते हैं, प्रत्येक एक के रूप में tool_use ब्लॉक एक में अपने पूरे इनपुट के साथ input_json_delta.

इस अंतिम बिंदु पर त्रुटियाँ एंथ्रोपिक के प्रारूप का उपयोग करती हैंः {"type": "error", "error": {"type": "not_found_error", "message": "…"}}. एक संक्षिप्त संतुलन है 402 billing_errorएक अप्रत्याशित प्रदाता 503 overloaded_errorधारा शुरू होने के बाद एक विफलता को एक के रूप में भेजा जाता है error घटना।

cURL

curl https://nymbot.ai/api/v1/messages \
  -H "x-api-key: $NYMBOT_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "max_tokens": 1024,
    "messages": [{"role": "user", "content": "What is a Lightning invoice?"}]
  }'

Python

import os
import anthropic

client = anthropic.Anthropic(base_url="https://nymbot.ai/api", api_key=os.environ["NYMBOT_API_KEY"])

message = client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "What is a Lightning invoice?"}],
)
print(message.content[0].text)

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://nymbot.ai/api", apiKey: process.env.NYMBOT_API_KEY });

const message = await client.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "What is a Lightning invoice?" }],
});
console.log(message.content[0].text);

टोकन की गिनती

संदेश अनुरोध में कितने इनपुट टोकन का उपयोग होगा, ताकि एक क्लाइंट भेजने से पहले चेक कर सके. यह मुफ्त है, लेकिन अभी भी एक कुंजी की आवश्यकता है.

POST https://nymbot.ai/api/v1/messages/count_tokens - एक एपीआई कुंजी की आवश्यकता है। मुफ़्त।

शरीर के लिए समान है संदेश, बिना max_tokensमॉडल के नाम को हल करना होता है। गिनती एक अनुमान हैः सिस्टम प्रॉम्प्ट के वर्ण, संदेश, टूल कॉल और उपकरण परिभाषाओं को चार से विभाजित किया जाता है, साथ ही प्रत्येक चित्र के लिए 1,600। यह प्रदाता का अपना टोकनाइज़र नहीं है, इसलिए वास्तविक गिनती भिन्न हो सकती है। एक कुंजी जो अपनी सीमा तक पहुंच गई है वह अभी भी इसका उपयोग कर सकती है।

प्रतिक्रिया

{ "input_tokens": 318 }

cURL

curl https://nymbot.ai/api/v1/messages/count_tokens \
  -H "x-api-key: $NYMBOT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5",
    "messages": [{"role": "user", "content": "What is a Lightning invoice?"}]
  }'

Python

import os
import anthropic

client = anthropic.Anthropic(base_url="https://nymbot.ai/api", api_key=os.environ["NYMBOT_API_KEY"])

count = client.messages.count_tokens(
    model="claude-sonnet-5",
    messages=[{"role": "user", "content": "What is a Lightning invoice?"}],
)
print(count.input_tokens)

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ baseURL: "https://nymbot.ai/api", apiKey: process.env.NYMBOT_API_KEY });

const count = await client.messages.countTokens({
  model: "claude-sonnet-5",
  messages: [{ role: "user", content: "What is a Lightning invoice?" }],
});
console.log(count.input_tokens);

मॉडलों की सूची

प्रत्येक मॉडल और जनरेटर एपीआई स्वीकार करता है, इसकी लागत के साथ. सूची एप्लिकेशन के पिकर के रूप में एक ही लाइव कैटलॉग से पढ़ी जाती है, इसलिए यह हमेशा वह है जो सर्वर चलाएगा।

GET https://nymbot.ai/api/v1/models - कोई कुंजी की जरूरत नहीं. पांच मिनट के लिए छिपाया गया।

GET /api/v1/models/{id} एक प्रवेश द्वार वापस

कीमतें वे हैं जो आप भुगतान करते हैं, शुल्क और मार्जिन के साथ पहले से ही डॉलर में और वर्तमान बिटक्वाइन मूल्य पर सैट्स में। balance यह बताता है कि मॉडल कौन सा संतुलन खर्च करता है। nymbot_key ऐप में मॉडल का संक्षिप्त नाम है। created हमेशा 0 है, क्योंकि कैटलॉग में कोई रिकॉर्ड नहीं रिकॉर्ड किया गया है जब एक मॉडल जोड़ा गया था। per_request बजाय।

nymbot/auto हमेशा पहले है, कीमत के रूप में variable, ए के साथ routes सूची प्रत्येक मानक मार्ग की दरों को देता है. यह दृष्टि और तर्क को सूचीबद्ध करता है, लेकिन उपकरण नहीं।

GET /api/v1/models/{id} एक अनुरोध के रूप में एक ही नाम और उपनाम स्वीकार करता है, और उस मॉडल के लिए आइटम को वापस करता है जिसे वे हल करते हैं।

प्रतिक्रिया

{
  "object": "list",
  "data": [
    {
      "id": "anthropic/claude-sonnet-5",
      "object": "model",
      "type": "chat",
      "owned_by": "anthropic",
      "name": "Claude Sonnet 5",
      "created": 0,
      "context_length": 1000000,
      "max_output_tokens": 64000,
      "architecture": { "input_modalities": ["text", "image"], "output_modalities": ["text"] },
      "supported_parameters": ["max_tokens", "temperature", "tools", "tool_choice", "reasoning", "response_format", "stop"],
      "capabilities": { "vision": true, "video": false, "tools": true, "reasoning": true, "web_search": true },
      "balance": "pro",
      "pricing": {
        "type": "per_token",
        "currency": "USD",
        "input_per_1M_tokens": 4.725,
        "output_per_1M_tokens": 23.625,
        "cache_read_per_1M_tokens": 0.4725,
        "sats_input_per_1M_tokens": 4038,
        "sats_output_per_1M_tokens": 20192
      },
      "description": "...",
      "nymbot_key": "claude-sonnet"
    }
  ]
}

अन्य प्रकारः

• छवि प्रविष्टियाँ हैं capabilities (accepts_image_url, requires_image_url, edit) और एक कीमत per_generation.
• वीडियो प्रविष्टियाँ हैं max_duration_seconds और resolutions, और एक कीमत per_second प्रत्येक संकल्प के लिए।
• ऑडियो प्रविष्टियाँ हैं audio_type speech या transcriptionकीमत per_1k_chars या per_minute.
• इम्बेड प्रविष्टियाँ हैं dimensions, context_length, max_inputs और एक मिलियन input tokens प्रति मूल्य।

मार्क की कीमतें "estimated": true एक जनरेटर के लिए ऐप का अनुमान है जिसकी कीमत प्रकाशित नहीं की गई है। एक अज्ञात type वापस 400.

cURL

curl "https://nymbot.ai/api/v1/models?type=chat"

Python

import requests

models = requests.get("https://nymbot.ai/api/v1/models", params={"type": "chat"}).json()["data"]
for m in models:
    print(m["id"], m["balance"], m["pricing"].get("input_per_1M_tokens"))

JavaScript

const res = await fetch("https://nymbot.ai/api/v1/models?type=chat");
const { data } = await res.json();
for (const m of data) console.log(m.id, m.balance, m.pricing.input_per_1M_tokens);