Cara Mengakses Gemini 3.1 Flash Lite API

Google Gemini 3.1 Flash Lite diluncurkan pada 3 Maret 2026, dan merupakan model tercepat serta paling terjangkau dalam jajaran Gemini. Dengan harga $0.25 per juta token masukan dan $1.50 per juta token keluaran, model ini dibangun untuk pengembang yang membutuhkan AI dalam skala besar tanpa menghabiskan banyak anggaran.

Panduan ini menunjukkan dengan tepat bagaimana cara mendapatkan akses, mengatur kunci API Anda, dan mulai membuat permintaan. Anda akan memiliki kode yang berfungsi dalam waktu kurang dari 10 menit.

RINGKASAN

Pengaturan Cepat:

Buka Google AI Studio
Buat proyek dan hasilkan kunci API
Instal SDK: pip install google-generativeai
Buat permintaan pertama Anda dengan model gemini-3.1-flash-lite
Uji di Apidog untuk debugging yang lebih mudah dan kolaborasi tim

Harga: $0.25/1M token masukan, $1.50/1M token keluaran
Kecepatan: 2.5X lebih cepat dari Gemini 2.5 Flash
Tingkat Gratis: 1 juta token masukan gratis selama pratinjau

Apa itu Gemini 3.1 Flash Lite?

Gemini 3.1 Flash Lite adalah model AI terbaru Google yang dirancang untuk aplikasi bervolume tinggi. Model ini 2.5X lebih cepat dari Gemini 2.5 Flash dengan kecepatan keluaran 45% lebih cepat, sementara mencetak 86.9% pada GPQA Diamond dan 76.8% pada benchmark MMMU Pro.

Model ini menyertakan tingkat pemikiran yang dapat Anda sesuaikan per permintaan. Turunkan untuk tugas sederhana, tingkatkan untuk penalaran kompleks. Fleksibilitas ini memungkinkan Anda mengoptimalkan biaya sambil menangani beban kerja yang bervariasi.

Tersedia melalui Google AI Studio untuk pengembang individu dan Vertex AI untuk perusahaan.

Prasyarat

Sebelum Anda mulai, pastikan Anda memiliki:

Akun Google
Python 3.7+ atau Node.js 14+ terinstal
Pemahaman dasar tentang REST API
(Opsional) Apidog terinstal untuk pengujian API

Langkah 1: Buat Akun Google AI Studio

Google AI Studio adalah cara tercepat untuk mengakses model Gemini untuk pengembangan.

Buka aistudio.google.com
Masuk dengan akun Google Anda
Setujui persyaratan layanan
Anda akan mendarat di dashboard AI Studio

Antarmuka menampilkan model yang tersedia, penggunaan API Anda, dan template mulai cepat. Flash Lite muncul di dropdown model sebagai gemini-3.1-flash-lite.

Langkah 2: Hasilkan Kunci API Anda

Kunci API memungkinkan Anda mengautentikasi permintaan ke Gemini API.

Klik Dapatkan Kunci API di pojok kanan atas
Pilih Buat kunci API di proyek baru (atau pilih proyek yang sudah ada)
Google akan membuat proyek Cloud baru dan menghasilkan kunci Anda
Salin kunci API - tampilannya seperti AIzaSyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
Simpan dengan aman - Anda tidak akan melihatnya lagi

Tips keamanan: Jangan pernah menyimpan kunci API ke kontrol versi. Gunakan variabel lingkungan atau alat manajemen rahasia.

Langkah 3: Instal SDK

Google menyediakan SDK resmi untuk Python dan Node.js.

Python

pip install google-generativeai

Node.js

npm install @google/generative-ai

SDK menangani autentikasi, pemformatan permintaan, dan penguraian respons. Anda juga dapat menggunakan REST API secara langsung jika Anda mau.

Langkah 4: Buat Permintaan Pertama Anda

Mari kirimkan prompt sederhana ke Flash Lite.

Contoh Python

import google.generativeai as genai
import os

# Configure API key
genai.configure(api_key=os.environ.get('GOOGLE_API_KEY'))

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

# Generate content
response = model.generate_content('Explain REST APIs in one sentence.')

print(response.text)

Contoh Node.js

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

// Initialize with API key
const genAI = new GoogleGenerativeAI(process.env.GOOGLE_API_KEY);

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

  // Generate content
  const result = await model.generateContent("Explain REST APIs in one sentence.");
  const response = await result.response;
  const text = response.text();

  console.log(text);
}

run();

Contoh cURL (REST API)

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-flash-lite:generateContent?key=YOUR_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts": [{
        "text": "Explain REST APIs in one sentence."
      }]
    }]
  }'

Jalankan salah satu contoh ini dan Anda akan mendapatkan respons dalam hitungan detik. Model ini mengembalikan teks yang jelas dan ringkas yang menjawab prompt Anda.

Langkah 5: Uji dengan Apidog

Apidog membuat pengujian API lebih mudah dengan antarmuka visual, kolaborasi tim, dan dokumentasi otomatis.

Mengapa Menggunakan Apidog untuk Gemini API?

Pembangun permintaan visual - Tidak perlu menulis perintah cURL
Variabel lingkungan - Mudah beralih antara kunci API dev/prod
Validasi respons - Tangkap kesalahan sebelum mencapai produksi
Berbagi tim - Bagikan koleksi API dengan tim Anda
Dokumentasi otomatis - Hasilkan dokumen dari permintaan Anda

Anda akan melihat respons di panel kanan dengan penyorotan sintaks, waktu respons, dan kode status.

Simpan sebagai Variabel Lingkungan

Buka Environments di Apidog
Buat lingkungan baru (misalnya, "Gemini Dev")
Tambahkan variabel: GOOGLE_API_KEY = kunci API Anda yang sebenarnya
Gunakan {{GOOGLE_API_KEY}} dalam permintaan Anda

Sekarang Anda dapat beralih lingkungan tanpa mengubah permintaan Anda. Sempurna untuk mengelola kunci dev, staging, dan produksi.

Memahami Format Permintaan

Gemini API menggunakan struktur JSON tertentu.

Struktur Permintaan Dasar

{
  "contents": [{
    "parts": [{
      "text": "Your prompt here"
    }]
  }]
}

Dengan Tingkat Pemikiran

{
  "contents": [{
    "parts": [{
      "text": "Generate API documentation for a user authentication endpoint"
    }]
  }],
  "generationConfig": {
    "thinkingLevel": "high"
  }
}

Tingkat pemikiran: low, medium, high

Rendah: Respons cepat, sederhana
Sedang: Penalaran seimbang
Tinggi: Analisis mendalam, tugas kompleks

Dengan Instruksi Sistem

{
  "systemInstruction": {
    "parts": [{
      "text": "You are an API documentation expert. Write clear, concise docs."
    }]
  },
  "contents": [{
    "parts": [{
      "text": "Document this endpoint: POST /api/users"
    }]
  }]
}

Instruksi sistem memandu perilaku model di semua permintaan dalam percakapan.

Format Respons

API mengembalikan JSON dengan struktur ini:

{
  "candidates": [{
    "content": {
      "parts": [{
        "text": "REST APIs are interfaces that let applications communicate over HTTP using standard methods like GET, POST, PUT, and DELETE."
      }],
      "role": "model"
    },
    "finishReason": "STOP",
    "index": 0,
    "safetyRatings": [...]
  }],
  "usageMetadata": {
    "promptTokenCount": 8,
    "candidatesTokenCount": 25,
    "totalTokenCount": 33
  }
}

Bidang kunci:

candidates[0].content.parts[0].text - Respons yang dihasilkan
usageMetadata - Jumlah token untuk penagihan
finishReason - Alasan mengapa generasi berhenti (STOP, MAX_TOKENS, SAFETY)

Kasus Penggunaan Umum

1. Pembuatan Dokumentasi 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
Creates a new user account
Body: { "email": string, "password": string, "name": string }
"""

response = model.generate_content(
    f"Generate comprehensive API documentation for this endpoint:\n{endpoint_spec}",
    generation_config={"thinkingLevel": "medium"}
)

print(response.text)

2. Validasi Permintaan

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

    prompt = f"""
    Validate this API request body and list any issues:
    {request_body}

    Check for:
    - Missing required fields
    - Invalid data types
    - Security concerns
    """

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

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

3. Pembuatan Pesan Kesalahan

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

    prompt = f"""
    Convert this technical error into a user-friendly message:
    Error Code: {error_code}
    Technical: {technical_message}

    Make it clear, actionable, and non-technical.
    """

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

# Example
friendly_error = generate_user_friendly_error(
    "AUTH_TOKEN_EXPIRED",
    "JWT token validation failed: exp claim is in the past"
)
print(friendly_error)

Batas Kecepatan dan Kuota

Flash Lite memiliki batasan yang murah hati selama pratinjau:

Tingkat Gratis:

1 juta token masukan gratis
15 permintaan per menit
1.500 permintaan per hari

Tingkat Berbayar:

$0.25 per 1M token masukan
$1.50 per 1M token keluaran
60 permintaan per menit
Tidak ada batasan harian

Pantau penggunaan Anda di Google AI Studio di bawah Penggunaan & Penagihan.

Penanganan Kesalahan

Tangani kesalahan umum dengan baik:

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 "Batas kecepatan terlampaui. Coba lagi dalam satu menit."
    except exceptions.InvalidArgument as e:
        return f"Permintaan tidak valid: {str(e)}"
    except exceptions.PermissionDenied:
        return "Kunci API tidak valid atau kedaluwarsa."
    except Exception as e:
        return f"Terjadi kesalahan tak terduga: {str(e)}"

result = safe_generate("Jelaskan API")
print(result)

Kesalahan umum:

400 Bad Request - JSON tidak valid atau bidang wajib tidak ada
401 Unauthorized - Kunci API tidak valid
429 Too Many Requests - Batas kecepatan terlampaui
500 Internal Server Error - Server Google mengalami masalah

Pemecahan Masalah

"Kunci API tidak valid"

Periksa hal-hal berikut:

Kunci API disalin dengan benar (tanpa spasi tambahan)
Kunci API diaktifkan di Google Cloud Console
Penagihan diaktifkan pada proyek Anda
Menggunakan nama variabel lingkungan yang benar

"Model tidak ditemukan"

Pastikan Anda menggunakan nama model yang tepat:

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

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

"Batas kecepatan terlampaui"

Anda mencapai batas permintaan per menit. Solusi:

Tambahkan logika coba ulang (retry logic) dengan exponential backoff
Gabungkan beberapa prompt menjadi satu permintaan
Tingkatkan ke tingkat berbayar untuk batas yang lebih tinggi
Terapkan antrean permintaan

Respons lambat

Flash Lite cepat, tetapi jika Anda melihat penundaan:

Periksa koneksi jaringan Anda
Gunakan tingkat pemikiran yang lebih rendah untuk tugas sederhana
Kurangi panjang prompt
Pertimbangkan streaming respons untuk keluaran panjang

Lanjutan: Streaming Respons

Untuk keluaran panjang, streaming token saat dihasilkan:

import google.generativeai as genai

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

prompt = "Write a detailed explanation of REST API authentication methods"

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

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

Streaming meningkatkan kinerja yang dirasakan. Pengguna melihat keluaran segera daripada menunggu respons lengkap.

Tips Optimasi Biaya

1. Kelompokkan Permintaan Serupa

# Mahal: 3 permintaan terpisah
response1 = model.generate_content("Explain GET")
response2 = model.generate_content("Explain POST")
response3 = model.generate_content("Explain PUT")

# Lebih murah: 1 permintaan gabungan
combined_prompt = """
Jelaskan metode HTTP berikut:
1. GET
2. POST
3. PUT
"""
response = model.generate_content(combined_prompt)

2. Gunakan Tingkat Pemikiran yang Lebih Rendah

# Untuk klasifikasi sederhana
response = model.generate_content(
    "Apakah email ini spam? 'Beli sekarang!'",
    generation_config={"thinkingLevel": "low"}
)

# Untuk analisis kompleks
response = model.generate_content(
    "Analisis desain API ini dan sarankan perbaikan...",
    generation_config={"thinkingLevel": "high"}
)

3. Terapkan Caching

Cache respons untuk kueri berulang. Cache in-memory sederhana dapat memangkas biaya hingga 50%+ untuk permintaan umum.

4. Pangkas Prompt

Hapus konteks yang tidak perlu:

# Bertele-tele (lebih banyak token)
prompt = "Saya ingin Anda menjelaskan kepada saya apa itu REST API dan bagaimana cara kerjanya secara detail"

# Ringkas (lebih sedikit token)
prompt = "Jelaskan REST API"

Pertimbangan Keamanan

1. Lindungi Kunci API Anda

Simpan dalam variabel lingkungan atau pengelola rahasia
Rotasi kunci secara teratur
Gunakan kunci terpisah untuk dev/staging/prod
Jangan pernah mencatat kunci API

2. Validasi Masukan Pengguna

def safe_prompt(user_input):
    # Hapus potensi upaya injeksi
    cleaned = user_input.replace("Abaikan instruksi sebelumnya", "")
    cleaned = cleaned[:1000]  # Batasi panjang

    return f"Pertanyaan pengguna: {cleaned}"

3. Saring Data Sensitif

Jangan kirim informasi sensitif ke API:

import re

def sanitize_for_ai(text):
    # Hapus alamat email
    text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
    # Hapus nomor telepon
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', text)
    # Hapus kartu kredit
    text = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[CARD]', text)
    return text

4. Terapkan Pembatasan Kecepatan

Lindungi kunci API Anda dari penyalahgunaan:

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()
        # Hapus permintaan lama
        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 "Batas kecepatan terlampaui. Coba lagi nanti."

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

Membandingkan Flash Lite dengan Model Gemini Lain

Fitur	Flash Lite	Flash	Pro
Harga Masukan	$0.25/1M	$0.50/1M	$1.25/1M
Harga Keluaran	$1.50/1M	$3.00/1M	$7.50/1M
Kecepatan	2.5X lebih cepat	Cepat	Standar
Jendela Konteks	32K token	1M token	2M token
Terbaik Untuk	Bervolume tinggi, sensitif biaya	Seimbang	Penalaran kompleks

Pilih Flash Lite ketika:

Anda membutuhkan respons cepat
Biaya menjadi pertimbangan
Permintaan di bawah 32K token
Persyaratan kualitas moderat

Pilih Flash ketika:

Anda membutuhkan jendela konteks yang besar
Kualitas lebih penting daripada biaya

Pilih Pro ketika:

Anda membutuhkan kemampuan penalaran maksimum
Biaya bukan masalah
Bekerja dengan dokumen yang sangat besar

Integrasi dengan Alur Kerja Apidog

Pengguna Apidog dapat mengintegrasikan Flash Lite ke dalam alur kerja pengembangan API mereka:

1. Hasilkan Kasus Uji Otomatis

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

    prompt = f"""
    Hasilkan kasus uji komprehensif untuk titik akhir API ini:
    {json.dumps(endpoint_spec, indent=2)}

    Sertakan:
    - Tes jalur yang berhasil (Happy path tests)
    - Kasus tepi (Edge cases)
    - Skenario kesalahan
    - Kondisi batas

    Format sebagai array JSON kasus uji.
    """

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

2. Validasi Respons API

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

    prompt = f"""
    Validasi respons API ini terhadap skema:

    Respons: {json.dumps(response_data, indent=2)}
    Skema: {json.dumps(expected_schema, indent=2)}

    Daftar ketidakcocokan atau masalah apa pun.
    """

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

3. Hasilkan Data Mock

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

    prompt = f"""
    Hasilkan {count} entri data mock realistis yang cocok dengan skema ini:
    {json.dumps(schema, indent=2)}

    Kembalikan sebagai array JSON.
    """

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

FAQ

Apakah Gemini 3.1 Flash Lite gratis?

1 juta token masukan pertama gratis selama pratinjau. Setelah itu, Anda membayar $0.25 per juta token masukan dan $1.50 per juta token keluaran.

Seberapa cepat Flash Lite dibandingkan dengan model lain?

Flash Lite 2.5X lebih cepat dari Gemini 2.5 Flash untuk waktu ke token pertama dan 45% lebih cepat untuk kecepatan keluaran. Ini adalah salah satu model tercepat yang tersedia.

Bisakah saya menggunakan Flash Lite dalam produksi?

Ya. Meskipun diberi label "pratinjau", model ini cukup stabil untuk penggunaan produksi. Para pengguna awal seperti Latitude, Cartwheel, dan Whering sudah menggunakannya dalam skala besar.

Berapa ukuran jendela konteksnya?

Flash Lite mendukung hingga 32.000 token konteks. Ini cukup untuk sebagian besar kasus penggunaan API tetapi lebih kecil dari Flash (1M token) atau Pro (2M token).

Bagaimana cara kerja tingkat pemikiran?

Tingkat pemikiran mengontrol seberapa banyak pemrosesan yang diterapkan model. Rendah (Low) cepat dan sederhana. Tinggi (High) lebih lambat tetapi lebih menyeluruh. Gunakan rendah untuk klasifikasi, tinggi untuk penalaran kompleks.

Bisakah saya menggunakan Flash Lite dengan Apidog?

Ya. Apidog bekerja dengan REST API apa pun, termasuk Gemini. Atur permintaan Anda di Apidog untuk pengujian yang lebih mudah, kolaborasi tim, dan dokumentasi.

Apa yang terjadi jika saya melebihi batas kecepatan?

Anda akan mendapatkan kesalahan 429. Terapkan logika coba ulang (retry logic) dengan exponential backoff atau tingkatkan ke tingkat berbayar untuk batas yang lebih tinggi (60 permintaan/menit vs 15).

Apakah data saya digunakan untuk melatih model?

Menurut kebijakan Google, permintaan API tidak digunakan untuk melatih model. Data Anda tetap pribadi.

Bisakah saya melakukan fine-tune Flash Lite?

Belum. Fine-tuning tersedia untuk beberapa model Gemini tetapi belum untuk Flash Lite saat diluncurkan. Gunakan instruksi sistem untuk memandu perilaku sebagai gantinya.

Bagaimana perbandingan Flash Lite dengan GPT-4 Turbo?

Flash Lite lebih cepat dan lebih murah, tetapi GPT-4 Turbo memiliki penalaran yang lebih kuat untuk tugas-tugas kompleks. Untuk beban kerja API bervolume tinggi, Flash Lite unggul dalam biaya dan kecepatan.

Langkah Selanjutnya

Anda sekarang memiliki semua yang Anda butuhkan untuk mulai menggunakan Gemini 3.1 Flash Lite:

Dapatkan kunci API Anda dari Google AI Studio
Instal SDK dan jalankan permintaan pertama Anda
Uji di Apidog untuk pengembangan yang lebih mudah
Terapkan penanganan kesalahan dan logika coba ulang
Pantau penggunaan untuk mengoptimalkan biaya

Model ini siap untuk produksi. Penentuan harga membuat AI dapat diakses dalam skala besar. Kecepatannya membuat pengguna Anda senang.

Mulai membangun.

button