---
title: "Latensi LLM: TTFT, token per detik, end-to-end | BroadRouter"
description: "Apa yang diukur time to first token, token per detik, dan latensi end-to-end, cara mengukurnya dari klien dengan kode, dan perbaikan mana mengubah angka mana."
url: https://broadrouter.com/id/blog/llm-latency-ttft-throughput/
lang: id
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan dari bahasa Inggris dengan bantuan AI. [Baca versi asli bahasa Inggris](https://broadrouter.com/blog/llm-latency-ttft-throughput/) (diperbarui 2026-11-16).

# Latensi LLM: TTFT vs token per detik vs waktu end-to-end

Oleh tim BroadNet Inference · 4 menit baca · Dipublikasikan 2026-11-14 · Diperbarui 2026-11-16

Time to first token (TTFT) adalah waktu tunggu sebelum token output pertama. Token per detik adalah seberapa cepat jawaban mengalir setelahnya. Latensi end-to-end adalah totalnya: TTFT ditambah waktu generasi, yang kira-kira sama dengan token output dibagi kecepatan per pengguna. Panjang prompt dan antrean menentukan TTFT, ukuran model dan beban menentukan kecepatan, dan panjang jawaban menentukan total. Ukur ketiganya di p50 dan p95.

## Poin penting

-   Latensi end-to-end ≈ TTFT + (token output − 1) × latensi antar-token, kira-kira TTFT + token output ÷ token per detik per pengguna. Untuk jawaban panjang, kecepatan dan panjang yang dominan; untuk jawaban pendek, TTFT yang dominan.
-   Pada model penalaran, token pertama yang terlihat muncul setelah proses berpikir, jadi ukur time to first content token terpisah dari time to first token.
-   Prompt panjang menaikkan TTFT karena model membaca seluruh prompt lebih dulu; prefiks yang di-cache biasanya membantu.
-   Pada sekitar 100 token per detik, waktu generasi tumbuh seiring panjang jawaban: token output sepuluh kali lebih banyak butuh sekitar sepuluh kali lebih lama untuk mengalir.
-   Laporkan p50 dan p95 beserta panjang prompt; rata-rata tanpa ukuran prompt tidak bisa dibandingkan.

**Di halaman ini**

1.  Apa itu TTFT, token per detik, dan latensi end-to-end?
2.  Mengapa model penalaran butuh angka keempat?
3.  Bagaimana mengukur latensi dari klien?
4.  Apa yang benar-benar memperbaiki tiap angka?
5.  Bagaimana panjang prompt mengubah trade-off-nya?
6.  Di mana posisi BroadNet Inference?

“API-nya lambat” bisa berarti tiga hal berbeda, dan masing-masing punya solusi berbeda. Pengguna chat menunggu kata pertama. Agen menunggu seluruh tool call. Job batch peduli pada token per jam. Artikel ini mendefinisikan ketiga angka tersebut, menunjukkan cara mengukurnya dari kode Anda sendiri, dan memetakan setiap perbaikan ke angka yang benar-benar diubahnya.

## Apa itu TTFT, token per detik, dan latensi end-to-end?

Panduan benchmarking NVIDIA memberi definisi yang rapi, dan cocok dengan apa yang bisa Anda amati dari klien:

| Metrik | Yang diukur | Siapa yang merasakan | Dipengaruhi oleh |
| --- | --- | --- | --- |
| [Time to first token](https://broadrouter.com/id/glossary/time-to-first-token/) (TTFT) | Permintaan dikirim → token pertama diterima | Pengguna chat | Jaringan, antrean, panjang prompt (prefill), cache hit |
| Inter-token latency (ITL) | Rata-rata jeda antar-token | Pembaca jawaban yang di-stream | Ukuran model, hardware, beban server |
| [Token per detik](https://broadrouter.com/id/glossary/tokens-per-second/) per pengguna | Token output setelah token pertama ÷ waktu generasi (dari token pertama hingga terakhir); sama dengan 1 ÷ ITL rata-rata | Pembaca, agen | Sama dengan ITL |
| Latensi end-to-end | Permintaan dikirim → token terakhir diterima | Agen, API, batch | TTFT + waktu generasi |

Rumus yang menghubungkan semuanya:

**end-to-end ≈ TTFT + (token output − 1) × ITL ≈ TTFT + token output ÷ token per detik per pengguna**

Kecepatan per pengguna tidak sama dengan [throughput](https://broadrouter.com/id/glossary/throughput/) server, yaitu total token yang dihasilkan server untuk semua pengguna; penyedia bisa menaikkan yang satu sementara yang lain turun.

Ambil kecepatan tipikal yang dipublikasikan BroadNet untuk model paketnya, sekitar 100 token per detik. Waktu generasi tumbuh seiring panjang jawaban: file kode 4.000 token butuh waktu sekitar delapan puluh kali lebih lama untuk dibuat dibanding klasifikasi 50 token, sementara keduanya menunggu TTFT yang sama. Untuk jawaban pendek, sebagian besar waktu tunggu adalah TTFT; untuk jawaban panjang, kecepatan dan panjanglah yang menentukan.

## Mengapa model penalaran butuh angka keempat?

Model penalaran seperti [DeepSeek V4.1 Flash](https://broadrouter.com/id/models/deepseek-v4.1-flash/) berpikir sebelum menjawab, dan proses berpikir itu juga berupa token output. Jika model menghabiskan 800 token untuk bernalar pada sekitar 100 token per detik, pengguna menunggu sampai ke-800 token itu selesai dibuat sebelum kata pertama terlihat, meski TTFT di jaringan tampak cepat. Jadi ukur **time to first content token** secara terpisah. Di BroadNet Inference, `reasoning_effort: "low"` memperpendek proses berpikir untuk langkah-langkah sederhana; [panduan penalaran](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/) menjelaskan trade-off-nya.

## Bagaimana mengukur latensi dari klien?

Ukur di tempat pengguna Anda berada, dengan [streaming](https://broadrouter.com/id/glossary/streaming/) aktif. Timer di sisi server melewatkan jaringan dan proxy apa pun.

```python
import os, time, statistics
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

def timed(model, messages, max_tokens=1500):
    t0 = time.perf_counter()
    first = first_content = None
    usage = None
    stream = client.chat.completions.create(
        model=model, messages=messages, max_tokens=max_tokens,
        stream=True, stream_options={"include_usage": True},
    )
    for chunk in stream:
        now = time.perf_counter()
        if chunk.choices:
            if first is None:
                first = now
            if chunk.choices[0].delta.content and first_content is None:
                first_content = now
        if chunk.usage:
            usage = chunk.usage
    end = time.perf_counter()
    out = usage.completion_tokens if usage else 0
    return {
        "ttft": first - t0,
        "ttfct": (first_content or end) - t0,
        "e2e": end - t0,
        "tps": (out - 1) / (end - first) if out > 1 and end > first else 0,
        "prompt_tokens": usage.prompt_tokens if usage else None,
    }

runs = [timed("broadnet/gemma-4-26b-a4b", [{"role": "user", "content": "Summarise SSE in 100 words."}]) for _ in range(50)]
for k in ("ttft", "ttfct", "e2e", "tps"):
    xs = sorted(r[k] for r in runs)
    print(k, "p50", round(statistics.median(xs), 3), "p95", round(xs[int(len(xs) * 0.95) - 1], 3))
```

Lima aturan untuk benchmark yang adil:

1.  **Tetapkan panjang prompt** dan laporkan. TTFT pada 500 token prompt dan pada 200.000 token adalah angka yang berbeda. [Penghitung token](https://broadrouter.com/tools/token-counter/) memberi tahu panjang prompt uji sebelum Anda mengirimnya.
2.  **Tetapkan panjang output** dengan `max_tokens` dan prompt yang mengisinya, agar token per detik bisa dibandingkan.
3.  **Laporkan p50 dan p95**, bukan rata-rata. Latensi ekor (tail) itulah yang diingat pengguna.
4.  **Sebarkan percobaan dari waktu ke waktu.** Beban berubah sepanjang hari.
5.  **Lakukan pemanasan dulu.** Panggilan pertama menanggung biaya DNS, TLS, dan pembukaan koneksi; gunakan ulang satu klien.

## Apa yang benar-benar memperbaiki tiap angka?

| Untuk memperbaiki | Lakukan ini | Alasannya |
| --- | --- | --- |
| TTFT | Perpendek atau cache prefiks prompt | Waktu prefill bertambah seiring panjang prompt; prefiks yang di-cache melewati pekerjaan itu |
| TTFT | Jaga koneksi tetap hangat, gunakan region terdekat | Menghilangkan biaya setup dan round trip |
| Time to first content token | Turunkan tingkat penalaran, atau gunakan model non-penalaran untuk langkah sederhana | Lebih sedikit proses berpikir tersembunyi sebelum jawaban |
| Token per detik | Gunakan model yang lebih kecil atau lebih cepat untuk langkah itu | Kecepatan decode bergantung pada ukuran model dan cara penyajiannya |
| End-to-end | Minta output yang lebih pendek (skema, batas kata) | Panjang output mengalikan ITL |
| End-to-end untuk banyak panggilan | Jalankan panggilan independen secara paralel dalam batas [konkurensi](https://broadrouter.com/id/glossary/concurrency/) Anda | Waktu total turun meski tiap panggilan sama |
| Latensi yang dirasakan | Stream ke pengguna | Pengguna membaca selagi model menulis |

Panjang output adalah tuas yang paling diremehkan. Meminta “JSON dengan empat field ini” alih-alih “jelaskan jawabanmu” bisa memangkas waktu generasi hingga sepersepuluhnya tanpa pekerjaan infrastruktur apa pun. [Output terstruktur](https://broadrouter.com/id/glossary/structured-output/) membantu di sini.

Tuas cache dibahas di [struktur prompt untuk caching](https://broadrouter.com/id/blog/prompt-structure-for-caching/). Tuas paralelisme cepat terbentur rate limit; lihat [menangani error 429](https://broadrouter.com/id/blog/handle-llm-api-429-rate-limits/).

## Bagaimana panjang prompt mengubah trade-off-nya?

TTFT bertambah seiring panjang prompt karena model harus memproses setiap token input sebelum bisa menulis. Itulah biaya tersembunyi prompt yang sangat panjang, dan bagian dari keputusan [konteks panjang vs RAG](https://broadrouter.com/id/blog/long-context-vs-rag/): prompt 1M token bisa menjawab pertanyaan yang tidak bisa dijawab RAG, tetapi mulainya lebih lambat. Jika kecepatan interaktif penting, jaga jalur utama (hot path) tetap pendek dan kirim konteks besar hanya saat pertanyaannya membutuhkan.

## Di mana posisi BroadNet Inference?

BroadNet memublikasikan kecepatan tipikal sekitar 100 token per detik untuk model paketnya dan melakukan streaming dengan format SSE standar, jadi kode di atas berjalan tanpa perubahan. BroadNet tidak memublikasikan angka TTFT atau SLA latensi, jadi ukur dengan prompt Anda sendiri sebelum berkomitmen; satu [jam Meteor](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-latency-ttft-throughput&utm_content=body) seharga $1 cukup untuk benchmark 50 percobaan, dan kredit awal mencukupi satu benchmark di Gemma 4 VL 26B. Jika Anda butuh latensi di bawah satu detik yang dijamin dalam skala besar, uji dengan cermat: kunci bayar sesuai pemakaian mengizinkan 4 permintaan berjalan, yang lebih cocok untuk aplikasi dan agen daripada penyajian real-time bervolume tinggi. Model dan harganya ada di halaman [model](https://broadrouter.com/id/models/) dan [harga](https://broadrouter.com/id/pricing/).

Alat gratis untuk topik ini (bahasa Inggris)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Alat gratis (bahasa Inggris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

[Token](https://broadrouter.com/id/glossary/token/)

Token adalah satuan teks yang dibaca dan ditulis model bahasa: sebuah kata, bagian kata, tanda baca, atau urutan byte yang dihasilkan tokenizer model. API LLM menghitung, membatasi, dan biasanya menagih pemakaian dalam token.

[Time to first token (TTFT)](https://broadrouter.com/id/glossary/time-to-first-token/)

Time to first token (TTFT) adalah waktu sejak permintaan dikirim ke model bahasa sampai token output pertama tiba. TTFT mencakup waktu jaringan, antrean di server, dan prefill, yaitu tahap saat model membaca seluruh prompt, sehingga nilainya naik seiring panjang prompt dan beban server.

[Latensi (latency)](https://broadrouter.com/id/glossary/latency/)

Latensi, untuk API model bahasa, adalah waktu yang dibutuhkan sebuah permintaan sejak dikirim sampai token output terakhir diterima. Latensi adalah jumlah dari time to first token dan waktu generasi, dan biasanya dilaporkan sebagai persentil seperti p50 dan p95, bukan rata-rata.

[Streaming (respons streaming)](https://broadrouter.com/id/glossary/streaming/)

Streaming adalah cara mengembalikan respons model bahasa dalam potongan-potongan kecil selagi masih dihasilkan, bukan sebagai satu balasan utuh di akhir. API yang kompatibel dengan OpenAI melakukan streaming lewat server-sent events jika permintaan mengatur stream ke true.

[Token input dan output](https://broadrouter.com/id/glossary/input-and-output-tokens/)

Token input adalah token yang dibaca model bahasa dalam sebuah permintaan, termasuk system prompt, riwayat percakapan, definisi tool, dan gambar. Token output adalah token yang dihasilkannya sebagai balasan, termasuk penalaran. API LLM biasanya menghargainya secara terpisah, dan output biasanya lebih mahal.

[Konkurensi (concurrency)](https://broadrouter.com/id/glossary/concurrency/)

Konkurensi (concurrency) adalah jumlah permintaan yang sedang berjalan dari sebuah client pada saat yang sama. API LLM sering membatasinya per kunci atau per paket, terpisah dari batas permintaan per menit, karena setiap permintaan yang terbuka menahan kapasitas GPU sampai responsnya selesai.

[Token per detik (tokens per second, TPS)](https://broadrouter.com/id/glossary/tokens-per-second/)

Token per detik (TPS) adalah laju model bahasa menghasilkan token output, biasanya diukur untuk satu permintaan setelah token pertamanya tiba. Angka ini menentukan seberapa cepat balasan mengalir setelah dimulai. Jika dijumlahkan di semua permintaan bersamaan, ia menjadi throughput sistem; waktu tunggu sebelum token pertama diukur terpisah.

[Prefill dan decode (fase inferensi LLM)](https://broadrouter.com/id/glossary/prefill-and-decode/)

Prefill dan decode adalah dua fase inferensi LLM. Pada prefill, model memproses seluruh prompt secara paralel dan mengisi KV cache-nya; pada decode, model menghasilkan balasan satu token demi satu token sambil memakai ulang cache tersebut. Prefill terutama menentukan time to first token; decode menentukan kecepatan output.

## Pertanyaan umum

### Berapa time to first token yang bagus untuk API LLM?

Untuk chat, di bawah sekitar satu detik pada prompt pendek terasa responsif. Prompt panjang dan model penalaran memang lebih lama. Bandingkan TTFT hanya pada panjang prompt dan model yang sama.

### Apakah token per detik sama dengan throughput?

Tidak persis. Token per detik per pengguna adalah seberapa cepat satu jawaban mengalir. Throughput adalah total token yang dihasilkan server untuk semua pengguna. Penyedia bisa menaikkan throughput total sementara kecepatan tiap pengguna turun.

### Kenapa TTFT model penalaran begitu tinggi?

Model menghasilkan token penalaran tersembunyi sebelum jawaban yang terlihat. Token pertama bisa datang cepat, tetapi token konten pertama menunggu sampai proses berpikir selesai. Turunkan reasoning\_effort untuk tugas sederhana.

### Apakah streaming mengurangi latensi?

Streaming tidak memperpendek waktu end-to-end. Streaming membuat pengguna bisa membaca jawaban selagi masih ditulis, sehingga latensi yang dirasakan turun hingga kira-kira sebesar TTFT.

### Berapa banyak permintaan yang dibutuhkan untuk benchmark latensi yang andal?

Cukup untuk melihat ekornya (tail). Lima puluh sampai seratus permintaan per ukuran prompt memberi p95 yang bisa dipakai. Sebarkan sepanjang hari, karena beban berubah-ubah.

## Baca juga

-   [Penjelasan streaming LLM: chunk SSE, delta, usage, dan pembatalan](https://broadrouter.com/id/blog/llm-streaming-sse-explained/)
-   [Cara menyusun prompt agar prefiksnya ter-cache](https://broadrouter.com/id/blog/prompt-structure-for-caching/)
-   [Long context vs RAG: kapan 1M token menggantikan vector database](https://broadrouter.com/id/blog/long-context-vs-rag/)
-   [Hardware GPU dan pendekatan serving BroadNet, menurut BroadNet](https://broadrouter.com/id/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache respons API LLM untuk memangkas biaya: exact cache di Python](https://broadrouter.com/id/blog/cache-llm-responses-cut-cost/)
-   [Panduan: Streaming chat completions dan menangani koneksi terputus](https://broadrouter.com/id/guides/streaming-chat-completions/)
-   [Panduan: Kenapa model reasoning mengembalikan jawaban kosong](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/)

Coba dengan beban kerja Anda yang sebenarnya. Akun baru mendapat kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM, dan Qwen3.8 memerlukan top up.

[Mulai](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-latency-ttft-throughput&utm_content=page-cta) ·

**Sumber**

-   [Panduan benchmarking NVIDIA NIM, metrik latensi dan throughput LLM (diakses 2026-11-14)](https://docs.nvidia.com/nim/benchmarking/llm/metrics)
-   [Paket BroadNet Inference, kecepatan tipikal (dicek 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Referensi API BroadNet Inference, streaming dan penalaran (dicek 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-latency-ttft-throughput&utm_content=sources)
-   [Baseten Inference Engineering, mengukur latensi dan throughput (dicek 2026-11-16)](https://www.baseten.co/inference-engineering/book/01-prerequisites/measuring-latency-and-throughput/)
