Token-based LLM API

Open-weight language models behind an OpenAI-compatible API, billed per token consumed, in Brazilian reais. Change the base_url in your code and start using it.

Pricing by model

Price per million tokens, in Brazilian reais. Input tokens (what you send: instructions, history and context) and output tokens (what the model generates) are counted separately, because they cost differently.

Price per million tokens, in Brazilian reais.

Use gpub-max, gpub-base, gpub-pro, gpub-plus, gpub-mini or gpub-fast in the model field. These are stable identifiers: when the model behind one of them is updated to a newer generation, your code keeps working unchanged. For convenience the model name is also accepted on input (kimi-k3, qwen3.8), and the response always echoes back the identifier you sent.

Cost simulator

Estimate what a call would cost before writing the first line of code. For reference, a short question (500 input tokens and 300 output tokens) lands in the fractions-of-a-cent range on the cheaper models.

Base URL and authentication

All endpoints live under the base URL below and follow the OpenAI API format:

https://gpubrasil.com.br/v1

Authenticate with the same API key you already use to provision GPUs, in the Authorization header. Treat it like a password.

Authorization: Bearer gpub_live_suachaveaqui

Code examples

cURL

curl https://gpubrasil.com.br/v1/chat/completions \
  -H "Authorization: Bearer gpub_live_suachaveaqui" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpub-plus",
    "messages": [
      { "role": "user", "content": "Explain what an LLM token is in two sentences." }
    ]
  }'

Response (abridged):
{
  "id": "chatcmpl-...",
  "object": "chat.completion",
  "model": "gpub-plus",
  "choices": [
    { "index": 0, "message": { "role": "assistant", "content": "..." }, "finish_reason": "stop" }
  ],
  "usage": {
    "prompt_tokens": 22,
    "completion_tokens": 64,
    "total_tokens": 86,
    "cost_brl": 0.0012
  }
}

The usage.cost_brl field is the cost of that call in Brazilian reais, already computed by the server. It is the same amount charged against your balance.

If you do not send max_tokens, we apply a default cap of 4,096 output tokens (32,768 maximum per call, and always bounded by what is left of the context window). It is the guard that keeps a single call from costing tens of reais — pass max_tokens explicitly when you need longer answers, otherwise the response comes back with finish_reason: "length".

Python (official OpenAI SDK)

Install with pip install openai. Only the base_url and the key change:

from openai import OpenAI

client = OpenAI(
    api_key="gpub_live_suachaveaqui",
    base_url="https://gpubrasil.com.br/v1",
)

response = client.chat.completions.create(
    model="gpub-plus",
    messages=[{"role": "user", "content": "Summarize this text in 3 bullets: ..."}],
)

print(response.choices[0].message.content)
print("Cost in R$:", response.usage.model_dump().get("cost_brl"))

Node.js (openai package)

Install with npm i openai:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "gpub_live_suachaveaqui",
  baseURL: "https://gpubrasil.com.br/v1",
});

const response = await client.chat.completions.create({
  model: "gpub-mini",
  messages: [{ role: "user", content: "Classify this comment as positive or negative: ..." }],
});

console.log(response.choices[0].message.content);
console.log("Cost in R$:", response.usage.cost_brl);

Streaming

With stream: true tokens arrive as they are generated. Ask for stream_options.include_usage to receive the usage block, with the cost in reais, in the final event of the stream:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "gpub_live_suachaveaqui",
  baseURL: "https://gpubrasil.com.br/v1",
});

const stream = await client.chat.completions.create({
  model: "gpub-max",
  messages: [{ role: "user", content: "Write a short script about..." }],
  stream: true,
  stream_options: { include_usage: true },
});

for await (const part of stream) {
  const text = part.choices?.[0]?.delta?.content;
  if (text) process.stdout.write(text);
  // The final event carries no text: it carries the usage and the cost in reais.
  if (part.usage) console.log("\nCost in R$:", part.usage.cost_brl);
}

Errors use the same OpenAI envelope: {"error":{"message","type","param","code"}}. The common ones: 402 insufficient balance (add funds and retry), 403 the programmatic API unlocks after your first confirmed deposit — until then, try the models in the dashboard playground, 429 rate limit (wait and retry) and 503 service temporarily unavailable.

When to use the token API and when to use a dedicated GPU

Internet access

In the dashboard playground, internet lookup is automatic. An ordinary conversation queries nothing and pays for tokens only; when your question needs current information — recent news, a number that moves during the day — the data is fetched before the question reaches the model, and the answer cites the value and the time of the lookup.

A R$ 0.05 access fee applies to those messages only, on top of the token cost. A badge on the reply marks when a lookup happened and where the data came from.

Tool support varies by model. gpub-max, gpub-pro and gpub-plus request tools and use the result correctly. gpub-fast requests tools but does not always make good use of the result. gpub-mini does not support tools — it ignores the request even when forced. For tool-using agents, pick gpub-max, gpub-pro or gpub-plus.

About max_tokens on reasoning models. Five of the six models — gpub-max, gpub-base, gpub-pro, gpub-plus and gpub-mini — think before they answer, and that text arrives in reasoning_content, separate from content. Those tokens are billed as output, whether or not they show up in the answer: they were generated. With a low ceiling the reasoning eats the whole budget, the answer comes back empty and the call ends with finish_reason: "length" — we measured gpub-max burning a full 1,024 tokens thinking without writing a single line. For a real question on these models, use at least 4,096 output tokens. Only gpub-fast answers straight through, with no reasoning phase.

Frequently asked questions