GPT-6.1 Terra (gpt-6.1-terra) is OpenAI’s mid-tier GPT-6.1 model released on October 26, 2026. It delivers strong visual reasoning, precise computer use, and natural writing at half the price of GPT-6.1 Sol and GPT-5.6 Terra ($1 input / $5 output per million tokens standard). With a 1.05M-token context window, configurable reasoning effort (none to max), image input, and full tool support via the Responses API, it is ideal for high-volume agentic workflows such as invoice processing, technical drawing interpretation, screen interaction, and document revision. This guide covers exact setup, code examples, reasoning strategies, best practices, comparisons, and how to access it more cost-effectively through CometAPI.
Key Takeaways
Model ID: gpt-6.1-terra — 1,050,000 context window, 128,000 max output tokens, knowledge cutoff June 1, 2026.
Pricing (OpenAI standard): $1 / $5 per 1M input/output tokens; cached input $0.05; long-context (>272K input) and Fast mode cost more.
Reviewed for clarity, source attribution and current API terminology.
Best for visual + computer-use tasks; outperforms GPT-5.6 Terra significantly while matching or approaching higher-tier models at far lower cost and higher speed.
Prefer the Responses API for tool calling, computer use, structured outputs, and reasoning control.
CometAPI offers the same model at discounted rates (around $0.80 / $4.00) with a single OpenAI-compatible key for 500+ models, enabling easy switching and 20–40% ongoing savings.
What Is GPT-6.1 Terra?
GPT-6.1 Terra is OpenAI’s fast, efficient mid-tier model in the GPT-6.1 family, positioned between the lightweight Luna and the more capable Sol/Astra tiers. Official positioning emphasizes detailed visual reasoning, precise computer use (screen interaction, form filling, application control), and clearer natural writing.
It accepts text and image inputs and produces text output. It does not natively support audio or video input/output. Key capabilities include streaming, structured outputs, function calling, prompt caching, web search, file search, computer use, code interpreter, and more—primarily through the Responses API.
OpenAI highlights major gains over GPT-5.6 Terra: higher scores on Agents’ Last Exam (professional computer-use tasks) at roughly one-third the cost, near-parity with GPT-6 Astra on some visual and agent benchmarks at ~1/10th the price per token, substantially lower hallucination rates, and over 3× faster task completion than Sol or Astra in relevant workloads.
GPT-6.1 Terra Specifications and Pricing
Standard OpenAI Pricing (per 1M tokens)
Input: $1.00
Cached input: $0.05
Cache writes (30-min retention): $1.25
Output: $5.00
Notes: Prompts exceeding 272K input tokens incur 2× input/cache and 1.5× output rates for the full request. Batch/Flex are 50% lower; Fast mode is 2×. Regional processing may add premiums.
CometAPI currently lists GPT-6.1 Terra at approximately $0.80 input / $4.00 output (confirm in dashboard), delivering meaningful savings while providing a unified OpenAI-compatible endpoint.
How to Set Up GPT-6.1 Terra API
Direct OpenAI
Create or use an OpenAI project with API access (Build tier and above; Free tier is not supported for this model).
Generate an API key and store it securely (environment variable or secret manager).
Install the latest OpenAI SDK: pip install --upgrade openai (Python) or npm install openai (Node.js).
Via CometAPI (Recommended for most production and multi-model use)
How Do You Access the GPT-6.1 Terra API in CometAPI?
Account and credentials
Sign in at CometAPI, generate an API key, and confirm that gpt-6.1-terra is available. Store the credential as an environment variable, not in your application source code.
A CometAPI key authenticates requests to CometAPI. Keep it in your development environment or backend; do not embed it in a public web page or commit it to source control. The environment variable must be available in the terminal that runs your script.
Set the key in Bash.
export COMETAPI_KEY="your_cometapi_api_key"
On Windows, set the same variable in PowerShell.
$env:COMETAPI_KEY="your_cometapi_api_key"
A small, specific first request
Use one short text prompt and one response before adding image data, a JSON schema, or functions. Confirm model access and the base URL https://api.cometapi.com/v1. If your account offers multiple routes, choose the route whose documentation covers the features you plan to use.
How Do You use a GPT-6.1 Terra API Response?
Send the first text request
Add the following code after the client setup and save the combined script as first_request.py. It asks for a short answer, checks completion, and writes the text to a UTF-8 file.
Generate a text response, verify completion, and save answer.txt.
from pathlib import Path
response = client.responses.create(
model="gpt-6.1-terra",
instructions="You are a concise technical writing assistant.",
input="Summarize three common causes of failed API integrations and their fixes.",
reasoning={"effort": "medium"},
max_output_tokens=2000,
)
if response.status != "completed":
raise RuntimeError(
f"Response status: {response.status}; "f"details: {response.incomplete_details}"
)
ifnot response.output_text.strip():
raise RuntimeError("No text returned; inspect response.output")
Path("answer.txt").write_text(response.output_text, encoding="utf-8")
print(response.output_text)
print("Saved answer.txt")
print(response.usage)
Run the combined client-and-request script.
python first_request.py
Check the saved answer
Open answer.txt and confirm that the answer addresses the prompt and contains all three requested causes and fixes. A completed API response establishes that generation finished; your application still needs to check whether the content meets its requirements. Keep the returned usage record if you are comparing request costs.
Use cURL for a direct HTTP check
For a quick endpoint check without the SDK, run this command in Bash with COMETAPI_KEY set. Inspect the returned JSON, including status, output, and usage. Do not assume that the first output item always contains the final text.
curl -sS https://api.cometapi.com/v1/responses \
-H "Authorization: Bearer $COMETAPI_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"gpt-6.1-terra","input":"Explain how AI can reduce invoice-processing errors in 100 words.","reasoning":{"effort":"medium"},"max_output_tokens":600}'
Choose request settings
Use the Responses request fields below as a compact reference. Start with model, input, and a modest output budget; add format or tool settings only when the workflow needs them.
Choose low effort for a simple extraction task, or begin with medium for document analysis. Increase effort when your own examples show a useful improvement. Under the GPT-6 parameter compatibility rules, omit temperature, top_p, and top_logprobs when effort is not none.
Reasoning tokens count toward the output budget. If the response is incomplete, inspect its status and incomplete_details before parsing or displaying it. The reasoning-token guidance explains why a small max_output_tokens value can be consumed before a complete visible answer is returned.
Controlling Reasoning Effort
Choose effort deliberately to balance quality, latency, and cost:
none: Fastest, for simple extraction/classification.
low: Routine tasks.
medium (default): Most mixed or multi-step work.
high / xhigh / max: Complex visual discrepancies, planning, or high-stakes tasks—use only when evaluations justify the extra tokens/latency.
Chat Completions works for pure text/image without tools, but tool calling and some advanced features require Responses.
How Can GPT-6.1 Terra API Analyze Images?
The model accepts images alongside text. This supports screenshot interpretation, document extraction, technical drawing review, and comparison of visual materials. OpenAI's vision input documentation specifies the input_image content block.
Analyze a local invoice image with Python
Place invoice.png in the working directory.
Encode a local PNG and send it with an invoice-extraction prompt. Terra shines at product photo matching, technical drawings, screenshots, and visual QA.
response = client.responses.create(
model="gpt-6.1-terra",
reasoning={"effort": "medium"},
input=[{
"role": "user",
"content": [
{"type": "input_text", "text": "Review this campaign image. List only visible issues with cropping, text placement, contrast, and logo safety. Cite regions and propose fixes."},
{"type": "input_image", "image_url": "https://example.com/image.jpg", "detail": "high"}
]
}]
)
print(response.output_text)
Supported formats include PNG, JPEG, WEBP, non-animated GIF. Use detail: "high" or "low" appropriately; higher detail costs more tokens. Base64 data URLs are also supported.
Tool Calling, Computer Use, and Structured Outputs
Tool calling (function calling, computer use, web search, file search, code interpreter, MCP, etc.) requires the Responses API.
Best practices for computer use:
Run in an isolated environment (browser/VM).
Apply strict allowlists for sites/actions.
Require human approval for high-impact actions (purchases, deletions, data export).
Set step/time/cost limits.
Verify final state rather than trusting the model summary alone.
Treat page content as untrusted (strong prompt-injection resistance is claimed, but defense-in-depth is essential).
Should You Use Responses or Chat Completions?
For GPT-6.1 Terra, Chat Completions supports ordinary text and image requests without tools. Tool calling requires Responses, which is also recommended for multi-step agent workflows, conversation state management, preserving reasoning context across tool calls, and advanced streaming events. Use Responses for the examples below and for workflows that rely on its structured-output or state-management features. A compatible gateway must also support the endpoint and fields you send. See the official migration guidance.
When moving an existing integration, check three things before changing traffic: the model ID, the endpoint, and your request parameters. A tool-enabled Chat Completions request needs a Responses implementation; changing only the model name is not enough. In Responses, use reasoning.effort; in Chat Completions, use reasoning_effort.
Comparison Table: GPT-6.1 Terra vs Related Models
Handle Errors in a GPT-6.1 Terra API Workflow
First separate a request that needs correction from a temporary connection or service failure. Start from the smallest working request when diagnosing optional parameters, and keep error details in server-side logs without including the API key.
Authentication or access failure: verify the key, destination host, account access, and available balance before retrying.
Unsupported parameter: remove optional fields, confirm the endpoint and model, and add one field at a time.
Incomplete generation: inspect status and incomplete_details; adjust the output budget or simplify the task before consuming the result.
Rate limit or transient failure: use bounded backoff and a retry limit. Retrying can generate another billable response.
Interrupted stream: preserve partial text as interrupted output. Do not treat it as a complete answer or execute an action based on a partial tool request.
Tool or downstream failure: check the saved response and operation records before repeating a business
Conclusion
GPT-6.1 Terra represents a practical leap for developers building high-volume visual and computer-use agents. Its combination of improved capability, dramatically better cost-efficiency, and configurable reasoning makes it the default choice for many production workloads that previously required more expensive models.
Start with the Responses API, begin at medium reasoning effort, enforce structured outputs and safety guardrails, and route traffic through a unified platform like CometAPI for optimal cost and flexibility. With the setup and patterns outlined above, you can move from zero to production-ready integration in minutes while keeping long-term costs under control.
For the absolute latest pricing, rate limits, and feature availability, always cross-check the official OpenAI documentation and your CometAPI dashboard. Happy building!
FAQs
Can multiple users share a GPT-6.1 Terra API conversation?
Keep conversation history isolated by user or authorized workspace. A shared backend may hold the API credential, but that does not give every user permission to read every conversation. Before loading prior messages or stored results, check that the current user can access that conversation. For collaborative workflows, define who can view and extend the shared history.
Will the same GPT-6.1 Terra API prompt return identical text?
Do not rely on byte-identical output from repeated generation. Preserve the prompt, model ID, settings, and accepted result when reproducibility matters. If a workflow needs the exact same approved wording later, retrieve the saved answer rather than generating it again. Evaluate a new response against the task requirements instead of treating wording differences alone as a failure.
Does store=False define the privacy policy for the entire API workflow?
No. A request-level storage setting does not describe every log, cache, or retention policy across your application and API gateway. Review the terms and data controls that apply to each service before sending confidential documents. Limit the data you submit and avoid recording sensitive prompt content in application logs merely to make debugging easier.
How do I get a GPT-6.1 Terra API key?
You can access the GPT-6.1 Terra API through CometAPI. Create an account, generate an API key, and configure your SDK with the base URL https://api.cometapi.com/v1 and model ID gpt-6.1-terra. No separate OpenAI API key is required.
How much does the GPT-6.1 Terra API cost?
As of October 28, 2026, OpenAI's official pricing is $1.00 per million input tokens, $0.05 per million cached input tokens, and $5.00 per million output tokens. CometAPI's published rates are $0.80 for input and $4.00 for output, approximately 20% lower. For 10,000 uncached input tokens and 2,000 output tokens, the estimated cost is $0.016 through CometAPI versus $0.020 through OpenAI, excluding additional charges.
Is GPT-6.1 Terra API free to use?
No. According to OpenAI's model documentation, GPT-6.1 Terra is unavailable on the Free API tier and accessible from the paid Build tier onward. ChatGPT Plus, Pro, Enterprise, and Edu users can access Terra through ChatGPT Work and Codex, but API usage is billed separately from ChatGPT subscriptions. Alternatively, developers can access GPT-6.1 Terra through CometAPI with a valid API key and sufficient credits, subject to provider availability.
Specification
Details
Model ID
gpt-6.1-terra
Context Window
1,050,000 tokens
Max Input Tokens
~922,000
Max Output Tokens
128,000
Knowledge Cutoff
June 1, 2026
Input Modalities
Text, Image
Output Modalities
Text
Reasoning Effort Levels
none, low, medium (default), high, xhigh, max
Supported Endpoints
Chat Completions, Responses, Batch
Tool Calling
Requires Responses API
Fine-tuning
Not supported
Parameter
Use in this tutorial
model
Select gpt-6.1-terra.
input
Pass a prompt, messages, images, or conversation items.
instructions
Set behavior and output requirements.
reasoning.effort
Choose none, low, medium (default), high, xhigh, or max.
max_output_tokens
Cap the combined reasoning and visible output budget.
