Claude Opus 5 vs Gemini 3.1 Pro
Qual usar, quando — veredito curado, não uma tabela de benchmark
Escolha o Gemini 3.1 Pro quando a carga de trabalho envolver documentos longos e for multimodal: ele lê texto, imagem, áudio e vídeo a $2/$12 contra $5/$25 do Opus 5. Escolha o Claude Opus 5 para codificação agêntica profunda e uso de ferramentas de longo alcance, e observe que seu tokenizador cobra o mesmo texto como mais tokens do que a geração Sonnet 4.6 — compare a contagem de tokens, não os preços de tabela.
Preços
| Claude Opus 5 | Gemini 3.1 Pro | Δ | |
|---|---|---|---|
| Entrada / 1M tokens | $5 | $2 | 2.5× |
| Saída / 1M tokens | $25 | $12 | 2.1× |
| Leitura de cache / 1M tokens | $0.5 | $0.2 | 2.5× |
| Escrita de cache | 1.25x (5m) / 2x (1h) | — | — |
Tarifas do catálogo em tempo real no momento do build; a página de cada modelo contém o cartão atual.
Onde eles se posicionam — preço de entrada por 1M tokens entre todos os 63 modelos de chat nesta unidade de cobrança (escala logarítmica)
Capacidades
| Claude Opus 5 | Gemini 3.1 Pro | |
|---|---|---|
| Uso de ferramentas | sim | sim |
| Controle de raciocínio | configurável | sempre ativo |
| Saída estruturada | sim | sim |
| Cache de prompt | explícito (você marca o prefixo) | implícito + explícito |
| Tempo de vida do cache | 5m default, 1h option | não publicado |
| Prefixo mínimo em cache | 1024 tokens | 4096 tokens |
Especificações
| Claude Opus 5 | Gemini 3.1 Pro | |
|---|---|---|
| Modalidades de entrada | texto imagem | texto imagem áudio vídeo |
| Modalidades de saída | texto | texto |
| Lançamento | 2026-07-24 | 2026-02-19 |
| Corte de conhecimento | 2026-05 | 2025-01 |
| Janela de contexto | 1M | 1M |
| Saída máxima | 128K | 66K |
| Parâmetro de raciocínio |
| thinkingLevel |
| Valores aceitos | thinking.type
effort
|
|
| Padrão | thinking on effort
| high |
As especificações são transcritas da documentação de cada fornecedor; uma linha que um fornecedor não publica é omitida em vez de ser inferida. Fontes completas: Claude Opus 5 · Gemini 3.1 Pro
Um prompt, ambos os modelos — medidos pelo gateway
Claude Opus 5 passou · 3 sentences
When reasoning is enabled, the model generates a hidden chain of "thinking" tokens before it writes the visible answer, and those internal tokens are billed at the output rate even though no one ever sees them — commonly 3–10x more tokens than the response itself. Because output tokens are priced several times higher than input tokens, that added volume hits us at our most expensive rate, which is why the bill roughly doubled while our request count stayed flat. The spend is controllable: we can cap the reasoning budget per call, route only genuinely hard requests to reasoning mode and cheaper models for the rest, and track cost per successfully completed task rather than cost per token, since a single correct answer usually beats three cheap retries plus human cleanup.
saída 529 tok latência 9.0 s
Gemini 3.1 Pro passou · 3 sentences
Enabling the AI's reasoning capability forces the model to generate a massive amount of invisible "thought" tokens to logically work through complex problems before delivering its final answer. Because our vendor's pricing model charges us for total computational effort—including all of these hidden background tokens—our billable usage effectively doubled per request. While this directly increases our upfront software expenses, we are trading this higher compute cost for a drastic reduction in expensive downstream errors and manual human rework.
saída 1412 tok (+1318 pensamento) latência 12.7 s
Cumprimento da instrução (exatamente três frases — contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.
Claude Opus 5 passou · 8/8 cases
## Fixed version ```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: cur = 1 if cur > best: best = cur return best ``` ## The bug The counters were tracking the wrong quantity: `cur` counted *matching adjacent pairs* rather than *elements in the current run*, and both counters started at `0` instead of `1`. Since a run of length *n* contains only *n − 1* adjacent equal pairs, every result came back one too small — `[1, 1]` returned 1, `[3, 3, 3]` returned 2 — and a single-element list returned 0 because the loop body never executed and `best` kept its initial value of `0`. […]
saída 1094 tok latência 16.1 s
Gemini 3.1 Pro passou · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` **Explanation:** The original function initializes `cur` and `best` to 0 and only increments `cur` when two adjacent elements are equal. This effectively counts the number of *matching consecutive pairs* (or transitions) rather than the actual number of *elements* in the run, causing all calculated lengths to be […]
saída 4092 tok (+3933 pensamento) latência 31.1 s
Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.
Claude Opus 5 passou · 5/5 fields, guidance "Withheld pending Q4 close"
```json { "company": "Meridian Robotics", "quarter": "Q3", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "Withheld pending Q4 close" } ``` Notes on judgment calls: - **quarter**: "September quarter" is labeled Q3 because the text refers to an upcoming "Q4 close," implying a calendar-aligned fiscal year. No fiscal year is given. - **revenue_usd_m**: 412 is stated as constant-currency and hedged ("call it"), so it's approximate; the currency is not explicitly stated as USD. - **growth_pct**: "up eleven and change" means slightly more than 11, so 11 is a floor rather than an exact figure.
saída 539 tok latência 7.6 s
Gemini 3.1 Pro passou · 5/5 fields, guidance "withheld"
```json { "company": "Meridian Robotics", "quarter": "September", "revenue_usd_m": 412, "growth_pct": "11 and change", "guidance": "withheld" } ```
saída 1806 tok (+1743 pensamento) latência 14.1 s
Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.
Claude Opus 5 passou · 123 words, 0 banned, 1 question
**Cross-Provider Prompt Caching** We're introducing Cross-Provider Prompt Caching in the API Gateway. Repeated system prompts, long documents, and few-shot examples are stored once at the gateway layer and reused across OpenAI, Anthropic, Google, and self-hosted models. Instead of paying full input token costs on every request, your application sends a cache reference, and the gateway rehydrates the context before forwarding it downstream. Why does that matter? Teams running high-volume agents and retrieval pipelines typically see input token spend fall 40 to 70 percent, with median latency dropping by several hundred milliseconds. Caches are scoped per project, encrypted at rest, and invalidated automatically when a prompt template changes. Enable it with a single header, and see the docs for TTL tuning and per-route controls.
saída 1593 tok latência 19.1 s
Gemini 3.1 Pro passou · 120 words, 0 banned, 1 question
We are excited to announce universal prompt caching for our API gateway. Handling multiple AI models usually means paying for redundant prompts across various platforms. Why should you pay twice for identical queries? Now, our gateway automatically stores and retrieves exact prompt matches regardless of the backend provider you select. This reduces latency and significantly cuts your inference costs. Whether you route a request to one service today or a different vendor tomorrow, our intelligent caching layer intercepts the call and serves the saved response instantly. Developers can configure cache expiration times and specify matching criteria directly in the control panel. Experience faster response times and optimized resource usage starting today. Upgrade your software client to version two right now.
saída 4060 tok (+3929 pensamento) latência 28.6 s
Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.
Alterne entre eles com uma linha
Ambos os IDs estão em todas as abas abaixo — o par de linhas destacado é a única edição. Mesmo endpoint, mesma chave, mesmo formato de requisição.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="claude-opus-5",
# model="gemini-3.1-pro-preview", # descomente esta linha, comente a linha acima
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "claude-opus-5",
// model: "gemini-3.1-pro-preview", // descomente esta linha, comente a linha acima
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "claude-opus-5",
# "model": "gemini-3.1-pro-preview", # descomente esta linha, comente a linha acima
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "claude-opus-5",
// Model: "gemini-3.1-pro-preview", // descomente esta linha, comente a linha acima
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("claude-opus-5")
// .model("gemini-3.1-pro-preview") // descomente esta linha, comente a linha acima
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));FAQ
Qual é mais barato, Claude Opus 5 ou Gemini 3.1 Pro?
Gemini 3.1 Pro é mais barato em entrada / 1m tokens ($2 vs $5, com 2.5× de diferença). Outras linhas podem apontar para o outro lado — a tabela acima traz o quadro completo, e o custo real depende do seu mix.
Posso fazer um teste A/B de Claude Opus 5 contra Gemini 3.1 Pro sem duas integrações?
Sim. Ambos são servidos pelo mesmo endpoint compatível com OpenAI com uma única chave de API — a troca é uma alteração de uma linha na string do modelo, de modo que você pode rotear uma fração do tráfego para cada um e comparar as faturas diretamente.
Claude Opus 5 e Gemini 3.1 Pro suportam prompt caching?
Sim — ambos cobram leituras em cache abaixo da sua taxa de entrada, então cargas de trabalho com warm-prefix custam menos do que as taxas listadas sugerem. As linhas exatas de leitura em cache estão na tabela de preços acima.