GPT, Claude, Gemini और DeepSeek के लिए एक API: डेवलपर के लिए व्यावहारिक गाइड

AI ऐप बनाते समय शायद आपने यह स्थिति देखी हो: एक तरह के काम के लिए GPT चाहिए, दूसरे के लिए Claude, और Gemini को भी आजमाना है। जब खर्च मायने रखता है, तो DeepSeek से भी तुलना करनी होती है।

अलग-अलग मॉडल सचमुच अलग-अलग कामों में अच्छे होते हैं।

इन मॉडलों को खोजना मुश्किल नहीं है। असली सवाल यह है कि इन सभी को अपने ऐप से कैसे जोड़ें।

आपको अलग-अलग API कुंजियां, खाते और बिलिंग डैशबोर्ड संभालने पड़ सकते हैं। कभी-कभी अलग SDK भी इस्तेमाल करने पड़ते हैं।

API Hop में हम इस प्रक्रिया को थोड़ा आसान बनाने पर काम कर रहे हैं। हमारा एक प्लेटफॉर्म डेवलपर को साझा API और बैलेंस से कई AI मॉडल तक पहुंच देता है।

लेकिन कोड में यह कैसा दिखता है? क्या एकीकृत API सचमुच विकास आसान कर सकती है?

इस लेख में हम वास्तविक सेटअप से शुरू करेंगे, मॉडल बदलना दिखाएंगे, खर्च और प्रतिक्रिया समय मापेंगे, और लाइव जाने से पहले की जरूरी जांच समझेंगे।

1. वास्तविक सेटअप: कई मॉडल, कई इंटीग्रेशन

मान लें कि हम एक छोटा AI ऐप बना रहे हैं।

हम इनका इस्तेमाल करना चाहते हैं:

• GPT: सामान्य काम और संरचित प्रतिक्रियाओं के लिए।
• Claude: लेखन, कोडिंग और लंबे कामों के लिए।
• Gemini: मल्टीमोडल कामों के लिए।
• DeepSeek: खर्च और आउटपुट की गुणवत्ता जांचने के दूसरे विकल्प के रूप में।

अगर हर प्रदाता की आधिकारिक API से अलग-अलग जुड़ें, तो API क्रेडेंशियल, मूल्य पृष्ठ और इंटीग्रेशन तरीकों के चार अलग सेट संभालने होंगे।

यह एक सरल तुलना है:

आखिरी पंक्ति महत्वपूर्ण है।

एक API का मतलब यह नहीं कि हर AI मॉडल बिल्कुल एक जैसा व्यवहार करेगा।

समर्थित पैरामीटर, संदर्भ की लंबाई, टूल कॉल, प्रतिक्रिया प्रारूप और इनपुट प्रकार मॉडल के अनुसार अलग हो सकते हैं। एकीकृत API इंटीग्रेशन आसान कर सकती है, लेकिन हर मॉडल की वास्तविक क्षमताएं समझना फिर भी जरूरी है।

2. API Hop से शुरुआत करें

हमें सिर्फ तीन चीजें चाहिए:

1. एक API Hop खाता।
2. एक API Hop API कुंजी।
3. वर्तमान में उपलब्ध मॉडल का ID।

समर्थित मॉडल और वर्तमान कीमतें वेबसाइट पर देख सकते हैं:

• API Hop मॉडल सूची
• API Hop मूल्य पृष्ठ
• API Hop API दस्तावेज़

OpenAI SDK के साथ संगत इंटीग्रेशन के लिए API Hop यह बेस URL देता है:

https://api.apihop.ai/openai/v1

ध्यान दें, यह हमारे सामान्य HTTP चैट एंडपॉइंट से अलग पता है:

POST https://api.apihop.ai/v1/chat-completions

नीचे दिए SDK उदाहरणों में हम OpenAI-संगत एंडपॉइंट इस्तेमाल करेंगे।

चरण 1: SDK इंस्टॉल करें

Python:

pip install --upgrade openai

Node.js:

npm install openai

चरण 2: API कुंजी सेट करें

हम API कुंजी को कोड में सीधे लिखने के बजाय एनवायरनमेंट वेरिएबल में रखने की सलाह देते हैं।

export APIHOP_API_KEY="your-api-key"
export APIHOP_MODEL="your-supported-model-id"

your-supported-model-id को वर्तमान मॉडल सूची के वास्तविक ID से बदलें।

मॉडल के मार्केटिंग नाम से अनुमान लगाने के बजाय ID सीधे कॉपी करें। API पहचानकर्ता मॉडल की आधिकारिक वेबसाइट पर दिखने वाले नाम से बिल्कुल मेल न भी खाए।

3. Python से पहला API कॉल करें

OpenAI SDK इस्तेमाल करने वाला यह एक बुनियादी Python उदाहरण है।

import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model=os.environ["APIHOP_MODEL"],
    messages=[
        {
            "role": "user",
            "content": "Explain what an API is in one sentence."
        }
    ],
)

print(response.choices[0].message.content)

बुनियादी सेटअप इतना ही है।

API कुंजी और बेस URL सिर्फ एक बार सेट करने हैं। इसके बाद समर्थित मॉडल से चैट अनुरोध भेज सकते हैं।

प्रतिक्रिया में क्या मिलना चाहिए?

अनुरोध सफल होने पर मॉडल द्वारा तैयार सामग्री वाली प्रतिक्रिया मिलेगी।

मिसाल के तौर पर मॉडल यह समझा सकता है: “API दो सॉफ़्टवेयर एप्लिकेशन के बीच संवाद करने का तरीका है।”

सटीक शब्द मॉडल और अनुरोध के अनुसार बदलेंगे।

अनुरोध असफल होने पर पहले जांचें:

• API कुंजी मान्य है या नहीं।
• चुना गया मॉडल ID उपलब्ध है या नहीं।
• एंडपॉइंट मांगा गया ऑपरेशन समर्थित करता है या नहीं।
• खाते में पर्याप्त बैलेंस है या नहीं।
• कोई अनुरोध पैरामीटर असमर्थित तो नहीं है।

हम हर त्रुटि पर बिना सोचे दोबारा प्रयास करने की सलाह नहीं देते। प्रमाणीकरण विफलता, गलत मॉडल नाम और अस्थायी दर सीमाओं के लिए अलग तरीके चाहिए।

4. GPT, Claude, Gemini और DeepSeek के बीच स्विच करें

अब वह हिस्सा जो हमें सबसे उपयोगी लगता है: ऐप के कोड में कम से कम बदलाव करके अलग-अलग मॉडल जांचना।

चार अलग API इंटीग्रेशन लिखने के बजाय हम मॉडल ID लेने वाले एक फ़ंक्शन से शुरुआत कर सकते हैं।

import os
from openai import OpenAI

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

def ask_model(model_id, question):
    response = client.chat.completions.create(
        model=model_id,
        messages=[
            {
                "role": "user",
                "content": question
            }
        ],
    )

    return response.choices[0].message.content

अब उसी फ़ंक्शन को अलग-अलग मॉडल ID के साथ कॉल कर सकते हैं।

question = "Explain REST APIs to a beginner."

model_ids = {
    "GPT": os.environ["GPT_MODEL_ID"],
    "Claude": os.environ["CLAUDE_MODEL_ID"],
    "Gemini": os.environ["GEMINI_MODEL_ID"],
    "DeepSeek": os.environ["DEEPSEEK_MODEL_ID"],
}

for name, model_id in model_ids.items():
    print(f"\n--- {name} ---")

    try:
        answer = ask_model(model_id, question)
        print(answer)
    except Exception as error:
        print(f"Request failed: {error}")

इसे चलाने से पहले नवीनतम मॉडल सूची में चार मान्य, उपलब्ध मॉडल ID खोजें और संबंधित एनवायरनमेंट वेरिएबल सेट करें:

export GPT_MODEL_ID="supported-gpt-model-id"
export CLAUDE_MODEL_ID="supported-claude-model-id"
export GEMINI_MODEL_ID="supported-gemini-model-id"
export DEEPSEEK_MODEL_ID="supported-deepseek-model-id"

उद्देश्य हर मॉडल परिवार के लिए अलग SDK इंटीग्रेशन लिखने के बजाय एक ही अनुरोध फ़ंक्शन दोबारा इस्तेमाल करना है।

एक बात याद रखें: चुने हुए मॉडलों को OpenAI-संगत चैट एंडपॉइंट और भेजे गए विशिष्ट पैरामीटर समर्थित करने चाहिए। कुछ उन्नत सुविधाओं के लिए दूसरे एंडपॉइंट लग सकते हैं।

5. परीक्षण के आंकड़ों को बोलने दें

एक सफल API अनुरोध सिर्फ यह बताता है कि एंडपॉइंट काम करता है। इससे यह साबित नहीं होता कि सेवा प्रोडक्शन के लिए पर्याप्त तेज, भरोसेमंद या किफायती है।

इसलिए अपने ऐप के लिए एक छोटा परीक्षण करें।

चारों मॉडलों को एक ही प्रॉम्प्ट भेजकर ये बातें दर्ज करें:

• अनुरोध सफल हुआ या नहीं।
• हर अनुरोध में कितना समय लगा।
• इनपुट टोकन की संख्या।
• आउटपुट टोकन की संख्या।
• मॉडल ने वास्तव में क्या लौटाया।

पहले दौर में हम यह प्रॉम्प्ट इस्तेमाल करते हैं:

Explain how HTTPS protects data between a browser and a server. Use fewer than 100 words.

यह अपेक्षाकृत सरल सवाल है, लेकिन अलग-अलग मॉडलों पर एक ही अनुरोध प्रारूप काम करता है या नहीं, यह जांचने की अच्छी शुरुआत है।

Python परीक्षण स्क्रिप्ट

import os
import time
import json
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["APIHOP_API_KEY"],
    base_url="https://api.apihop.ai/openai/v1",
    timeout=60.0,
    max_retries=0,
)

models = {
    "GPT": os.environ["GPT_MODEL_ID"],
    "Claude": os.environ["CLAUDE_MODEL_ID"],
    "Gemini": os.environ["GEMINI_MODEL_ID"],
    "DeepSeek": os.environ["DEEPSEEK_MODEL_ID"],
}

prompt = (
    "Explain how HTTPS protects data between "
    "a browser and a server. Use fewer than 100 words."
)

results = []

for provider, model_id in models.items():
    for run in range(5):
        start = time.perf_counter()

        try:
            response = client.chat.completions.create(
                model=model_id,
                messages=[
                    {"role": "user", "content": prompt}
                ],
            )

            elapsed = time.perf_counter() - start
            usage = response.usage

            results.append({
                "provider": provider,
                "model_id": model_id,
                "run": run + 1,
                "success": True,
                "latency_seconds": round(elapsed, 3),
                "input_tokens": (
                    usage.prompt_tokens if usage else None
                ),
                "output_tokens": (
                    usage.completion_tokens if usage else None
                ),
                "answer": (
                    response.choices[0].message.content
                ),
            })

        except Exception as error:
            elapsed = time.perf_counter() - start

            results.append({
                "provider": provider,
                "model_id": model_id,
                "run": run + 1,
                "success": False,
                "latency_seconds": round(elapsed, 3),
                "error": str(error),
            })

with open("apihop-test-results.json", "w") as f:
    json.dump(results, f, indent=2)

print(json.dumps(results, indent=2))

हम max_retries=0 सेट करते हैं क्योंकि हर अलग अनुरोध की विफलता देखना चाहते हैं, न कि SDK के अपने आप दोबारा प्रयास करने से त्रुटियां छिपाना। यह मापन के लिए है; जरूरी नहीं कि प्रोडक्शन में भी यही सेटिंग इस्तेमाल करें।

मूल अनुरोध सिर्फ model और messages भेजता है, जिन्हें सभी चुने मॉडल समर्थित करने चाहिए। temperature और top_p जैसे वैकल्पिक सैंपलिंग पैरामीटर इसमें नहीं हैं। किसी मॉडल के लिए वैकल्पिक पैरामीटर जोड़ने से पहले उसका समर्थन जांचें और बदलाव दर्ज करें। असमर्थित पैरामीटर से आया 400 अनुरोध संगतता की त्रुटि है, मॉडल के आउटपुट की खराब गुणवत्ता का प्रमाण नहीं।

परीक्षण दोहराने लायक पर्याप्त संदर्भ दर्ज करें

यह स्क्रिप्ट मूल्यांकन का तरीका है, प्रकाशित प्रदर्शन रैंकिंग नहीं। पिछला पांच-अनुरोध सारांश हटा दिया गया है, क्योंकि पाठकों के सत्यापन के लिए मूल अनुरोध रिकॉर्ड और ऐतिहासिक दरें उपलब्ध नहीं हैं।

अपने परीक्षण में UTC समय, सटीक मॉडल ID, एंडपॉइंट, सभी अनुरोध पैरामीटर और प्रॉम्प्ट, कच्चे usage फ़ील्ड, प्रतिक्रिया या संवेदनशील जानकारी हटाई हुई त्रुटि, और लागू दर का स्रोत व तारीख रखें। रिकॉर्ड में कभी API कुंजियां न डालें। मॉडल के बिलिंग नियमों के अनुसार सामान्य इनपुट, कैश किया इनपुट, कैश लेखन और आउटपुट अलग रखें, ताकि एक ही उपयोग दो बार न गिना जाए।

यहां latency_seconds पूरे गैर-स्ट्रीमिंग अनुरोध का समय मापता है, पहले टोकन तक का समय नहीं। खर्च की तुलना से पहले अप्रत्याशित टोकन संख्या को पूरे अनुरोध और उपयोग रिकॉर्ड से जांचें। कार्य के कुल खर्च में विफल प्रयास और दोबारा प्रयास भी शामिल करें। पांच सफल अनुरोध किसी SLA या पूरे प्लेटफॉर्म की गुणवत्ता रैंकिंग को स्थापित नहीं करते।

6. वास्तविक टोकन उपयोग से API खर्च की तुलना करें

AI API की कीमतें उलझाने का एक बड़ा कारण यह है कि इनपुट और आउटपुट टोकन की दरें आम तौर पर अलग होती हैं।

कुछ मॉडल कैश किए इनपुट की अलग कीमत भी देते हैं, जिससे अंतिम खर्च और बदल सकता है।

टेक्स्ट API के लिए हम आम तौर पर इस सूत्र से शुरुआत करते हैं:

अनुमानित खर्च = (इनपुट टोकन x इनपुट कीमत + आउटपुट टोकन x आउटपुट कीमत) / 1,000,000

इसमें माना गया है कि दोनों कीमतें प्रति दस लाख टोकन हैं और पूरे उपयोग पर सामान्य, गैर-कैश दर लागू है।

एक सरल खर्च गणना करें

मान लें कि हमारा ऐप महीने में 100,000 अनुरोध करता है।

हमारा अनुमान है कि हर अनुरोध में औसतन ये टोकन लगते हैं:

• 1,000 इनपुट टोकन।
• 300 आउटपुट टोकन।

इससे मासिक उपयोग यह होगा:

अब काल्पनिक कीमतों के दो सेट की तुलना करें।

इस उदाहरण में B, A से 50% सस्ता है।

समान टोकन उपयोग पर महीने में $220 का अंतर है।

प्रदाता चुनने से पहले मॉडल की नवीनतम कीमतें सूत्र में डालें और प्लेटफॉर्म शुल्क, कैश नियम, न्यूनतम शुल्क तथा दूसरे बिलिंग नियम जांचें।

API Hop की वर्तमान मॉडल कीमतें मूल्य पृष्ठ पर हैं।

वास्तविक टोकन आंकड़े क्यों जरूरी हैं?

एक ही सवाल का जवाब देते समय भी अलग मॉडल अलग संख्या में आउटपुट टोकन तैयार कर सकते हैं।

यह जरूरी है क्योंकि आउटपुट टोकन अक्सर इनपुट टोकन से महंगे होते हैं।

हम अपने वास्तविक प्रॉम्प्ट से मॉडल जांचने और जहां संभव हो, खपत की पुष्टि के लिए API से लौटे उपयोग आंकड़े इस्तेमाल करने की सलाह देते हैं।

एक और बात आसानी से छूट जाती है: अलग मॉडल परिवार अलग टोकनाइज़र इस्तेमाल कर सकते हैं, इसलिए बताई गई टोकन संख्याओं की सीधी तुलना हमेशा संभव नहीं होती।

इसीलिए सिर्फ “कौन सा मॉडल कम टोकन इस्तेमाल करता है?” पूछने के बजाय हमारा मुख्य सवाल है: उन्हीं निश्चित कामों को पूरा करने के लिए वास्तव में कितना शुल्क लगा?

7. लाइव जाने से पहले और क्या जांचें?

डेमो में शुरुआती कदम पूरा करने के लिए मॉडल से प्रतिक्रिया मिलना आम तौर पर पर्याप्त है।

लेकिन ऐप को वास्तविक उपयोगकर्ताओं के सामने रखना अलग बात है।

हम विफल अनुरोधों, बजट से ज्यादा खर्च, सुरक्षा समस्याओं और सिस्टम के स्थिर व अनुमानित व्यवहार पर अधिक ध्यान देते हैं।

वास्तविक व्यावसायिक ट्रैफ़िक भेजने से पहले हम ये जांचें सुझाते हैं।

त्रुटि संभालना

हम इनमें अंतर करते हैं:

• प्रमाणीकरण की समस्याएं, जैसे अमान्य API कुंजी।
• दर सीमाएं या अस्थायी क्षमता की कमी।
• असमर्थित मॉडल या अनुरोध पैरामीटर।
• समय सीमा पूरी होना और नेटवर्क त्रुटियां।
• सर्वर की विफलताएं।

हम तभी दोबारा प्रयास करते हैं जब अगले प्रयास के सफल होने की संभावना हो। प्रयासों की संख्या सीमित रखते हैं और बीच में उचित बढ़ता हुआ विराम देते हैं।

मॉडल संगतता

हम यह नहीं मानते कि हर मॉडल हर सुविधा समर्थित करता है।

टूल कॉलिंग, संरचित JSON आउटपुट, चित्र इनपुट, लंबे संदर्भ या स्ट्रीमिंग प्रतिक्रिया इस्तेमाल करने से पहले विशिष्ट मॉडल और एंडपॉइंट का समर्थन जांचते हैं।

खर्च पर नियंत्रण

हम हर मुख्य व्यावसायिक काम का खर्च ट्रैक करने की सलाह देते हैं।

मिसाल के तौर पर, सामग्री बनाने का टूल बनाते समय सिर्फ प्रति दस लाख टोकन की सूचीबद्ध कीमत नहीं, बल्कि “एक पूरा दस्तावेज़ बनाने का औसत खर्च कितना है?” पर ध्यान देना चाहिए।

तीन अतिरिक्त प्रयास मांगने वाला सस्ता मॉडल अंत में पैसे बचाए, यह जरूरी नहीं।

सुरक्षा और डेटा प्रबंधन

कुंजियां उजागर होने का जोखिम घटाने के लिए हम API कुंजियां सर्वर पर रखते हैं और जरूरत पड़ने पर तुरंत बदलते हैं।

API Hop समेत किसी भी तृतीय-पक्ष API प्लेटफॉर्म को ग्राहक डेटा भेजने से पहले उसकी डेटा प्रबंधन और संग्रहण नीतियां भी पढ़ते हैं।

संगत API का मतलब समान गोपनीयता नियम और सेवा प्रतिबद्धताएं नहीं है।

भरोसेमंद संचालन

महत्वपूर्ण कामों के लिए हम विफलता की बैकअप योजना जांचने और वैकल्पिक मॉडल द्वारा वही इनपुट संभाले जा सकने की पुष्टि करने की सलाह देते हैं।

वैकल्पिक मॉडल पर जाना तभी उपयोगी है जब वह मॉडल वास्तव में उस काम के साथ संगत हो।

8. एकीकृत API कब उपयोगी है?

हमारे अनुसार इन स्थितियों में एकीकृत API पर विचार करना उचित है:

• आप छोटा AI SaaS बना रहे हैं और मॉडल की तुलना करना चाहते हैं।
• आप GPT, Claude, Gemini और DeepSeek जांच रहे हैं।
• आप कई अलग बिलिंग खाते नहीं संभालना चाहते।
• उत्पाद तेजी से बदल रहा है और पहले इंटीग्रेशन आसान करना चाहते हैं।
• वास्तविक परीक्षण परिणामों के आधार पर अलग कामों के लिए अलग मॉडल चुनना चाहते हैं।

लेकिन एकीकृत API हमेशा सबसे अच्छा विकल्प नहीं होती।

अगर मॉडल प्रदाता की नई सुविधा गेटवे में अभी समर्थित नहीं है, प्रदाता से सीधा अनुबंध चाहिए, उसके समर्पित सहायता तंत्र पर निर्भर हैं, या संगत API में उपलब्ध न होने वाले उन्नत नियंत्रण चाहिए, तो आधिकारिक API का सीधा इस्तेमाल बेहतर हो सकता है।

इसी तरह, अगर आपकी टीम के पास पहले से परिपक्व आंतरिक गेटवे है जो भरोसेमंद संचालन, निगरानी और मॉडल इंटीग्रेशन की जरूरतें पूरी करता है, तो प्लेटफॉर्म बदलने से खास लाभ नहीं होगा।

हम चाहते हैं कि डेवलपर सिर्फ मार्केटिंग दावों के बजाय अपनी वास्तविक जरूरतों पर विकल्पों की तुलना करें।

9. अक्सर पूछे जाने वाले सवाल

क्या एक API कुंजी से GPT, Claude, Gemini और DeepSeek कॉल कर सकते हैं?

API Hop समर्थित मॉडलों के लिए साझा API कुंजी और प्लेटफॉर्म बैलेंस देता है। फिर भी हर कॉल के लिए वर्तमान सूची से सटीक मॉडल ID और उपयुक्त समर्थित एंडपॉइंट चाहिए।

API Hop इस्तेमाल करने के लिए क्या मौजूदा OpenAI SDK कोड बदलना होगा?

समर्थित OpenAI-संगत चैट अनुरोधों के लिए आम तौर पर वही OpenAI SDK इस्तेमाल कर सकते हैं। सिर्फ बेस URL, API कुंजी और मॉडल ID बदलनी होती है।

लेकिन प्रदाता की विशिष्ट उन्नत सुविधाएं इस्तेमाल करते हैं, तो कोड में बदलाव फिर भी करना पड़ सकता है।

क्या एकीकृत API हमेशा आधिकारिक API से सीधे जुड़ने से सस्ती होती है?

यह मॉडल, टोकन उपयोग, कैश की कीमतों, प्लेटफॉर्म शुल्क और वास्तविक कार्यभार पर निर्भर है।

हम सभी गेटवे को सस्ता मान लेने के बजाय एक ही काम के सेट के वास्तविक बिलों की तुलना सुझाते हैं।

API Hop हर मॉडल और कार्यभार के लिए कम कीमत या बेहतर आउटपुट गुणवत्ता का वादा नहीं करता। समान बिलिंग शर्तों में वर्तमान दरें तुलना करें, फिर अपने कामों पर आउटपुट की गुणवत्ता जांचें।

क्या ऐप चलते समय मॉडल अपने आप बदल सकता है?

हां। आपका ऐप हर अनुरोध के लिए अलग समर्थित मॉडल ID चुन सकता है।

लेकिन मॉडल के पैरामीटर, प्रतिक्रिया और सुविधाओं के अंतर फिर भी संभालने होंगे।

क्या API Hop सिर्फ टेक्स्ट मॉडल समर्थित करता है?

नहीं।

API Hop चित्र, वीडियो और कुछ डेटा API सेवाएं भी देता है।

इन सेवाओं के एंडपॉइंट और अनुरोध प्रारूप अलग हो सकते हैं, इसलिए इन्हें टेक्स्ट चैट API की तरह कॉल नहीं कर सकते।

आखिरी विचार

कई AI मॉडल इस्तेमाल करने का मतलब चार पूरी तरह अलग इंटीग्रेशन सिस्टम संभालना नहीं होना चाहिए।

API Hop में हमारा उद्देश्य साझा हिस्सों को आसान बनाना है: एक प्लेटफॉर्म, संभालने के लिए एक बैलेंस और समर्थित मॉडलों तक पहुंचने का एकीकृत तरीका।

लेकिन हम यह भी मानते हैं कि वास्तविक परिणाम मापना सबसे जरूरी है।

मॉडल या सेवा प्रदाता चुनने से पहले हम तीन सवालों के जवाब सुझाते हैं:

1. क्या यह काम करता है? ऐप को वास्तव में जिन API सुविधाओं की जरूरत है, उन्हें जांचें।
2. कितना खर्च होता है? सिर्फ विज्ञापित कीमतों के बजाय वास्तविक उपयोग से खर्च निकालें।
3. प्रदर्शन कैसा है? अपने प्रॉम्प्ट से विलंब, विफलताओं और आउटपुट गुणवत्ता की तुलना करें।

ऊपर हमने कोड और एक सरल परीक्षण वर्कफ़्लो दिया है, ताकि आप अपने खाते से खुद जांच सकें।

शुरू करने के लिए हमारी मॉडल सूची देखें, नवीनतम कीमतें जांचें और API दस्तावेज़ का पालन करें।

हमें जानकर खुशी होगी कि आप इससे क्या बनाते हैं।

API Hop टीम