Início / Guias / API de IA gratuita para bot no Discord ou Telegram

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:fast ordena 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.
Privacidade: o bot envia as mensagens dos usuários ao provedor que responde. Algumas camadas gratuitas podem usar os prompts para melhorar os próprios modelos. Informe aos seus usuários que um serviço de IA lê as mensagens deles. Leia quais APIs gratuitas de LLM treinam com os seus dados e remova da sua cadeia os provedores que você não aceita.

Estes modelos gratuitos têm a velocidade medida mais alta hoje. Muitos deles têm limites altos de requisições:

Modelos de chat gratuitos e rápidos
ModeloGratuito emContextoLimites gratuitos (melhor oferta)FerramentasVisão
Qwen3.8 27BBlazeAPI, ElectronHub, Gizmo +3 a mais262K30 req/min
250 req/dia
70,000 tokens/min
~6M
SimSim
GPT-OSS 20BApi.Airforce, Cloudflare Workers AI, Groq +4 a mais131K30 req/min
1,000 req/dia
8,000 tokens/min
200,000 tokens/dia
~6M
SimNão
Nemotron 3.5 LightningElectronHub, Gizmo, Kilo Gateway +2 a mais1M20 req/min
50 req/dia
50 req/day account-wide (1,000 after a $10 purchase)
SimNão
GPT-OSS 120BCloudflare Workers AI, ElectronHub, Groq +1 a mais131K30 req/min
1,000 req/dia
8,000 tokens/min
200,000 tokens/dia
~6M
SimNão
GPT-OSS 20B (via Groq)DreamPrompting131K100 req/min
5,000 req/dia
500,000 tokens/dia
500K tokens/day · 5,000 req/day
NãoNão
GPT-OSS Safeguard 20BGroq131K30 req/min
1,000 req/dia
8,000 tokens/min
200,000 tokens/dia
~6M
SimNão
Groq Compound MiniDreamPrompting131K100 req/min
5,000 req/dia
500,000 tokens/dia
500K tokens/day · 5,000 req/day
NãoNão
Gemini 3.5 Flash LiteElectronHub, Google AI Studio1M15 req/min
20 req/dia
250,000 tokens/min
~3M
SimSim
Step 3.7 FlashElectronHub256K$0.25/week shared recurring creditSimSim
Gemini 3.1 Flash-LiteDreamPrompting, Google AI Studio1M100 req/min
5,000 req/dia
500,000 tokens/dia
500K tokens/day · 5,000 req/day
SimSim

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

  1. Abra o Portal de Desenvolvedores do Discord e crie uma aplicação. Adicione um bot e copie o token.
  2. Na aba do bot, vá até Privileged Gateway Intents. Ative Message Content.
  3. Convide o bot para o seu servidor com o escopo bot e a permissão Send Messages.
  4. Defina o token na variável de ambiente DISCORD_TOKEN e 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

  1. No Telegram, abra o @BotFather e envie /newbot. Copie o token.
  2. Defina o token na variável de ambiente TELEGRAM_TOKEN.
  3. 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.

AgenteComando de configuraçãoO que ele grava
OpenClawnpx 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 Agentnpx 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

ProblemaCausaSolução
O bot do Discord lê mensagens vaziasO intent Message Content está desativadoAtive-o no portal e em intents.message_content
O bot responde às próprias mensagensNão há verificação de autores botsRetorne quando message.author.bot for verdadeiro
Erro 50035 do Discord em respostas longasA mensagem tem mais de 2000 caracteresDivida a resposta, como no código acima
"Todos os modelos gratuitos estão ocupados" à noiteTodas as chaves da cadeia atingiram o limite diárioAdicione chaves de mais provedores. Muitos limites diários são renovados à meia-noite UTC.
Respostas lentasUm modelo lento ou um histórico longoUse auto:fast e mantenha 10 mensagens ou menos
Connection refused no botO bot roda no Docker e usa localhostUse host.docker.internal ou uma rede Docker compartilhada
Use todos estes modelos com uma única chave. FreeLLMAPI é um roteador de código aberto e de hospedagem própria. Ele coloca todas estas camadas gratuitas atrás de um único endpoint compatível com OpenAI e passa para o próximo provedor quando um deles está com limite de requisições. Ver o catálogo ou colocar em produção.

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

Fontes

Todos os guias · Ver todos os modelos gratuitos