Python में मुफ़्त LLM API
आधिकारिक openai Python package किसी भी OpenAI-compatible API के साथ काम करता है। आप base URL और key बदलते हैं। यह guide FreeLLMAPI इस्तेमाल करती है, जो एक key के पीछे 45 मुफ़्त provider tiers इकट्ठा करता है और जब कोई limit request रोकती है, तो अगले provider पर चला जाता है। नीचे का हर उदाहरण पूरा है और जैसा है वैसा ही चलता है।
कोड, मॉडल नाम और लाइव कैटलॉग लेबल अंग्रेज़ी में दिखाए गए हैं।
सेटअप
FreeLLMAPI इंस्टॉल करें। यह Docker में चलता है। http://localhost:3001 पर dashboard खोलें, Keys page पर दो या अधिक providers की मुफ़्त keys जोड़ें और unified key कॉपी करें। फिर Python package इंस्टॉल करें।
आपका Python code सिर्फ unified key इस्तेमाल करता है। Provider keys FreeLLMAPI में रहती हैं, उसके database में encrypted। अगर आप provider key बदलते या जोड़ते हैं, तो आपका code नहीं बदलता।
इंस्टॉल करें
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai
export FREELLMAPI_API_KEY=<unified-key>client.py
import os
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=3, # the SDK retries 429, 408, 409 and 5xx errors
timeout=60,
)
resp = client.chat.completions.create(
model="auto",
messages=[{"role": "user", "content": "Name three uses of Python in one line."}],
)
print(resp.choices[0].message.content)Model auto dashboard पर आपकी fallback chain का पालन करता है। आप auto:fast, auto:smart या auto:reliable भी इस्तेमाल कर सकते हैं, auto:coding जैसा profile, या एक fixed model ID।
Streaming और response headers
जवाब stream करें
from client import client
stream = client.chat.completions.create(
model="auto:fast",
messages=[{"role": "user", "content": "Write a haiku about Python."}],
stream=True,
)
for chunk in stream:
if chunk.choices:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()हर response में X-Routed-Via header होता है, जिसमें वह provider और model लिखा होता है जिसने जवाब दिया। SDK से headers पढ़ने के लिए with_raw_response इस्तेमाल करें और सामान्य object पाने के लिए parse() को call करें।
Routing headers पढ़ें
from client import client
raw = client.chat.completions.with_raw_response.create(
model="auto",
messages=[{"role": "user", "content": "hi"}],
)
print("Served by:", raw.headers.get("x-routed-via"))
print("Failed attempts:", raw.headers.get("x-fallback-attempts", "0"))
print(raw.parse().choices[0].message.content)Tool calling
OpenAI-style tools भेजें। Router उन्हें OpenAI-compatible providers को देता है और Gemini के लिए बदलता है। जवाब हर provider के लिए एक ही format में वापस आता है।
एक tool call और अंतिम जवाब
import json
from client import client
tools = [{
"type": "function",
"function": {
"name": "get_exchange_rate",
"description": "Get the exchange rate between two currencies.",
"parameters": {
"type": "object",
"properties": {
"base": {"type": "string"},
"quote": {"type": "string"},
},
"required": ["base", "quote"],
},
},
}]
messages = [{"role": "user", "content": "How many euros is 250 US dollars?"}]
first = client.chat.completions.create(model="auto", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"base": args["base"], "quote": args["quote"], "rate": 0.92} # your real lookup
messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
final = client.chat.completions.create(model="auto", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)कुछ providers tool call को सादे text के रूप में लौटाते हैं। FreeLLMAPI इन जवाबों को असली tool_calls में बदलता है, ताकि आपका code एक ही format पढ़े। हमेशा msg.tool_calls जाँचें, msg.content पढ़ने से पहले, क्योंकि model बिना tool के भी जवाब दे सकता है।
Tool calling वाला model इस्तेमाल करें। ये मुफ़्त models tools सपोर्ट करते हैं और आज मापी गई सबसे तेज़ गति रखते हैं:
| मॉडल | मुफ़्त उपलब्ध | कॉन्टेक्स्ट | मुफ़्त सीमाएँ (सबसे अच्छा विकल्प) | टूल | विज़न |
|---|---|---|---|---|---|
| Qwen3.8 27B | ElectronHub, Groq, OVH AI Endpoints | 262K | 30 अनुरोध/मिनट 250 अनुरोध/दिन 70,000 टोकन/मिनट ~6M | हाँ | हाँ |
| Nemotron 3.5 Lightning | ElectronHub, Kilo Gateway, OpenRouter | 1M | 20 अनुरोध/मिनट 50 अनुरोध/दिन 50 req/day account-wide (1,000 after a $10 purchase) | हाँ | नहीं |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 और | 131K | 30 अनुरोध/मिनट 1,000 अनुरोध/दिन 8,000 टोकन/मिनट 200,000 टोकन/दिन ~6M | हाँ | नहीं |
| GPT-OSS 20B | Cloudflare Workers AI, Groq, NVIDIA NIM +1 और | 131K | 30 अनुरोध/मिनट 1,000 अनुरोध/दिन 8,000 टोकन/मिनट 200,000 टोकन/दिन ~6M | हाँ | नहीं |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 अनुरोध/मिनट 1,000 अनुरोध/दिन 8,000 टोकन/मिनट 200,000 टोकन/दिन ~6M | हाँ | नहीं |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 अनुरोध/मिनट 20 अनुरोध/दिन 250,000 टोकन/मिनट ~3M | हाँ | हाँ |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | हाँ | हाँ |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 अनुरोध/मिनट 5,000 अनुरोध/दिन 500,000 टोकन/दिन 500K tokens/day · 5,000 req/day | हाँ | हाँ |
| Nemotron 3.5 Lightning 30B | Requesty | 1M | 200 अनुरोध/दिन 200 rpd | हाँ | नहीं |
| Gemini 2.5 Flash-Lite | ElectronHub, Google AI Studio | 1M | 15 अनुरोध/मिनट 20 अनुरोध/दिन 250,000 टोकन/मिनट ~3M | हाँ | हाँ |
146 मिलते-जुलते मुफ़्त मॉडल में से 10 दिखाए जा रहे हैं। सभी मॉडल देखें.
FreeLLMAPI कैटलॉग से लाइव डेटा (संस्करण 2026.11.19, जाँच 2026-11-19)। मुफ़्त सीमाएँ अक्सर बदलती हैं। कैटलॉग की हर दिन जाँच होती है।
मुफ़्त limits के भीतर async batches
AsyncOpenAI एक साथ कई requests भेजता है। मुफ़्त tiers प्रति मिनट requests सीमित करते हैं, इसलिए semaphore से एक साथ चलने वाली requests की संख्या सीमित करें। यह उदाहरण तब भी retry करता है जब हर provider अपनी limit पर हो।
batch.py
import asyncio
import os
import openai
from openai import AsyncOpenAI
client = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
)
limit = asyncio.Semaphore(4) # at most 4 requests at a time
async def summarize(text: str) -> str:
async with limit:
for attempt in range(5):
try:
resp = await client.chat.completions.create(
model="auto:fast",
messages=[
{"role": "system", "content": "Summarize in one sentence."},
{"role": "user", "content": text},
],
)
return resp.choices[0].message.content
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
await asyncio.sleep(min(wait, 60))
return "ERROR: rate limited"
async def main():
docs = [f"Document {i}: Python is a programming language." for i in range(20)]
results = await asyncio.gather(*(summarize(d) for d in docs))
for r in results:
print(r)
await client.close()
asyncio.run(main())Router 429 तभी लौटाता है जब chain की हर key अपनी limit पर हो। Response में फिर Retry-After header होता है। बड़े batches के लिए छोटा semaphore मान और ज़्यादा provider keys सबसे अच्छे परिणाम देते हैं।
हर काम के लिए model string चुनें
Model string router को बताती है कि model कैसे चुनना है। हर call में अलग string इस्तेमाल की जा सकती है। Dashboard बदलने की ज़रूरत नहीं है।
| काम | Model string | कारण |
|---|---|---|
| उपयोगकर्ताओं के लिए chat जवाब | auto | Dashboard पर आपकी सेट की गई fallback chain का पालन करता है |
| वर्गीकरण, extraction, छोटे सार | auto:fast | सक्रिय models को मापी गई गति के हिसाब से क्रम में लगाता है |
| कठिन सवाल, code review, योजना | auto:smart | सक्रिय models को intelligence के हिसाब से क्रम में लगाता है |
| Scheduled jobs जिन्हें पूरा होना ज़रूरी है | auto:reliable | सक्रिय models को हाल की सफलता दर के हिसाब से क्रम में लगाता है |
| एक app के लिए अलग chain | auto:<profile> | नाम वाली fallback chain इस्तेमाल करता है |
| Tests जो दोहराए जा सकें | एक fixed model ID | हर बार एक ही model, लेकिन उस model की limit पर रुक जाता है |
यह देखने के लिए कि आपकी keys अभी कौन से models call कर सकती हैं, filter के साथ model list माँगें। पूरी list में वे models भी हैं जिनकी अभी कोई key नहीं है।
वे models सूचीबद्ध करें जो अभी जवाब दे सकते हैं
import os
import httpx
r = httpx.get(
"http://localhost:3001/v1/models",
params={"execution_status": "ready"},
headers={"Authorization": f"Bearer {os.environ['FREELLMAPI_API_KEY']}"},
timeout=30,
)
r.raise_for_status()
for m in r.json()["data"]:
print(m["id"])जिस model का status exhausted है, उसकी keys हैं, लेकिन सभी अभी अपनी limit पर हैं। Cooldowns खत्म होने पर status साफ़ हो जाता है। जिस model का status needsKey है, उसकी कोई सक्रिय key नहीं है।
एक बातचीत के लिए X-Session-Id header को extra_headers के साथ भेजें। तब FreeLLMAPI उस बातचीत को 30 मिनट तक एक ही model पर रखता है। Header न होने पर वह पहले user message के hash को session key के रूप में इस्तेमाल करता है।
Embeddings
Text embed करें
from client import client
resp = client.embeddings.create(
model="bge-m3", # one embedding family
input=["Python is a programming language.", "A snake is a reptile."],
)
print(len(resp.data), "vectors of", len(resp.data[0].embedding), "dimensions")Embedding failover कभी model नहीं बदलता। वह सिर्फ उन providers के बीच जाता है जो एक ही family देते हैं, इसलिए आपके vectors संगत रहते हैं। मान auto dashboard पर सेट की गई default family इस्तेमाल करता है।
एक input list में कई texts भेजें। 32 texts वाली एक request मुफ़्त limit से एक request लेती है, 32 नहीं। हर text को family की अधिकतम input से छोटा रखें। Vectors के साथ family नाम सेव करें, ताकि बाद में queries भी उसी family से embed हों।
Errors और समाधान
| Exception | कारण | समाधान |
|---|---|---|
openai.AuthenticationError | गलत unified key | Keys page से key फिर से कॉपी करें |
openai.APIConnectionError | FreeLLMAPI नहीं चल रहा, या port गलत है | ब्राउज़र में http://localhost:3001 खोलें |
openai.NotFoundError | Base URL में /v1 नहीं है | http://localhost:3001/v1 इस्तेमाल करें |
openai.RateLimitError | Chain की सभी keys अपनी limit पर हैं | Providers जोड़ें, concurrency घटाएँ, Retry-After का इंतज़ार करें |
openai.BadRequestError, auto:name के साथ | Profile नाम मौजूद नहीं है | Dashboard पर profile नाम जाँचें |
Images के साथ openai.UnprocessableEntityError (422) | आपकी chain में कोई vision model नहीं है | Fallback chain में एक vision model चालू करें |
मुफ़्त tiers पर कोई SLA नहीं है। Latency दिन भर बदलती है। सबसे मज़बूत models अपनी दैनिक limits पहले पहुँचते हैं, और कई limits आधी रात UTC पर reset होती हैं। जिस service को तय समय में जवाब देना हो, उसके लिए मुफ़्त gateway इस्तेमाल न करें।
अक्सर पूछे जाने वाले प्रश्न
क्या Python के लिए कोई मुफ़्त LLM API है?
हाँ। कई providers के मुफ़्त tiers हैं जो openai Python package के साथ काम करते हैं। FreeLLMAPI उन्हें एक base URL और एक key के पीछे जोड़ता है, और providers के बीच failover करता है।
अलग base URL के साथ openai Python library कैसे इस्तेमाल करें?
OpenAI() या AsyncOpenAI() को base_url दें, उदाहरण के लिए base_url="http://localhost:3001/v1"। अपनी gateway key को api_key के रूप में दें।
Python में rate limit errors कैसे संभालें?
Client पर max_retries सेट करें। openai.RateLimitError को पकड़ें, Retry-After header पढ़ें और इंतज़ार करें। asyncio semaphore से concurrency सीमित करें।
क्या Python में मुफ़्त LLM APIs के साथ streaming काम करती है?
हाँ। stream=True दें और chunk.choices[0].delta.content पढ़ें। FreeLLMAPI हर provider के लिए OpenAI format में stream करता है।
क्या मुफ़्त LLM API के साथ async Python इस्तेमाल किया जा सकता है?
हाँ। वही base_url और key के साथ AsyncOpenAI इस्तेमाल करें। समानांतर requests की संख्या कम रखें, क्योंकि मुफ़्त tiers प्रति मिनट requests सीमित करते हैं।
संबंधित गाइड
- मुफ़्त OpenAI-compatible API base URLs
- LangChain के लिए मुफ़्त LLM API
- AI एजेंट्स के लिए मुफ़्त LLM API
- Function calling वाला मुफ़्त LLM API
- मुफ़्त LLM API रेट सीमाएँ
स्रोत
- OpenAI Python SDK README (async, retries, raw responses, errors) (जाँचा गया 20 November 2026)
- FreeLLMAPI docs: REST API (chat, streaming, tool calling, embeddings, headers) (जाँचा गया 20 November 2026)
- FreeLLMAPI docs: degraded mode and failover (जाँचा गया 20 November 2026)