LLM API-prijzen vergeleken: hoe aggregators u geld besparen

Als u ooit slechts één LLM-provider hebt gebruikt, ziet de adviesprijs op de prijzenpagina van die provider er waarschijnlijk uit als de prijs. Dat is het niet. Het is de retailprijs, en zoals bij de meeste retailprijzen zit er veel marge en structuur in verwerkt. Aggregators verdienen hun geld door precies die structuur aan te vallen.

Waarom directe adviesprijzen hoog zijn

Directe prijzen hebben kosten die niets met het draaien van het model te maken hebben. Wanneer u rechtstreeks bij een leverancier koopt, betaalt u ook voor:

•Minimale verplichtingen. Sommige providers willen een vooruitbetaald saldo of een toegezegde besteding voordat ze hun beste tarief geven. Kleine teams halen die drempels zelden.

•Één provider, één contract. Elke leverancier heeft zijn eigen aanmelding, zijn eigen facturering, zijn eigen valuta. Drie providers draaien betekent drie facturen en drie betaalmethoden.

•Geen concurrentie binnen uw eigen rekening. Wanneer u aan één leverancier vastzit, heeft die leverancier geen reden om korting te geven. U betaalt hun tarief of u vertrekt.

•Snelheidslimieten die zijn ingesteld voor hun bescherming, niet voor uw gemak.

Aggregators bestaan omdat ze upstream capaciteit in volume kunnen inkopen en een deel van de korting kunnen doorgeven. Ze laten u ook uw besteding tussen providers verschuiven, en dat is de echte hefboom: als model A volgende maand goedkoper wordt, verplaatst u uw verkeer zonder van leverancier te wisselen.

De rekensom, met ronde getallen

Laat me bewust eenvoudige voorbeeldgetallen gebruiken zodat de vorm duidelijk is. Echte prijzen veranderen voortdurend, maar de rekensom blijft hetzelfde.

Stel dat een provider een model aanbiedt voor $2,50 per miljoen input-tokens en $10,00 per miljoen output-tokens. Een typische workload, bijvoorbeeld een supportticket-samenvatter die per maand 10 miljoen input-tokens en 4 miljoen output-tokens verwerkt, zou kosten:

Direct:  (10M x $2,50) + (4M x $10,00) = $25 + $40 = $65,00 / maand

Een aggregator die volumeprijzen heeft onderhandeld, zou hetzelfde model kunnen aanbieden voor ongeveer een kwart van de adviesprijs, $0,60 per miljoen in en $2,40 per miljoen uit:

Aggregated:  (10M x $0,60) + (4M x $2,40) = $6,00 + $9,60 = $15,60 / maand

Dat is ongeveer $49 bespaard per maand op één bescheiden workload, een verlaging van ~76%, nog voordat u iets anders aanraakt. Schaal de tokenaantallen op met een factor tien en de absolute besparingen schalen mee.

Het belangrijkste punt zijn niet deze specifieke getallen. Het punt is dat het verschil tussen "adviesprijs" en "volumeprijs" reëel is, en dat het de taak van een aggregator is om in dat verschil te zitten en een deel ervan aan u terug te geven.

De andere kosten die zich in de kleine lettertjes verstoppen

De prijs per token is de kop, maar het is niet de hele rekening. Drie dingen zorgen voor verrassingen:

Prijzen voor cache-hits. Sommige modellen geven korting op tokens die een promptcache raken. Als de ene provider de volle prijs rekent voor gecachte input en een andere 10% daarvan, kan een workload met repetitieve prompts enorm verschillen in kosten, zelfs bij dezelfde adviesprijs. Vraag het voordat u zich vastlegt.

Valuta- en betalingsfrictie. Kopen bij een leverancier wiens facturering in een valuta of regio plaatsvindt die uw kaart niet prettig vindt, voegt conversiekosten en mislukte betalingen toe. Eén aggregatorfactuur in uw eigen valuta haalt dat weg.

Snelheidslimieten als verborgen kosten. Een goedkoop model dat u slechts 10 keer per minuut kunt aanroepen is niet goedkoop; u bouwt retry- en wachtrijlogica om dat te compenseren, en dat is engineeringtijd. Doorvoerlimieten horen in de prijsvergelijking, ook al staan ze niet op de prijzenpagina.

Een snelle kostenraming

Het ramen van de besteding voordat u bouwt is eenvoudig zodra u de getallen hebt. Hier is een klein Python-script in die geest:

def monthly_cost(input_tokens, output_tokens, in_price, out_price):
    # prijzen zijn per miljoen tokens
    return (input_tokens / 1e6) * in_price + (output_tokens / 1e6) * out_price

# Directe adviesprijs
direct = monthly_cost(10_000_000, 4_000_000, 2.50, 10.00)

# Aggregatorprijs (voorbeeldwaarden)
aggregated = monthly_cost(10_000_000, 4_000_000, 0.60, 2.40)

print(f"Direct:     ${direct:.2f}")
print(f"Aggregated: ${aggregated:.2f}")
print(f"Saved:      ${direct - aggregated:.2f}")

Voer uw echte tokenaantallen erdoor met uw echte prijzen. Dat is het enige getal dat telt.

Waar aggregators u geen geld besparen

Ik moet eerlijk zijn over de beperkingen. Een aggregator is een wederverkoper. Sommige modellen zijn helemaal niet via wederverkopers beschikbaar, en voor sommige niche-modellen kan de markup van een aggregator slechter zijn dan direct gaan. De besparingen zijn het grootst bij de populaire general-purpose modellen waar volumekortingen bestaan. Voor een exotisch model dat u zelden aanroept, is het verschil ruis.

Bovendien is een goedkopere prijs waardeloos als de betrouwbaarheid van de aggregator slecht is. Een besparing van 30% die u een onbetrouwbaar endpoint oplevert, kost meer dan 30% zodra u retries, supporttickets en uw eigen tijd meerekent. Prijs en betrouwbaarheid zijn één beslissing, niet twee.

SiCore TokenWorks is een rechttoe rechtaan versie van dit model: OpenAI-compatibel, pay-as-you-go, met een catalogus van populaire modellen van DeepSeek, Qwen, ERNIE, Doubao, Spark en Pangu naast GPT-4o, Claude en Gemini, ruim onder de officiële tarieven per token.