> Markdown mirror of https://router.one/blog/gpt-6-1-terra-api-guide for AI assistants and crawlers. Router One is a unified, OpenAI-compatible LLM API gateway.
> Published: 2026-10-28 · Author: Router One Team

# GPT-6.1 Terra API Guide: Model ID, Tool Calls, Billing

_GPT-6.1 Terra on Router One: openai/gpt-6.1-terra ID, tool calls on the Responses API per OpenAI, wallet billing (no plan tier) and what changes from 6.1 Sol._

Router One lists GPT-6.1 Terra, which OpenAI released on October 26, 2026, as `openai/gpt-6.1-terra` as of the 2026-10-28 catalog. The [GPT-6.1 Terra model page](https://router.one/models/gpt-6-1-terra) lists two endpoints for it: `POST /v1/responses`, the wire format Codex CLI speaks, and `POST /v1/chat/completions`. Point any OpenAI-compatible SDK or client at `https://api.router.one/v1`, send `"model": "openai/gpt-6.1-terra"` with a Router One key, and the request is routed, metered and logged like every other model. GPT-6.1 Terra is in no plan tier as of the 2026-10-28 plan response, so every call bills per token to your wallet, plan or no plan; the model page carries the live rates.

This guide covers what the catalog lists for the id, how OpenAI positions it against GPT-6.1 Sol, GPT-6 Astra and GPT-5.6 Terra, what changes in requests written for GPT-6.1 Sol or GPT-5.6 Terra, what OpenAI documents about computer use, how billing works when no plan covers the model, and the first request on each endpoint. Catalog and plan observations are dated; the live catalog is the source of truth for a new request.

## GPT-6.1 Terra at a glance

| Field | What the catalog lists (2026-10-28) |
| --- | --- |
| Catalog id | `openai/gpt-6.1-terra`, listed as of the 2026-10-28 catalog |
| Context window | 1,050,000 tokens |
| Input / output | text and image in, text out |
| Capability flags | chat, streaming, tool calling, vision |
| Price lines | two: a standard line, and a whole-request line for requests strictly above 272,000 input tokens |
| Endpoints | `POST /v1/responses` and `POST /v1/chat/completions`, as the model page lists them |
| Not served on | `POST /v1/messages` (Claude-family and DeepSeek ids only) |
| Channel | default channel only — the 2026-10-28 catalog lists no Azure-channel id for it |
| Plans | no Pro, Max or Ultra tier (2026-10-28 plan response) — wallet billing |

OpenAI's [GPT-6.1 Terra model page](https://developers.openai.com/api/docs/models/gpt-6.1-terra) (checked 2026-10-28) adds what the catalog does not carry. It describes "a fast, efficient model for visual reasoning, precise computer use, and clear, natural writing", lists a maximum of 922,000 input tokens and 128,000 output tokens inside the 1,050,000-token window and a June 1, 2026 knowledge cutoff, and documents `reasoning.effort` values `none`, `low`, `medium` (the default), `high`, `xhigh` and `max`. The same page says tool calling requires the Responses API. Those are OpenAI's statements; what Router One vouches for is the catalog entry and how the gateway routes and bills it.

## GPT-6.1 Terra, GPT-6.1 Sol, GPT-6 Astra or GPT-5.6 Terra?

OpenAI's [GPT-6 guide](https://developers.openai.com/api/docs/guides/latest-model) (checked 2026-10-28) lists GPT-6.1 Terra beside GPT-6 Astra and GPT-6.1 Sol and gives each a one-line label: GPT-6 Astra for the "highest intelligence", GPT-6.1 Sol for "balanced speed, cost, and intelligence", and GPT-6.1 Terra as "fast and efficient", for visual reasoning, precise computer use and clear, natural writing — matching product photos to catalog entries, comparing technical drawings, acting on application screens, or drafting and revising text. OpenAI's [model selection guide](https://developers.openai.com/api/docs/guides/model-selection) (checked 2026-10-28) suggests trying GPT-6.1 Terra for concise writing based on supplied material, computer-use tasks with a defined outcome and scoped code fixes, and comparing it with GPT-6.1 Sol on the same inputs and reasoning effort. GPT-5.6 Terra, the earlier Terra model, is "designed for workloads that balance intelligence and cost", per its own model page. Those are OpenAI's descriptions, not Router One measurements: run your own prompts on the same inputs before you move a workload.

What Router One adds to the choice:

- **Plan quota or wallet.** As of the 2026-10-28 plan response, GPT-6.1 Terra is in no plan tier, so it bills the wallet on every account; GPT-6.1 Sol counts against the Premium models allowance of Pro, Max and Ultra, GPT-5.6 Terra against the Mid-tier models allowance of all three plans, and GPT-6 Astra against the Flagship models allowance, which Max and Ultra carry.
- **Posted rates.** Router One posts its own rates for each id. The comparison pages below render the live figures side by side, so re-baseline cost when you switch.
- **Same request path.** All four are GPT-family ids that the model pages list on `/v1/responses`, the Codex CLI path, and on `/v1/chat/completions`.

Two comparison pages render the spec sheets and live rates side by side:

- [GPT-6.1 Terra vs GPT-6.1 Sol](https://router.one/models/compare/gpt-6-1-terra-vs-gpt-6-1-sol) — the comparison OpenAI itself suggests; in the 2026-10-28 plan response GPT-6.1 Sol draws the Premium models allowance, while GPT-6.1 Terra is in no plan tier and bills the wallet.
- [GPT-6.1 Terra vs GPT-5.6 Terra](https://router.one/models/compare/gpt-6-1-terra-vs-gpt-5-6-terra) — the generation step; tool calls move to the Responses API, and in the 2026-10-28 plan response GPT-5.6 Terra draws the Mid-tier models allowance, while GPT-6.1 Terra bills the wallet.

## What changes in your requests

The key, base URL and endpoints stay the same when you move to GPT-6.1 Terra from another GPT id, and OpenAI's model pages list the same 1,050,000-token window, maximum input and output, and input types for GPT-6.1 Terra, GPT-6.1 Sol and GPT-5.6 Terra. What changes, per OpenAI's [GPT-6 guide](https://developers.openai.com/api/docs/guides/latest-model) (migration quickstart and the GPT-6.1 Terra section, checked 2026-10-28):

From GPT-6.1 Sol:

- **The model string.** `openai/gpt-6.1-sol` becomes `openai/gpt-6.1-terra`.
- **Reasoning effort.** GPT-6.1 Terra also accepts `none`, which GPT-6.1 Sol does not; both default to `medium` and accept `low` to `max`. Set it with `reasoning.effort` on Responses or `reasoning_effort` on Chat Completions. OpenAI suggests starting at `medium` and raising it if the gain in quality is worth the added time and tokens.
- **Sampling parameters.** OpenAI's rule is the same for both: when the reasoning effort is not `none`, remove `temperature`, `top_p` and `top_logprobs`, plus `logprobs` on Chat Completions; on Responses, take `message.output_text.logprobs` out of `include`. GPT-6.1 Terra defaults to `medium`, so leave them out; OpenAI's rule covers every effort other than `none`.
- **Tool calls.** No change: both models take tool calls only on the Responses API.
- **Knowledge cutoff.** Per the two model pages, June 1, 2026, against GPT-6.1 Sol's April 30, 2026.

From GPT-5.6 Terra:

- **The model string.** `openai/gpt-5.6-terra` becomes `openai/gpt-6.1-terra`.
- **Tool calls.** OpenAI's guide says that if your application calls tools through Chat Completions, those requests migrate to the Responses API. GPT-6.1 Terra takes tool calls only on the Responses API, so code that sends tools on `/v1/chat/completions` moves to `/v1/responses`.
- **Compare before you switch.** OpenAI suggests comparing both models on representative images and workflows at the same reasoning effort.
- **Reasoning effort.** Both model pages list the same values, `none` to `max`, with `medium` as the default.
- **Knowledge cutoff.** June 1, 2026, against GPT-5.6 Terra's February 16, 2026.

GPT-5.6 Terra remains listed: as of the 2026-10-28 catalog, Router One still lists `openai/gpt-5.6-terra`, and OpenAI's deprecations page (checked 2026-10-28) names no retirement for it.

## Computer use and image input

OpenAI's model page lists `computer_use` among the tools GPT-6.1 Terra supports on the Responses API, and its [computer use guide](https://developers.openai.com/api/docs/guides/tools-computer-use) (checked 2026-10-28) describes the tool as a loop your application runs: the model returns `computer_call` items, your code carries them out in an environment you provide, and you send the result back as `computer_call_output`, with a screenshot, until the task is done. That is OpenAI's documentation for its own API. This guide makes no claim about running a computer-use loop through Router One; test one on your own key before you depend on it.

The catalog lists text and image input for `openai/gpt-6.1-terra`, and the visual tasks OpenAI names — product photos, technical drawings, application screens — work from images: an image in the request, or screenshots your application returns in the computer-use loop. OpenAI's GPT-6 guide points to its image inputs guide for visual analysis and to the computer use guide for acting on screens.

## How billing works

The model page shows two rate lines, and the total input tokens of one request select which one applies. At exactly 272,000 input tokens the standard line still applies. Strictly above it, the long-context line applies to the whole request — output included — not only to the tokens past the threshold. Monthly volume plays no part. OpenAI's model page (checked 2026-10-28) prices a prompt with more than 272K input tokens at twice its input and cache prices and 1.5 times its output price, for the full request, and Router One's long-context line mirrors that rule.

An agent loop that resends a growing conversation can cross 272,000 input tokens. From that request on, each request bills on the long-context line until the context is back under the threshold, so the client's compaction settings decide which line most of a long session lands on.

Reasoning output is billed at the model's posted output rate, with no separate reasoning line ([pricing facts](https://router.one/facts/pricing.md)), so the reasoning effort is a cost lever as much as a quality one, and on GPT-6.1 Terra it reaches down to `none`. The model page also lists a cached-input line; the [prompt caching guide](https://router.one/llm-prompt-caching) shows how to read cache counts in `usage` so input is not counted twice, the [pricing methodology](https://router.one/pricing-methodology) spells out the long-context rule, and the [cost calculator](https://router.one/llm-cost-calculator) applies it per request.

This guide prints no per-token figures because they go stale. The [GPT-6.1 Terra model page](https://router.one/models/gpt-6-1-terra) shows both lines live, and the comparison pages above render the gap against GPT-6.1 Sol and GPT-5.6 Terra.

## Do subscription plans cover GPT-6.1 Terra?

Not as of the 2026-10-28 plan response: GPT-6.1 Terra is in no tier of the Pro, Max or Ultra plans, so its calls bill per token to your wallet balance at the posted rates, whether or not you hold a plan. In the same response GPT-6.1 Sol is in the Premium models tier of all three plans, GPT-5.6 Terra in the Mid-tier models tier of all three, and GPT-6 Astra in the Flagship models tier of Max and Ultra. Plan model lists change; the [pricing page](https://router.one/pricing) shows the live lists and each plan's allowance.

## Send the first request

1. **Create a key.** Dashboard → API Keys → Create Key. Keys look like `sk-...`. For a trial, give the key a `maxSpend` cap. A key's spend cap (maxSpend) limits what that key can charge to your wallet: once its cumulative wallet charges reach the cap, its wallet-billed requests return HTTP 402. Requests covered by your plan's quota draw from the account's shared plan quota and do not count toward any key's cap. Your other keys keep working ([per-key cost tracking](https://router.one/llm-cost-tracking)).
2. **Keep a wallet balance.** GPT-6.1 Terra calls bill the wallet, on a plan or not (2026-10-28 plan response) — top up in Dashboard → Deposit.
3. **Set the base URL** to `https://api.router.one/v1` in any OpenAI-compatible SDK or client.
4. **Call the model.** The examples use the catalog id `openai/gpt-6.1-terra` and set an explicit output cap.

Responses, with the reasoning effort set explicitly (`medium` is the vendor default):

```bash
curl https://api.router.one/v1/responses \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6.1-terra",
    "reasoning": {"effort": "medium"},
    "max_output_tokens": 25000,
    "input": "Rewrite this changelog line for customers in one plain sentence: Fixed a race in token refresh that caused intermittent 401s."
  }'
```

Tool calls go on this endpoint. A function tool in the Responses format:

```bash
curl https://api.router.one/v1/responses \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6.1-terra",
    "reasoning": {"effort": "low"},
    "max_output_tokens": 25000,
    "tools": [{
      "type": "function",
      "name": "get_order_status",
      "description": "Look up the status of an order by its id.",
      "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]
      }
    }],
    "input": "Where is order 8812?"
  }'
```

When the output contains a `function_call` item, run the function and send its result back as a `function_call_output` item with the same `call_id`.

Chat Completions, for clients that send it — without tools, since OpenAI's model page says tool calling requires the Responses API:

```bash
curl https://api.router.one/v1/chat/completions \
  -H "Authorization: Bearer sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6.1-terra",
    "max_tokens": 25000,
    "messages": [{"role": "user", "content": "Rewrite this changelog line for customers in one plain sentence: Fixed a race in token refresh that caused intermittent 401s."}]
  }'
```

The same Responses call from the OpenAI Python SDK — only `base_url` and the key change:

```python
from openai import OpenAI

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

response = client.responses.create(
    model="openai/gpt-6.1-terra",
    reasoning={"effort": "medium"},
    max_output_tokens=25000,
    input="Rewrite this changelog line for customers in one plain sentence: Fixed a race in token refresh that caused intermittent 401s.",
)
print(response.status, response.output_text)
print(response.usage)
```

Rules that hold on both endpoints:

- **Set an output cap on every request.** Reasoning tokens count toward the output cap; OpenAI suggests reserving at least 25,000 tokens for reasoning and outputs when you start (reasoning guide, checked 2026-10-28). On the Responses API, per the same guide, a response that reaches the cap comes back with `status: "incomplete"`, possibly before any visible text. On Router One's Chat Completions, `max_tokens` and `max_completion_tokens` both set this cap (if both are sent, `max_completion_tokens` wins); on the Responses API it is `max_output_tokens`.
- **Leave out the sampling parameters.** No `temperature`, `top_p`, `top_logprobs` or `logprobs`: OpenAI's rule covers every effort other than `none`, as listed above.
- **Stream long work.** `stream: true` returns output as it is generated, on either endpoint ([streaming guide](https://router.one/llm-streaming)).
- **Stay off `/v1/messages`.** Sending the id there returns HTTP 400 before any model is called, and the message says the model must be called via /v1/chat/completions. The [API compatibility facts](https://router.one/facts/api-compatibility.md) state the endpoint rule per family.

5. **Read the trace.** Dashboard → Logs shows each call with model, input and output tokens, cost, latency and status ([per-request observability](https://router.one/llm-observability)). Retryable upstream failures are absorbed by [automatic fallback](https://router.one/llm-fallback) across the candidate routes for the same model; a GPT-6.1 Terra request is never answered by a different model.

## Other coding tools

Coding agents send tools on almost every turn, and per OpenAI's GPT-6.1 Terra model page (checked 2026-10-28) tool calling requires the Responses API, so agent work with it needs a client that sends Responses requests. Before you point a tool at it, check which protocol that tool sends: the tool table in [GPT-6 Sol in Codex CLI, Cursor, Cline and OpenCode](https://router.one/blog/gpt-6-sol-coding-tools-setup) lists the request path per tool. Claude Code cannot call GPT-6.1 Terra: it sends Anthropic Messages requests, and `/v1/messages` serves Claude-family and DeepSeek ids only. Per the openai/codex source (rust-v0.165.0, checked 2026-10-28), Codex CLI 0.165.0 added `gpt-6.1-terra` to its bundled model list; the default that Codex 0.159.1 and later use when `config.toml` names no model is still `gpt-6.1-sol`.

## From mainland China

Requests reach `api.router.one` from mainland China without a VPN, on the same key and base URL. Top up with a card or Alipay through one hosted checkout, or with USDT/USDC on six chains (Tron, BSC, Ethereum, Polygon, Base, Arbitrum). No US credit card required. GPT-6.1 Terra's live rates are on its [model page](https://router.one/models/gpt-6-1-terra); for Codex CLI, see [Codex CLI in China](https://router.one/codex-china).

## FAQ

**What is the model id for GPT-6.1 Terra on Router One?**
openai/gpt-6.1-terra, listed as of the 2026-10-28 catalog; use it on /v1/responses and /v1/chat/completions. GPT-5.6 Terra (openai/gpt-5.6-terra) is a different, earlier model, also listed as of the 2026-10-28 catalog. GPT-6.1 Terra is in no plan tier as of the 2026-10-28 plan response, so its calls bill the wallet per token.

**Is GPT-6.1 Terra included in Router One subscription plans?**
Not as of the 2026-10-28 plan response: GPT-6.1 Terra is in no tier of the Pro, Max or Ultra plans, so its calls bill per token to the wallet, on a plan too. In the same response GPT-6.1 Sol is in the Premium models tier of all three plans and GPT-5.6 Terra in the Mid-tier models tier. The pricing page shows the live plan model lists.

**GPT-6.1 Terra or GPT-6.1 Sol?**
OpenAI labels GPT-6.1 Terra "fast and efficient" and GPT-6.1 Sol "balanced speed, cost, and intelligence" (GPT-6 guide, checked 2026-10-28), and its model selection guide suggests comparing the two on the same inputs and reasoning effort. Per OpenAI, both take tool calls only on the Responses API, and only GPT-6.1 Terra accepts the none reasoning effort. On Router One the billing differs: as of the 2026-10-28 plan response, GPT-6.1 Sol counts against the Premium models allowance on Pro, Max and Ultra, while GPT-6.1 Terra is in no plan tier and bills the wallet. The GPT-6.1 Terra vs GPT-6.1 Sol page renders the live rates side by side.

**Can I call tools on Chat Completions with GPT-6.1 Terra?**
Not per OpenAI: its GPT-6.1 Terra model page (checked 2026-10-28) says tool calling requires the Responses API, and its GPT-6 guide says GPT-6.1 Terra supports Chat Completions but takes tool calls only through Responses. Send tool-using requests to /v1/responses and keep Chat Completions for requests without tools; GPT-5.6 Terra code that sends tools on Chat Completions has to move.

**Which reasoning efforts does GPT-6.1 Terra accept?**
Per OpenAI's model page (checked 2026-10-28): none, low, medium (the default), high, xhigh and max. OpenAI's GPT-6 guide suggests starting at medium and raising it if the gain in quality is worth the added time and tokens. At any effort other than none, OpenAI says to leave out temperature, top_p and top_logprobs (plus logprobs on Chat Completions). Reasoning tokens bill as output, so the effort is also the cost lever.

**Why does a request over 272K input tokens cost more?**
Because the model page has two rate lines and the whole request moves to the long-context line once its total input is strictly above 272,000 tokens — output included, not only the tokens past the threshold. At exactly 272,000 the standard line applies, and monthly usage does not select the line. OpenAI's model page (checked 2026-10-28) prices its own API the same way: above 272K input tokens, twice the input and cache prices and 1.5 times the output price, for the full request.

**Does Codex CLI list GPT-6.1 Terra?**
Yes, in its bundled model list from Codex CLI 0.165.0. Per the openai/codex source (rust-v0.165.0, checked 2026-10-28), that list has a gpt-6.1-terra entry, and the default that Codex 0.159.1 and later use when config.toml names no model is still gpt-6.1-sol. OpenAI's Codex models page (checked 2026-10-28) says GPT-6.1 Terra requires Codex CLI 0.159.0 or later; with a custom model provider such as Router One's, Codex by default reads a model's settings only from its bundled list, so releases before 0.165.0 run the name on generic fallback settings. GPT-6.1 Terra is in no plan tier as of the 2026-10-28 plan response, so its calls bill the wallet at its posted rates.

**Is there no GPT-6 Terra?**
OpenAI's model catalog (checked 2026-10-28) has no GPT-6 Terra entry, and its GPT-6 guide lists GPT-6.1 Terra as its Terra model. Router One lists GPT-6.1 Terra (openai/gpt-6.1-terra) as of the 2026-10-28 catalog and the earlier GPT-5.6 Terra (openai/gpt-5.6-terra); the live catalog at /models is the source of truth.

**Can Claude Code call GPT-6.1 Terra?**
No. Claude Code sends Anthropic Messages requests to /v1/messages, which serves Claude-family and DeepSeek ids only; a GPT id there returns HTTP 400 before any model is called.

## Next steps

- Open the [GPT-6.1 Terra model page](https://router.one/models/gpt-6-1-terra) for the live rates, both price lines and the endpoint list.
- Compare it with [GPT-6.1 Sol](https://router.one/models/compare/gpt-6-1-terra-vs-gpt-6-1-sol) or [GPT-5.6 Terra](https://router.one/models/compare/gpt-6-1-terra-vs-gpt-5-6-terra).
- Weighing GPT-6.1 Sol or GPT-6 Astra instead? The [GPT-6.1 Sol API guide](https://router.one/blog/gpt-6-1-sol-api-guide) and the [GPT-6 Astra API guide](https://router.one/blog/gpt-6-astra-api-guide) cover them.
- Set up Codex CLI with [Codex CLI in China](https://router.one/codex-china) and the [Codex and Responses API page](https://router.one/codex-responses-api).
- Check which models each plan covers on the [pricing page](https://router.one/pricing).
- See October's other catalog changes in the [October 2026 new-model guide](https://router.one/blog/new-llm-models-october-2026).

## See also

- Canonical page: https://router.one/blog/gpt-6-1-terra-api-guide
- Codex CLI China: https://router.one/codex-china
- All blog posts: https://router.one/blog
- Models and per-model token rates: https://router.one/models (markdown: https://router.one/models.md)
- Pricing: https://router.one/pricing
- API docs (markdown): https://router.one/docs.md
- Company facts: https://router.one/facts/company.md