LLM-kostenmonitoring: volg je uitgaven vóór de piek (2026)

LLM-kostenmonitoring: volg je uitgaven vóór de piek (2026)

LLM-kostenmonitoring is het verschil tussen een verrassingsfactuur van $412 en een Slack-ping bij 80% van je budget. Claude Sonnet 5 kost deze maand $3,00 per miljoen input-tokens, en één op hol geslagen agent-loop verbrandt dat in een middag. De meeste teams hebben de tracking in een dag opgezet; het alarm is het deel dat ze overslaan.

Belangrijkste punten:

• LLM-kostenmonitoring koppelt een tokenaantal en een kostenraming aan elk verzoek en aggregeert vervolgens per model en team.
• Volg vijf metrics: tokens per verzoek, kosten per feature/team/model, cache hit ratio, kosten per gesprek, piekfrequentie.
• LiteLLM-budgets, Langfuse-traces of Datadog LLM Observability: elk geeft in minder dan een dag zicht op je uitgaven.
• Dashboards tonen ramingen; door cached-inputprijzen en batchkortingen valt de factuur meestal lager uit.

Wat meet LLM-kostenmonitoring precies?

LLM-kostenmonitoring betekent dat je aan elk LLM-verzoek een tokenaantal en een kostenraming koppelt, die ramingen aggregeert per model, feature en team, en zo kunt alarmeren over uitgaven vóórdat de factuur binnenkomt. De raming wordt per verzoek berekend uit gepubliceerde tokenprijzen, opgerold via de tags die je aan de call meegeeft en vergeleken met een vooraf ingesteld budget.

De onderliggende rekensom is vendor-neutraal. Elke provider splitst tokens in velden in zijn usage-response, en Datadogs kostendocumentatie beschrijft de relaties expliciet. De OpenTelemetry GenAI semantic conventions standaardiseren dezelfde velden over vendors heen, zodat een dashboard dat erop bouwt niet aan één provider vastzit.

Drie relaties doen het meeste werk: totale tokens = input + output; input = niet-gecachet + cache_read + cache_write; en reasoning-tokens zitten in output, tegen het outputtarief. Klopt dat, dan blijft de raming per verzoek dicht bij de werkelijkheid; negeer ze en het dashboard loopt elke maand verder uit de pas met de factuur. Kostenmonitoring is één pijler van AI observability; tracing en evals zijn de andere twee, en ze delen dezelfde veldvocabulaire.

Je dashboard toont een raming; de factuur is de enige kostenmetric die nooit gecachet wordt.

Hoeveel kost 1 miljoen tokens bij een LLM?

Dat hangt af van het model en de richting: 1M tokens kost $0,14 als DeepSeek-V4 input en $15,00 als GPT-5.6 Terra output, een verschil van 100x voor dezelfde eenheid. Hier zijn vier modellen uit ons prijsonderzoek van 14 juli 2026, geverifieerd tegen de officiële pagina's:

Bronnen: OpenAI-prijzen en Anthropic-prijzen. Eén voetnoot: Claude Sonnet 5 hanteert tot 31 augustus 2026 een introductieprijs van $2,00 input / $10,00 output en valt daarna terug op de cijfers hierboven.

De 5 metrics die er echt toe doen

Vijf metrics dekken LLM cost tracking af, en de meeste teams alarmeren ooit maar over twee ervan. Begin met de eerste twee rijen: tokens per verzoek vangt prompt-bloat af op de dag dat hij ontstaat, en kosten per team is het getal waar finance uiteindelijk om vraagt. De andere drie verfijnen het beeld zodra die twee staan.

Eén notitie over granulariteit: Datadog slaat kosten op verzoekniveau op in nanodollars (miljardsten van een dollar), aldus de kostendocumentatie. Bij $0,14 per miljoen tokens kan één DeepSeek-V4-verzoek minder dan een duizendste cent kosten, dus aggregeer vóórdat je afrondt, anders verdwijnt verkeer van kleine modellen uit het rapport.

Track je niets anders, track dan rij één en twee. Tokens per verzoek is je vroegste waarschuwing; kosten per team is de metric die contact met de boekhouding overleeft.

Drie manieren om LLM-kostenmonitoring op te zetten

Geen van de best scorende pagina's voor deze zoekopdracht bevat één uitvoerbare regel code, dus hier zijn drie werkende setups. Elke staat in minder dan een dag live, en ze combineren: wij draaien de eerste twee samen.

Wat wij daadwerkelijk in productie draaien: in onze setup praat elke client-agent met de LiteLLM-proxy via een eigen virtual key, met een maandbudget op elke key en Langfuse-tracing van elk verzoek achter de proxy. Toen we de twee samen uitrolden, was de werkverdeling het punt: de proxy handhaaft de limieten en de traces verklaren wat ze verbruikte. Elke client-key heeft ook een tpm_limit van 100.000 tokens per minuut als tweede zekering; volgens de documentatie van LiteLLM weigert de proxy verzoeken zodra een limiet bereikt is, en op dat gedocumenteerde gedrag vertrouwen we, niet op een benchmark die we zelf gemeten hebben. Onze configuratie slaat LiteLLM 1.82.7 en 1.82.8 volledig over, de twee versies die geraakt werden door het supply-chain-incident van maart 2026, en pint de image-tag in plaats van op latest te drijven.

LiteLLM-proxy: virtual keys + budgetten

Techsy draait een LiteLLM-proxy-setup in productie met één virtual key per client en een maandbudget op elke key. Het verzoek hieronder is de gedocumenteerde vorm uit LiteLLM's virtual_keys-documentatie: volgens die documentatie weigert de proxy verdere verzoeken met een budget-exceeded error zodra de cumulatieve uitgaven op deze key in een maand boven de $50 komen, in plaats van achteraf een waarschuwing te loggen.

curl -X POST http://localhost:4000/key/generate \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "key_alias": "client-acme-search",
    "max_budget": 50.0,
    "budget_duration": "monthly",
    "tpm_limit": 100000,
    "models": ["anthropic/claude-sonnet-4-5"]
  }'

Reken het na tegen de gepubliceerde prijzen: bij $3,00 / $15,00 per miljoen tokens voor Claude Sonnet 5 koop je voor $50 ruwweg 16,7M input-tokens of 3,3M output-tokens, ongeveer een week verkeer voor een van onze lichtere client-agents. Dat is precies de blast radius die we willen. De tpm_limit is de tweede zekering: een op hol geslagen loop tript de 100K tokens per minuut ruim voordat hij het maandbudget raakt. Per-user-attributie werkt hetzelfde via het users-endpoint, en onze gids voor de beste LLM-gateway-tools behandelt wanneer een proxy zijn plek verdient en wanneer hij slechts een extra hop is.

Langfuse: kosten-tracing met @observe

Google-autocomplete koppelt "langfuse monitoring" aan deze zoekopdracht, en niet zonder reden: Langfuse is de open-source tracing-standaard. De Python SDK wrapt je provider-client zodat elke call een trace wordt met tokenaantallen en een berekende kostprijs, volgens de Langfuse-tracingdocumentatie:

# pip install langfuse openai
from langfuse import observe
from langfuse.openai import openai  # drop-in wrapper, auto-traces

@observe()
def answer(question: str):
    return openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": question}],
    )

answer("what is llm cost monitoring")
# the trace now carries usage.total_tokens and total_cost,
# priced from Langfuse's model price cards

De kosten landen op de trace zonder dat jij tokenwiskunde hoeft te doen; groepeer traces per sessie of user id voor rollups per feature en self-host als de data je netwerk niet mogen verlaten.

Datadog LLM Observability: als je er toch al in zit

Als je team toch al Datadog-agents uitrolt, is de LLM-kostendocumentatie de diepste enkelvoudige referentie op deze pagina: kosten op verzoekniveau in nanodollars, custom cost_tags voor team- en feature-uitsplitsingen en een echte troubleshooting-sectie voor partial-cost gaten. De eerlijke beperking: het is alleen Datadog. De metrics verlaten het platform niet en er is geen open-source fallback als de prijzen niet meer passen. Kies het voor consolidatie, niet voor flexibiliteit.

Hoe koppel je budgetten, alarmen en chargeback?

Je bouwt het in drie lagen: een budgetlimiet die verzoeken weigert bij de limiet, een webhook-alarm dat afgaat op een procentdrempel vóór de limiet en virtual keys per team die van showback en chargeback een query maken in plaats van een discussie. LiteLLM levert alle drie standaard; de patronen gaan op voor elke gateway met budgetten op key-niveau.

Een budget dat alleen telt is een rapport; een budget dat verzoeken weigert bij de limiet is een beheersmaatregel.

Alarmen die afgaan vóór de piek

Zet het alarm op 80% van de limiet, niet op 100%. LiteLLM heeft Slack-alarming ingebouwd: zet alerting: ["slack"] en alerting_threshold: 80 in general_settings, wijs de omgevingsvariabele SLACK_WEBHOOK_URL naar een kanaal, en zodra een key de drempel passeert komt er een bericht als dit binnen:

{
  "text": "LLM budget alert: client-acme-search spent $40.18 of its $50.00 monthly cap (80.4%). Top model: anthropic/claude-sonnet-4-5."
}

Bij 80% heeft een mens nog dagen om in te grijpen: downgrade het model, trek de prompt strak aan of verhoog de limiet met een naam onder de goedkeuring. Een alarm op 100% is een autopsie.

Van showback naar chargeback

Showback betekent dat elk team zijn eigen uitgaven ziet; chargeback betekent dat ze van hun budget afgaan. Beide draaien op één ingrediënt: een virtual key per team, getagd bij aanmaak. Het maandrapport is dan een group-by over de uitgaventabel:

Voorbeeldformaat, geen cliëntdata. De rij evals-batch is het patroon dat werkt zoals bedoeld: batchwerk liep tot zijn limiet en stopte, in plaats van stilletjes in de factuur weg te lekken. Het handhavingsgedrag is gedocumenteerd in LiteLLM's virtual_keys-documentatie, inclusief hoe de budgetduur reset.

Waarom wijkt je dashboard af van de factuur?

Omdat dashboards tegen de lijstprijs factureren terwijl facturen kortingen toepassen die je monitoring nooit ziet. Cached input landt op 0,1x tot 0,25x van de basisprijs, batch draait op de helft en reasoning-tokens worden tegen het outputtarief gefactureerd binnen de outputtelling. Als de twee cijfers uiteenlopen, is de factuur meestal de laagste, en het gat is bijna altijd een van vier prijsaanpassingen.

De open pydantic/genai-prices-catalogus laat zien waarom deze vermenigvuldigers per model verschillen: elke provider stelt zijn eigen cache- en batchfactoren vast, dus één hardgecodeerde prijstabel loopt uit de pas vanaf de dag dat een provider zijn prijskaarten herzien. De kostendocumentatie van Datadog beschrijft de andere helft van het probleem: partial-cost gaten waarbij een ontbrekend tokenveld COST UNAVAILABLE oplevert voor een verzoek. Kijk daar als het dashboard lager leest dan de factuur; kijk naar de kortingentabel als het hoger leest. Het mechanisme achter de grootste vermenigvuldiger is LLM prompt caching, en een hoge cache hit ratio is de meest voorkomende reden dat een getrackte raming boven de echte factuur uitkomt.

Een kostenraming zonder cache-hit- en batchkortingen is een plafond, geen prognose.

Welke tools doen daadwerkelijk aan LLM cost tracking?

Zes tools dekken de meeste productie-setups af: Langfuse, LiteLLM, Helicone en Portkey aan de open-source- en gateway-kant, Datadog en Braintrust aan de commerciële kant. De eerlijke scheiding is handhaving versus observability: een proxy kan verzoeken weigeren bij een budget, terwijl een tracing-tool de uitgaven achteraf meet. De meeste volwassen stacks eindigen met één van elk.

Eén voorbehoud bij vendor-content in dit veld: Braintrust's eigen vergelijking van cost-tracking-tools uit 2026 zet zichzelf op één en laat elke open-source-optie uit de tabel hierboven weg. Lees vendor-lijstjes voor hun data, niet voor hun rangschikking.

Voor een team dat bij nul begint, zouden we LiteLLM voorin draaien en Langfuse erachter: de proxy handhaaft de budgetten, de traces verklaren ze en de combinatie kost niets tot je overstapt op hosted plannen. Weeg je de twee tracing-standaarden tegen elkaar af, dan gaat onze Langfuse vs Langsmith-vergelijking diep op die keuze in, en de beste AI observability-platforms-roundup dekt het hele veld.

Van monitoren naar kosten besparen

Monitoring laat zien waar het geld naartoe gaat; de volgende stap is bepalen hoeveel daar naartoe gaat. De drie hefbomen, op volgorde van rendement: cache herhaalde input, route makkelijke verzoeken naar goedkopere modellen en verklein het model waar de kwaliteit nog standhoudt. Onze gids LLM API-kosten verlagen behandelt elke hefboom, en de LLM API-prijsvergelijking is de input voor alle rekensommen hierboven.

Onze visie: als een cliënt verrast wordt door zijn LLM-uitgaven, monitoren we eerst en snijden we daarna, nooit andersom. Teams die cachen vóórdat ze meten, cachen meestal de verkeerde prompts. Monitoring vertelt je waar het geld naartoe gaat; caching en routing bepalen hoeveel daar naartoe gaat. Doet je factuur nu al pijn, vraag dan een gratis consult aan en we kijken samen naar de cijfers.

Veelgestelde vragen

Hoeveel kost 1 miljoen tokens bij een LLM?

Tegen lijstprijs ergens tussen $0,14 en $15 per miljoen, afhankelijk van model en richting: DeepSeek-V4 input kost $0,14 per miljoen, terwijl GPT-5.6 Terra output $15 kost. Output-tokens kosten bij elke grote provider 3 tot 6 keer het inputtarief. De tabel in de eerste sectie bevat vier modellen, en onze LLM API-prijsvergelijking prijst alle zeventien, in juli 2026 geverifieerd tegen de pagina's van OpenAI en Anthropic.

Wat is LLM-kostenoptimalisatie?

De praktijk om de kosten per verzoek te verlagen zonder kwaliteitsverlies: prompt caching voor herhaalde input, makkelijke taken naar goedkopere modellen routen, batch-API's voor asynchroon werk en het model per feature passend dimensioneren. LLM-kostenmonitoring is de voorwaarde, want je kunt niet optimaliseren wat je niet toegerekend hebt. Cache hit ratio en kosten per feature zijn de twee metrics die het eerst naar de grootste hefbomen wijzen.

Waarom zijn LLM's zo duur?

Inference is compute-gebonden: elke gegenereerde token draait een volledige forward pass van het model op GPU's, en reasoning-modellen besteden extra tokens aan nadenken vóórdat ze antwoorden, gefactureerd tegen outputtarieven. Lange systeemprompts vermenigvuldigen die kosten over elk afzonderlijk verzoek. De factuur groeit met breedsprakigheid aan beide kanten van de call, en daarom is tokens per verzoek de eerste metric die het volgen waard is.

Hoeveel kost een LLM in de VS?

API-prijzen zijn in USD en wereldwijd: OpenAI, Anthropic en Google rekenen dezelfde lijstprijs per miljoen tokens, of het verzoek nu uit Ohio of Osaka komt. Regionale verschillen verschijnen bij self-hosting, waar GPU-uren per cloudregio variëren, en bij hosted platforms die marge toevoegen. Voor API-werk verandert locatie de latency, niet de prijs.

Hoe track ik LLM-kosten per team?

Geef één virtual key per team uit via een proxy als LiteLLM, tag elke key bij aanmaak met de teamnaam en aggregeer uitgaven per tag. Elk verzoek draagt dan attributie vanaf het moment dat het gedaan wordt, zonder log-parsing. De showback-tabel in de budgetsectie hierboven is het eindproduct: team, maandbudget, uitgaven tot nu toe, status.

Langfuse vs Datadog voor LLM cost tracking: welke moet ik kiezen?

Kies Langfuse als je open source, self-hosting en data in eigen beheer wilt; het draait gratis en tracet kosten per verzoek out of the box. Kies Datadog alleen als je team het toch al draait voor infrastructuur, want de LLM-kostenfeatures verlaten het platform niet. Voor de meeste teams die fris beginnen, verslaat Langfuse plus een LiteLLM-proxy elk van beide opties alleen.

Komen geraamde LLM-kosten overeen met de echte factuur?

Nee, en meestal is de factuur lager. Dashboards factureren tegen lijstprijs terwijl cached input op 0,1x tot 0,25x landt en batchjobs op 0,5x, dus bij een workload met veel caching komt de echte factuur ruim onder de getrackte raming uit. Ontbrekende tokenvelden duwen de fout de andere kant op. De drift-tabel hierboven noemt elke vermenigvuldiger en waar je moet kijken.

Hoe alarmeer ik bij pieken in LLM-uitgaven?

Zet een drempelalarm op 80% van het maandbudget van elk team, afgeleverd in Slack via webhook, plus een dag-op-dag-anomalie-alarm op +50% voor loops die snel verbranden. LiteLLM levert het drempelpatroon standaard via de instelling alerting_threshold. Een alarm op 80% laat dagen om te reageren; een alarm op 100% bevestigt alleen dat de limiet zijn werk deed.

Bestaat er een gratis LLM cost tracker?

Ja, drie geloofwaardige. Langfuse self-hosted is gratis en open source, met een gratis hobby-tier in de cloud volgens de Langfuse-prijspagina. De ingebouwde key-budgetten van LiteLLM kosten niets op de open-source proxy. De gratis tier van Helicone dekt kostenlogs op proxyniveau met rate limits. Gratis tiers dekken monitoring; handhaving en alarmering op schaal is waar de betaalde plannen beginnen.

Conclusie

Kies vandaag een setup-pad, want het alarm dat je over zes weken wilt hebben, kost nu een middag om op te zetten. De korte versie:

• Track eerst tokens per verzoek en kosten per team; voeg de andere drie metrics toe zodra die werken.
• Een budget dat verzoeken weigert is een beheersmaatregel; een dat alleen telt is een rapport.
• Zet het alarm op 80%, in Slack, vóórdat de factuur iemand kan verrassen.
• Je dashboard is een raming; door cached-input- en batchprijzen valt de factuur meestal lager uit.

Laat je liever iemand samen naar je cijfers kijken, vraag dan een gratis consult aan.