होम / गाइड / Python में मुफ़्त LLM API

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 सपोर्ट करते हैं और आज मापी गई सबसे तेज़ गति रखते हैं:

Tool calling वाले तेज़ मुफ़्त models
मॉडलमुफ़्त उपलब्धकॉन्टेक्स्टमुफ़्त सीमाएँ (सबसे अच्छा विकल्प)टूलविज़न
Qwen3.8 27BElectronHub, Groq, OVH AI Endpoints262K30 अनुरोध/मिनट
250 अनुरोध/दिन
70,000 टोकन/मिनट
~6M
हाँहाँ
Nemotron 3.5 LightningElectronHub, Kilo Gateway, OpenRouter1M20 अनुरोध/मिनट
50 अनुरोध/दिन
50 req/day account-wide (1,000 after a $10 purchase)
हाँनहीं
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 और131K30 अनुरोध/मिनट
1,000 अनुरोध/दिन
8,000 टोकन/मिनट
200,000 टोकन/दिन
~6M
हाँनहीं
GPT-OSS 20BCloudflare Workers AI, Groq, NVIDIA NIM +1 और131K30 अनुरोध/मिनट
1,000 अनुरोध/दिन
8,000 टोकन/मिनट
200,000 टोकन/दिन
~6M
हाँनहीं
GPT-OSS Safeguard 20BGroq131K30 अनुरोध/मिनट
1,000 अनुरोध/दिन
8,000 टोकन/मिनट
200,000 टोकन/दिन
~6M
हाँनहीं
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 अनुरोध/मिनट
20 अनुरोध/दिन
250,000 टोकन/मिनट
~3M
हाँहाँ
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditहाँहाँ
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 अनुरोध/मिनट
5,000 अनुरोध/दिन
500,000 टोकन/दिन
500K tokens/day · 5,000 req/day
हाँहाँ
Nemotron 3.5 Lightning 30BRequesty1M200 अनुरोध/दिन
200 rpd
हाँनहीं
Gemini 2.5 Flash-LiteElectronHub, Google AI Studio1M15 अनुरोध/मिनट
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 जवाबautoDashboard पर आपकी सेट की गई fallback chain का पालन करता है
वर्गीकरण, extraction, छोटे सारauto:fastसक्रिय models को मापी गई गति के हिसाब से क्रम में लगाता है
कठिन सवाल, code review, योजनाauto:smartसक्रिय models को intelligence के हिसाब से क्रम में लगाता है
Scheduled jobs जिन्हें पूरा होना ज़रूरी हैauto:reliableसक्रिय models को हाल की सफलता दर के हिसाब से क्रम में लगाता है
एक app के लिए अलग chainauto:<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 keyKeys page से key फिर से कॉपी करें
openai.APIConnectionErrorFreeLLMAPI नहीं चल रहा, या port गलत हैब्राउज़र में http://localhost:3001 खोलें
openai.NotFoundErrorBase URL में /v1 नहीं हैhttp://localhost:3001/v1 इस्तेमाल करें
openai.RateLimitErrorChain की सभी 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 इस्तेमाल न करें।

इनमें से हर एक का उपयोग एक ही कुंजी से करें। FreeLLMAPI एक ओपन-सोर्स, सेल्फ़-होस्टेड राउटर है। यह इन सभी मुफ़्त टियर को एक OpenAI-संगत एंडपॉइंट के पीछे रखता है। जब कोई एक सीमा पर पहुँचता है, तो यह अगले प्रदाता पर स्विच कर देता है। कैटलॉग देखें या शुरू करें.

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

क्या 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 सीमित करते हैं।

संबंधित गाइड

स्रोत

सभी गाइड · सभी मुफ़्त मॉडल देखें