Python में TTS API कुंजी: सेटअप, स्ट्रीमिंग, JSON मोड

जांचें कि कुंजी क्या खोलती है

जो लोग tts api key python उदाहरण खोजते हैं, वे आमतौर पर टेक्स्ट को बोली गई ऑडियो में बदलना चाहते हैं। इस सेवा से कुंजी ऐसा नहीं करती। यह एक टेक्स्ट LLM के लिए अनुरोधों को प्रमाणीकृत करती है: POST /v1/chat/completions और GET /v1/models, मॉडल uncensored का उपयोग करके। कोई स्पीच सिंथेसिस, कोई ऑडियो अपलोड और कोई एम्बेडिंग नहीं है।

यदि यह आपके प्रोजेक्ट के लिए उपयुक्त है, उदाहरण के लिए क्योंकि आप स्क्रिप्ट, संवाद या नैरेशन जनरेट करते हैं जिसे आप एक अलग स्पीच टूल में पास करते हैं, तो इस पृष्ठ का शेष भाग आपको काम करने वाला Python देता है। यदि आपको API स्वयं से ऑडियो आउटपुट की आवश्यकता है, तो यह गलत सेवा है, और बेहतर है कि आप यह अभी जान लें। docs सटीक फीचर सेट सूचीबद्ध करते हैं।

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

इसका अनुसरण करने के लिए आपको Python 3.9 या नया और एक कुंजी की आवश्यकता है। API कुंजी पेज पर साइन अप करें और क्लिक-ऑन $0.50 ट्रायल क्रेडिट दावा करें; यह 7 दिनों के लिए लागू रहता है और कार्ड की आवश्यकता नहीं है।

कुंजी को स्टोर करें और पैकेज इंस्टॉल करें

कुंजी को किसी फ़ाइल में कभी न लिखें जिसे आप कमीट करेंगे। इसे एक एन्वायरमेंट वेरिएबल में डालें और रनटाइम पर इसे पढ़ें।

Copy# base URL used below: https://api.ttsapihub.com/v1 , model: uncensored
pip install openai
export API_KEY="paste-your-key-here"

Windows PowerShell पर समतुल्य है $env:API_KEY = "paste-your-key-here"। एक प्रोजेक्ट के लिए, .env फ़ाइल जिसे python-dotenv जैसे पैकेज के साथ लोड किया जाता है, एक सामान्य पैटर्न है, जब तक कि .env आपकी .gitignore में हो।

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

क्लाइएंट बनाएं और पहला कॉल करें

आधिकारिक पैकेज एक base_url स्वीकार करता है। बाकी सब कुछ सामान्य OpenAI कॉल शैली है।

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.ttsapihub.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short narration scripts."},
        {"role": "user", "content": "Draft a 40-word intro for a podcast about night trains."},
    ],
    temperature=0.8,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

usage ऑब्जेक्ट दिखाता है कि कॉल ने कितने टोकन उपयोग किए, ताकि आप लागत की गणना कर सकें: इनपुट टोकन × प्रति मिलियन $0.15, प्लस आउटपुट टोकन × प्रति मिलियन $0.50। यदि ऊपर की कॉल ने 60 इनपुट टोकन और 80 आउटपुट टोकन उपयोग किए, तो लागत $0.000009 प्लस $0.00004 होती है, जो कुल $0.000049 है। विफल या अस्वीकृत अनुरोधों के लिए चार्ज नहीं किया जाता है।

max_tokens वैकल्पिक है। इसके बिना, पूर्णता 100,000-टोकन विंडो में शेष जो कुछ भी है, उसका उपयोग कर सकती है, इसलिए लंबाई और लागत पर कठोर सीमा तय करने के लिए इसे सेट करें।

प्रतिक्रिया को स्ट्रीम करें

स्ट्रीमिंग सर्वर-सेंट इवेंट्स का उपयोग करके टोकन को जनरेट होते ही लौटाती है। stream=True सेट करें और पुनरावृत्ति करें।

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Describe a rainy station platform in four sentences."}],
    stream=True,
)

parts = []
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta.content or ""
    parts.append(delta)
    print(delta, end="", flush=True)

text = "".join(parts)

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

JSON मांगें और टूल्स कॉल करें

JSON मोड

प्रतिक्रिया को पार्स करने योग्य बनाने के लिए response_format को एक JSON ऑब्जेक्ट पर सेट करें। साथ ही, प्रॉम्प्ट में मॉडल को बताएं कि आपको JSON चाहिए; सेटिंग फॉर्मेट को बाध्य करती है, और प्रॉम्प्ट उसे आकार बताता है।

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": str, \"beats\": [str]}"},
        {"role": "user", "content": "Outline a three-beat radio drama about a lost key."},
    ],
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], len(data["beats"]))

फिर भी json.loads को एक try ब्लॉक में लपेटें। एक प्रतिक्रिया जो max_tokens पर पहुँचती है, एक ऑब्जेक्ट के बीच में कट सकती है।

टूल कॉलिंग

tools और वैकल्पिक रूप से tool_choice पास करें। जब मॉडल टूल का अनुरोध करता है, तो उसे स्वयं चलाएं और role: "tool" वाले संदेश के रूप में परिणाम वापस भेजें।

Copyimport json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a text",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = len(args["text"].split())
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

एक बातचीत रखें और टोकन बजट पर नज़र रखें

API स्टेटलेस है। यदि आप एक ऐसी चैट चाहते हैं जो कहा गया याद रखे, तो आप संदेश लिस्ट को अपने प्रोग्राम में रखते हैं और हर कॉल के साथ उसे भेजते हैं। एक छोटा क्लास काम करता है, और यह इतिहास को कैप करने के लिए सही जगह भी है ताकि लागत बढ़ न जाए।

Copyimport os
from openai import OpenAI

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"])

history = [{"role": "system", "content": "You are a dialogue writer. Keep replies under 120 words."}]

def say(user_text, keep_last=12):
    history.append({"role": "user", "content": user_text})
    # keep the system message plus the most recent turns
    trimmed = [history[0]] + history[1:][-keep_last:]
    resp = client.chat.completions.create(model="uncensored", messages=trimmed, max_tokens=250)
    reply = resp.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply, resp.usage.total_tokens

print(say("Open a scene in a ticket office at closing time.")[0])

ट्रिमिंग पैसे के मामले में विंडो से अधिक महत्वपूर्ण है। मॉडल कुल मिलाकर 100,000 टोकन तक स्वीकार करता है, लेकिन यदि हर टर्न इतिहास के 30,000 टोकन फिर से भेजता है, तो हर कॉल की इनपुट लागत अकेले $0.0045 होती है (30,000 × प्रति मिलियन $0.15)। ऐसे 50 टर्न जोड़कर एकल आउटपुट टोकन गिने जाने से पहले ही $0.225 हो जाते हैं। पिछले 12 टर्न को रखना, या पुराने टर्न को एक छोटी नोट में सारांशित करना, आमतौर पर गुणवत्ता बनाए रखता है और बिल को तेजी से कम करता है।

कंकरेंसी डिज़ाइन करने के लिए दूसरी चीज है। यदि आपका प्रोग्राम एक साथ कई उपयोगकर्ताओं की सेवा करता है, तो एक सेमाफोर जो आपके कुंजी की सीमा के लिए आकार दिया गया है (पूर्ण कुंजी के लिए 8, ट्रायल कुंजी के लिए 2) आपको concurrency त्रुटि से बचाता है। सीमा से ऊपर कॉल आपकी अपनी कतार में प्रतीक्षा करती हैं, जो 429 पर पुन: प्रयास करने से अधिक मित्रवत है।

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

अंत में, प्रत्येक प्रतिक्रिया से अनुरोध ID लॉग करें। जब कोई कॉल अजीब व्यवहार करता है, तो वह ID सपोर्ट को सटीक अनुरोध की ओर इशारा करने का सबसे तेज़ तरीका है।

लिमिट्स, त्रुटियों और बैलेंस को हैंडल करें

एक पूर्ण कुंजी 8 समानांतर अनुरोध और प्रति मिनट 300 अनुरोध की अनुमति देती है। ट्रायल कुंजी 2 और 60 की अनुमति देती है। पहले को पार करने पर HTTP 429 त्रुटि कोड concurrency के साथ लौटाया जाता है, और दूसरे को पार करने पर 429 rate_limited के साथ लौटाया जाता है। अस्थायी ओवरलोड भी Retry-After: 5 हेडर के साथ 429 लौटाता है।

OpenAI पैकेज कुछ विफलताओं को स्वयं पुन: प्रयास करता है, और आप max_retries के साथ उसे बढ़ा सकते हैं। एक बैच जॉब के लिए, समानांतर कार्य पर अपनी स्वयं की सीमा भी जोड़ें, ताकि आप पुन: प्रयासों पर निर्भर रहने के बजाय कंकरेंसी सीमा के नीचे रहें।

Copyimport os
from openai import OpenAI, RateLimitError

client = OpenAI(base_url="https://api.ttsapihub.com/v1", api_key=os.environ["API_KEY"], max_retries=3)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "One sentence about trains."}],
    max_tokens=60,
)
print("balance:", raw.headers.get("X-Balance-USD"))
print("request id:", raw.headers.get("X-Request-Id"))
print(raw.parse().choices[0].message.content)

प्रतिक्रिया हेडर X-Request-Id और X-Balance-USD लॉग में उपयोगी हैं। सहायता से संपर्क करते समय अनुरोध ID का उल्लेख करें। लागत मूल्य निर्धारण पृष्ठ पर दी गई है: 1M इनपुट टोकन के लिए $0.15 और 1M आउटपुट टोकन के लिए $0.50, $20 से $500 तक टॉप-अप और $50, $100 और $200 पर क्रमशः 5%, 10% और 15% बोनस। कार्ड (Visa, Mastercard, Apple Pay, Google Pay) और क्रिप्टो (TRC20 पर USDT, Base पर USDC) स्वीकार किए जाते हैं। प्रॉम्प्ट को प्रशिक्षण के लिए उपयोग नहीं किया जाता है। मॉडल कानूनी वयस्क उपयोग के लिए है, और नाबालिगों से जुड़े यौन सामग्री की कभी अनुमति नहीं है।

अधिक गाइड

• SillyTavern के लिए मुफ़्त API: ट्रायल क्रेडिट और सेटअप
• TTS API बेस यूआरएल: यह क्या है और क्या दर्ज करें
• Elevenlabs API चेकलिस्ट: बिना सेंसर TTS पाइपलाइन