ToAPIs
    InícioToAPIs
    Geração de imagensGPT Image 2.6, Gemini, FLUX…Geração de vídeoSeedance, Veo, Kling, Sora…Chat e escritaGPT-5.6, Claude, DeepSeek…Voz e músicaLocuções, TTS, áudio
    NovidadeSeedance 2.5
    PreçosDocumentação da APIMCP
    BlogAlternativas
    EntrarComece grátis
    Todos os modelosPreçosDocumentação da APIMCPBlogAlternativas
    EntrarComece grátis

    Idioma

    Esc
    • Seedance 2.5Geração de vídeo
    • GPT Image 2Geração de imagens
    • GPT Image 2.6Geração de imagens
    • GPT Image 2.5Geração de imagens
    • Veo 3.1 FastGeração de vídeo
    • Kling 3.0 TurboGeração de vídeo
    • Kling V4 FlashGeração de vídeo
    • Grok Video 1.5Geração de vídeo
    • Nano Banana 2Geração de imagens
    • Seedream 5.5Geração de imagens
    • FLUXGeração de imagens
    • Sora 2Geração de vídeo
    • Todos os modelos de imagemCategoria
    • Todos os modelos de vídeoCategoria
    • GPT-5.6 SolChat e código
    • Claude Opus 4.8Chat e código
    • Claude Opus 4.7Chat e código
    • DeepSeek V4 ProDeepSeek · Texto
    • Gemini Omni 1.1 FlashGoogle · Multimodal
    1. Início
    2. Blog
    3. Comparação
    4. GPT-6.2 Astra vs Sol: preços, cenários e custo por tarefa aceita
    Voltar a todos os artigos
    comparison2026-11-1816 min de leitura

    GPT-6.2 Astra vs Sol: preços, cenários e custo por tarefa aceita

    Compare o GPT-6.2 Astra e o Sol pelos preços de tabela oficiais, com um exemplo de custo simples e uma forma em três passos de decidir quando o prêmio de 4x do Astra vale a pena.

    ToAPIs Engineering & Evaluation Team
    Educação para desenvolvedores
    GPT-6.2 AstraGPT-6.2 SolPreços de APISeleção de modelosOtimização de custos
    TL;DR - Principais conclusões
    • A OpenAI apresentou o GPT-6.2 Astra e o Sol em 17 de novembro de 2026. Nas tarifas padrão da API para contexto curto, o Astra custa $8 por milhão de tokens de entrada e $40 por milhão de saída; o Sol custa $2 e $10.
    • O Astra custa exatamente 4x o Sol nas tarifas de tabela padrão de entrada, saída e entrada em cache. Esse prêmio é uma decisão de qualidade e risco, não uma opção padrão de economia.
    • Para uma tarefa que usa 10,000 tokens de entrada e 2,000 de saída por chamada, uma chamada custa cerca de $0.04 com o Sol e $0.16 com o Astra. O Astra só ganha se evitar tentativas ou edições suficientes para compensar a diferença.
    • Os números são aritmética de planejamento a partir dos preços de tabela padrão da OpenAI, não resultados medidos nem uma cotação da ToAPIs. O harness de comparação do apêndice para desenvolvedores não foi executado para este artigo.

    GPT-6.2 Astra e Sol não são dois tamanhos da mesma compra. O Astra é o modelo da OpenAI para os projetos mais difíceis; o Sol é o modelo dela para o trabalho cotidiano e para agentes de alto volume. Nas tarifas de tabela padrão de contexto curto, o Astra custa quatro vezes mais por token de entrada e de saída. A pergunta prática, portanto, não é qual modelo soa mais forte, mas qual supera o seu critério de aceitação com o menor custo por tarefa utilizável — e quando uma saída melhor vale pagar um prêmio.

    Escopo e evidência. A OpenAI publicou o lançamento do GPT-6.2 Astra e Sol em 17 de novembro de 2026. As especificações e os preços de tabela abaixo vêm do anúncio de lançamento da OpenAI e das páginas oficiais de modelo, verificados em 18 de novembro de 2026. Este é um guia de planejamento, não um relatório de benchmark: não executamos nenhum dos modelos, não medimos latência nem pontuamos saídas. O exemplo de custo é aritmética a partir das tarifas oficiais mais as premissas indicadas. O catálogo internacional da ToAPIs lista o Astra e o Sol; use o catálogo em tempo real para as variantes, tarifas e roteamento disponíveis na sua conta. Este artigo não afirma tarifas, caminhos de endpoint nem cobertura regional específicos da plataforma.

    1. Os fatos oficiais que ancoram a decisão

    O anúncio de lançamento da OpenAI posiciona o Astra para trabalho profissional complexo — apresentações, planilhas, documentos, programação, uso do computador e raciocínio visual — e o Sol para tarefas técnicas e não técnicas do dia a dia, incluindo fluxos agênticos de várias etapas. Ambos aceitam texto e imagens e retornam texto. As páginas oficiais de modelo listam os mesmos limites de contexto e de saída para cada um:

    EspecificaçãoGPT-6.2 AstraGPT-6.2 Sol
    ID de modelo da APIgpt-6.2-astragpt-6.2-sol
    Posicionamento da OpenAIOs projetos mais difíceis, de ponta a pontaTrabalho cotidiano e agentes em escala
    Modalidades de entradaTexto, imagemTexto, imagem
    SaídaTextoTexto
    Janela de contexto1,050,000 tokens1,050,000 tokens
    Entrada máxima922,000 tokens922,000 tokens
    Saída máxima128,000 tokens128,000 tokens
    Corte de conhecimento18 de maio de 20261 de junho de 2026
    Ajuste de raciocínioMáximo; none é rejeitadoMáximo; none é rejeitado
    Ajuste finoNão suportadoNão suportado

    A diferença econômica central é o preço, não um limite de contexto diferente:

    Tarifa oficial padrão de contexto curtoAstraSolAstra / Sol
    Entrada, por 1M de tokens$8.00$2.004x
    Entrada em cache, por 1M de tokens$0.40$0.104x
    Saída, por 1M de tokens$40.00$10.004x
    Escrita de cache de 30 minutos, por 1M de tokens$10.00$2.504x

    Fonte: página de preços da API da OpenAI e páginas de modelo, verificadas em 18 de novembro de 2026. As tarifas estão em USD por milhão de tokens, antes de impostos e de qualquer cobrança da plataforma. São preços de tabela de referência, não uma cotação da ToAPIs.

    A OpenAI também faz afirmações de desempenho relatadas pelo fornecedor. Diz que o Sol fica a 0.5 pontos do Astra no FrontierCode 2.0 da Cognition com cerca de um quinto do custo (ambos com raciocínio máximo), e relata o Astra com 1,318 Elo contra 1,259 do Sol na avaliação de preferência humana AA-3D da Artificial Analysis. São resultados relatados pelo fornecedor em configurações que não auditamos. Use-os como hipóteses; seus prompts, ferramentas e regras de aceitação podem produzir uma ordem diferente.

    2. A diferença de preço de 4x: o que precisa ser verdade para o Astra

    Nas tarifas de tabela padrão de contexto curto, o Astra e o Sol têm a mesma relação 4:1 em entrada, saída e entrada em cache. Se ambos os modelos consumirem a mesma quantidade de tokens cobráveis e precisarem do mesmo número de tentativas, o Astra não pode ter um custo por tarefa aceita menor a menos que a taxa de aceitação dele seja mais de quatro vezes a do Sol. Como a aceitação é limitada a 100%, isso se torna impossível quando a taxa de aceitação do Sol passa de 25%.

    Essa afirmação tem escopo estreito: mesmo volume de tokens, mesmas tentativas, mesmas unidades cobráveis. Ainda assim é um ponto de partida útil, porque mostra o quão grande a diferença de qualidade precisa ser antes de o Astra ganhar apenas por custo. A sensibilidade do ponto de equilíbrio é assim:

    Taxa de aceitação do SolAceitação do Astra necessária para igualar o custo por tarefa aceita do Sol
    10%40%
    15%60%
    20%80%
    25%100%
    30%120% (inalcançável)
    50%200% (inalcançável)

    Pressupõe contagens de tokens e tentativas idênticas por tarefa, e que cada tentativa é cobrada. Um perfil de tokens diferente muda o ponto de equilíbrio.

    O enquadramento de ponto de equilíbrio não é um argumento de que o Astra está sobreprecificado. É um argumento contra tratar o rótulo "melhor modelo" como política de roteamento. O Astra pode ser racional quando a saída do Sol é inutilizável, quando uma resposta errada é caro, ou quando o reparo humano custa mais do que o prêmio de tokens. Raramente é o padrão para classificação, extração ou respostas curtas de suporte rotineiras.

    Três ressalvas importam:

    • A eficiência de tokens pode mover o ratio. Se o Astra alcança a aceitação com materialmente menos tokens de saída ou menos tentativas, o prêmio efetivo fica abaixo de 4x. Não temos medições pareadas, então não afirmamos um número.
    • O ratio não é a fatura. Acima de 272,000 tokens de entrada, as tarifas de entrada e cache dobram e a saída custa 1.5x sobre toda a requisição. A relação 4:1 de tarifas de tabela se mantém, mas os custos absolutos sobem; não reutilize exemplos de contexto curto para trabalho de contexto longo.
    • Outras unidades cobráveis podem quebrar o ratio. Chamadas de ferramentas, contêineres, busca de arquivos, modos batch ou Fast, Ultrafast, janelas em segundo plano, acréscimos regionais, impostos e taxas de plataforma ficam fora desta aritmética. Verifique a página de preços oficial e a tarifa da sua conta.

    3. Mapa de cenários: onde cada modelo conquista seu lugar

    A decisão fica mais clara quando você nomeia a carga de trabalho, o custo da falha e o volume. A tabela abaixo é uma política de partida, não uma afirmação sobre qualidade medida.

    Carga de trabalhoComece comEscale para o Astra quandoPrincipal impulsionador de custo
    Suporte, classificação e extração de alto volumeSolOs casos ambíguos ou de alto valor falham na rubrica, ou uma resposta errada dispara uma revisão manual caroTentativas por tarefa e taxa de aceitação
    Tarefas de código delimitadas, geração de testes, revisão de PRSolA mudança abrange vários arquivos, exige julgamento de design, ou uma regressão é caro de detectar depoisCusto por tarefa aceita mais tempo de revisão
    Apresentações, planilhas, memorandos, entregáveis para clientesSol para rascunhosA fidelidade ao modelo, a síntese factual e a usabilidade na primeira passada determinam se o entregável serveRetrabalho e tempo de revisão
    Agentes de horizonte longo e fluxos com ferramentasSol para a execuçãoO planejamento ou os passos ambíguos falham repetidamente, ou o agente precisa de julgamento visual ou de uso do computador mais forteTokens acumulados e tentativas
    Frontends visuais, 3D, CAD e interativosSol para páginas simplesA precisão espacial, a qualidade visual ou um uso detalhado do computador definem o resultado para o usuárioTentativas e revisão humana
    Processamento em lote offlineSolUm filtro de qualidade rejeita saídas demais do Sol, ou a tarefa é intrinsecamente de fronteiraDescontos de lote e taxa de rejeição

    Suporte e extração de alto volume: o Sol é a opção econômica padrão

    Um pipeline de triagem de suporte ou de extração de faturas pode processar milhares de requisições curtas por dia, com alguns milhares de tokens de entrada e um rótulo curto ou uma saída JSON. A tarifa de $2/$10 do Sol é uma vantagem grande, e o contexto de 1.05M iguala o do Astra, então capacidade de contexto não é motivo para subir de nível. Escale apenas falhas específicas: uma falha de esquema em uma conta de alto valor, documentos de origem contraditórios, ou um erro que dispara revisão de reembolso ou de conformidade. Meça essa coorte; não mova a fila inteira porque uma demonstração parecia melhor.

    Mudanças de código em todo o repositório: a qualidade aparece como tempo de revisão

    Para um ajuste de uma linha, o Sol é a primeira tentativa sensata. Para uma refatoração de vários arquivos com design pouco claro, o custo real inclui a leitura de engenheiros sênior, a busca de pontos de chamada omitidos e a reparação de testes. Se o Sol precisa de várias rodadas enquanto o Astra produz uma mudança integrável em uma ou duas, o Astra pode sair mais barato por mudança aceita apesar do preço de tokens 4x. A aceitação precisa ser execução: aplique o patch e rode os testes em um ambiente descartável; um diff plausível não basta.

    Entregáveis profissionais: o prêmio do Astra é mais fácil de justificar

    Apresentações, livros de avaliação, resumos legais e memorandos para clientes têm custos de retrabalho altos. Uma apresentação que ignora o modelo ou um memorando que omite uma cláusula obrigatória podem consumir mais tempo humano do que a tarifa do modelo. A OpenAI posiciona o Astra para convenções profissionais e fidelidade a modelos. Ainda assim, faça uma revisão cega com o modelo real: se o rascunho do Sol serve, pague Sol; se precisa ser reestruturado, compare o tempo de revisão com o prêmio do Astra.

    Agentes e fluxos visuais: separe o planejador do executor

    Fluxos agênticos acumulam contexto, então a diferença de preço se compõe. Um padrão comum é Sol para chamadas de ferramentas rotineiras, extração e respostas curtas, com o Astra reservado para planejamento, decisões ambíguas ou passos visuais ou de uso do computador que determinam a trajetória. Defina orçamentos de tokens e tentativas por tarefa. Registre a trace completa e avalie a tarefa concluída, não a melhor mensagem intermediária.

    4. Um exemplo de custo simples

    Tome uma tarefa que usa 10,000 tokens de entrada e 2,000 de saída por chamada, nas tarifas de tabela padrão de contexto curto da OpenAI. Cada chamada é uma tentativa, e cada chamada é cobrada:

    • Sol: $0.02 de entrada mais $0.02 de saída = $0.04 por chamada.
    • Astra: $0.08 de entrada mais $0.08 de saída = $0.16 por chamada.

    Se o Sol acerta na segunda tentativa, a tarefa custa $0.08. Se o Astra acerta na primeira tentativa, custa $0.16. Se o Sol precisa de cinco tentativas, custa $0.20 — mais do que a única chamada bem-sucedida do Astra. O prêmio, portanto, vale a pena apenas quando o Astra evita tentativas ou edição suficientes para fechar essa diferença. As contagens de tentativas são premissas para ilustrar, não medições; use os seus próprios registros.

    Essa é a versão prática do custo por tarefa aceita: conte cada chamada cobrável e depois pese o total em dólares contra o tempo que você passa tornando o resultado utilizável.

    Esses números são uma estimativa de planejamento a partir dos preços padrão de contexto curto publicados pela OpenAI, supondo entrada abaixo de 272,000 tokens por requisição. Excluem acertos e escritas de cache, cobranças de ferramentas, preços de lote, Fast, Ultrafast ou de janela em segundo plano (incluindo descontos), acréscimos regionais, impostos, taxas de plataforma e tempo de revisão ou edição humana. Não são uma cotação da ToAPIs; verifique o catálogo de modelos e a página de preços para as tarifas em tempo real da sua conta.

    5. Como escolher em três passos

    1. Comece pelo Sol. Execute a tarefa real, ou uma amostra pequena dela, com o Sol usando seu prompt de produção e suas regras de saída. Registre se cada resultado passa, quantas chamadas levou e quanto tempo você passou consertando.
    2. Teste o Astra nas falhas específicas. Se o Sol falha por um motivo que um modelo mais forte poderia resolver — instruções ambíguas, julgamento de design fraco, um passo visual difícil — execute as mesmas entradas com o Astra. Não mova a carga de trabalho inteira porque uma demonstração parecia melhor.
    3. Compare o custo total de chamadas e o tempo de edição. Some cada chamada cobrável pela tarifa por chamada de cada modelo e depois coloque ao lado o tempo que você passa revisando ou reparando a saída. Escolha o Astra só quando o custo extra de chamadas é coberto por menos tentativas, menos edição ou menor custo de erro.

    Para a integração de API, use o catálogo de modelos, a página de preços e a documentação da API. Para os IDs de modelo e uma primeira requisição, veja o guia da API do GPT-6.2 que acompanha este artigo. Verifique o catálogo em tempo real para as variantes, tarifas e regiões disponíveis na sua conta; este artigo não afirma tarifas, caminhos de endpoint nem cobertura regional específicos da plataforma.

    6. Perguntas frequentes

    O Astra vale 4x o preço?

    Apenas quando a qualidade incremental muda o resultado o bastante para justificar o prêmio. Para trabalho rotineiro e bem especificado, o Sol é difícil de superar. Para entregáveis de alto valor, mudanças de código caras ou falhas repetidas do Sol, o Astra pode sair mais barato por tarefa realmente utilizável apesar da tarifa de tokens mais alta.

    O preço menor do Sol significa menor qualidade em programação?

    A OpenAI relata o Sol a 0.5 pontos do Astra no FrontierCode 2.0 com cerca de um quinto do custo (ambos no máximo). Essa é uma afirmação do fornecedor, não um resultado para o seu repositório. Teste a aplicabilidade dos patches, a taxa de testes que passam, o esforço de revisão e o risco de regressão.

    Como devo contabilizar a entrada em cache?

    A entrada em cache custa $0.40 por milhão no Astra contra $8.00 sem cache; o Sol custa $0.10 contra $2.00. As escritas de cache são à parte. Se você reutiliza prompts ou documentos longos, meça a taxa de acerto de cache em vez de supor preços sem cache. O exemplo pressupõe que não há benefício de cache.

    E os prompts longos acima de 272K tokens?

    Calcule à parte. Acima de 272,000 tokens de entrada, as tarifas de entrada e cache dobram e a saída custa 1.5x a tarifa de contexto curto sobre toda a requisição. A relação 4:1 de tarifas de tabela se mantém, mas os custos absolutos sobem; mantenha o trabalho de contexto longo fora das estimativas de contexto curto.

    Posso usar a ToAPIs para executar esta comparação?

    O catálogo internacional da ToAPIs lista o Astra e o Sol, mas este artigo não afirma tarifas, endpoints nem cobertura regional específicos da plataforma. Verifique o catálogo em tempo real e a página de preços. O harness de comparação do apêndice para desenvolvedores aponta por padrão para a API oficial da OpenAI; se você usar outro endpoint compatível com OpenAI, confirme os IDs de modelo, os campos e as unidades de cobrança.

    7. Fontes e método

    • OpenAI: Introducing GPT-6.2 Astra and Sol, publicado em 17 de novembro de 2026 — posicionamento de lançamento, disponibilidade e resultados relatados pelo fornecedor.
    • Página de modelo da OpenAI: GPT-6.2 Astra — ID de modelo, limites de contexto, modalidades, ferramentas e preços, verificados em 18 de novembro de 2026.
    • Página de modelo da OpenAI: GPT-6.2 Sol — ID de modelo, limites de contexto, modalidades, ferramentas e preços, verificados em 18 de novembro de 2026.
    • Preços da API da OpenAI — termos de standard, cache, contexto longo, lote, Fast e Ultrafast, verificados em 18 de novembro de 2026.
    • ToAPIs: guia da API do GPT-6.2 — configuração e preços específicos da plataforma; artigo complementar.

    Nota sobre o método. Os números em dólares são aritmética determinística a partir das tarifas de tabela publicadas e das premissas de tokens e tentativas do exemplo. Não são faturas, cotações nem resultados medidos. Nenhuma inferência de modelo, medição de latência, pontuação de qualidade ou revisão cega foi realizada para este artigo, e o harness de comparação do apêndice para desenvolvedores não foi executado. Substitua as tarifas, as contagens de tokens e as contagens de tentativas pelos seus próprios dados de piloto antes de tomar uma decisão de produção.

    Apêndice para desenvolvedores: execute sua própria comparação

    O protocolo abaixo foi desenhado para produzir evidência para a sua própria carga de trabalho. Ele deliberadamente não é um ranking. A comparação não foi executada para este artigo, e aqui não se reportam saídas de modelo nem números de latência.

    Desenho do teste

    1. Congele o conjunto de tarefas. Use entre 20 e 50 casos representativos, incluindo casos fáceis que protegem o comportamento existente e casos difíceis que distinguem os modelos. Remova dados confidenciais ou substitua por equivalentes sintéticos.
    2. Congele a requisição. Use o mesmo prompt de sistema, entrada de usuário, ferramentas, esquema de saída e orçamento de tokens para ambos os modelos sempre que os contratos permitirem. Registre as diferenças inevitáveis.
    3. Repita as tarefas não determinísticas. Preserve a distribuição e as falhas, não apenas a melhor saída.
    4. Pontue às cegas. Remova o rótulo do modelo antes da revisão. Uma tarefa passa só quando passa em todas as verificações obrigatórias; uma resposta polida que omite um campo, inventa um identificador ou falha um teste é uma falha.
    5. Conte as tentativas cobráveis e separe a latência. As tentativas falhas pertencem ao numerador do custo quando cobradas. Informe separadamente o tempo até o primeiro token, o tempo de conclusão e o tempo até um resultado aceito, e declare o que o cronômetro inclui.

    Um conjunto mínimo de casos pode ser assim:

    CasoTarefaVerificações de aceitação
    extract-01Extrair item e quantidade de uma mensagem curta de pedidoJSON válido; chaves exatas; a quantidade é um inteiro; sem valores inventados
    code-01Implementar uma função com condições de contornoO patch aplica; os testes passam; a entrada inválida é rejeitada; sem mudanças não relacionadas
    clarify-01Responder a uma solicitação de status de pedido sem ID de pedidoPede o ID; não o inventa; nenhuma ação de escrita
    memo-01Transformar um pacote de fontes fornecido em um memorando de uma páginaTodas as seções obrigatórias presentes; números rastreáveis até a fonte; nenhuma afirmação sem suporte

    O harness chama o endpoint oficial de Chat Completions da OpenAI com ambos os IDs de modelo, registra o uso, a latência, os identificadores de modelo solicitados e retornados e os carimbos de tempo, e deixa accepted para um revisor humano. Ele exige uma chave de API e só faz chamadas cobráveis com --execute. estimate_cost ignora acertos de cache, descontos por modo de cobrança e taxas de plataforma, então concilie com o uso cobrado. Não use dados de produção; não presuma que um agregador preserva os IDs de modelo ou as tarifas.

    python
    #!/usr/bin/env python3
    """Reusable GPT-6.2 Astra vs Sol comparison harness.
    
    The comparison was not executed for the accompanying article. Requires OPENAI_API_KEY and
    explicit --execute consent because calls are billable. Acceptance is manual.
    """
    from __future__ import annotations
    
    import argparse
    import json
    import os
    import time
    import urllib.request
    from datetime import datetime, timezone
    from pathlib import Path
    
    API_URL = os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1").rstrip("/") + "/chat/completions"
    MODELS = ("gpt-6.2-astra", "gpt-6.2-sol")
    RATES = {
        "gpt-6.2-astra": {"input": 8.00, "output": 40.00},
        "gpt-6.2-sol": {"input": 2.00, "output": 10.00},
    }
    CASES = [
        {
            "id": "extract-01",
            "system": "Return only valid JSON with exactly the keys item and quantity.",
            "user": "Please order 3 blue mugs.",
            "rubric": ["valid JSON", "item is blue mugs", "quantity is the integer 3"],
        },
        {
            "id": "code-01",
            "system": "Return a unified diff only. Do not include commentary.",
            "user": (
                "Implement merge_intervals(intervals) so overlapping or adjacent "
                "intervals are merged. Reject invalid ranges. Include tests."
            ),
            "rubric": ["patch applies", "tests pass", "invalid ranges rejected"],
        },
        {
            "id": "clarify-01",
            "system": "You are an order-support agent. Never invent identifiers.",
            "user": "Where is my order?",
            "rubric": ["asks for order ID", "does not invent an ID", "no write action"],
        },
    ]
    
    
    def estimate_cost(model: str, prompt_tokens: int, completion_tokens: int) -> float:
        rate = RATES[model]
        return (
            prompt_tokens * rate["input"] + completion_tokens * rate["output"]
        ) / 1_000_000
    
    
    def call_model(model: str, case: dict) -> dict:
        body = json.dumps(
            {
                "model": model,
                "messages": [
                    {"role": "system", "content": case["system"]},
                    {"role": "user", "content": case["user"]},
                ],
                "max_completion_tokens": 8000,  # fixed cap for this comparison
            }
        ).encode("utf-8")
        request = urllib.request.Request(
            API_URL,
            data=body,
            headers={
                "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
                "Content-Type": "application/json",
            },
        )
        started = time.perf_counter()
        with urllib.request.urlopen(request, timeout=180) as response:
            payload = json.load(response)
        elapsed = time.perf_counter() - started
        usage = payload.get("usage", {})
        prompt_tokens = usage.get("prompt_tokens", 0)
        completion_tokens = usage.get("completion_tokens", 0)
        return {
            "requested_model": model,
            "returned_model": payload.get("model"),
            "api_url": API_URL,
            "timestamp_utc": datetime.now(timezone.utc).isoformat(),
            "case_id": case["id"],
            "run": None,
            "latency_seconds": round(elapsed, 3),
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "cost_usd": round(estimate_cost(model, prompt_tokens, completion_tokens), 6),
            "output": payload["choices"][0]["message"]["content"],
            "rubric": case["rubric"],
            "accepted": None,
            "reviewer": None,
            "review_notes": None,
        }
    
    
    def main() -> None:
        parser = argparse.ArgumentParser()
        parser.add_argument("--execute", action="store_true", help="make billable API calls")
        parser.add_argument("--repeats", type=int, default=1)
        parser.add_argument("--out", default="gpt-6-2-runs.jsonl")
        args = parser.parse_args()
    
        if not args.execute:
            print("Dry plan only. Re-run with --execute after checking access, budget and data rules.")
            for case in CASES:
                print(json.dumps({"case": case["id"], "models": MODELS, "repeats": args.repeats}))
            return
    
        if not os.environ.get("OPENAI_API_KEY"):
            raise SystemExit("Set OPENAI_API_KEY first.")
    
        output = Path(args.out)
        with output.open("a", encoding="utf-8") as handle:
            for case in CASES:
                for model in MODELS:
                    for run in range(args.repeats):
                        record = call_model(model, case)
                        record["run"] = run + 1
                        handle.write(json.dumps(record, ensure_ascii=False) + "\n")
                        print(json.dumps({
                            "case_id": record["case_id"],
                            "model": record["requested_model"],
                            "latency_seconds": record["latency_seconds"],
                            "cost_usd": record["cost_usd"],
                        }))
    
        print(f"Wrote {output}. Fill 'accepted' manually against each rubric before comparing costs.")
    
    
    if __name__ == "__main__":
        main()
    

    Depois da revisão, calcule o número central para a decisão de roteamento:

    python
    import json
    from pathlib import Path
    
    rows = [json.loads(line) for line in Path("gpt-6-2-runs.jsonl").read_text().splitlines()]
    if not rows or any(type(row["accepted"]) is not bool for row in rows):
        raise SystemExit("Review every row before comparing costs.")
    for model in sorted({row["requested_model"] for row in rows}):
        model_rows = [row for row in rows if row["requested_model"] == model]
        accepted = sum(row["accepted"] is True for row in model_rows)
        estimated = sum(row["cost_usd"] for row in model_rows)
        per_accepted = estimated / accepted if accepted else None
        print(model, {"accepted": accepted, "estimated_usd": round(estimated, 4),
                      "cost_per_accepted": round(per_accepted, 4) if per_accepted is not None else None})
    

    O harness não testa a execução de ferramentas, porque executar código ou comandos de shell gerados pelo modelo traz problemas de segurança e reprodutibilidade. Se o seu fluxo de trabalho usa ferramentas, avalie a trace de ferramentas separadamente: argumentos válidos, autorização, efeitos colaterais, tentativas e se uma pergunta de esclarecimento era a ação correta. Um modelo que escreve uma resposta perfeita mas chama uma ferramenta destrutiva de forma errada não passou na tarefa.

    Artigos relacionados

    comparison2026-10-21T14:00:00+08:0016 min de leitura

    Onde encontrar a API mais barata do Seedance 2.0: preços oficiais versus gateways agregadores

    Um benchmark minucioso de preços de mercado da API do ByteDance Seedance 2.0 em canais empresariais oficiais, hosts de contêineres genéricos, agregadores de mídia e ToAPIs. Compare tarifas por segundo, evite as penalidades de inicialização a frio e economize até 46% na geração de vídeo em produção.

    TO
    ToAPIs Engineering & Evaluation Team
    #Seedance 2.0
    comparison2026-10-21T14:00:00+08:009 min de leitura

    Seedance 2.0 vs 2.5: preços de API, custo por segundo e detalhamento por resolução

    Uma comparação exaustiva para desenvolvedores dos modelos de precificação das APIs Seedance 2.0 e 2.5. Analisa tarifas por segundo de geração de vídeo, multiplicadores de resolução 720p vs 1080p, presets de qualidade e arquiteturas de roteamento orçamentário automatizado.

    TO
    ToAPIs Engineering & Evaluation Team
    #Seedance 2.0 vs 2.5 API Pricing
    comparison2026-11-20T10:00:00+08:008 min de leitura

    Wan 3.0 Prime vs Wan 2.6 Flash: Generation Speed, Frame Fidelity, and Cost

    A contract-faithful comparison of wan3.0-video-prime and wan2.6-flash on ToAPIs: documented modes, duration and resolution windows, official pricing snapshots, and why published pages do not support numeric latency or savings claims.

    TO
    ToAPIs Engineering & Evaluation Team
    #Wan 3.0 Prime
    ToAPIs
    InícioToAPIs
    Gateway empresarial de API de IA. Acesse GPT-5, Claude, Gemini e mais de 200 modelos por uma única API unificada.

    Modelos populares

    • Seedance 2.5 API
    • Seedance 2.0 API
    • Veo 3.1 Fast API
    • Kling 3.0 Turbo API
    Mostrar maisMostrar menos
    • GPT Image 2 API
    • Claude Opus 4.8 API
    • Nano Banana 2 API
    • Seedance 2 Mini API
    • Todos os modelos

    Categorias de API

    • API de imagem com IA
    • API de vídeo com IA
    • API de texto para vídeo
    • API de imagem para vídeo
    Mostrar maisMostrar menos
    • API de edição de imagens com IA
    • API de LLM e raciocínio
    • Todas as ferramentas de API →

    Alternativas

    Alternativas
    • Alternativa ao Kie.ai
    • Alternativa ao Fal.ai
    • Alternativa ao OpenRouter
    • Alternativa ao Replicate
    • Alternativa ao Wavespeed AI
    • Todas as comparações →

    Guias em destaque

    Guias em destaque
    • Preços do Seedance 2.0 e 2.5
    • Guia da API Seedance mais barata
    • Guia de integração do MiniMax H3
    • Chave de API gratuita do Seedance 2
    • Início rápido da API Seedance 2
    • Todos os artigos técnicos →

    Desenvolvedores e plataforma

    Desenvolvedores e plataforma
    • Documentação da API
    • MCP
    • Preços
    • Playground de modelos
    • LLMs.txt
    • Falar com o suporte
    • Diretório de guias de modelos
    Entidade operadora:
    鯨樞智能科技有限公司
    JINGSHU INTELLIGENT LIMITED
    Sede social:
    ROOM 5042, 5/F, YAU LEE CENTRE, NO.45, HOI YUEN ROAD, KWUN TONG, KOWLOON, HONG KONG
    PrivacidadeTermosUso aceitávelExclusão de dadosRetenção de dadosSubprocessadores e regiõesCobrança e reembolsosPolítica de CookiesMapa do siteSobre

    © 2026 ToAPIs. Todos os direitos reservados.