Anthropic bijna winstgevend: wat dit betekent voor jouw Claude Code project

Anthropic verdubbelt omzet en verwacht eerste winstgevende kwartaal

Anthropics CEO heeft investeerders laten weten dat het bedrijf z'n eerste winstgevende kwartaal tegemoet gaat. De omzet verdubbelt naar bijna 11 miljard dollar per kwartaal, mede doordat Anthropic nu ook compute levert aan andere partijen. Lees het volledige verhaal op TechCrunch.

Voor jou als maker is dit ronduit goed nieuws. Een winstgevend Anthropic is een stabieler Anthropic, en een stabieler Anthropic betekent minder kans dat de API waarmee jij je SaaS bouwt straks verdwijnt of drastisch verandert. Maar "minder kans" is niet "geen kans", en dat brengt ons bij de echte vraag van vandaag.

Wat betekent dit voor jouw project?

Als jouw SaaS draait op de Claude API, dan is dit het perfecte moment om te checken hoe kwetsbaar je eigenlijk bent. Niet omdat er nu iets mis is, maar juist omdat het nu rustig is. Stel jezelf twee vragen:

1. Wat gebeurt er in je app als de Claude API even niet beschikbaar is of een fout teruggooit?
2. Weet je hoeveel API-calls je elke dag maakt, en wat dat kost?

De meeste makers bouwen de happy path en denken later pas aan foutafhandeling. Vanavond draaien we dat om.

Hoe pak je dit aan met Claude Code?

Stap 1: laat Claude Code je huidige API-gebruik in kaart brengen

Open je project in Claude Code en geef deze prompt:

Analyseer alle plekken in mijn codebase waar ik de Anthropic API aanroep. Maak een overzicht van: welke bestanden, welke functies, welk model wordt gebruikt, en of er al foutafhandeling aanwezig is. Geef dat overzicht terug als een nette markdown-tabel.

Je krijgt een eerlijk beeld van hoe verspreid (of geconcentreerd) je API-gebruik is. Als het antwoord is "het staat overal", dan is dat waardevolle informatie.

Stap 2: bouw een centrale API-wrapper met foutafhandeling

Vraag Claude Code om alle losse API-aanroepen samen te brengen in één plek:

Refactor mijn Anthropic API-aanroepen naar een centrale wrapper in lib/claude.ts. De wrapper moet:

• een retry doen bij een tijdelijke fout (status 529 of 503), maximaal 3 keer met exponential backoff
• bij een permanente fout (status 400, 401) direct falen met een duidelijke foutmelding
• elke aanroep loggen met timestamp, model, geschat tokengebruik en of het gelukt is
• een optionele fallbackMessage accepteren die getoond wordt als de API helemaal niet bereikbaar is

Een voorbeeld van hoe zo'n wrapper er na afloop uit kan zien:

// lib/claude.ts
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

interface ClaudeOptions {
  model?: string;
  maxTokens?: number;
  fallbackMessage?: string;
}

export async function askClaude(
  prompt: string,
  options: ClaudeOptions = {}
): Promise<string> {
  const {
    model = "claude-opus-4-5",
    maxTokens = 1024,
    fallbackMessage = "Even geen antwoord beschikbaar, probeer het later.",
  } = options;

  const maxRetries = 3;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const start = Date.now();
      const response = await client.messages.create({
        model,
        max_tokens: maxTokens,
        messages: [{ role: "user", content: prompt }],
      });

      const duur = Date.now() - start;
      console.log(`[Claude] poging ${attempt} geslaagd in ${duur}ms`);

      return response.content[0].type === "text"
        ? response.content[0].text
        : fallbackMessage;
    } catch (err: unknown) {
      const status =
        err instanceof Anthropic.APIError ? err.status : undefined;

      // Permanente fout: niet opnieuw proberen
      if (status === 400 || status === 401) {
        console.error(`[Claude] permanente fout (${status}), stoppen.`);
        return fallbackMessage;
      }

      // Tijdelijke fout: wacht en probeer opnieuw
      if (attempt < maxRetries) {
        const wacht = Math.pow(2, attempt) * 500; // 1s, 2s, 4s
        console.warn(
          `[Claude] tijdelijke fout (${status}), opnieuw over ${wacht}ms`
        );
        await new Promise((r) => setTimeout(r, wacht));
      } else {
        console.error(`[Claude] na ${maxRetries} pogingen opgegeven.`);
        return fallbackMessage;
      }
    }
  }

  return fallbackMessage;
}

Stap 3: voeg een eenvoudig gebruiksdashboard toe

Als je Supabase gebruikt, kun je het loggen direct naar een tabel sturen. Geef Claude Code deze prompt:

Voeg aan de askClaude wrapper logging toe naar een Supabase-tabel genaamd api_logs. Sla per aanroep op: timestamp, model, prompt_lengte (aantal tekens), response_lengte, duur_ms en of het gelukt is (success boolean). Gebruik de bestaande Supabase client uit mijn project.

Zo bouw je in vijf minuten een simpele basis voor kostenbewaking.

Stap 4: test of je fallback werkt

Vraag Claude Code om een testbestand te maken:

Schrijf een testscript in scripts/test-fallback.ts dat de Claude wrapper aanroept met een opzettelijk ongeldige API-key, en checkt of de fallbackMessage wordt teruggegeven in plaats van een crash.

Run het daarna met:

npx tsx scripts/test-fallback.ts

Als je de fallbackMessage ziet in de output in plaats van een unhandled exception, zit je goed.

Wat te checken na afloop

• Je app crasht niet meer als de Claude API een fout teruggeeft, maar toont een nette boodschap.
• In je logs zie je per aanroep hoelang het duurde en of het gelukt is.
• Je kunt in Supabase (of je logbestand) zien hoeveel calls je per dag maakt.
• De centrale wrapper wordt gebruikt op alle plekken in je codebase, niet meer losse client.messages.create() calls verspreid door je code.

Een stabiel Anthropic is fijn, maar een robuuste eigen codebase is nog fijner.