Prompt API vs. OpenAI API: quando usar cada uma

A Prompt API (Chrome, on-device, Gemini Nano) e a OpenAI API (cloud, GPT-4o/GPT-5.4) são duas filosofias completamente diferentes de colocar IA numa aplicação web. Uma roda no navegador do usuário. A outra, em servidores lá fora. Parece simples, mas os trade-offs são reais — e nenhuma das duas ganha em tudo.

TL;DR

• Prompt API: latência 2-8x menor, gratuita, privacidade total — mas só Chrome desktop e qualidade inferior
• OpenAI API: multilingual, cross-platform, qualidade superior — mas custo por token e dados saem do device
• O padrão híbrido (on-device + cloud fallback) é a arquitetura certa para a maioria dos casos reais

Eu comparo as duas em sete dimensões aqui. E no final, mostro o padrão híbrido que — adianto logo — é provavelmente o que você vai querer implementar.

Comparativo geral

Dimensão	Prompt API (On-Device)	OpenAI API (Cloud)
Modelo	Gemini Nano (~4,27 GB)	GPT-4o, GPT-4o-mini, GPT-5.4
Localização	Local no dispositivo	Servidores OpenAI
Latência (TTFT)	~50-200ms	300-2000ms
Custo por token	Gratuito	$0,15-60/milhão tokens
Privacidade	Dados nunca saem do device	Dados enviados à OpenAI
Qualidade (geral)	Boa para tarefas simples	Superior em tarefas complexas
Idiomas	5 (en, es, ja, de, fr)	90+ idiomas
Context window	~4.096 tokens	128K-1M tokens
Multimodal input	Texto, imagem, áudio	Texto, imagem, áudio, vídeo
Multimodal output	Só texto	Texto, imagem, áudio
Offline	✅ Funciona	❌ Requer internet
Interoperabilidade	Só Chrome 148+	Qualquer plataforma
Hardware	GPU >4GB VRAM ou 16GB RAM	Qualquer com internet
Structured output	JSON Schema	JSON Schema (Structured Outputs)
Rate limits	Sem limites	Tier-based (TPM, RPM)

A tabela já conta a história, mas os detalhes importam. Vamos por dimensão.

1. Latência

Esse é o argumento mais forte para a Prompt API:

Métrica	Prompt API	OpenAI API	Diferença
Time to First Token	50-200ms	300-800ms	2-8x mais rápido
Throughput (tokens/seg)	15-30 tok/s	50-150 tok/s	Cloud gera mais rápido
Latência total (prompt curto)	100-500ms	500-2000ms	2-5x mais rápido
Variabilidade	Baixa (hardware fixo)	Alta (load do servidor)	On-device é previsível

Para respostas curtas (classificação, extração), a Prompt API vence. Para geração longa, o throughput superior do cloud compensa a latência inicial.

O detalhe que importa na prática: o Time to First Token local é consistente. Não depende de rede. O usuário vê feedback imediato. Com APIs cloud, em horários de pico, você pode ter spikes de 3-5 segundos. Já perdi usuários por causa disso.

2. Custo

Cenário	Prompt API	OpenAI GPT-4o-mini	OpenAI GPT-4o
1.000 classificações/dia	$0	~$0,03	~$0,30
10.000 resumos/dia	$0	~$1,50	~$15,00
100.000 extrações/mês	$0	~$45	~$450
1M prompts/mês	$0	~$450	~$4.500

Zero é zero. Para aplicações de alto volume com tarefas simples, eliminar custos de inferência é significativo.

O custo oculto: funciona só no Chrome, exclui mobile, qualidade inferior pode significar mais iterações ou necessidade de fallbacks. Grátis não é grátis se metade dos seus usuários não consegue usar.

3. Privacidade

Aspecto	Prompt API	OpenAI API
Dados saem do device?	Nunca	Sempre
GDPR/LGPD compliance	Facilitada (dados locais)	Requer DPA e configuração
PII em prompts	Sem risco de vazamento	Risco de exposição
Opt-out de treinamento	N/A (local)	API data não usada para treino

Para dados sensíveis (saúde, finanças, dados pessoais), a Prompt API é a escolha óbvia. Dados nunca saem do dispositivo do usuário — sem brechas, sem trust necessário, sem DPA para negociar.

Cenários onde isso é decisivo: análise de sentimento em mensagens privadas, classificação de documentos confidenciais, autocomplete em campos sensíveis, qualquer coisa regulada por LGPD ou GDPR.

4. Qualidade

Aqui a diferença entre 4 GB e centenas de bilhões de parâmetros fica evidente:

Tarefa	Prompt API	GPT-4o-mini	GPT-4o
Classificação binária	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Classificação multi-class	⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Resumo simples	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Extração de dados	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Raciocínio complexo	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Geração criativa longa	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Código/programação	⭐⭐	⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Português (PT-BR)	⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐
Alucinações	~6% falha	~2% falha	<1% falha

Resumindo: Gemini Nano dá conta de classificação, extração e resumo simples. Para raciocínio, criatividade, código ou multilingual, cloud é incomparavelmente melhor.

5. Disponibilidade

Aspecto	Prompt API	OpenAI API
Browsers suportados	Só Chrome 148+ desktop	Qualquer (HTTP API)
Mobile	❌	✅
Hardware necessário	GPU >4GB ou 16GB RAM	Internet
% de usuários cobertos	~30-40%	~99%
Primeiro uso	Espera download 4,27 GB	Imediato

A OpenAI API alcança virtualmente todo mundo. A Prompt API atinge uma fração — Chrome desktop com hardware adequado. Para produtos que precisam funcionar para todos, cloud é a única opção como funcionalidade primária.

6. Interoperabilidade

Ironicamente, apesar de ser uma “API web”, a Prompt API é menos interoperável que APIs HTTP cloud. A OpenAI API funciona em qualquer lugar que faz HTTP requests. A Prompt API funciona em um browser.

Mais: a interface OpenAI virou meio que um padrão de facto. Anthropic, Google, Groq — todos oferecem APIs compatíveis. Se amanhã você quer trocar de provider, troca. Com a Prompt API, você está preso ao Google e ao Gemini Nano.

7. Offline

Cenário	Prompt API	OpenAI API
Sem internet	✅ Funciona	❌ Falha
Conexão instável	✅ Sem impacto	⚠️ Timeouts
Avião/metrô	✅ Funciona	❌

Esse é o diferencial mais absoluto. Se sua feature precisa funcionar offline, não tem alternativa cloud que resolva. Ponto.

Quando usar cada uma

Use a Prompt API quando:

• Privacidade é requisito inegociável
• Precisa funcionar offline
• Tarefas simples e repetitivas (classificação, extração, filtragem)
• Alto volume sem budget para APIs
• Latência mínima é prioridade
• Público é Chrome desktop
• IA é progressive enhancement, não core

Use a OpenAI API quando:

• Qualidade é prioridade
• Precisa de português ou multilingual
• Todos os dispositivos e browsers
• Context window grande (documentos longos)
• Produção com SLA
• Output multimodal (imagem, áudio)
• Modelo customizado (fine-tuning)

O padrão híbrido: a resposta certa

Na maioria dos cenários reais, a melhor arquitetura combina as duas:

class HybridAI {
  constructor(cloudApiKey) {
    this.cloudApiKey = cloudApiKey;
    this.localSession = null;
    this.localAvailable = false;
  }

  async init() {
    if ('LanguageModel' in window) {
      const status = await LanguageModel.availability();
      if (status === 'available') {
        this.localSession = await LanguageModel.create();
        this.localAvailable = true;
        console.log('🏠 Usando IA local (Prompt API)');
        return;
      }
    }
    console.log('☁️ Usando IA cloud (fallback)');
  }

  async classify(text, schema) {
    if (this.localAvailable) {
      try {
        const result = await this.localSession.prompt(
          `Classify: "${text}"`,
          { responseConstraint: schema }
        );
        return { source: 'local', data: JSON.parse(result) };
      } catch (e) {
        console.warn('Local falhou, indo pro cloud:', e.message);
      }
    }

    // Fallback: OpenAI API
    const response = await fetch('https://api.openai.com/v1/chat/completions', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${this.cloudApiKey}`
      },
      body: JSON.stringify({
        model: 'gpt-4o-mini',
        messages: [{ role: 'user', content: `Classify: "${text}"` }],
        response_format: {
          type: 'json_schema',
          json_schema: { name: 'classification', schema }
        }
      })
    });

    const data = await response.json();
    return {
      source: 'cloud',
      data: JSON.parse(data.choices[0].message.content)
    };
  }

  destroy() {
    if (this.localSession) this.localSession.destroy();
  }
}

Quality gate: quando local não basta

Uma variação mais sofisticada — usa local, mas verifica a confiança do resultado:

async function classifyWithQualityGate(text, session, cloudApiKey) {
  const localResult = await session.prompt(
    `Classify sentiment and confidence (0-1): "${text}"`,
    {
      responseConstraint: {
        type: "object",
        properties: {
          sentiment: { type: "string", enum: ["positive", "negative", "neutral"] },
          confidence: { type: "number" }
        },
        required: ["sentiment", "confidence"]
      }
    }
  );

  const parsed = JSON.parse(localResult);

  // Confidence alta? Aceita local.
  if (parsed.confidence >= 0.8) {
    return { ...parsed, source: 'local' };
  }

  // Confidence baixa? Manda pro cloud confirmar.
  console.log(`⚠️ Confidence ${parsed.confidence}, verificando com cloud...`);
  const cloudResult = await callOpenAI(text, cloudApiKey);
  return { ...cloudResult, source: 'cloud (quality gate)' };
}

Benchmarks de cenários reais

Cenário	Prompt API	OpenAI 4o-mini	Recomendação
Filtro de spam (binário)	89% acc, 80ms	97% acc, 450ms	Local (velocidade compensa)
Resumo de artigo (EN)	Adequado, 1.2s	Excelente, 1.8s	Local (qualidade ok)
Resumo de artigo (PT)	Fraco	Excelente	Cloud (idioma)
Extração de email	92% acc	99% acc	Local com fallback
Geração de código	Fraco	Excelente	Cloud (sempre)
Alt text para imagem	Bom, 800ms	Excelente, 1.5s	Local (privacidade)
Chatbot de suporte	Limitado	Excelente	Cloud (qualidade)

Fluxograma de decisão rápida

1. Precisa funcionar offline?
   → SIM: Prompt API (ou WebGPU/WASM custom)
   → NÃO: continue

2. Dados sensíveis/PII?
   → SIM: Prompt API preferencial
   → NÃO: continue

3. Precisa de português?
   → SIM: Cloud API
   → NÃO: continue

4. Tarefa simples (classificação, extração, filtro)?
   → SIM: Prompt API (custo zero, latência baixa)
   → NÃO: Cloud API (qualidade superior)

5. Público 100% Chrome desktop?
   → SIM: Prompt API como primary
   → NÃO: Cloud primary, Prompt API como enhancement

Conclusão

A Prompt API e a OpenAI API não são concorrentes. São complementares. Uma faz bem o que a outra faz mal — e vice-versa.

A Prompt API brilha em tarefas simples, privacidade e offline. Cloud APIs brilham em qualidade, multilingual e alcance universal. A arquitetura que faz sentido em 2026 junta as duas: Prompt API como edge layer rápida para classificação e extração, cloud para o trabalho pesado de geração e raciocínio, com um quality gate no meio decidindo quem responde cada request.

Para código funcionando, veja os 5 demos práticos. Para o contexto político de tudo isso, leia sobre a controvérsia Google vs. Mozilla.

Leia também:

• O que é a Chrome Prompt API — visão geral completa
• Como testar a Prompt API hoje — tutorial prático

---

FAQ

A Prompt API pode substituir a OpenAI API completamente?

Não. O Gemini Nano é um modelo de ~4 GB otimizado para tarefas simples. Não compete com GPT-4o em raciocínio, geração criativa, código ou multilingual. Use cada uma para o que faz bem.

Qual é mais barata para alto volume?

A Prompt API é gratuita — zero custo por token. Para 1 milhão de classificações por mês, economizaria ~$450 vs. GPT-4o-mini. O trade-off: qualidade inferior e limitação a Chrome desktop.

Posso usar as duas ao mesmo tempo?

Sim, e é o padrão recomendado. O exemplo HybridAI neste artigo demonstra: usa local quando disponível, cloud como fallback. Melhor dos dois mundos.

Qual tem melhor suporte a português?

OpenAI API, sem comparação. GPT-4o tem suporte excelente a PT-BR. O Gemini Nano lista apenas inglês, espanhol, japonês, alemão e francês oficialmente.

E se eu já uso a Vercel AI SDK ou LangChain?

A Prompt API tem interface diferente (browser-native, não HTTP). Mas o polyfill oficial permite usar um provider local compatível. Você pode criar uma camada de abstração que escolhe o provider baseado em disponibilidade.

Referências

• Chrome Built-in AI — Prompt API Documentation
• OpenAI API Reference — Structured Outputs
• Prompt API Polyfill — Chrome Labs GitHub
• Chrome Platform Status — Built-in AI
• Prompt API Explainer — Web Machine Learning GitHub