Plan a relaxed Saturday using these options: a park open 9am-6pm, a museum open 10am-5pm, and a cafe open 8am-8pm. Start at 10am, include a lunch break, and allow 30 minutes between stops. Return a timetable without inventing prices or opening hours.
GPT 5.6 Terra API: Online text generation, tutorials and integration guide
Connect to GPT 5.6 Terra in one click on RequestBeam. One API key connects AI and multiple data services, so you can focus on your business and explore new ideas.
GPT 5.6 Terra API pricing and billing
0-272K input tokens
Official price
- Input
-
$2.0000/M - Output
-
$12.0000/M - Cache input
-
$0.2000/M - Cache write
-
$2.5000/M
Our price Save 70%
- Input
- $0.6000 /M
- Output
- $3.6000 /M
- Cache input
- $0.0600 /M
- Cache write
- $0.7500 /M
272.001K-922K input tokens
Official price
- Input
-
$4.0000/M - Output
-
$18.0000/M - Cache input
-
$0.4000/M - Cache write
-
$5.0000/M
Our price Save 70%
- Input
- $1.2000 /M
- Output
- $5.4000 /M
- Cache input
- $0.1200 /M
- Cache write
- $1.5000 /M
GPT 5.6 Terra online chat tool
Model settings
It includes completed, reusable turns from this conversation in your next request, so you can ask follow-up questions without repeating the context.
What happens when it is off?Only your new message and any system prompt are sent. Existing messages stay visible; turning memory back on includes eligible earlier turns again.
Is this long-term memory?No. This is conversation context, not memory across separate conversations. Failed, stopped, truncated, or non-reusable replies are excluded. More history can use more input tokens and increase cost.
Advanced parameters
Conversation

How can I help you today?
No response data yet GPT 5.6 Terra prompt examples
Draft a polite customer email for this situation: an order will arrive two days late, the revised delivery date is October 15, and tracking will be sent tomorrow. Apologize without inventing compensation. Include a subject line and keep the email under 120 words.
Turn these meeting notes into an action list: Maya will revise the proposal by Friday; Leo will confirm the venue next Monday; the budget needs approval, with no owner assigned. Use columns for task, owner, deadline, and open questions. Mark missing details as unknown.
What is GPT 5.6 Terra?
GPT 5.6 Terra model focus and core capabilities
GPT 5.6 Terra is an OpenAI model positioned between demanding flagship work and cost-sensitive workloads. It balances intelligence and cost, roughly corresponding to earlier mini tiers, with adjustable reasoning, a 1,050,000-token context window, and up to 128,000 output tokens at the model level. It is a candidate for structured extraction, document analysis, and routine coding assistance.
GPT 5.6 Terra online tools and API on RequestBeam
RequestBeam provides an online text Playground, unified Chat Completions, and OpenAI-compatible Responses for GPT 5.6 Terra. Test source fidelity and formatting on representative work before integrating it. Model-level limits and image understanding do not mean the text chat tool accepts uploads or that every RequestBeam channel exposes the full context allowance or tool set.
GPT 5.6 Terra capabilities and domain strengths
Terra is useful to evaluate where repeated text work needs both judgment and a predictable output contract. Define what a correct result looks like, preserve uncertainty, and make validation part of the workflow rather than relying on fluent answers.
Structured extraction and classification
Use Terra to turn supplied orders, tickets, or meeting notes into fields and categories. Specify types, allowed labels, and how to represent absent values; a missing address should stay unknown rather than become a plausible location.
Test cases with several items, contradictory dates, and incomplete names. Keep source passages or identifiers alongside extracted values so a reviewer can distinguish an extraction error from a source ambiguity. The text form does not enforce a schema simply because you request JSON.
Long-context document analysis
A broad context window makes Terra a candidate for comparing related documents and consolidating requirements. Ask for confirmed facts, conflicting statements, and unanswered questions as separate outputs, rather than one summary that silently resolves disagreements.
Select material relevant to the question and retain document labels. Check conclusions against original passages, especially exceptions and tentative commitments. Your effective input allowance depends on the target interface and upstream; context capacity is not perfect recall or permanent memory.
Routine coding and implementation support
Evaluate Terra on bounded development tasks such as explaining a function, drafting validation logic, proposing tests, or locating a defect from supplied code and logs. State expected behavior and interfaces so the answer can be checked without guessing your architecture.
Review generated diffs and run compilation, unit tests, and security checks in your own environment. For difficult cross-module repairs, compare with GPT 5.6 Sol using the same acceptance criteria. This Playground does not open a repository, execute commands, or deploy a patch.
Adjustable reasoning and visual-input boundaries
Terra supports reasoning effort from none through max, with medium as its model default, and accepts image input at the model level. Reasoning configuration is a way to evaluate different task demands, not a guarantee that more effort always gives a better answer.
Use text descriptions of charts or interfaces in the chat tool. For images or PDFs, follow the documented Responses input format and confirm channel support; the chat workspace has no upload controls. A URL in ordinary text does not establish that its contents were inspected.
GPT 5.6 Terra benchmarks and performance
Choose Terra with a workload-specific evaluation rather than an assumed score or speed advantage. The checks below separate answer accuracy, operational duration, and cost; they are evaluation criteria, not published RequestBeam performance results.
Measure extraction accuracy beyond valid JSON
Build a fixed sample with missing fields, multiple entities, and ambiguous dates. Count correct values, invented values, omissions, and label mistakes separately. A parser accepting an object does not prove that its contents match the order or document.
Measure manual correction time as well as first-pass success. If an extra verification step removes the apparent cost benefit, revise the schema, narrow the task, or compare another model before increasing volume.
Evaluate code and reasoning with checkable outcomes
For code, use test outcomes and minimal-change review instead of judging whether an explanation sounds confident. For analysis, require complete constraint coverage and distinguish existing evidence from proposed measurements.
Keep inputs and acceptance criteria fixed when comparing Terra with Sol. Record reasoning configuration and execution environment where applicable; a coding agent with tools is not equivalent to one text-only prompt, and a family name does not establish a benchmark result.
Track latency and cost per accepted result
Record time to first answer text, total duration, input and output usage, and the number of retries or corrections. Compare cost per accepted result, not only token price, especially for repeated classification or extraction work.
Conversation history, long source material, and reasoning can increase usage or delay final text. Begin with a small representative sample and current account pricing; measure the chosen configuration before promising production throughput or response times.
GPT 5.6 Terra compared with Claude and GPT models
Compare Terra with GPT 5.6 Sol for the same requirements, and include alternatives for shorter text tasks. This table identifies what to test rather than ranking models without a controlled evaluation.
| Task | GPT 5.6 Terra evaluation | GPT 5.6 Sol evaluation | Validation method |
|---|---|---|---|
| Structured extraction | Candidate for repeated field-level work | Compare on ambiguity and exceptions | Check source-aligned values and omissions |
| Code changes | Start with bounded implementation tasks | Include difficult repairs in the same sample | Run tests and review change scope |
| Document synthesis | Test labeled sources and conflicting statements | Compare difficult multi-constraint conclusions | Trace claims and preserve unknowns |
| Production economics | Measure corrections and token usage | Measure with identical acceptance criteria | Compare cost per accepted result |
When to prioritize testing GPT 5.6 Terra
Start with Terra when a workflow repeats a well-defined task but still needs judgment: extracting fields from imperfect text, producing constrained summaries, or drafting routine code. Keep a clear escalation rule for uncertain outputs and difficult failures.
Do not assume the lower-tier position makes Terra universally faster or sufficiently accurate. Compare the complete workflow, including validation and rework, with GPT 5.6 Sol or GPT 5.5 before deciding which steps should use which model.
Choose models by task on RequestBeam
For an alternative text baseline, include Claude Haiku 4.5 or Gemini 3.8 Flash on the same summary or classification samples. Shared Chat Completions authentication helps reuse client code, but model-specific options and native protocols still differ.
Keep acceptance criteria and input material consistent, and use current account prices. Assign different steps to different models only when your results support that choice; model names alone do not establish speed, accuracy, or total cost.
Why use GPT 5.6 Terra through RequestBeam?
Usage-based billing and model cost optimization
Reliable service at prices lower than official rates. Top up on demand and use what you pay for.
Unified AI models and data APIs, with multi-model access in one place
One API key connects multiple AI models and data services, reducing integration costs and letting you switch with one click. Business applications need both AI and data.
Call logs and application access controls, with clarity on every call
Every API call is recorded in your dashboard. Create separate API keys for different applications.
Model capabilities without compromise
We do not water down our models. We cannot offer you the cheapest, but we are committed to offering you the best.
How to use GPT 5.6 Terra on RequestBeam
After creating an API key in the console, follow the documentation to get started with GPT 5.6 Terra.
Prepare your account and test online
Sign in, confirm your balance, and create an API key.
Try it in the Playground
Explore the model's capabilities in the Playground to find the best way to use it.
Integrate GPT 5.6 Terra into your business
Follow our developer documentation to integrate GPT 5.6 Terra into your business.
Future model upgrades
When a new model is released, simply replace the model name with the new one to upgrade.
GPT 5.6 Terra API FAQ
Can the GPT 5.6 Terra Playground accept images or PDFs?
The chat workspace accepts text and has no image or file upload controls. Terra has model-level image understanding, and the separate RequestBeam Responses contract documents public image URLs and PDF input. Use that documented format with confirmed channel support; an ordinary text link does not make this chat download or inspect a file.
Why is there no final text, or why does an answer stop early?
With reasoning enabled, output usage can include thinking as well as final text. A small explicit allowance can be exhausted first. Check the Chat finish reason or Responses completion status and returned items, narrow the task, and adjust the supported budget. Reasoning need not be displayed as readable reasoning_content; its absence does not prove the model used no reasoning.
Is conversation memory permanent, and why does usage grow?
Memory here is current conversation context, not permanent model memory. Enabling it includes reusable completed turns and can increase input usage. Disabling it leaves history visible but excludes it from new requests. Failed, stopped, truncated, or non-reusable replies are not appended as normal history. A Responses ID also does not guarantee stateful continuation on every channel.
How should I troubleshoot 401, 402, 403, or 429 errors?
For 401, check the RequestBeam key, Base URL, and authentication format; for 402, check balance; for 403, check access to gpt-5.6-terra; for 429, check request rate or allowance. Verify the exact ID against the models visible to your key. Numeric platform code is separate from HTTP status. Diagnose 5xx and in-stream failures using the complete error and request record.
Can I call GPT 5.6 Terra using OpenAI Responses or Claude Messages?
RequestBeam documents Chat Completions and OpenAI-compatible Responses for gpt-5.6-terra, not Claude Messages. Responses uses input and returns output items; Chat uses messages and choices. Match your SDK endpoint, body, and parser to the selected protocol rather than changing only the model name.
Can one request return multiple alternatives or guarantee valid JSON?
Ask for several alternatives inside one answer, and verify n support before requesting multiple Chat choices; Responses is a different contract. Terra has model-level structured output support, but a JSON prompt in this chat form is not schema enforcement. For an API schema, use the documented supported configuration and still validate missing fields, types, source fidelity, and business meaning.
Can GPT 5.6 Terra execute code, use tools, or perform business actions here?
The chat workspace returns text, not executed code or confirmed actions. An agent integration must provide or enable supported tools, validate arguments, execute approved operations, and return results. RequestBeam Responses tool availability depends on the selected model and channel; upstream capabilities do not mean this page can modify repositories, access databases, send email, or make payments.
Should I immediately retry a slow response, interrupted stream, or stopped request?
Check existing results, request records, and usage first. Long source text, conversation history, and reasoning can affect duration. Stopping browser waiting or losing a stream does not prove the upstream request was unprocessed. Use bounded retries appropriate to the error and reconcile outstanding work before resubmitting to avoid duplicate requests and charges.
Related text APIs
GPT 5.6 Terra API specification and requests
GPT 5.6 Terra API quickstart
gpt-5.6-terraChat CompletionsPOST /v1/chat-completions
curl -X POST "https://api.requestbeam.com/v1/chat-completions" \
-H "Authorization: Bearer <API_KEY>" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-5.6-terra","messages":[{"role":"user","content":"Hello, introduce yourself in one sentence."}],"stream":false}'ResponsesPOST /openai/responses
curl -X POST "https://api.requestbeam.com/openai/responses" \
-H "Authorization: Bearer <API_KEY>" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-5.6-terra","input":"Hello, reply with one short sentence.","stream":false}'Family and protocol reference
OpenAI Multimodal Responses
Full API documentationOpenAI-compatible Responses API. This endpoint uses OpenAI-style `input`, supports text, public image URLs, PDF file input, tool calls, reasoning options, and streaming parameters.
https://api.requestbeam.com/openai/responsesOpenAI-compatible Responses API. This endpoint uses OpenAI-style input, supports text, public image URLs, PDF file input, tool calls, reasoning options, and streaming parameters.
POST https://api.requestbeam.com/openai/responsesAuthentication
All requests require Bearer Token authentication.
Authorization: Bearer YOUR_API_KEYBody
modelstringrequiredDefault: gpt-5.4Current active models with Responses support:
gpt-5.4gpt-5.5gpt-5.6-solgpt-5.6-terragpt-6-astra
See the Model Catalog for the models visible to the current API Key.
inputstring | object[]Input content. Required unless a non-empty previous_response_id is provided. Omitting both fields or using an invalid input type returns 400 before billing.
Supported forms:
- A string, equivalent to one
usertext input. - An array of input items for conversation history, multimodal input, and tool call results.
Each object in the input array may contain the following fields:
typestringInput item type.
Common values:
message: a message input.function_call_output: the result of a function tool call.
rolestringRole when type=message.
Common values:
developersystemuserassistant
contentstring | object[]Message content.
Use a content-block array for multimodal requests. Content blocks support:
typestringContent block type.
Currently supported:
input_textinput_imageinput_file
textstringText content when type=input_text.
image_urlstringPublic image URL when type=input_image.
Only publicly accessible http:// or https:// image URLs are supported. Base64 Data URLs such as data:image/...;base64,... are not supported.
detailstringDefault: autoImage detail level when type=input_image.
Common values:
autolowhigh
file_datastringFile content Data URL when type=input_file. PDFs may use data:application/pdf;base64,....
filenamestringFile name when type=input_file.
instructionsstringSystem or developer instructions inserted into the model context.
max_output_tokensintegerOptional maximum output tokens, as a positive integer. Omit this field to use the upstream default for the selected model. Depending on the model, the budget may include reasoning tokens as well as final text. A small budget can truncate the answer or be exhausted before final text; increasing it may increase cost.
streambooleanDefault: falseWhether to stream the response.
false: return one complete responsetrue: return OpenAI Responses-style SSE events
temperaturenumberDefault: 1.0Sampling temperature, usually from 0 to 2.
top_pnumberDefault: 1.0Nucleus sampling parameter, usually from 0 to 1.
textobjectText output configuration.
text.formatobjectText format configuration, such as { "type": "text" } or a JSON schema.
text.verbositystringOutput verbosity, such as low, medium, or high. Support depends on the selected model.
toolsobject[]Tool definitions. Availability depends on the selected model and available features.
tool_choicestring | objectTool selection policy.
parallel_tool_callsbooleanWhether parallel tool calls are allowed.
reasoningobjectReasoning-related options.
includestring[]Extra fields to include in the response.
prompt_cache_keystringPrompt cache key for prompt cache reuse.
prompt_cache_retentionstringPrompt cache retention policy. Supported values depend on the selected model and available features.
safety_identifierstringStable end-user identifier for safety controls.
storebooleanWhether response state may be stored.
Model Parameter Differences
- Native OpenAI-compatible Responses forwarding preserves
top_pin the upstream request; validation and sampling behavior depend on the selected model and upstream. The checks on 2026-09-26 acceptedtop_p: 0.9forgpt-5.5,gpt-5.6-sol, andgpt-5.6-terra. Acceptance and forwarding do not prove a sampling effect or guarantee support for other values, models, or later requests. Start with a minimal request. - Support on this page applies only to the regular
/openai/responsesendpoint. It does not imply that the same model supports/openai/responses/compact, WebSocket, or statefulprevious_response_id. - The five GPT models listed above currently have no verified Compact channel. Compact requests are rejected before billing when no explicitly enabled channel is available. Ordinary Responses and Responses WebSocket remain available.
Request Examples
The examples below provide input. A continuation may omit input when it provides a valid previous_response_id and the selected channel supports stateful continuation. A response ID does not enable that capability on an unsupported channel. Tool results remain valid input items, including function_call_output.
Text
{
"model": "gpt-5.4",
"input": "Hello, introduce yourself in one sentence."
}Codex CLI-Style Parameters
{
"model": "gpt-5.5",
"input": "Reply with READY only.",
"reasoning": {
"effort": "xhigh"
},
"store": false,
"text": {
"verbosity": "low"
},
"stream": true
}Image Understanding
{
"model": "gpt-5.4",
"input": [
{
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": "What is in this image?"
},
{
"type": "input_image",
"image_url": "https://example.com/cat.png",
"detail": "high"
}
]
}
]
}File Input
Use file_data plus filename to submit PDF content. file_data must be a complete Data URL.
{
"model": "gpt-5.4",
"input": [
{
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": "Summarize the key points in this PDF."
},
{
"type": "input_file",
"file_data": "data:application/pdf;base64,JVBERi0xLjQKJc...",
"filename": "report.pdf"
}
]
}
]
}Image and File Input
{
"model": "gpt-5.4",
"input": [
{
"type": "message",
"role": "user",
"content": [
{
"type": "input_text",
"text": "Give three conclusions based on the image and attachment."
},
{
"type": "input_image",
"image_url": "https://example.com/chart.png",
"detail": "high"
},
{
"type": "input_file",
"file_data": "data:application/pdf;base64,JVBERi0xLjQKJc...",
"filename": "notes.pdf"
}
]
}
]
}Streaming Output
{
"model": "gpt-5.4",
"stream": true,
"input": [
{
"role": "user",
"content": [
{
"type": "input_text",
"text": "Explain this diagram step by step."
},
{
"type": "input_image",
"image_url": "https://example.com/diagram.png"
}
]
}
]
}Response
Non-streaming responses follow OpenAI Responses style. Actual fields may vary with selected model capabilities.
idstringUnique response identifier.
objectstringResponse object type, usually response.
created_atintegerCreation timestamp.
modelstringActual model used.
outputobject[]Output item list. Common items include message, function_call, and tool-related output.
usageobjectToken usage statistics, such as input_tokens, output_tokens, and total_tokens.
Success Example
{
"id": "resp_123",
"object": "response",
"created_at": 1766534400,
"model": "gpt-5.4",
"output": [
{
"type": "message",
"role": "assistant",
"content": [
{
"text": "The image shows a cat, and the attachment is a document about pet care."
}
]
}
],
"usage": {
"input_tokens": 128,
"output_tokens": 42,
"total_tokens": 170
}
}Streaming Response
When stream=true, the endpoint returns Server-Sent Events.
event: response.output_text.delta
data: {"type":"response.output_text.delta","delta":"The image"}
event: response.completed
data: {"type":"response.completed","response":{"id":"resp_123"}}Read events until response.completed or the connection closes.
Error Response
See Error Codes and Troubleshooting for the full code reference, protocol differences, and diagnostic steps.
Platform-generated HTTP errors use the flat fields below instead of an error wrapper. Some upstream errors may retain their original structure; errors inside an already-started SSE stream do not follow this HTTP response example.
{
"code": 40000,
"message": "Insufficient credit. Required: 30000, Available: 20000",
"type": "api_error"
}Notes
- The
Responsesendpoint usesinput, notmessages. If your client only sendsmessages, use/openai/v1/chat/completions. - Image input uses
input_image;image_urlmust be a publichttp://orhttps://URL. Base64 Data URLs are not supported for images. - File input uses
input_file. For PDFs, usefile_dataplusfilename;file_datashould be a completedata:application/pdf;base64,...URL. - Audio input/output, image generation tools, file search, and other advanced capabilities depend on the selected model and available features.
- The fields listed on this page form the current public Responses request contract; do not assume unlisted fields are available.
/openai/responsesis the recommended public path./v1/responsesfollows the same public request and response contract./compat/v1/responsesfollows the same public request and response contract./openai/v1/responsesfollows the same public request and response contract.