GPT-6.1 Terra: OpenRouter Routing and API Configuration

One-sentence takeaway

The model ID on OpenRouter is openai/gpt-6.1-terra. It can be called through the OpenRouter SDK or an HTTP API compatible with Chat Completions. The provider field in the request body can rank, restrict, or filter candidate providers. By default, routing load-balances based on recent availability and price.

Use cases

• Suitable tasks: Connecting to GPT-6.1 Terra through OpenRouter; choosing a provider routing strategy through a single API; ranking candidate endpoints by price, throughput, or latency.

• Unsuitable tasks: Inferring the URL, key, or routing parameters of the native OpenAI API from this information; treating OpenRouter's performance ranking as a service-level guarantee.

• Applicable model version: GPT-6.1 Terra listed on the OpenRouter model page, with ID openai/gpt-6.1-terra.

• Applicable clients, agents, or APIs: OpenRouter TypeScript SDK and HTTP Chat Completions API; the model page also lists compatible Responses API and Anthropic Messages API endpoints.

• Recommended reasoning level and parameters: Choose reasoning.effort according to the task. OpenRouter documentation lists the general values max, xhigh, high, medium, low, minimal, and none. Check the model metadata and actual request results to confirm whether the model supports a particular level. The routing example uses provider.sort: "throughput".

Ready-to-use content

Set up an API key

Create an API key in the OpenRouter console and store it in an environment variable:

export OPENROUTER_API_KEY="sk-or-v1-..."

TypeScript SDK: streaming call

The following SDK call is provided on the model page. Replace the model ID and the user message in the example with the desired values:

import { OpenRouter } from "@openrouter/sdk";

const openrouter = new OpenRouter({
  apiKey: process.env.OPENROUTER_API_KEY!,
});

const stream = await openrouter.chat.send({
  chatRequest: {
    model: "openai/gpt-6.1-terra",
    messages: [{ role: "user", content: "Hello" }],
    stream: true,
  },
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

HTTP API: sort by throughput

OpenRouter's Provider Selection documentation provides the provider.sort setting. Combined with the Terra model ID, the following Chat Completions request prioritizes providers with higher throughput:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-6.1-terra",
    "messages": [{"role": "user", "content": "Hello"}],
    "provider": {"sort": "throughput"},
    "stream": false
  }'

To sort by price or latency, replace throughput with price or latency, respectively. When provider.sort is set, the router tries endpoints in sorted order, and the default price-based load balancing is turned off.

Configurable reasoning parameters

OpenRouter provides a unified reasoning parameter for models that support reasoning. First check which values the model supports before using the example level:

{
  "model": "openai/gpt-6.1-terra",
  "messages": [{"role": "user", "content": "Hello"}],
  "reasoning": {"effort": "medium"},
  "max_tokens": 4096
}

The model page also lists seed, response_format, tools, tool_choice, and verbosity as request parameters. max_tokens sets the generation limit; with most providers, reasoning tokens also count toward this limit and output billing, so leave enough budget for the visible answer.

Test or workflow steps

1. Create an API key in OpenRouter and set OPENROUTER_API_KEY.

2. Send a basic Chat Completions request using the model ID openai/gpt-6.1-terra.

3. To route by performance or cost, choose throughput, latency, or price in provider.sort. To pin a provider, use provider.only or provider.order, and set allow_fallbacks as needed.

4. Set reasoning.effort only if the model supports it. Set max_tokens appropriately, then check the response, usage, and actual charges.

flowchart LR
  A[Create an OpenRouter API key] --> B[Set OPENROUTER_API_KEY]
  B --> C[Request openai/gpt-6.1-terra]
  C --> D{Need to specify routing preferences?}
  D -- No --> E[Use default load balancing]
  D -- Yes --> F[Set provider.sort or filter providers]
  E --> G[Check response and usage]
  F --> G

Original evidence and data

• The OpenRouter model page identifies the model as OpenAI: GPT-6.1 Terra, with ID openai/gpt-6.1-terra; it lists input/output prices of $1 / $5 per million tokens, a context length of 1.1M, and a publication date of 2026-10-26. Prices and catalog information can change.

• The model page's API panel has tabs for the OpenRouter SDK, Python, TypeScript fetch, cURL, Python OpenAI SDK, and TypeScript OpenAI SDK. Its TypeScript SDK example uses openrouter.chat.send, chatRequest, the model ID above, and a streaming response.

• The API panel lists Chat Completions, Responses API, and Anthropic Messages API endpoints. The Chat Completions URL is https://openrouter.ai/api/v1/chat/completions, and the authentication header is Authorization: Bearer $OPENROUTER_API_KEY.

• The model page lists reasoning, seed, max_tokens, response_format, tools, tool_choice, and verbosity as parameters.

• Provider Selection documentation lists routing fields such as provider.order, allow_fallbacks, require_parameters, data_collection, zdr, only, ignore, quantizations, sort, preferred_min_throughput, preferred_max_latency, and max_price. By default, routing selects providers based on recent availability and price.

• Reasoning Tokens documentation describes the general values for reasoning.effort, options such as reasoning.max_tokens and reasoning.exclude, and the effect of reasoning tokens on max_tokens and billing.

Scope and limitations

• The model ID, API URL, and provider parameters on OpenRouter are configuration for accessing OpenRouter. They cannot replace the native OpenAI API URL or be taken as evidence that the native OpenAI API supports these fields.

• provider.sort is a cross-provider ranking preference; it does not guarantee actual latency, throughput, or price. Provider availability and ranking results can change over time.

• The model page lists the reasoning parameter but does not specify which reasoning levels Terra supports. medium in this article is only a format example; check the model metadata or request results before using it.

• The model page shows Responses and Anthropic Messages endpoints, but the ready-to-use HTTP example in this article covers only Chat Completions. Configure other endpoints according to the corresponding OpenRouter API documentation.

• Prices, context length, and provider information shown on the OpenRouter page reflect the page at the time it was collected and are not a long-term commitment.

Reproduction notes

Open the model page in the Tabbit browser and inspect its API panel to verify the model ID, SDK example, endpoints, and parameters. Then open OpenRouter's Provider Selection and Reasoning Tokens documentation to verify the routing fields, default policy, and reasoning parameters. The collection date was 2026-10-27. The routing configuration in the code combines the request format from the official documentation with the Terra model ID.