Documentação

Referência da API

Guia completo para integrar o Reqpoint. Se você já usa a API da OpenAI, a migração é trocar a base URL e a key.

Visão geral

O Reqpoint transforma sua assinatura ChatGPT Plus/Pro em um endpoint REST compatível com o formato da OpenAI.

Qualquer ferramenta, SDK ou automação que funciona com a API da OpenAI funciona com o Reqpoint — basta trocar a URL base e a API key.

As requisições consomem da sua própria assinatura ChatGPT, sem custo adicional por token.

Base URL

bash

https://api.reqpoint.online/v1

Autenticação

Envie sua API key no header Authorization. Gere sua key no dashboard após conectar o ChatGPT.

bash

Authorization: Bearer rqp_sua_api_key_aqui

GET /models

Os modelos disponíveis dependem do plano da conta ChatGPT que você conectou. Uma conta Plus enxerga mais modelos que uma conta gratuita, e a lista muda conforme a OpenAI lança ou aposenta modelos.

Por isso não publicamos uma lista fixa: consulte /models com a sua key e você recebe exatamente o que a sua conta aceita. Um modelo fora dessa lista retorna erro.

bash

curl https://api.reqpoint.online/v1/models \
  -H "Authorization: Bearer rqp_sua_key"

json

{
  "object": "list",
  "data": [
    {
      "id": "gpt-5.6-sol",
      "object": "model",
      "owned_by": "openai",
      "display_name": "GPT-5.6-Sol",
      "description": "Latest frontier agentic coding model.",
      "context_window": 272000,
      "input_modalities": ["text", "image"],
      "supports_web_search": true,
      "reasoning_levels": ["low", "medium", "high", "xhigh", "max", "ultra"],
      "default_reasoning_level": "low"
    },
    {
      "id": "gpt-5.4-mini",
      "object": "model",
      "owned_by": "openai",
      "display_name": "GPT-5.4-Mini",
      "description": "Small, fast, and cost-efficient model for simpler coding tasks.",
      "context_window": 272000,
      "input_modalities": ["text", "image"],
      "supports_web_search": true,
      "reasoning_levels": ["low", "medium", "high", "xhigh"],
      "default_reasoning_level": "medium"
    }
  ]
}

Os modelos vêm ordenados por relevância — o primeiro da lista é o mais indicado pela OpenAI. Além dos campos do padrão OpenAI (id, object, owned_by), incluímos o tamanho do contexto, se aceita imagem, se suporta busca na web e os níveis de raciocínio.

POST /chat/completions

Endpoint principal para gerar respostas. Formato idêntico ao da OpenAI.

bash

curl -X POST https://api.reqpoint.online/v1/chat/completions \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [
      {"role": "system", "content": "Você é um assistente útil."},
      {"role": "user", "content": "O que é uma API REST?"}
    ]
  }'

Resposta

json

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "model": "gpt-5.4-mini",
  "choices": [
    {
      "index": 0,
      "message": { "role": "assistant", "content": "Uma API REST é..." },
      "finish_reason": "stop"
    }
  ],
  "usage": { "prompt_tokens": 25, "completion_tokens": 150, "total_tokens": 175 }
}

POST /responses

A Responses API é o padrão atual da OpenAI e o recomendado para novos projetos. O Reqpoint fala esse protocolo nativamente — sem tradução intermediária —, então recursos como tools nativas, itens tipados e anotações funcionam exatamente como na OpenAI.

A diferença para o /chat/completions: você envia input em vez de messages, e recebe um array output de itens tipados em vez de choices.

bash

curl -X POST https://api.reqpoint.online/v1/responses \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "input": "Explique o que é uma API REST em uma frase."
  }'

Com o SDK oficial da OpenAI, basta apontar a base_url para o Reqpoint:

python

from openai import OpenAI

client = OpenAI(
    api_key="rqp_sua_key",
    base_url="https://api.reqpoint.online/v1"
)

resposta = client.responses.create(
    model="gpt-5.4-mini",
    input="Explique o que é uma API REST em uma frase."
)

print(resposta.output_text)

Aqui a busca na web usa o formato nativo — em tools, e não com "web_search": true:

bash

curl -X POST https://api.reqpoint.online/v1/responses \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "tools": [{ "type": "web_search" }],
    "input": "Qual a cotação do dólar hoje no Brasil?"
  }'

A resposta traz o output com um item web_search_call (contendo a query e sources — todas as URLs consultadas) seguido do item message com o texto:

json

{
  "id": "resp_...",
  "object": "response",
  "status": "completed",
  "output": [
    {
      "type": "web_search_call",
      "status": "completed",
      "action": {
        "type": "search",
        "query": "cotação do dólar hoje Brasil PTAX",
        "sources": [
          { "type": "url", "url": "https://www.bcb.gov.br/" },
          { "type": "url", "url": "https://www.bcb.gov.br/conversao?hl=pt-BR" }
        ]
      }
    },
    {
      "type": "message",
      "role": "assistant",
      "content": [
        {
          "type": "output_text",
          "text": "Hoje a cotação de referência do dólar está em R$ 5,1088...",
          "annotations": [
            {
              "type": "url_citation",
              "url": "https://www.bcb.gov.br/conversao",
              "title": "Banco Central do Brasil",
              "start_index": 210,
              "end_index": 317
            }
          ]
        }
      ]
    }
  ],
  "usage": { "input_tokens": 6865, "output_tokens": 195, "total_tokens": 7060 }
}

Diferenças em relação à OpenAI: conversas não são persistidas no servidor — store é sempre false, e previous_response_id não é suportado. Envie o contexto completo a cada requisição. O campo annotations depende do modelo ancorar a citação e nem sempre é preenchido — use sources quando precisar de garantia.

Instruções do sistema (system prompt)

O system prompt define a personalidade, as regras e o contexto do agente. Ele é enviado a cada requisição — a API não guarda estado entre chamadas.

O campo muda conforme o endpoint. Em /chat/completions, é uma mensagem com "role": "system" — deve ser a primeira do array:

json

{
  "model": "gpt-5.4-mini",
  "messages": [
    {
      "role": "system",
      "content": "Você é o atendente da Loja Exemplo. Seja educado e objetivo. Ajude com dúvidas sobre pedidos, entregas e devoluções. Responda sempre em português."
    },
    { "role": "user", "content": "Meu pedido atrasou, o que faço?" }
  ]
}

Já em /responses, use o campo instructions, separado do input:

json

{
  "model": "gpt-5.4-mini",
  "instructions": "Você é o atendente da Loja Exemplo. Seja educado e objetivo.",
  "input": "Meu pedido atrasou, o que faço?"
}

Conversas com várias mensagens: como não há estado no servidor, envie o histórico completo a cada requisição — system, mensagens anteriores do usuário e as respostas do assistente. O system prompt vai sempre na primeira posição.

json

{
  "model": "gpt-5.4-mini",
  "messages": [
    { "role": "system", "content": "Você é o atendente da Loja Exemplo." },
    { "role": "user", "content": "Meu pedido atrasou" },
    { "role": "assistant", "content": "Sinto muito! Pode me informar o número do pedido?" },
    { "role": "user", "content": "É o 12345" }
  ]
}

Busca na web (web search)

Por padrão, a busca na web vem desligada — igual ao comportamento da API da OpenAI. Isso deixa as respostas mais rápidas e evita consumo desnecessário da sua assinatura.

A forma de ativar muda conforme o endpoint — os dois formatos não são intercambiáveis:

Em /chat/completions: "web_search": true no corpo. É um atalho nosso — a Chat Completions da OpenAI não tem busca nativa.
Em /responses: "tools": [{ "type": "web_search" }]. É o formato nativo da OpenAI, e o único que aceita configurar a tool (como user_location).

Mandar "web_search": true em /responses não funciona, e tools com web_search em /chat/completions também não. Ative apenas quando precisar de informação atualizada — a busca consome bem mais tokens.

bash

curl -X POST https://api.reqpoint.online/v1/chat/completions \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "web_search": true,
    "messages": [
      {"role": "user", "content": "Quais as novidades de tecnologia esta semana?"}
    ]
  }'

Quando a busca é usada, a resposta traz a prova de que ela aconteceu — e não apenas o texto. Isso permite auditar as fontes em vez de confiar no que o modelo escreveu.

web_search_used — confirma que a busca foi executada.
search_queries — as consultas exatas enviadas ao buscador.
search_sources — todas as URLs que a busca consultou (normalmente mais que as citadas).
message.annotations — as citações no formato url_citation, com a URL, o título e os índices do trecho do texto que aquela fonte sustenta. Nem sempre vem preenchido — veja abaixo.

Sobre o annotations: ele só é emitido quando o modelo ancora a citação em um trecho específico da resposta. Quando ele apenas escreve a URL no meio do texto, o campo volta vazio — mesmo com a busca tendo acontecido. Esse comportamento é do modelo, não da plataforma, e varia entre chamadas idênticas.

Por isso, não use annotations como garantia. Se o seu fluxo depende de verificar fontes, use search_sources: ele é preenchido sempre que houve busca e contém todas as URLs consultadas. Quando o annotations vier, trate-o como um bônus — ele indica quais fontes o modelo considerou mais relevantes.

Se você precisa de citações consistentes, peça isso nas instruções do agente — por exemplo: “ao usar a busca, ancore cada afirmação na fonte correspondente”. Nos nossos testes isso aumentou bastante a taxa de citações ancoradas, mas ainda assim não é garantia.

Cruzando annotations com search_sources você verifica se cada URL citada saiu mesmo da busca. URLs que aparecem no texto mas não estão em search_sources não foram consultadas.

json

{
  "web_search_used": true,
  "search_queries": ["cotação dólar hoje Brasil USD BRL"],
  "web_search_requests": 1,
  "search_sources": [
    { "type": "url", "url": "https://www.bcb.gov.br/" },
    { "type": "url", "url": "https://ptax.bcb.gov.br/ptax_internet/consultarUltimaCotacaoDolar.do" },
    { "type": "api", "name": "oai-finance" }
  ],
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Hoje a cotação de referência do dólar está em R$ 5,0736 na compra...",
        "annotations": [
          {
            "type": "url_citation",
            "url": "https://ptax.bcb.gov.br/ptax_internet/consultarUltimaCotacaoDolar.do",
            "title": "Banco Central do Brasil",
            "start_index": 210,
            "end_index": 317
          }
        ]
      },
      "finish_reason": "stop"
    }
  ]
}

No streaming, essas informações chegam em chunks próprios antes do texto: o delta traz web_search (com queries e sources) e, conforme o texto é gerado, annotations. SDKs que não conhecem esses campos simplesmente os ignoram — a compatibilidade com a OpenAI é mantida.

Localização e horário

O modelo não tem relógio. Quando você pergunta as horas, ele consulta um serviço de tempo — e para saber qual fuso consultar, precisa que você informe onde o usuário está.

Sem essa informação, o padrão assumido é Estados Unidos: a hora vem correta em UTC, mas rotulada no fuso errado. Uma resposta como “15:23 UTC−03:00” vira “18:23 UTC+00:00” — mesmo instante, rótulo que não é o do seu usuário.

A correção é o campo user_location, enviado dentro da tool web_search — não como parâmetro solto:

bash

curl -X POST https://api.reqpoint.online/v1/responses \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "tools": [{
      "type": "web_search",
      "user_location": {
        "type": "approximate",
        "country": "BR",
        "city": "Sao Paulo",
        "timezone": "America/Sao_Paulo"
      }
    }],
    "input": "Que horas são agora?"
  }'

O timezone usa o formato IANA (America/Sao_Paulo, Europe/Lisbon). O type é sempre approximate; country, city e region são opcionais e também melhoram resultados de busca locais.

Em aplicações web, o navegador já sabe o fuso do usuário — não peça a ele:

javascript

const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
// "America/Sao_Paulo"

body: JSON.stringify({
  model: 'gpt-5.4-mini',
  tools: [{ type: 'web_search', user_location: { type: 'approximate', timezone } }],
  input: pergunta,
})

Sem busca na web? Aí não há onde informar a localização — o campo só existe dentro da tool. Nesse caso, passe a data e o fuso nas instruções do agente:

json

{
  "role": "system",
  "content": "Você é um assistente de agendamento. Hoje é 2026-07-16, fuso America/Sao_Paulo (UTC−03:00)."
}

Use o formato ISO (YYYY-MM-DD) para evitar ambiguidade entre padrões de data. Sem nenhuma das duas abordagens, o modelo responde com o fuso errado — e sem avisar que está assumindo.

Parâmetros de amostragem

Os modelos gpt-5.x são modelos de raciocínio e controlam a amostragem internamente. Por isso não aceitam os parâmetros clássicos de geração:

temperature
top_p
max_tokens / max_completion_tokens
frequency_penalty, presence_penalty
n, seed, logprobs, logit_bias

Enviá-los não causa erro — o Reqpoint os remove antes de encaminhar, para que SDKs que mandam temperature por padrão continuem funcionando. Mas eles não têm efeito: a resposta virá com os valores internos do modelo, não com os que você enviou.

Para controlar o comportamento, use as alternativas dos modelos de raciocínio:

Profundidade: reasoning: { effort: "low" | "medium" | "high" }. Os níveis aceitos por cada modelo vêm em /models.
Tamanho da resposta: text: { verbosity: "low" | "medium" | "high" }, ou peça nas instruções (“responda em uma frase”).
Determinismo: não há equivalente. Modelos de raciocínio não garantem saída idêntica entre chamadas.

Visão (envio de imagens)

Os modelos suportam análise de imagens. Para enviar uma imagem, o campo content da mensagem passa a ser uma lista com partes de texto e imagem — exatamente como na API da OpenAI.

A imagem pode ser enviada de duas formas: embutida em base64 (recomendado, mais confiável) ou por URL pública (a imagem precisa estar acessível para download).

Python (imagem em base64)

python

import base64
from openai import OpenAI

client = OpenAI(api_key="rqp_sua_key", base_url="https://api.reqpoint.online/v1")

# Lê a imagem do disco e converte para base64
with open("foto.jpg", "rb") as f:
    img_b64 = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "O que você vê nesta imagem?"},
                {"type": "image_url", "image_url": {
                    "url": f"data:image/jpeg;base64,{img_b64}"
                }}
            ]
        }
    ]
)
print(response.choices[0].message.content)

Imagem por URL

bash

curl -X POST https://api.reqpoint.online/v1/chat/completions \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.4-mini",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "Descreva esta imagem."},
          {"type": "image_url", "image_url": {"url": "https://exemplo.com/foto.jpg"}}
        ]
      }
    ]
  }'

Transcrição de áudio

O endpoint POST /audio/transcriptions converte fala em texto. O formato é o mesmo da API da OpenAI (Whisper), então SDKs existentes funcionam sem adaptação.

A requisição é multipart/form-data (não JSON), com o arquivo no campo file. Formatos comuns são aceitos — webm, mp3, wav, m4a, ogg.

bash

curl -X POST https://api.reqpoint.online/v1/audio/transcriptions \
  -H "Authorization: Bearer rqp_sua_key" \
  -F "file=@audio.webm" \
  -F "language=pt"

O campo language é opcional, mas recomendado: sem ele o modelo tenta adivinhar o idioma e erra com frequência em áudios curtos. Use o código ISO-639-1 (pt, en, es).

Também são aceitos prompt (contexto para melhorar a transcrição de termos específicos) e temperature.

A resposta segue o padrão da OpenAI:

json

{
  "text": "Texto transcrito do áudio."
}

Exemplo com o SDK oficial da OpenAI:

python

from openai import OpenAI

client = OpenAI(
    api_key="rqp_sua_key",
    base_url="https://api.reqpoint.online/v1"
)

with open("audio.webm", "rb") as f:
    resposta = client.audio.transcriptions.create(
        model="whisper-1",
        file=f,
        language="pt"
    )

print(resposta.text)

Geração de imagens

O endpoint POST /images/generations gera imagens a partir de um prompt de texto. O formato é compatível com a OpenAI Image API, então SDKs existentes funcionam sem adaptação.

Internamente, o Reqpoint traduz a requisição para o protocolo Responses API com a tool image_generation, envia para a conta ChatGPT conectada e devolve a imagem em base64.

Requisito: a conta ChatGPT conectada precisa ser Plus ou Pro. Contas gratuitas não têm acesso à geração de imagens via API — o modelo responde com texto descritivo em vez de gerar a imagem.

bash

curl -X POST https://api.reqpoint.online/v1/images/generations \
  -H "Authorization: Bearer rqp_sua_key" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Um gato aquarela sentado numa janela",
    "size": "1024x1024",
    "quality": "low"
  }'

Parâmetros aceitos:

prompt (obrigatório) — texto descrevendo a imagem desejada.
size — dimensões da imagem. Valores: 1024x1024, 1536x1024 (paisagem), 1024x1536 (retrato), auto. Padrão: auto.
quality — qualidade da geração. Valores: low, medium, high, auto. Padrão: auto. Qualidades mais altas demoram mais e geram imagens maiores.
n — quantidade de imagens (padrão: 1).
output_format — formato da imagem: png, jpeg, webp.
background — fundo da imagem: opaque, transparent, auto.

Resposta

json

{
  "created": 1785268000,
  "data": [
    {
      "b64_json": "/9j/4AAQSkZJRgABAQ... (imagem em base64)",
      "revised_prompt": "A watercolor painting of a cat sitting..."
    }
  ]
}

A imagem vem no campo b64_json em formato base64. O campo revised_prompt traz o prompt que o modelo realmente usou (com eventuais refinamentos).

Exemplo com o SDK oficial da OpenAI:

python

import base64
from openai import OpenAI

client = OpenAI(
    api_key="rqp_sua_key",
    base_url="https://api.reqpoint.online/v1"
)

result = client.images.generate(
    model="gpt-image-1",
    prompt="Um gato aquarela sentado numa janela",
    size="1024x1024",
    quality="low"
)

# Salva a imagem em disco
img_bytes = base64.b64decode(result.data[0].b64_json)
with open("imagem.png", "wb") as f:
    f.write(img_bytes)

print("Imagem salva!")

javascript

import fs from 'fs';

const res = await fetch('https://api.reqpoint.online/v1/images/generations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer rqp_sua_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    prompt: 'Um gato aquarela sentado numa janela',
    size: '1024x1024',
    quality: 'low',
  }),
});

const data = await res.json();
const imgBuffer = Buffer.from(data.data[0].b64_json, 'base64');
fs.writeFileSync('imagem.png', imgBuffer);
console.log('Imagem salva!');

Montando um chat completo

As seções acima mostram cada recurso isolado. Aqui está tudo junto: um agente com histórico, instruções, imagem, áudio e busca na web.

O ponto central: a API não guarda estado. Você mantém o array de mensagens no seu lado e envia ele inteiro a cada chamada. Foi assim que construímos o nosso próprio Ambiente de Teste.

javascript

const API = 'https://api.reqpoint.online/v1';
const KEY = 'rqp_sua_key';

// O histórico vive no seu código — a API não guarda nada.
// O system prompt vai sempre na primeira posição.
const historico = [
  { role: 'system', content: 'Você é o atendente da Loja Exemplo. Seja objetivo.' }
];

// ── 1. Mensagem de texto ────────────────────────────────
async function enviar(texto, { comBusca = false } = {}) {
  historico.push({ role: 'user', content: texto });

  const res = await fetch(`${API}/chat/completions`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      model: 'gpt-5.4-mini',
      messages: historico,
      ...(comBusca ? { web_search: true } : {}),
    }),
  });

  const data = await res.json();
  const resposta = data.choices[0].message.content;

  // Guarda a resposta para a próxima rodada manter o contexto
  historico.push({ role: 'assistant', content: resposta });

  // Quando houve busca, a prova vem junto
  if (data.web_search_used) {
    console.log('Buscou:', data.search_queries);
    console.log('Fontes consultadas:', data.search_sources.map(s => s.url));
    console.log('Fontes citadas:', data.choices[0].message.annotations);
  }

  return resposta;
}

// ── 2. Enviar imagem ────────────────────────────────────
async function enviarImagem(arquivo, pergunta) {
  const base64 = await new Promise(resolve => {
    const r = new FileReader();
    r.onloadend = () => resolve(r.result);
    r.readAsDataURL(arquivo);
  });

  historico.push({
    role: 'user',
    content: [
      { type: 'text', text: pergunta },
      { type: 'image_url', image_url: { url: base64 } },
    ],
  });

  const res = await fetch(`${API}/chat/completions`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ model: 'gpt-5.4-mini', messages: historico }),
  });

  const data = await res.json();
  const resposta = data.choices[0].message.content;
  historico.push({ role: 'assistant', content: resposta });
  return resposta;
}

// ── 3. Áudio → texto → chat ─────────────────────────────
async function enviarAudio(blob) {
  const form = new FormData();
  form.append('file', blob, 'audio.webm');
  form.append('language', 'pt');   // evita o modelo errar o idioma

  const res = await fetch(`${API}/audio/transcriptions`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${KEY}` },
    body: form,
  });

  const { text } = await res.json();
  return enviar(text);   // manda o texto transcrito para o chat
}

// ── 4. Modelos que a conta aceita ───────────────────────
async function listarModelos() {
  const res = await fetch(`${API}/models`, {
    headers: { 'Authorization': `Bearer ${KEY}` },
  });
  const { data } = await res.json();
  return data.map(m => m.id);
}

// ── Uso ─────────────────────────────────────────────────
await enviar('Meu pedido atrasou');
await enviar('Qual a cotação do dólar hoje?', { comBusca: true });

Streaming: envie "stream": true e leia a resposta em pedaços, em vez de esperar tudo:

javascript

const res = await fetch(`${API}/chat/completions`, {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ model: 'gpt-5.4-mini', messages: historico, stream: true }),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
let texto = '';
let buffer = '';

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  buffer += decoder.decode(value, { stream: true });
  const linhas = buffer.split('\n');
  buffer = linhas.pop();

  for (const linha of linhas) {
    if (!linha.startsWith('data: ')) continue;
    const payload = linha.slice(6);
    if (payload === '[DONE]') continue;

    const json = JSON.parse(payload);
    const delta = json.choices[0].delta;

    if (delta.content) {
      texto += delta.content;
      // atualize sua UI aqui
    }

    // Prova da busca chega antes do texto
    if (delta.web_search) {
      console.log('Buscando:', delta.web_search.queries);
    }
  }
}

Exemplos de integração

Python (OpenAI SDK)

python

from openai import OpenAI

client = OpenAI(
    api_key="rqp_sua_key",
    base_url="https://api.reqpoint.online/v1"
)

response = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[{"role": "user", "content": "Olá!"}]
)

print(response.choices[0].message.content)

JavaScript / TypeScript

javascript

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'rqp_sua_key',
  baseURL: 'https://api.reqpoint.online/v1',
});

const response = await client.chat.completions.create({
  model: 'gpt-5.4-mini',
  messages: [{ role: 'user', content: 'Olá!' }],
});

console.log(response.choices[0].message.content);

n8n / Make / Automações

Use o node HTTP Request (n8n) ou o módulo HTTP (Make):

1. URL: https://api.reqpoint.online/v1/chat/completions

2. Método: POST

3. Header: Authorization: Bearer rqp_...

4. Body (JSON): mesmo formato do curl acima

Se a ferramenta já integra com a OpenAI, basta trocar a base URL e a key.

Limites de uso

Os limites são os mesmos da sua assinatura ChatGPT. A plataforma apenas faz o proxy — quem controla os limites é a OpenAI.

O plano Plus tem uma janela de uso que reseta periodicamente e um limite semanal. O Pro tem limites bem maiores.

Se a OpenAI retornar um erro de limite, a API retorna o mesmo erro para você.

Limite	Valor	Observação
Corpo da requisição	`10 MB`	Inclui imagens em base64, que ocupam ~33% a mais que o arquivo original
Arquivo de áudio	`25 MB`	Mesmo limite da OpenAI. Para áudios longos, divida antes de enviar
Janela de contexto	`272k tokens`	Varia por modelo — consulte `/models`
API keys por conta	`sem limite`	Todas compartilham a mesma assinatura conectada

Timeout: não impomos um limite de tempo próprio, mas requisições muito longas podem ser encerradas por camadas de rede intermediárias. Para respostas extensas, use "stream": true — além de melhorar a experiência, mantém a conexão ativa e evita cortes.

Códigos de erro

Status	Tipo	Descrição
`400`	connection_error	Conta Codex não conectada
`401`	auth_error	API key ausente, inválida ou não encontrada
`401`	token_error	Token do Codex expirado — reconecte a conta
`403`	auth_error	API key desativada ou conta inativa
`403`	plan_error	Trial expirado
`429`	upstream_error	Rate limit da assinatura ChatGPT atingido
`502`	upstream_error	Erro ao processar a requisição no provedor
`500`	server_error	Erro interno do servidor