TokenLab
Obter chave de API
DocumentaçãoReferência da APIIntegrações

Texto

Criar Resposta

Cria uma resposta usando o formato OpenAI Responses API

POST
/v1/responses

Use este endpoint quando accepted_request_formats nos detalhes do modelo incluir openai_responses. As solicitações e respostas usam o formato Responses API. Os campos opcionais e os valores aceitos dependem do modelo escolhido.

Corpo da Requisição

modelstringobrigatório

ID do modelo a ser usado. Veja Models para as opções disponíveis.

inputstring | array

A entrada é opcional quando a solicitação usa um prompt reutilizável ou continua uma resposta armazenada com previous_response_id.

Uma lista de itens de entrada que compõem a conversa.

Cada item pode ser:

  • message: Uma mensagem de conversa com role e content
  • function_call: Uma solicitação de chamada de função
  • function_call_output: Saída de uma chamada de função

Para entrada multimodal, message.content pode ser uma string simples ou um array de blocos de conteúdo. Para modelos com capacidade de imagem, como variantes GPT-5.6 Terra, envie imagens como blocos input_image em vez de incorporar URLs ou strings Base64 diretamente em texto simples.

Exemplo de blocos de conteúdo:

  • { "type": "input_text", "text": "Describe this image" }
  • { "type": "input_image", "image_url": "https://example.com/image.jpg" }
  • { "type": "input_image", "image_url": "data:image/png;base64,..." }
instructionsstring

Instruções do sistema para o modelo (equivalente à mensagem do system).

max_output_tokensinteger

Número máximo de tokens a serem gerados.

temperaturenumber

Temperatura de amostragem. Os valores aceitos e os padrões dependem do modelo escolhido.

toolsarray

Ferramentas que o modelo pode chamar. Os tipos e combinações aceitos dependem do modelo escolhido.

streambooleanpadrão: false

Se true, retorna um fluxo de eventos.

previous_response_idstring

ID de uma resposta anterior para continuar a conversa a partir dela.

storebooleanpadrão: true

Se a resposta deve ser armazenada para recuperação posterior.

backgroundbooleanpadrão: false

Solicita execução assíncrona. O suporte depende do modelo escolhido.

promptobject

Referência a um modelo de prompt reutilizável e suas variáveis.

metadataobject

Metadados para anexar à resposta para fins de rastreamento.

textobject

Configurações de saída de texto. O suporte a text.format depende do modelo escolhido.

parallel_tool_callsbooleanpadrão: true

Se permite múltiplas chamadas de ferramentas em paralelo.

top_pnumber

Parâmetro de amostragem nucleus (0-1).

reasoningobject

As opções de raciocínio, incluindo effort, dependem do modelo escolhido.

Resposta

idstring

Identificador único da resposta.

objectstring

Sempre response.

created_atinteger

Timestamp Unix de quando a resposta foi criada.

statusstring

Estado da resposta: queued, in_progress, completed, incomplete, failed ou cancelled. Verifique este campo mesmo quando a solicitação HTTP for bem-sucedida.

outputarray

Lista de itens de saída gerados pelo modelo.

usageobject

Estatísticas de uso de tokens.

Endpoints relacionados

  • GET /v1/responses/{id} recupera uma resposta salva e aceita include, include_obfuscation, stream e starting_after.
  • DELETE /v1/responses/{id} exclui uma resposta salva. Isso não cancela a geração.
  • POST /v1/responses/compact retorna um objeto response.compaction.
  • Os endpoints de cancelamento, input-items e input-tokens não estão disponíveis no momento.

Requisição

cURL
curl -X POST "https://api.tokenlab.sh/v1/responses" \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "input": [
      {"type": "message", "role": "user", "content": "Hello!"}
    ],
    "max_output_tokens": 1000
  }'
Python
from openai import OpenAI

client = OpenAI(
    api_key="sk-your-api-key",
    base_url="https://api.tokenlab.sh/v1"
)

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[
        {"type": "message", "role": "user", "content": "Hello!"}
    ],
    max_output_tokens=1000
)

print(response.output)
JavaScript
import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: 'sk-your-api-key',
  baseURL: 'https://api.tokenlab.sh/v1'
});

const response = await client.responses.create({
  model: 'gpt-5.6-terra',
  input: [
    { type: 'message', role: 'user', content: 'Hello!' }
  ],
  max_output_tokens: 1000
});

console.log(response.output);
Go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    payload := map[string]interface{}{
        "model": "gpt-5.6-terra",
        "input": []map[string]interface{}{
            {"type": "message", "role": "user", "content": "Hello!"},
        },
        "max_output_tokens": 1000,
    }
    body, _ := json.Marshal(payload)

    req, _ := http.NewRequest("POST", "https://api.tokenlab.sh/v1/responses", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer sk-your-api-key")
    req.Header.Set("Content-Type", "application/json")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Println(result["output"])
}
PHP
<?php
$ch = curl_init('https://api.tokenlab.sh/v1/responses');

curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Content-Type: application/json',
        'Authorization: Bearer sk-your-api-key'
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'model' => 'gpt-5.6-terra',
        'input' => [
            ['type' => 'message', 'role' => 'user', 'content' => 'Hello!']
        ],
        'max_output_tokens' => 1000
    ])
]);

$response = curl_exec($ch);
curl_close($ch);

$data = json_decode($response, true);
print_r($data['output']);

Exemplo de Entrada Vision

Use modelos com capacidade de imagem colocando imagens dentro de message.content como blocos input_image. O valor de image_url pode ser uma URL pública ou uma data URL em Base64.

{
  "model": "gpt-5.6-terra",
  "input": [
    {
      "type": "message",
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Please describe this image."
        },
        {
          "type": "input_image",
          "image_url": "https://example.com/demo.jpg"
        }
      ]
    }
  ]
}
{
  "model": "gpt-5.6-terra",
  "input": [
    {
      "type": "message",
      "role": "user",
      "content": [
        {
          "type": "input_text",
          "text": "Please describe this image."
        },
        {
          "type": "input_image",
          "image_url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."
        }
      ]
    }
  ]
}

Resposta

Response
{
  "id": "resp_abc123",
  "object": "response",
  "created_at": 1706000000,
  "status": "completed",
  "model": "gpt-5.6-terra",
  "output": [
    {
      "id": "msg_abc123",
      "type": "message",
      "status": "completed",
      "role": "assistant",
      "content": [
        {"type": "output_text", "text": "Hello! How can I help you today?", "annotations": []}
      ]
    }
  ],
  "usage": {
    "input_tokens": 10,
    "output_tokens": 12,
    "total_tokens": 22
  }
}

Autorização

BearerAuth
AuthorizationBearer <token>

Autenticação por Chave de API. Crie ou gerencie chaves de API em Dashboard > API > API Keys.

Local: header

Cabeçalhos

X-TokenLab-Delivery-Policy?string

Política de entrega por solicitação. Substitui os padrões da API key e do Workspace. Tenta automaticamente o TokenLab Verified primeiro e pode alternar uma vez para Official apenas antes da saída, aceitação da solicitação ou criação de recurso persistente.

Valores permitidos

  • "auto"
  • "verified"
  • "official"

Corpo da requisição

application/json

Resposta

application/json

application/json

application/json

Criar conclusão de chat

Anterior

Criar Mensagem

Próxima