GPT-6.1 Terra API Guide: Pricing, Capabilities, and Getting Started
Build Your First GPT-6.1 Terra Integration With Python, Then Add Image Inputs for Visual Workflows. Understand Standard Token Prices, Caching and Long-Context Costs, Choose the Right Endpoint for Tools, and Learn What to Validate Before Moving From a Successful Request to a Production Feature.
GPT-6.1 Terra gives developers a new model to evaluate for image understanding, screen-based workflows, and writing. OpenAI’s October 26 release entry confirms its launch through Responses and Chat Completions. The useful starting point is a small integration: send a request, inspect the result, and measure whether it solves your workload at an acceptable cost.
This guide uses the official OpenAI API. It does not assume that another provider exposes the same model ID, endpoints, or prices.
What GPT-6.1 Terra Supports
The official model page lists these integration essentials:
| Setting | Supported Value |
|---|---|
| Model ID | gpt-6.1-terra |
| Input | Text and images |
| Native output | Text |
| Context window | 1,050,000 tokens |
| Maximum output | 128,000 tokens |
| Reasoning effort | none, low, medium (default), high, xhigh, max |
| Tool calling | Requires the Responses API |
OpenAI positions Terra for tasks such as product-photo matching and technical-drawing interpretation. That makes it a candidate for analyzing creative assets before a separate generation step—not a replacement for an image or video generator. Native audio and video are not supported.
Start with Responses for a new integration, especially if tools are on your roadmap. Do not assume that a Chat Completions implementation provides identical tool access.
Make Your First API Request
You need Python, an OpenAI API project with access to the model, and an API key. Follow the official developer quickstart for account and key setup. Keep the key on your server, never in browser code or a public repository.
Install the Python SDK:
python -m pip install --upgrade openaiSave this as terra_start.py. It reads OPENAI_API_KEY if configured; otherwise, it asks for the key without displaying it:
import os
from getpass import getpass
from openai import OpenAI
api_key = os.environ.get("OPENAI_API_KEY") or getpass("OpenAI API key: ")
client = OpenAI(api_key=api_key)
response = client.responses.create(
model="gpt-6.1-terra",
reasoning={"effort": "low"},
input=(
"Write a two-sentence product description using only these facts: "
"a ceramic desk planter, matte white finish, drainage hole. "
"Do not invent dimensions, certifications, or environmental claims."
),
)
print(response.output_text)
print(response.usage)Run python terra_start.py. The text response checks basic connectivity; the usage object helps you inspect token consumption. This is a starter example, not a reported performance test. Each successful call can incur API charges.
The explicit low setting gives you a repeatable baseline. Try medium on the same inputs before choosing a setting for harder tasks; judge the resulting accuracy, latency, and bill together.
Add an Image Input
For a first visual test, use a JPEG you own and place it next to your script as product.jpg. Replace the request above with the following block, keeping the client setup. The structure follows OpenAI’s image-input documentation:
import base64
from pathlib import Path
image_data = base64.b64encode(
Path("product.jpg").read_bytes()
).decode("ascii")
response = client.responses.create(
model="gpt-6.1-terra",
reasoning={"effort": "low"},
input=[{
"role": "user",
"content": [
{
"type": "input_text",
"text": (
"Describe the visible product type, color, and shape. "
"Separate observations from uncertain inferences. "
"Do not infer a brand, price, dimensions, or material "
"unless directly supported by the image."
),
},
{
"type": "input_image",
"image_url": f"data:image/jpeg;base64,{image_data}",
},
],
}],
)
print(response.output_text)
print(response.usage)Base64 packages the local image into the request; it does not keep the image on your machine. Use assets you are authorized to send. For a PNG, change both the filename and MIME type to image/png.
The response is descriptive text, not a database-ready object. If your application needs fixed fields, use Structured Outputs with a JSON schema—a definition of the required data shape. Validate the field values separately, and handle refusals or incomplete responses before saving records.
GPT-6.1 Terra API Pricing
As of October 27, 2026, OpenAI’s pricing page lists these Standard, short-context text-token rates in USD:
| Billing Category | Price per 1 Million Tokens |
|---|---|
| Uncached input | $1.00 |
| Output | $5.00 |
| Cached input | $0.05 |
| Cache write, 30-minute retention | $1.25 |
| Cache write, 12-hour retention | $2.50 |
A hypothetical request with 10,000 uncached input tokens and 2,000 billable output tokens costs $0.02 at these rates, excluding other charges. OpenAI’s reasoning documentation explains that internal reasoning tokens are billed as output, so visible answer length alone does not determine cost.
The model’s documented pricing conditions also matter: above 272K input tokens, the entire request uses 2× input/cache rates and 1.5× output rates. Batch/Flex is 50% below Standard; Fast is 2× Standard. Regional processing adds 10% where available.
Do not interpret this table as a flat price per image or API call. Image inputs are token-billed; tools can add charges. A cache-read discount also does not make cache writes free.
Evaluate the Workflow Before Scaling
A sensible first experiment is product-image description with human review. Assemble a small labeled set containing clear photos, ambiguous materials, partially obscured objects, and unreadable labels. Define what counts as correct before running requests.
Measure four things:
- Accuracy: Does the answer distinguish visible facts from guesses?
- Usability: How often can the result be accepted without editing?
- Latency: What are typical and slow-request completion times?
- Cost per accepted result: Include rejected outputs and retries, not just successful requests.
Keep the prompts, images, and reasoning settings fixed when comparing configurations. These are evaluation recommendations, not benchmark results. A convincing demonstration does not establish production reliability.
Fix Common Integration Problems
| Symptom | First Check |
|---|---|
| Authentication or access failure | Verify the key’s project, model access, and billing configuration. |
| Unsupported tool request | Use Responses and check the specific tool’s documented schema. |
| Image rejected | Confirm the file format, MIME type, and request structure. |
| Plausible but incorrect description | Improve image legibility, request uncertainty explicitly, and retain review. |
| Unexpected cost | Inspect usage, reasoning, cache writes, context length, and service tier. |
For computer-control workflows, begin in a sandbox with narrowly permitted actions. Reading a screenshot and authorizing a consequential action are different responsibilities; keep sensitive operations behind application-level checks.
Start Small, Then Choose Your Production Route
Use GPT-6.1 Terra first on one measurable task. A working API request proves connectivity; a controlled evaluation tells you whether the feature is worth shipping.
If your next step is making or editing a visual rather than analyzing one, explore PicEditor’s image tools. Keep visual analysis and image creation as distinct stages, and choose the tool that matches the result you need. The OpenAI API examples above are separate from PicEditor’s browser-based tools.
