AI Engineering Academy · Pelajaran

Menghitung dan Memprediksi Biaya API

Tulis pembantu Python yang memperkirakan biaya sebelum mengirim permintaan dengan menghitung token dan menerapkan harga per model, sehingga Anda tidak pernah menerima tagihan tak terduga.

Menghitung dan Memprediksi Biaya API adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Mengapa Prediksi Biaya Penting

Biaya API untuk aplikasi LLM dapat menjadi sangat besar dalam skala tinggi. Satu kueri yang tampaknya murah, yaitu $0,002, menjadi $200 jika dijalankan 100.000 kali. Tanpa prediksi dan pemantauan biaya, fitur AI dapat menghasilkan tagihan cloud yang tidak terduga dan jauh melebihi seluruh pengeluaran infrastruktur Anda.

Kabar baiknya, biaya LLM sepenuhnya dapat diprediksi sebelum Anda mengirim permintaan: Anda mengetahui modelnya, dapat menghitung token input dengan tiktoken, dan dapat memperkirakan token output berdasarkan pengaturan max_tokens atau rata-rata historis. Menambahkan prediksi biaya ke aplikasi sejak hari pertama mencegah kejutan tagihan.

Struktur Harga OpenAI

OpenAI mengenakan biaya secara terpisah untuk token input dan token output, dengan biaya output biasanya 3–4 kali lebih mahal. Harga bervariasi menurut model. Sebagai panduan untuk 2025 (selalu periksa halaman harga terbaru karena harga dapat berubah):

gpt-4o-mini: sekitar $0,15 per juta token input, sekitar $0,60 per juta token output
gpt-4o: sekitar $2,50 per juta token input, sekitar $10,00 per juta token output
text-embedding-3-small: sekitar $0,02 per juta token

Perbedaan biaya antar-model sangat besar: gpt-4o kira-kira 17 kali lebih mahal daripada gpt-4o-mini per token input. Pemilihan model adalah pengungkit terbesar untuk mengendalikan biaya—selalu mulai dengan model termurah yang memenuhi persyaratan kualitas Anda.

Fungsi Pembantu Estimasi Biaya

Buat penghitung biaya yang Anda panggil sebelum mengirim permintaan apa pun. Fungsi ini menghitung token input dengan tiktoken, memperkirakan token output dari parameter max_tokens Anda, mencari harga per model, lalu mengembalikan perkiraan biaya dalam dolar. Panggil fungsi ini selama pengembangan dan catat hasilnya agar Anda membangun pemahaman tentang biaya berbagai jenis kueri.

import tiktoken

# Prices per million tokens as of early 2025
PRICING = {
    'gpt-4o': {'input': 2.50, 'output': 10.00},
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
    'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
    'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}

def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
    enc = tiktoken.encoding_for_model(model)
    input_tokens = sum(
        len(enc.encode(m.get('content', ''))) + 4
        for m in messages
    ) + 3

    if model not in PRICING:
        raise ValueError(f'Unknown model: {model}')

    rates = PRICING[model]
    input_cost = (input_tokens / 1_000_000) * rates['input']
    output_cost = (expected_output_tokens / 1_000_000) * rates['output']
    total = input_cost + output_cost

    print(f'Model: {model}')
    print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
    print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
    print(f'Estimated total: ${total:.6f}')
    return total

Melacak Biaya Aktual dari Respons API

Setelah setiap panggilan API, objek respons berisi jumlah token aktual yang digunakan. Ambil data ini untuk mencatat biaya nyata dan membandingkannya dengan perkiraan Anda. Seiring waktu, selisih antara token output yang diperkirakan dan yang sebenarnya menunjukkan seberapa akurat Anda memprediksi penggunaan, sedangkan catatan tersebut memberikan rincian biaya berdasarkan fitur atau segmen pengguna.

import openai

client = openai.OpenAI()

PRICING = {
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}

def chat_with_cost_tracking(model, messages):
    response = client.chat.completions.create(
        model=model, messages=messages
    )
    usage = response.usage
    rates = PRICING.get(model, {'input': 0, 'output': 0})
    actual_cost = (
        (usage.prompt_tokens / 1_000_000) * rates['input'] +
        (usage.completion_tokens / 1_000_000) * rates['output']
    )
    print(f'Input: {usage.prompt_tokens} tokens')
    print(f'Output: {usage.completion_tokens} tokens')
    print(f'Total: {usage.total_tokens} tokens')
    print(f'Actual cost: ${actual_cost:.6f}')
    return response, actual_cost

Memproyeksikan Biaya Bulanan

Setelah mengetahui biaya rata-rata per permintaan dan perkiraan volume permintaan, memproyeksikan biaya bulanan menjadi mudah. Buat lembar kerja model biaya atau skrip Python sederhana yang memungkinkan Anda menguji berbagai asumsi: bagaimana jika pengguna aktif harian berlipat ganda? Bagaimana jika kita menambahkan fitur yang membuat 3 panggilan API untuk setiap tindakan pengguna, bukan 1?

def project_monthly_cost(
    avg_cost_per_request,
    requests_per_day,
    days=30
):
    daily_cost = avg_cost_per_request * requests_per_day
    monthly_cost = daily_cost * days

    print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
    print(f'Requests/day: {requests_per_day:,}')
    print(f'Daily cost: ${daily_cost:.2f}')
    print(f'Monthly cost: ${monthly_cost:.2f}')

    # Growth scenarios
    for multiplier in [2, 5, 10]:
        scaled = monthly_cost * multiplier
        print(f'  At {multiplier}x traffic: ${scaled:.2f}/month')

# Example: customer support bot
project_monthly_cost(
    avg_cost_per_request=0.002,  # 2 cents per support query
    requests_per_day=5000
)

Dampak Pemilihan Model terhadap Biaya

Pengungkit terbesar untuk mengurangi biaya adalah menggunakan model termurah yang memenuhi persyaratan kualitas Anda. Untuk banyak tugas, gpt-4o-mini memiliki kinerja yang sebanding dengan gpt-4o, tetapi biayanya sekitar 17 kali lebih rendah. Sebelum menggunakan model paling kuat sebagai pilihan bawaan, lakukan tolok ukur terhadap model yang lebih murah pada tugas khusus Anda dan beralihlah ke model yang lebih mahal hanya jika kualitasnya berada di bawah ambang batas Anda.

Strategi perutean bertingkat bahkan lebih efektif: klasifikasikan permintaan masuk berdasarkan kompleksitas, lalu arahkan kueri sederhana ke model murah dan kueri kompleks ke model mahal. Bahkan jika 70% lalu lintas diarahkan ke model murah sementara 30% sisanya diarahkan ke model mahal, Anda dapat menghemat sekitar 70% biaya AI.

Panjang Prompt dan Biaya

Setiap token dalam prompt Anda memerlukan biaya. Prompt sistem yang terlalu panjang dan sebenarnya dapat dipadatkan tanpa kehilangan makna akan langsung meningkatkan tagihan API Anda pada setiap permintaan. Ukur jumlah token dalam prompt Anda dan cari peluang untuk memperketat susunan katanya. Demikian pula, contoh few-shot yang panjang sering kali dapat diganti dengan padanan yang lebih singkat tanpa mengurangi akurasi.

Untuk sistem RAG, konteks yang diambil sering kali merupakan bagian terbesar dari prompt. Mengembalikan 10 potongan besar ketika 3 potongan kecil yang dipilih dengan baik sudah memadai akan memboroskan token pada setiap kueri. Sesuaikan pengambilan data Anda untuk meminimalkan konteks yang berulang sekaligus memaksimalkan relevansinya.

Pemrosesan Batch untuk Efisiensi Biaya

OpenAI menyediakan Batch API yang memproses permintaan secara asinkron dengan harga 50% lebih murah daripada harga standar. Jika penggunaan Anda tidak sensitif terhadap latensi — pemrosesan dokumen, pekerjaan analisis malam hari, pembuatan konten dalam jumlah besar — Batch API dapat mengurangi biaya Anda hingga setengahnya dengan perubahan kode yang minimal.

Permintaan batch dikirim sebagai berkas JSONL, diproses dalam waktu 24 jam, lalu hasilnya diambil dari API. Ini ideal untuk pipeline prapemrosesan yang berjalan sesuai jadwal dan tidak memerlukan respons waktu nyata.

import openai
import json

client = openai.OpenAI()

# Create batch request file
requests = [
    {'custom_id': f'doc-{i}',
     'method': 'POST',
     'url': '/v1/chat/completions',
     'body': {
         'model': 'gpt-4o-mini',
         'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
         'max_tokens': 200
     }}
    for i in range(100)
]

# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
    for req in requests:
        f.write(json.dumps(req) + '\n')

# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')

Menetapkan Batas Pengeluaran

Selalu konfigurasikan batas pengeluaran untuk mencegah biaya yang tidak terkendali. Di dasbor OpenAI, Anda dapat menetapkan batas pengeluaran bulanan yang menghentikan akses API ketika batas tersebut tercapai. Tetapkan batas keras pada pengeluaran maksimum yang dapat Anda terima dan batas lunak pada 80% dari nilai tersebut agar Anda menerima peringatan melalui email sebelum mencapai batas keras.

Di kode aplikasi Anda, terapkan anggaran per pengguna atau per fitur yang dicatat dalam basis data. Periksa anggaran sebelum setiap panggilan API dan kembalikan error jika anggaran tersebut telah habis. Dengan demikian, satu pengguna yang tidak terkendali atau bug dalam pekerjaan batch tidak akan menghabiskan seluruh kuota bulanan Anda dalam hitungan jam.

Melakukan Caching untuk Menghindari Panggilan API yang Berulang

Panggilan API yang paling murah adalah panggilan yang tidak pernah Anda lakukan. Terapkan caching pada lapisan aplikasi untuk menyajikan permintaan yang identik dari cache, alih-alih memanggil API lagi. Bahkan cache Redis sederhana yang menggunakan hash SHA256 dari prompt sebagai kunci dapat menghilangkan sebagian besar panggilan berulang dalam aplikasi produksi.

Untuk embedding, caching sangat berdampak: teks yang sama seharusnya hanya diubah menjadi embedding sekali. Simpan embedding dalam basis data vektor dengan teks asli sebagai kunci, lalu periksa apakah embedding tersebut sudah ada sebelum memanggil API embedding. Dalam pipeline RAG, embedding dokumen dihitung sekali saat pengindeksan dan digunakan kembali untuk setiap kueri yang mengambil dokumen tersebut.

import hashlib
import json

# Simple in-memory cache (use Redis in production)
_cache = {}

def cached_completion(client, model, messages, **kwargs):
    cache_key = hashlib.sha256(
        json.dumps({'model': model, 'messages': messages}).encode()
    ).hexdigest()

    if cache_key in _cache:
        print('Cache HIT - no API call made')
        return _cache[cache_key]

    response = client.chat.completions.create(
        model=model, messages=messages, **kwargs
    )
    _cache[cache_key] = response
    print('Cache MISS - API call made')
    return response

Membangun Dasbor Biaya

Dalam lingkungan produksi, Anda perlu mengetahui biaya AI yang diperinci berdasarkan fitur, pengguna, dan model. Bangun dasbor biaya dengan mencatat jumlah token dan metadata terkait dari setiap panggilan API (ID pengguna, nama fitur, model) ke basis data deret waktu. Kemudian lakukan agregasi untuk menjawab pertanyaan seperti: fitur mana yang menghasilkan pengeluaran terbesar? Apakah pengguna intensif menimbulkan biaya yang tidak proporsional? Apakah biaya per kueri meningkat setelah perubahan prompt?

Visibilitas ini penting untuk mengambil keputusan pengoptimalan berdasarkan data, bukan menebak-nebak bagian mana yang harus dikurangi biayanya. Sebagian besar perusahaan menemukan bahwa 20% fitur mereka menyumbang 80% pengeluaran AI, dan pengoptimalan fitur-fitur tersebut memberikan dampak yang jauh lebih besar.

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Rekayasa AI dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa: biaya API dapat diprediksi sebelum pengiriman dengan menghitung token input menggunakan tiktoken dan memperkirakan token output, pemilihan model merupakan pengungkit biaya terbesar — gpt-4o-mini dapat 17 kali lebih murah daripada gpt-4o untuk tugas yang sesuai, dan caching, pemrosesan batch, serta batas pengeluaran mencegah biaya yang tidak terkendali dalam lingkungan produksi. Selanjutnya, kita akan membahas strategi untuk mengelola percakapan panjang yang melampaui jendela konteks.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghitung dan Memprediksi Biaya API” gratis?

Ya — teks lengkap “Menghitung dan Memprediksi Biaya API” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menghitung dan Memprediksi Biaya API”?

Tulis pembantu Python yang memperkirakan biaya sebelum mengirim permintaan dengan menghitung token dan menerapkan harga per model, sehingga Anda tidak pernah menerima tagihan tak terduga. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Menghitung dan Memprediksi Biaya API” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Apa Itu Token?
Jendela Konteks: Ukuran dan Implikasinya
Menghitung dan Memprediksi Biaya API
Strategi agar Tetap dalam Batas Konteks

← Kembali ke AI Engineering Academy