O que é a Chrome Prompt API? IA no Navegador para Desenvolvedores de API

O Chrome lançou um modelo de IA diretamente no navegador. A Prompt API é a interface JavaScript que você chama para usá-lo. Sem chave de API, sem ida e volta na rede, sem cobrança por token. O modelo é o Gemini Nano, ele roda no dispositivo do usuário e, a partir do Chrome 138, está geralmente disponível para extensões e por trás de um sinalizador para páginas da web. Para desenvolvedores de API, isso muda o que é razoável fazer no cliente.

Este guia aborda o que é a Prompt API do Chrome, como ela difere da Gemini API na nuvem, quando ela realmente se encaixa em um fluxo de trabalho de API, código prático para extensões e páginas da web, e os limites que você encontrará mais rápido do que a documentação admite. No final, combinamos com o Apidog para que as mesmas tarefas tenham um caminho de fallback quando o modelo não estiver disponível.

Em resumo

• A Prompt API do Chrome expõe o Gemini Nano através de LanguageModel, disponível em window.LanguageModel para páginas da web e chrome.languageModel para extensões.
• O modelo roda inteiramente no dispositivo. Nenhuma chamada de rede, nenhuma chave, nenhum custo por token.
• Estável para extensões do Chrome a partir do Chrome 138+. Para páginas da web, está sendo lançado por trás da flag chrome://flags/#prompt-api-for-gemini-nano e de um Origin Trial registrado.
• Melhores usos para desenvolvedores de API: análise de entrada no lado do cliente, correção de formato JSON, sumarização de respostas de API para UI e geração de stubs durante o desenvolvimento.
• Sempre configure um fallback na nuvem. O modelo no dispositivo falha abertamente; seu código não deve.

O que a Prompt API realmente expõe

A Prompt API é um de um pequeno grupo de APIs de "IA Incorporada" que o Chrome começou a lançar no ano passado. As outras são mais específicas: Summarizer (Sumarizador), Writer (Escritor), Rewriter (Reescritor), Translator (Tradutor) e Language Detector (Detector de Idiomas). A Prompt API é a interface de uso geral; as outras a envolvem com padrões específicos de tarefa.

Três primitivos são importantes:

• LanguageModel.availability(). Retorna available (disponível), downloadable (baixável), downloading (baixando) ou unavailable (indisponível). O modelo tem cerca de 2 GB e é baixado em segundo plano na primeira vez que um site o solicita.
• LanguageModel.create(options). Inicia uma sessão. A sessão mantém o estado da conversa, o prompt do sistema e alguns controles de amostragem.
• session.prompt(text) e session.promptStreaming(text). As duas maneiras de realmente chamar o modelo.

A estrutura é intencionalmente próxima ao SDK da Gemini na nuvem, mas simplificada. Ainda não há chamadas de ferramentas, nem entrada de imagem no canal estável (está em Origin Trial), e a janela de contexto é pequena (4K tokens de entrada, 1K de saída, com uma expansão suave para 8K no total).

Uma primeira chamada de uma página da web se parece com isto:

if (!('LanguageModel' in window)) {
  console.warn('Prompt API not available. Falling back to cloud.');
} else {
  const status = await LanguageModel.availability();
  if (status === 'unavailable') {
    console.warn('Device does not support Gemini Nano.');
  } else {
    if (status !== 'available') {
      // Triggers a background download. Show a UI.
      await LanguageModel.create({ monitor(m) {
        m.addEventListener('downloadprogress', e => {
          console.log(`downloaded ${(e.loaded * 100).toFixed(0)}%`);
        });
      }});
    }
    const session = await LanguageModel.create({
      systemPrompt: 'You answer in three concise bullets. JSON only.',
    });
    const reply = await session.prompt(
      'Summarize this changelog in three bullets.\n\n' + changelog
    );
    console.log(reply);
  }
}

Cada parte significativa é exibida no snippet: detecção de recursos, verificação de disponibilidade, download opcional, criação de sessão, prompt do sistema, chamada de prompt.

Como difere da Gemini API na nuvem

Mesma família, implantação diferente. As diferenças moldam o que você pode e não pode construir com ela.

O modelo no dispositivo é aproximadamente duas ordens de magnitude menor do que o gemini-3-flash. Use-o para tarefas curtas onde você teria usado uma regex ou um classificador de prompt ajustado manualmente. Não o use como um substituto direto para o Gemini na nuvem.

Onde realmente se encaixa no fluxo de trabalho de um desenvolvedor de API

Quatro casos de uso justificam o custo de integração. Fora deles, a API na nuvem ainda é a escolha certa.

1. Análise e reformatação de entrada do usuário no lado do cliente. Pegue uma consulta de formato livre e transforme-a em um filtro estruturado para sua API. O usuário digita "cobranças stripe acima de US$ 100 na semana passada"; a Prompt API a transforma em { "amount_gt": 100, "since": "2026-04-22", "provider": "stripe" } antes de você chamar seu endpoint de busca. Economiza uma ida e volta e protege a privacidade do usuário.

2. Sumarização de respostas de API para UI. Você acessa sua própria API, recebe 40 registros e precisa de um resumo de uma linha para mostrar em um cartão. Enviar os registros para um modelo na nuvem adiciona latência e custo. A Prompt API roda localmente e retorna em menos de 200 ms.

3. Correção de formato JSON. Respostas de LLM chegam malformadas com frequência suficiente para importar. Execute uma única passagem de reparo através do Gemini Nano: "Aqui está um JSON inválido. Retorne apenas JSON válido com os mesmos campos." Barato, rápido, sem custo.

4. Stubbing local durante o desenvolvimento. Enquanto você está configurando um novo endpoint e o backend está meio construído, gere corpos de resposta plausíveis em tempo real. As estruturas não serão corretas para produção, mas desbloqueiam o trabalho de front-end. Combine com o servidor de mock do Apidog para uma configuração híbrida onde endpoints críticos vêm de exemplos salvos e os exploratórios vêm da Prompt API.

Construindo-o em uma extensão

Extensões recebem a Prompt API no canal estável a partir do Chrome 138. Você declara a permissão e chama chrome.languageModel.

manifest.json:

{
  "manifest_version": 3,
  "name": "Sumarizador de Endpoint",
  "version": "1.0.0",
  "permissions": ["languageModel"],
  "action": { "default_popup": "popup.html" }
}

popup.js:

const status = await chrome.languageModel.availability();
if (status === 'unavailable') {
  document.getElementById('out').textContent =
    'O dispositivo não suporta IA no dispositivo.';
  return;
}

const session = await chrome.languageModel.create({
  systemPrompt: [
    'Você resume as respostas HTTP em três pontos curtos.',
    'Mencione o status, o campo mais alterado e quaisquer chaves de erro.',
  ].join(' '),
  temperature: 0.3,
  topK: 3,
});

document.getElementById('go').addEventListener('click', async () => {
  const tab = await chrome.tabs.query({ active: true, currentWindow: true });
  const [{ result }] = await chrome.scripting.executeScript({
    target: { tabId: tab[0].id },
    func: () => document.body.innerText.slice(0, 4000),
  });
  const stream = session.promptStreaming(result);
  const out = document.getElementById('out');
  out.textContent = '';
  for await (const chunk of stream) {
    out.textContent += chunk;
  }
});

Duas coisas que valem a pena mencionar. temperature e topK são os únicos controles de amostragem que a API expõe; topP não é suportado no canal estável. O streaming é um iterador assíncrono, não eventos enviados pelo servidor, então o padrão de consumo é for await em vez do leitor SSE que você escreveria para o Gemini na nuvem.

Construindo-o em uma página da web

Páginas da web precisam que o usuário ative uma flag ou que sua origem seja inscrita no Origin Trial. O token de teste vai em uma meta tag.

<!DOCTYPE html>
<html>
<head>
  <meta http-equiv="origin-trial" content="YOUR_TRIAL_TOKEN_HERE" />
</head>
<body>
  <textarea id="in" placeholder="Cole uma resposta de API..."></textarea>
  <button id="go">Resumir</button>
  <pre id="out"></pre>
  <script type="module">
    if (!('LanguageModel' in window)) {
      document.getElementById('out').textContent =
        'Prompt API não disponível neste navegador.';
    } else {
      const session = await LanguageModel.create({
        systemPrompt: 'Responder em JSON: { "summary": "...", "tags": [...] }',
        temperature: 0.2,
      });
      document.getElementById('go').onclick = async () => {
        const text = document.getElementById('in').value;
        const reply = await session.prompt(text);
        try {
          document.getElementById('out').textContent =
            JSON.stringify(JSON.parse(reply), null, 2);
        } catch {
          document.getElementById('out').textContent = reply;
        }
      };
    }
  </script>
</body>
</html>

Se você quiser testar a página sem um token de Origin Trial, abra chrome://flags/#prompt-api-for-gemini-nano, defina-o como Ativado e reinicie o Chrome. A flag tem sido estável nas últimas seis versões, mas não há garantia de que permanecerá para sempre; utilize o caminho do Origin Trial se desejar um comportamento previsível.

Limites e armadilhas que a documentação não enfatiza o suficiente

Seis coisas que podem te atrapalhar.

1. O contexto é pequeno. 4K de entrada, 1K de saída. Trunque agressivamente. Não cole um documento JSON de 50K tokens e espere uma resposta útil.
2. O suporte de hardware é irregular. O modelo precisa de aproximadamente 4 GB de VRAM ou memória unificada e funciona apenas no Chrome 138+ no Windows, macOS, Linux e ChromeOS recente. O Chrome para celular não é suportado até o momento.
3. A primeira carga é lenta. O download de 2 GB ocorre em segundo plano, mas bloqueia a primeira sessão. Sempre mostre uma interface de progresso de download.
4. Sem chamada de ferramentas. Se sua tarefa exige que o modelo chame sua API, faça isso você mesmo no cliente; o modelo apenas decide o que chamar.
5. Desvio do prompt do sistema. O modelo no dispositivo segue os prompts do sistema menos rigidamente do que as variantes na nuvem. Fixe o formato com exemplos de uma única vez no prompt do sistema.
6. Permissões importam. Extensões precisam de "languageModel" em permissions. Esqueça isso e a API retorna silenciosamente unavailable.

Configure um fallback na nuvem antes de lançar

Seu aplicativo será lançado para usuários que não possuem o modelo. Sempre configure um fallback. O padrão é simples:

async function summarize(text) {
  if ('LanguageModel' in window) {
    const status = await LanguageModel.availability();
    if (status === 'available') {
      const session = await LanguageModel.create({
        systemPrompt: 'Reply with one bullet summary, max 12 words.',
      });
      return session.prompt(text);
    }
  }
  // Fallback: chame seu servidor, que chama o Gemini na nuvem ou seu próprio modelo.
  const r = await fetch('/api/summarize', {
    method: 'POST', body: JSON.stringify({ text }),
  });
  return (await r.json()).summary;
}

Privacidade e o que dizer aos usuários

O ponto forte da Prompt API é que a entrada nunca sai do dispositivo. Isso é verdade hoje e é a intenção explícita do design da iniciativa de IA Incorporada. Duas ressalvas que valem a pena saber:

• O próprio modelo foi treinado pelo Google com dados do Google; executá-lo localmente não muda isso. O Chrome envia os pesos com a atualização do navegador.
• A telemetria sobre o uso ainda pode ser relatada pelo Chrome sob as configurações normais de telemetria do Chrome do usuário. O conteúdo do prompt não faz parte dessa telemetria.

Para a maioria dos aplicativos de consumo, esta é uma forte história de privacidade que você pode colocar em sua UI sem revisão legal. Para cargas de trabalho regulamentadas (HIPAA, PCI), confirme com um advogado antes de depender disso.

Quando ignorar a Prompt API

Escolha a Gemini API na nuvem quando:

• Sua tarefa precisa de mais de 4K tokens de entrada.
• Você precisa de chamada de ferramentas, saída estruturada com imposição de esquema ou entradas multimodais além do Origin Trial.
• Você atende usuários no Safari, Firefox ou Chrome móvel. O suporte do navegador é exclusivo do Chrome hoje, e a Apple não sinalizou uma data de lançamento.
• A qualidade da saída importa mais do que a latência. Nano é pequeno; Pro não é.

Para o ângulo de peso aberto, Como executar o DeepSeek V4 localmente aborda a execução de um modelo significativamente maior em uma máquina de desenvolvedor sem sair da rede local.

Perguntas Frequentes

A Prompt API está no processo oficial de padrões da web? Está no grupo comunitário W3C WebML como uma proposta. Trate-a como específica do Chrome até que outros motores a implementem.

Posso usá-la a partir de um service worker? No Chrome 138+, sim para extensões. As páginas da web atualmente a restringem ao contexto do documento. Verifique a documentação antes de usá-la em um service worker.

Qual tamanho de modelo estou realmente recebendo? O Gemini Nano está na faixa de 2-4B parâmetros, quantizado para se ajustar. O Google não se comprometeu com um tamanho específico; espere que ele cresça.

Ela suporta chamada de função? Não no canal estável. O branch do Origin Trial tem suporte experimental a ferramentas; não dependa disso para produção.

Como testá-la em um CI automatizado? Você ainda não pode executar o modelo no dispositivo em um Chromium sem interface gráfica. Simule o global LanguageModel em testes e execute o caminho de fallback da nuvem no CI.

É gratuito para uso comercial? Sim. Não há cobrança por chamada. Você arca com o custo de armazenamento no dispositivo do usuário (cerca de 2 GB) e o Chrome lida com as atualizações.

Para equipes que já executam fluxos de trabalho LLM na nuvem paralelamente a isso, a postagem O que é GPT-5.5 aborda as compensações do lado da nuvem em mais profundidade, e o Apidog gerencia a configuração de mock e fallback sem uma ferramenta de teste separada.