Claude Code als kostencheck: zo voorkom je dat je AI-budget ontploft door kleine taken

Bedrijven snijden in AI-budgetten: wat betekent dat voor jou als maker?

TechCrunch meldt vandaag dat grote bedrijven in rap tempo maatregelen nemen om te voorkomen dat medewerkers hun AI-budget opslokken met triviale taken. We gaan blijkbaar van het tokenmaxxing-tijdperk naar het token-rationeringstijdperk. Grote organisaties hebben budget-alerts en limieten nodig omdat de rekening onverwacht hoog uitvalt.

Als solo-maker of klein team dat Claude Code gebruikt om SaaS te bouwen, ben jij zelf die organisatie. Geen IT-afdeling die ingrijpt. Geen finance-team dat een alarm trekt. Jij bent de enige die ziet wanneer je Anthropic-rekening stilletjes oploopt.

Wat betekent dit voor jouw project?

Als jouw SaaS Claude API-calls maakt namens jouw gebruikers, dan is elke extra call direct jouw kosten. Een chatbot die iemand dagelijks vijftien keer vraagt "vat dit samen" voor een tekst van drie zinnen: je merkt het pas op de maandrekening. Met een simpel usage-dashboard in je eigen app weet je dagelijks waar je staat, en kun je eventueel per gebruiker limieten instellen.

Dit is precies het moment om dat te bouwen, voor het een probleem wordt.

Hoe pak je het aan met Claude Code?

We bouwen in vier stappen een minimaal usage-dashboard dat Anthropic API-gebruik bijhoudt per dag en per gebruiker. Je hoeft geen ervaren developer te zijn. Claude Code doet het zware werk.

Stap 1: leg de basis neer in je project

Open Claude Code in je projectmap en geef deze prompt:

Maak een nieuw bestand lib/usage-tracker.ts. Dit bestand moet een functie exporteren trackApiCall(userId: string, inputTokens: number, outputTokens: number) die een log-entry wegschrijft naar een Supabase-tabel genaamd api_usage. De tabel heeft kolommen: id (uuid), user_id (text), input_tokens (integer), output_tokens (integer), created_at (timestamp). Maak ook een functie getDailyUsage(userId: string) die de totale tokens van vandaag teruggeeft voor die gebruiker.

Claude Code genereert de TypeScript-functies en het SQL-schema voor de Supabase-tabel.

Stap 2: koppel de tracker aan je bestaande API-calls

Als je al Anthropic API-calls maakt in je project, voeg je de tracker toe. Geef Claude Code deze prompt:

Zoek alle plekken in mijn codebase waar ik anthropic.messages.create aanroep. Voeg na elke aanroep een call toe naar trackApiCall met de userId uit de request-context, en response.usage.input_tokens en response.usage.output_tokens uit het Anthropic-response-object.

Claude Code doorzoekt je bestanden en past ze aan. Controleer daarna de diff met git diff voordat je verder gaat.

Stap 3: bouw een minidashboard-pagina

Voeg een beschermde admin-pagina toe aan je Next.js app:

Maak een pagina op /admin/usage (alleen toegankelijk als de ingelogde gebruiker de rol 'admin' heeft in Supabase). Toon een tabel met de volgende kolommen: gebruiker-ID, totaal input tokens vandaag, totaal output tokens vandaag, geschatte kosten in euro (gebruik $3 per miljoen input tokens en $15 per miljoen output tokens als rekenfactor, gedeeld door 0.92 voor EUR). Haal de data op via een Server Component met de Supabase server client.

// Voorbeeld van wat Claude Code genereert (vereenvoudigd)
import { createServerComponentClient } from '@supabase/auth-helpers-nextjs'
import { cookies } from 'next/headers'

export default async function UsagePage() {
  const supabase = createServerComponentClient({ cookies })
  const today = new Date().toISOString().split('T')[0]

  const { data } = await supabase
    .from('api_usage')
    .select('user_id, input_tokens, output_tokens')
    .gte('created_at', today)

  const perUser = data?.reduce((acc, row) => {
    if (!acc[row.user_id]) acc[row.user_id] = { input: 0, output: 0 }
    acc[row.user_id].input += row.input_tokens
    acc[row.user_id].output += row.output_tokens
    return acc
  }, {} as Record<string, { input: number; output: number }>)

  return (
    <table>
      <thead>
        <tr>
          <th>Gebruiker</th>
          <th>Input tokens</th>
          <th>Output tokens</th>
          <th>Kosten (est.)</th>
        </tr>
      </thead>
      <tbody>
        {Object.entries(perUser ?? {}).map(([userId, usage]) => {
          const cost = (usage.input / 1_000_000 *3 + usage.output / 1_000_000* 15) / 0.92
          return (
            <tr key={userId}>
              <td>{userId}</td>
              <td>{usage.input.toLocaleString('nl-NL')}</td>
              <td>{usage.output.toLocaleString('nl-NL')}</td>
              <td>€{cost.toFixed(4)}</td>
            </tr>
          )
        })}
      </tbody>
    </table>
  )
}

Stap 4: voeg een dagelijkse limiet toe (optioneel maar slim)

Als je wilt voorkomen dat één gebruiker je budget leegtrekt, voeg dan een harde rem in:

Pas de functie trackApiCall aan: controleer eerst of de gebruiker vandaag al meer dan 100.000 tokens heeft gebruikt (input + output samen). Als dat zo is, gooi dan een error UsageLimitExceeded zodat de aanroepende code de API-call kan blokkeren en de gebruiker een vriendelijke melding kan tonen.

Wat te checken na afloop

• Ga naar je Supabase dashboard en kijk of er rijen verschijnen in de tabel api_usage nadat je een test-call doet.
• Open /admin/usage en verifieer dat de tokengetallen en de kostenberekening kloppen.
• Doe een snelle rekencheck: 1.000 input tokens + 500 output tokens = (0.001 x $3 + 0.0005 x $15) / 0.92 = ongeveer $0.0114. Als je dashboard dat weergeeft, werkt de formule.
• Controleer dat niet-admins de pagina niet kunnen bereiken (probeer het met een gewone testgebruiker).

Kleine investering van een avond, maar je hebt daarna nooit meer een verrassingsrekening.