Blog

Como Acessar a API Gemini 3.1 Flash Lite

Ashley Innocent

Ashley Innocent

4 março 2026

Como Acessar a API Gemini 3.1 Flash Lite

O Gemini 3.1 Flash Lite do Google foi lançado em 3 de março de 2026 e é o modelo mais rápido e acessível da linha Gemini. Custando US$ 0,25 por milhão de tokens de entrada e US$ 1,50 por milhão de tokens de saída, ele foi desenvolvido para desenvolvedores que precisam de IA em escala sem estourar o orçamento.

Este guia mostra exatamente como obter acesso, configurar sua chave de API e começar a fazer requisições. Você terá código funcionando em menos de 10 minutos.

TL;DR

Configuração Rápida:

  1. Vá para Google AI Studio
  2. Crie um projeto e gere uma chave de API
  3. Instale o SDK: pip install google-generativeai
  4. Faça sua primeira requisição com o modelo gemini-3.1-flash-lite
  5. Teste no Apidog para depuração e colaboração em equipe mais fáceis

Preço: US$ 0,25/1M tokens de entrada, US$ 1,50/1M tokens de saída
Velocidade: 2,5X mais rápido que o Gemini 2.5 Flash
Nível Gratuito: 1 milhão de tokens de entrada gratuitos durante a prévia

O que é o Gemini 3.1 Flash Lite?

O Gemini 3.1 Flash Lite é o mais novo modelo de IA do Google, projetado para aplicações de alto volume. Ele é 2,5X mais rápido que o Gemini 2.5 Flash, com uma velocidade de saída 45% maior, enquanto pontua 86,9% nos benchmarks GPQA Diamond e 76,8% nos benchmarks MMMU Pro.

O modelo inclui níveis de raciocínio que você pode ajustar por requisição. Diminua para tarefas simples, aumente para raciocínio complexo. Essa flexibilidade permite otimizar custos enquanto lida com cargas de trabalho variadas.

Ele está disponível através do Google AI Studio para desenvolvedores individuais e do Vertex AI para empresas.

Pré-requisitos

Antes de começar, certifique-se de ter:

Passo 1: Crie uma Conta no Google AI Studio

O Google AI Studio é a maneira mais rápida de acessar os modelos Gemini para desenvolvimento.

  1. Acesse aistudio.google.com
  2. Faça login com sua conta Google
  3. Aceite os termos de serviço
  4. Você será direcionado para o painel do AI Studio

A interface mostra os modelos disponíveis, seu uso de API e modelos de início rápido. O Flash Lite aparece na lista suspensa de modelos como gemini-3.1-flash-lite.

Passo 2: Gere Sua Chave de API

As chaves de API permitem autenticar requisições à API Gemini.

  1. Clique em Obter Chave de API no canto superior direito
  2. Selecione Criar chave de API em novo projeto (ou escolha um projeto existente)
  3. O Google cria um novo projeto na Nuvem e gera sua chave
  4. Copie a chave de API - ela se parece com AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  5. Armazene-a com segurança - você não a verá novamente

Dica de segurança: Nunca envie chaves de API para controle de versão. Use variáveis de ambiente ou ferramentas de gerenciamento de segredos.

Passo 3: Instale o SDK

O Google fornece SDKs oficiais para Python e Node.js.

Python

pip install google-generativeai

Node.js

npm install @google/generative-ai

O SDK cuida da autenticação, formatação de requisições e análise de respostas. Você também pode usar a API REST diretamente, se preferir.

Passo 4: Faça Sua Primeira Requisição

Vamos enviar um prompt simples para o Flash Lite.

Exemplo em Python

import google.generativeai as genai
import os

# Configure a chave de API
genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))

# Inicialize o modelo
model = genai.GenerativeModel('gemini-3.1-flash-lite')

# Gere conteúdo
response = model.generate_content('Explique APIs REST em uma frase.')

print(response.text)

Exemplo em Node.js

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Inicialize com a chave de API
const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);

async function run() {
  // Obtenha o modelo
  const model = genAI.getGenerativeModel({ model: "gemini-3.1-flash-lite" });

  // Gere conteúdo
  const result = await model.generateContent("Explique APIs REST em uma frase.");
  const response = await result.response;
  const text = response.text();

  console.log(text);
}

run();

Exemplo cURL (API REST)

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=SUA_CHAVE_API" \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Explique APIs REST em uma frase."
      }]
    }]
  }'

Execute qualquer um desses exemplos e você receberá uma resposta em segundos. O modelo retorna texto claro e conciso que responde ao seu prompt.

Passo 5: Teste com Apidog

O Apidog facilita o teste de API com uma interface visual, colaboração em equipe e documentação automática.

Por que usar o Apidog para a API Gemini?

Você verá a resposta no painel direito com realce de sintaxe, tempo de resposta e código de status.

Salvar como Variável de Ambiente

  1. Vá para Environments (Ambientes) no Apidog
  2. Crie um novo ambiente (ex: "Gemini Dev")
  3. Adicione a variável: GOOGLE_API_KEY = sua chave de API real
  4. Use {{GOOGLE_API_KEY}} em suas requisições

Agora você pode alternar entre ambientes sem alterar suas requisições. Perfeito para gerenciar chaves de desenvolvimento, staging e produção.

Compreendendo o Formato da Requisição

A API Gemini usa uma estrutura JSON específica.

Estrutura Básica da Requisição

{
  "contents": [{
    "parts": [{
      "text": "Seu prompt aqui"
    }]
  }]
}

Com Níveis de Raciocínio

{
  "contents": [{
    "parts": [{
      "text": "Gerar documentação de API para um endpoint de autenticação de usuário"
    }]
  }],
  "generationConfig": {
    "thinkingLevel": "high"
  }
}

Níveis de raciocínio: low (baixo), medium (médio), high (alto)

Com Instruções do Sistema

{
  "systemInstruction": {
    "parts": [{
      "text": "Você é um especialista em documentação de API. Escreva documentos claros e concisos."
    }]
  },
  "contents": [{
    "parts": [{
      "text": "Documente este endpoint: POST /api/users"
    }]
  }]
}

As instruções do sistema guiam o comportamento do modelo em todas as requisições de uma conversa.

Formato da Resposta

A API retorna JSON com esta estrutura:

{
  "candidates": [{
    "content": {
      "parts": [{
        "text": "APIs REST são interfaces que permitem que aplicativos se comuniquem via HTTP usando métodos padrão como GET, POST, PUT e DELETE."
      }],
      "role": "model"
    },
    "finishReason": "STOP",
    "index": 0,
    "safetyRatings": [...]
  }],
  "usageMetadata": {
    "promptTokenCount": 8,
    "candidatesTokenCount": 25,
    "totalTokenCount": 33
  }
}

Campos chave:

Casos de Uso Comuns

1. Geração de Documentação de API

import google.generativeai as genai

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

endpoint_spec = """
POST /api/v1/users
Cria uma nova conta de usuário
Corpo: { "email": string, "password": string, "name": string }
"""

response = model.generate_content(
    f"Gerar documentação de API abrangente para este endpoint:\n{endpoint_spec}",
    generation_config={"thinkingLevel": "medium"}
)

print(response.text)

2. Validação de Requisição

def validate_api_request(request_body):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    Valide o corpo desta requisição de API e liste quaisquer problemas:
    {request_body}

    Verifique por:
    - Campos obrigatórios ausentes
    - Tipos de dados inválidos
    - Preocupações de segurança
    """

    response = model.generate_content(prompt)
    return response.text

# Exemplo de uso
request = '{"email": "test@example.com", "password": "123"}'
validation_result = validate_api_request(request)
print(validation_result)

3. Geração de Mensagens de Erro

def generate_user_friendly_error(error_code, technical_message):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    Converta este erro técnico em uma mensagem amigável para o usuário:
    Código do Erro: {error_code}
    Técnico: {technical_message}

    Torne-a clara, acionável e não técnica.
    """

    response = model.generate_content(
        prompt,
        generation_config={"thinkingLevel": "low"}
    )
    return response.text

# Exemplo
friendly_error = generate_user_friendly_error(
    "AUTH_TOKEN_EXPIRED",
    "A validação do token JWT falhou: a reivindicação exp está no passado"
)
print(friendly_error)

Limites de Taxa e Cotas

O Flash Lite possui limites generosos durante a prévia:

Nível Gratuito:

Nível Pago:

Monitore seu uso no Google AI Studio em Usage & Billing (Uso e Faturamento).

Tratamento de Erros

Lide com erros comuns de forma elegante:

import google.generativeai as genai
from google.api_core import exceptions

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

def safe_generate(prompt):
    try:
        response = model.generate_content(prompt)
        return response.text
    except exceptions.ResourceExhausted:
        return "Limite de taxa excedido. Tente novamente em um minuto."
    except exceptions.InvalidArgument as e:
        return f"Requisição inválida: {str(e)}"
    except exceptions.PermissionDenied:
        return "Chave de API inválida ou expirada."
    except Exception as e:
        return f"Erro inesperado: {str(e)}"

result = safe_generate("Explique APIs")
print(result)

Erros comuns:

Solução de Problemas

"Chave de API inválida"

Verifique o seguinte:

  1. Chave de API copiada corretamente (sem espaços extras)
  2. Chave de API habilitada no Google Cloud Console
  3. Faturamento habilitado em seu projeto
  4. Usando o nome correto da variável de ambiente

"Modelo não encontrado"

Certifique-se de estar usando o nome exato do modelo:

# Correto
model = genai.GenerativeModel('gemini-3.1-flash-lite')

# Errado
model = genai.GenerativeModel('gemini-flash-lite')
model = genai.GenerativeModel('gemini-3.1-flash')

"Limite de taxa excedido"

Você atingiu o limite de requisições por minuto. Soluções:

  1. Adicione lógica de repetição com backoff exponencial
  2. Agrupe vários prompts em uma única requisição
  3. Atualize para o nível pago para limites mais altos
  4. Implemente enfileiramento de requisições

Respostas lentas

O Flash Lite é rápido, mas se você estiver vendo atrasos:

  1. Verifique sua conexão de rede
  2. Use níveis de raciocínio mais baixos para tarefas simples
  3. Reduza o comprimento do prompt
  4. Considere streaming de respostas para saídas longas

Avançado: Streaming de Respostas

Para saídas longas, transmita tokens à medida que são gerados:

import google.generativeai as genai

genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))
model = genai.GenerativeModel('gemini-3.1-flash-lite')

prompt = "Escreva uma explicação detalhada dos métodos de autenticação da API REST"

response = model.generate_content(prompt, stream=True)

for chunk in response:
    print(chunk.text, end='', flush=True)

O streaming melhora o desempenho percebido. Os usuários veem a saída imediatamente, em vez de esperar pela resposta completa.

Dicas de Otimização de Custos

1. Agrupar Requisições Semelhantes

# Caro: 3 requisições separadas
response1 = model.generate_content("Explique GET")
response2 = model.generate_content("Explique POST")
response3 = model.generate_content("Explique PUT")

# Mais barato: 1 requisição combinada
combined_prompt = """
Explique estes métodos HTTP:
1. GET
2. POST
3. PUT
"""
response = model.generate_content(combined_prompt)

2. Use Níveis de Raciocínio Mais Baixos

# Para classificação simples
response = model.generate_content(
    "Este e-mail é spam? 'Compre agora!'",
    generation_config={"thinkingLevel": "low"}
)

# Para análise complexa
response = model.generate_content(
    "Analise este design de API e sugira melhorias...",
    generation_config={"thinkingLevel": "high"}
)

3. Implementar Cache

Armazene em cache as respostas para consultas repetidas. Um cache simples em memória pode reduzir os custos em 50%+ para requisições comuns.

4. Reduzir Prompts

Remova o contexto desnecessário:

# Detalhado (mais tokens)
prompt = "Gostaria que você me explicasse o que são APIs REST e como elas funcionam em detalhes"

# Conciso (menos tokens)
prompt = "Explique APIs REST"

Considerações de Segurança

1. Proteja Sua Chave de API

2. Valide a Entrada do Usuário

def safe_prompt(user_input):
    # Remove tentativas de injeção potenciais
    cleaned = user_input.replace("Ignore previous instructions", "")
    cleaned = cleaned[:1000]  # Limita o comprimento

    return f"Pergunta do usuário: {cleaned}"

3. Filtre Dados Sensíveis

Não envie informações sensíveis para a API:

import re

def sanitize_for_ai(text):
    # Remove endereços de e-mail
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
    # Remove números de telefone
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', text)
    # Remove cartões de crédito
    text = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[CARD]', text)
    return text

4. Implemente Limitação de Taxa

Proteja sua chave de API contra abuso:

from collections import defaultdict
import time

class RateLimiter:
    def __init__(self, max_requests=10, window=60):
        self.max_requests = max_requests
        self.window = window
        self.requests = defaultdict(list)

    def allow_request(self, user_id):
        now = time.time()
        # Remove requisições antigas
        self.requests[user_id] = [
            req_time for req_time in self.requests[user_id]
            if now - req_time < self.window
        ]

        if len(self.requests[user_id]) < self.max_requests:
            self.requests[user_id].append(now)
            return True
        return False

limiter = RateLimiter(max_requests=10, window=60)

def generate_with_limit(user_id, prompt):
    if not limiter.allow_request(user_id):
        return "Limite de taxa excedido. Tente novamente mais tarde."

    model = genai.GenerativeModel('gemini-3.1-flash-lite')
    response = model.generate_content(prompt)
    return response.text

Comparando o Flash Lite com Outros Modelos Gemini

Recurso Flash Lite Flash Pro
Preço de Entrada US$ 0,25/1M US$ 0,50/1M US$ 1,25/1M
Preço de Saída US$ 1,50/1M US$ 3,00/1M US$ 7,50/1M
Velocidade 2,5X mais rápido Rápido Padrão
Janela de Contexto 32K tokens 1M tokens 2M tokens
Melhor Para Alto volume, sensível ao custo Equilibrado Raciocínio complexo

Escolha o Flash Lite quando:

Escolha o Flash quando:

Escolha o Pro quando:

Integração com Fluxos de Trabalho do Apidog

Usuários do Apidog podem integrar o Flash Lite em seu fluxo de trabalho de desenvolvimento de API:

1. Gerar Casos de Teste Automaticamente

Use o Flash Lite para gerar casos de teste a partir de suas especificações de API:

def generate_test_cases(endpoint_spec):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    Gerar casos de teste abrangentes para este endpoint de API:
    {json.dumps(endpoint_spec, indent=2)}

    Inclua:
    - Testes de caminho feliz
    - Casos de borda
    - Cenários de erro
    - Condições de limite

    Formate como um array JSON de casos de teste.
    """

    response = model.generate_content(prompt)
    return json.loads(response.text)

2. Validar Respostas da API

Verifique se as respostas correspondem aos esquemas esperados:

def validate_response(response_data, expected_schema):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    Valide esta resposta de API contra o esquema:

    Resposta: {json.dumps(response_data, indent=2)}
    Esquema: {json.dumps(expected_schema, indent=2)}

    Liste quaisquer incompatibilidades ou problemas.
    """

    response = model.generate_content(
        prompt,
        generation_config={"thinkingLevel": "low"}
    )
    return response.text

3. Gerar Dados Mock

Crie dados de teste realistas:

def generate_mock_data(schema, count=10):
    model = genai.GenerativeModel('gemini-3.1-flash-lite')

    prompt = f"""
    Gerar {count} entradas de dados mock realistas que correspondam a este esquema:
    {json.dumps(schema, indent=2)}

    Retornar como um array JSON.
    """

    response = model.generate_content(prompt)
    return json.loads(response.text)

FAQ

O Gemini 3.1 Flash Lite é gratuito?

O primeiro milhão de tokens de entrada é gratuito durante a prévia. Depois disso, você paga US$ 0,25 por milhão de tokens de entrada e US$ 1,50 por milhão de tokens de saída.

Quão rápido é o Flash Lite em comparação com outros modelos?

O Flash Lite é 2,5X mais rápido que o Gemini 2.5 Flash para o tempo até o primeiro token e 45% mais rápido para a velocidade de saída. É um dos modelos mais rápidos disponíveis.

Posso usar o Flash Lite em produção?

Sim. Embora rotulado como "prévia", o modelo é estável o suficiente para uso em produção. Adotantes iniciais como Latitude, Cartwheel e Whering já o estão usando em escala.

Qual é o tamanho da janela de contexto?

O Flash Lite suporta até 32.000 tokens de contexto. Isso é suficiente para a maioria dos casos de uso de API, mas menor que o Flash (1M tokens) ou o Pro (2M tokens).

Como funcionam os níveis de raciocínio?

Os níveis de raciocínio controlam o quanto o modelo processa. "Baixo" é rápido e simples. "Alto" é mais lento, mas mais completo. Use "baixo" para classificação, "alto" para raciocínio complexo.

Posso usar o Flash Lite com o Apidog?

Sim. O Apidog funciona com qualquer API REST, incluindo o Gemini. Configure suas requisições no Apidog para facilitar testes, colaboração em equipe e documentação.

O que acontece se eu exceder os limites de taxa?

Você receberá um erro 429. Implemente uma lógica de repetição com backoff exponencial ou atualize para o nível pago para limites mais altos (60 requisições/minuto vs 15).

Meus dados são usados para treinar o modelo?

De acordo com a política do Google, as requisições de API não são usadas para treinar modelos. Seus dados permanecem privados.

Posso fazer fine-tuning no Flash Lite?

Ainda não. O fine-tuning está disponível para alguns modelos Gemini, mas não para o Flash Lite no lançamento. Use instruções do sistema para guiar o comportamento em vez disso.

Como o Flash Lite se compara ao GPT-4 Turbo?

O Flash Lite é mais rápido e mais barato, mas o GPT-4 Turbo tem um raciocínio mais forte para tarefas complexas. Para cargas de trabalho de API de alto volume, o Flash Lite ganha em custo e velocidade.

Próximos Passos

Você agora tem tudo o que precisa para começar a usar o Gemini 3.1 Flash Lite:

  1. Obtenha sua chave de API no Google AI Studio
  2. Instale o SDK e execute sua primeira requisição
  3. Teste no Apidog para um desenvolvimento mais fácil
  4. Implemente tratamento de erros e lógica de repetição
  5. Monitore o uso para otimizar custos

O modelo está pronto para produção. O preço torna a IA acessível em escala. A velocidade mantém seus usuários satisfeitos.

Comece a construir.

botão

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs

Cadastre-se gratuitamenteBaixar