API de IA gratuita para bot no Discord ou Telegram
Um bot de chat envia uma requisição ao modelo para cada mensagem. Em um servidor movimentado, uma camada gratuita atinge o limite em minutos. Este guia conecta um bot do Discord e um bot do Telegram ao FreeLLMAPI. O FreeLLMAPI reúne 45 camadas gratuitas de provedores atrás de uma única chave compatível com OpenAI e passa para o próximo provedor quando um limite interrompe uma requisição. O código é em Python e está completo.
O código, os nomes dos modelos e os rótulos do catálogo ao vivo são exibidos em inglês.
Planeje os limites primeiro
As camadas gratuitas limitam as requisições por minuto e por dia. Um bot em um servidor com 200 usuários ativos pode enviar milhares de requisições por dia. O failover distribui essas requisições entre todas as suas chaves, mas o total continua sendo a soma dos limites gratuitos.
- Responda somente quando for chamado. No Discord, responda somente a menções. Em grupos do Telegram, responda somente a comandos ou respostas.
- Limite cada usuário. Permita uma requisição por usuário a cada poucos segundos.
- Mantenha o histórico curto. Envie as últimas 10 mensagens, e não o histórico completo do canal.
- Use uma rota rápida.
auto:fastordena os modelos pela velocidade. Os usuários do chat esperam menos. - Falhe com educação. Quando todas as chaves estiverem no limite, peça ao usuário que tente de novo mais tarde.
Estes modelos gratuitos têm a velocidade medida mais alta hoje. Muitos deles têm limites altos de requisições:
| Modelo | Gratuito em | Contexto | Limites gratuitos (melhor oferta) | Ferramentas | Visão |
|---|---|---|---|---|---|
| Qwen3.8 27B | BlazeAPI, ElectronHub, Gizmo +3 a mais | 262K | 30 req/min 250 req/dia 70,000 tokens/min ~6M | Sim | Sim |
| GPT-OSS 20B | Api.Airforce, Cloudflare Workers AI, Groq +4 a mais | 131K | 30 req/min 1,000 req/dia 8,000 tokens/min 200,000 tokens/dia ~6M | Sim | Não |
| Nemotron 3.5 Lightning | ElectronHub, Gizmo, Kilo Gateway +2 a mais | 1M | 20 req/min 50 req/dia 50 req/day account-wide (1,000 after a $10 purchase) | Sim | Não |
| GPT-OSS 120B | Cloudflare Workers AI, ElectronHub, Groq +1 a mais | 131K | 30 req/min 1,000 req/dia 8,000 tokens/min 200,000 tokens/dia ~6M | Sim | Não |
| GPT-OSS 20B (via Groq) | DreamPrompting | 131K | 100 req/min 5,000 req/dia 500,000 tokens/dia 500K tokens/day · 5,000 req/day | Não | Não |
| GPT-OSS Safeguard 20B | Groq | 131K | 30 req/min 1,000 req/dia 8,000 tokens/min 200,000 tokens/dia ~6M | Sim | Não |
| Groq Compound Mini | DreamPrompting | 131K | 100 req/min 5,000 req/dia 500,000 tokens/dia 500K tokens/day · 5,000 req/day | Não | Não |
| Gemini 3.5 Flash Lite | ElectronHub, Google AI Studio | 1M | 15 req/min 20 req/dia 250,000 tokens/min ~3M | Sim | Sim |
| Step 3.7 Flash | ElectronHub | 256K | $0.25/week shared recurring credit | Sim | Sim |
| Gemini 3.1 Flash-Lite | DreamPrompting, Google AI Studio | 1M | 100 req/min 5,000 req/dia 500,000 tokens/dia 500K tokens/day · 5,000 req/day | Sim | Sim |
Mostrando 10 de 215 modelos gratuitos correspondentes. Ver todos os modelos.
Dados ao vivo do catálogo FreeLLMAPI (versão 2026.11.19, verificado em 2026-11-19). Os limites gratuitos mudam com frequência. O catálogo é verificado todos os dias.
Código compartilhado: a chamada ao modelo
Os dois bots usam o mesmo módulo. Ele mantém um histórico curto para cada chat, envia um ID de sessão por chat e trata os limites de taxa. Instale o FreeLLMAPI primeiro e copie a chave unificada na página Keys do painel.
Instalação
curl -fsSL https://freellmapi.co/install.sh | bash
python3 -m pip install -U openai discord.py python-telegram-bot
export FREELLMAPI_API_KEY=<unified-key>brain.py
import asyncio
import os
import time
from collections import defaultdict, deque
import openai
from openai import AsyncOpenAI
llm = AsyncOpenAI(
base_url="http://localhost:3001/v1",
api_key=os.environ["FREELLMAPI_API_KEY"],
max_retries=2,
timeout=60,
)
SYSTEM = "You are a helpful chat bot. Answer in short paragraphs."
history = defaultdict(lambda: deque(maxlen=10)) # chat id -> last 10 messages
last_call = {} # user id -> time of the last request
COOLDOWN_S = 5
async def ask(chat_id: str, user_id: str, text: str) -> str:
now = time.monotonic()
if now - last_call.get(user_id, 0) < COOLDOWN_S:
return "Please wait a few seconds before the next question."
last_call[user_id] = now
turns = history[chat_id]
turns.append({"role": "user", "content": text[:4000]})
messages = [{"role": "system", "content": SYSTEM}, *turns]
for attempt in range(3):
try:
resp = await llm.chat.completions.create(
model="auto:fast",
messages=messages,
max_tokens=800,
extra_headers={"X-Session-Id": f"chat-{chat_id}"},
)
answer = resp.choices[0].message.content or "(no answer)"
turns.append({"role": "assistant", "content": answer})
return answer
except openai.RateLimitError as err:
header = err.response.headers.get("retry-after", "")
wait = int(header) if header.isdigit() else 2 ** attempt
if wait > 30:
break
await asyncio.sleep(wait)
except openai.APIError:
break
turns.pop() # forget the unanswered question
return "All free models are busy now. Please try again later."
def split(text: str, size: int) -> list[str]:
return [text[i:i + size] for i in range(0, len(text), size)] or [""]O cabeçalho X-Session-Id mantém um chat no mesmo modelo por 30 minutos. Assim, o bot mantém o mesmo estilo em uma conversa. Se esse modelo atingir o limite, o roteador passa para outro modelo, que recebe o mesmo histórico.
O histórico e os períodos de espera ficam na memória. Eles são perdidos quando o bot reinicia. Para um bot que precisa lembrar conversas longas, guarde o histórico em um banco de dados, como SQLite ou Redis.
Bot do Discord com discord.py
- Abra o Portal de Desenvolvedores do Discord e crie uma aplicação. Adicione um bot e copie o token.
- Na aba do bot, vá até Privileged Gateway Intents. Ative Message Content.
- Convide o bot para o seu servidor com o escopo
bote a permissão Send Messages. - Defina o token na variável de ambiente
DISCORD_TOKENe execute o script.
discord_bot.py
import os
import discord
from brain import ask, split
intents = discord.Intents.default()
intents.message_content = True
client = discord.Client(intents=intents)
@client.event
async def on_ready():
print(f"Logged in as {client.user}")
@client.event
async def on_message(message: discord.Message):
if message.author.bot or client.user not in message.mentions:
return
text = message.content
for tag in (f"<@{client.user.id}>", f"<@!{client.user.id}>"):
text = text.replace(tag, "")
text = text.strip()
if not text:
return
async with message.channel.typing():
answer = await ask(str(message.channel.id), str(message.author.id), text)
parts = split(answer, 2000) # Discord limit: 2000 characters
await message.reply(parts[0])
for part in parts[1:]:
await message.channel.send(part)
client.run(os.environ["DISCORD_TOKEN"])Bot do Telegram com python-telegram-bot
- No Telegram, abra o @BotFather e envie
/newbot. Copie o token. - Defina o token na variável de ambiente
TELEGRAM_TOKEN. - Execute o script. Envie uma mensagem para o seu bot.
telegram_bot.py
import os
from telegram import Update
from telegram.constants import ChatAction
from telegram.ext import Application, ContextTypes, MessageHandler, filters
from brain import ask, split
async def on_text(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
chat_id = update.effective_chat.id
await context.bot.send_chat_action(chat_id=chat_id, action=ChatAction.TYPING)
answer = await ask(str(chat_id), str(update.effective_user.id), update.message.text)
for part in split(answer, 4096): # Telegram limit: 4096 characters
await update.message.reply_text(part)
def main() -> None:
app = Application.builder().token(os.environ["TELEGRAM_TOKEN"]).build()
app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, on_text))
app.run_polling(allowed_updates=Update.ALL_TYPES)
if __name__ == "__main__":
main()O status de digitação no Telegram dura 5 segundos ou menos. Para modelos lentos, envie a ação de chat de novo durante requisições longas. O código usa a versão 22 do python-telegram-bot, que é totalmente assíncrona.
Agentes de bot prontos
Se você não quiser escrever um bot, dois agentes podem responder no Discord e no Telegram e usar o FreeLLMAPI como modelo. O FreeLLMAPI tem um comando de configuração para cada um. Cada comando aceita --dry-run e faz um backup da configuração antes.
| Agente | Comando de configuração | O que ele grava |
|---|---|---|
| OpenClaw | npx freellmapi setup-openclaw --url http://localhost:3001 --api-key <unified-key> | Um provedor freellmapi em ~/.openclaw/openclaw.json, com o modelo padrão freellmapi/auto |
| Hermes Agent | npx freellmapi setup-hermes --url http://localhost:3001 --api-key <unified-key> | Um bloco de modelo personalizado em ~/.hermes/config.yaml |
Um gateway do OpenClaw ou do Hermes em execução precisa ser reiniciado depois do comando de configuração.
Execute o bot e o FreeLLMAPI no mesmo computador ou servidor. Assim, o bot acessa o gateway em localhost, e a porta do gateway continua fechada para a internet. Um servidor pequeno ou um Raspberry Pi basta para os dois.
Solução de problemas
| Problema | Causa | Solução |
|---|---|---|
| O bot do Discord lê mensagens vazias | O intent Message Content está desativado | Ative-o no portal e em intents.message_content |
| O bot responde às próprias mensagens | Não há verificação de autores bots | Retorne quando message.author.bot for verdadeiro |
| Erro 50035 do Discord em respostas longas | A mensagem tem mais de 2000 caracteres | Divida a resposta, como no código acima |
| "Todos os modelos gratuitos estão ocupados" à noite | Todas as chaves da cadeia atingiram o limite diário | Adicione chaves de mais provedores. Muitos limites diários são renovados à meia-noite UTC. |
| Respostas lentas | Um modelo lento ou um histórico longo | Use auto:fast e mantenha 10 mensagens ou menos |
Connection refused no bot | O bot roda no Docker e usa localhost | Use host.docker.internal ou uma rede Docker compartilhada |
Perguntas frequentes
Existe uma API de IA gratuita para bot do Discord?
Sim. Vários provedores têm camadas gratuitas que funcionam com o pacote openai para Python. O FreeLLMAPI as combina atrás de uma única chave, então um bot movimentado pode usar os limites de muitos provedores.
Posso criar um bot de IA gratuito para o Telegram?
Sim. Use python-telegram-bot para o bot e uma API gratuita compatível com OpenAI para as respostas. O código desta página está completo.
Como impeço que o meu bot de IA atinja os limites de taxa?
Responda somente a menções ou comandos, limite cada usuário a uma requisição a cada poucos segundos, mantenha o histórico curto e adicione chaves de mais provedores.
Por que o meu bot do Discord recebe conteúdo de mensagem vazio?
O intent Message Content está desativado. Ative-o no Developer Portal, na aba do bot, e defina intents.message_content = True no código.
O que acontece quando todos os modelos gratuitos estão no limite?
O FreeLLMAPI retorna o erro 429 com um cabeçalho Retry-After. O código do bot captura o erro e pede ao usuário que tente de novo mais tarde.
Guias relacionados
- LLM gratuito em Python
- Limites de taxa da API LLM gratuita
- URLs base de APIs gratuitas compatíveis com OpenAI
- API LLM gratuita para agentes de IA
- API gratuita de LLM sem cartão de crédito
Fontes
- discord.py docs: quickstart (verificado em 20 November 2026)
- discord.py docs: privileged intents (verificado em 20 November 2026)
- Discord developer docs: message resource (2000 character content limit) (verificado em 20 November 2026)
- python-telegram-bot v22 docs: echobot example (verificado em 20 November 2026)
- Telegram Bot API: sendMessage and sendChatAction (verificado em 20 November 2026)
- FreeLLMAPI docs: clients (OpenClaw, Hermes Agent, context handoff) (verificado em 20 November 2026)