OpenAI-Abrechnungsmodell

​

Warum OpenAIs Modell der Standard ist

1. Planbare Umsätze und geringes Risiko: Da die API-Nutzung im Voraus bezahlt wird, können Nutzer keine Rechnungen anhäufen, die sie nicht bezahlen können. OpenAI erhält das Geld sofort, und der Nutzer gibt es bei der Nutzung des Dienstes aus.
2. Skalierbarkeit für Entwickler: Eine Aufladung von $5 ist eine niedrige Einstiegshürde. Wenn eine Anwendung wächst, können Entwickler Aufladungen automatisieren oder größere Pakete kaufen. Der Einstieg ist günstig, und die Nutzung kann wachsen, ohne dass ein Planwechsel erforderlich ist.
3. Nutzerpsychologie: In US-Dollar denominierte Credits machen den Wert klarer als abstrakte „Tokens“ oder „Punkte“. Das Guthaben funktioniert wie ein vorausbezahltes Konto für AI-Dienste, was die Budgetplanung für Unternehmen erleichtert.

​

Wie OpenAI abrechnet

1. API (Pay-as-you-go): Die API verwendet im Voraus bezahlte, auf Dollar lautende Guthaben. Nutzer laden ihre Konten mit $5, $10, $50 oder mehr auf. Die Guthaben zeigen einen Dollarwert an, können aber nicht außerhalb von OpenAI verwendet werden. OpenAI rechnet pro Token ab, mit unterschiedlichen Preisen für Input- und Output-Tokens. Gekaufte Guthaben verfallen ein Jahr nach dem Kauf und sind nicht erstattungsfähig (OpenAI Help Center). Wenn ein Guthaben von $0 erreicht ist, schlagen API-Aufrufe fehl.
2. ChatGPT Plus, Business und Enterprise: Dies sind Pauschalabonnements. ChatGPT Plus kostet $20 pro Monat, und der Business-Tarif (früher Team) kostet bei monatlicher Abrechnung $25 pro Nutzer und Monat. Sie haben weiche Nutzungslimits: Bei intensiver Nutzung wechseln Nutzer zu einem kleineren Modell, anstatt blockiert zu werden.
3. Ausgabenbasierte Tarifstufen: Wenn die Gesamtausgaben im Laufe der Zeit steigen, schaltet das Konto höhere API-Ratenlimits frei. Der Zugriff erweitert sich mit der Abrechnungshistorie.

​

Was macht das Modell einzigartig?

• Auf Fiatwährung lautende Guthaben: Die Guthaben sind in US-Dollar angegeben und fühlen sich daher wie Geld an. Entwickler können den Preis einer Anfrage direkt ablesen.
• Lange Gültigkeit: Gekaufte Guthaben sind ein Jahr lang gültig, wodurch der Druck nach dem Motto „nutze es oder verliere es“ sinkt. Nutzer laden ihre Konten daher gerne mit größeren Beträgen auf.
• Mehrdimensionale Abrechnung: Input- und Output-Tokens werden separat erfasst, aber vom selben Guthaben abgezogen. OpenAI kann teurere Output-Tokens höher bepreisen als Input-Tokens.
• Vertrauensstufen: Ratenlimits, die mit den Gesamtausgaben steigen, belohnen langfristige Kunden und ermutigen sie, zu bleiben.

​

Strategische Vorteile

​

Mit Dodo Payments umsetzen

import DodoPayments from 'dodopayments';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_credit_pack_50', quantity: 1 }
  ],
  customer: { email: 'developer@example.com' },
  return_url: 'https://yourapp.com/dashboard'
});

// requestId and customerId come from your application's request context.
await client.usageEvents.ingest({
  events: [{
    event_id: `req_${requestId}`,
    customer_id: customerId,
    event_name: 'llm.input_tokens',
    timestamp: new Date().toISOString(),
    metadata: {
      model: 'gpt-4o',
      tokens: 1500
    }
  }, {
    event_id: `req_${requestId}_out`,
    customer_id: customerId,
    event_name: 'llm.output_tokens',
    timestamp: new Date().toISOString(),
    metadata: {
      model: 'gpt-4o',
      tokens: 800
    }
  }]
});

async function checkCreditsBeforeRequest(customerId: string) {
  const balance = await client.creditEntitlements.balances.retrieve(customerId, {
    credit_entitlement_id: 'cde_your_credit_entitlement_id',
  });

  if (Number(balance.balance) <= 0) {
    throw new Error('Insufficient credits. Please top up your account.');
  }
}

import DodoPayments from 'dodopayments';
import express from 'express';

const app = express();
app.use(express.raw({ type: 'application/json' }));

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
});

// sendLowBalanceEmail is your application's own function.
app.post('/webhooks/dodo', async (req, res) => {
  try {
    const event = client.webhooks.unwrap(req.body.toString(), {
      headers: {
        'webhook-id': req.headers['webhook-id'] as string,
        'webhook-signature': req.headers['webhook-signature'] as string,
        'webhook-timestamp': req.headers['webhook-timestamp'] as string,
      },
    });

    if (event.type === 'credit.balance_low') {
      const { customer_id, available_balance } = event.data;
      await sendLowBalanceEmail(customer_id, available_balance);
    }

    res.json({ received: true });
  } catch (error) {
    res.status(401).json({ error: 'Invalid signature' });
  }
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'pdt_plus_subscription', quantity: 1 }
  ],
  customer: { email: 'user@example.com' },
  return_url: 'https://yourapp.com/billing'
});

// getUsageForCurrentPeriod and SOFT_CAP_THRESHOLD are defined in your application.
async function checkSubscriptionUsage(customerId: string) {
  const usage = await getUsageForCurrentPeriod(customerId);
  
  if (usage > SOFT_CAP_THRESHOLD) {
    // Route to a smaller model instead of blocking
    return 'gpt-4o-mini';
  }
  
  return 'gpt-4o';
}

​

Mit dem LLM Ingestion Blueprint schneller vorankommen

npm install @dodopayments/ingestion-blueprints

import { createLLMTracker } from '@dodopayments/ingestion-blueprints';
import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const tracker = createLLMTracker({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'llm.chat_completion',
});

// customerId and prompt come from your application.
const trackedClient = tracker.wrap({
  client: openai,
  customerId: customerId,
});

// Every API call now automatically tracks token usage
const response = await trackedClient.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: prompt }],
});

// inputTokens, outputTokens, and totalTokens are sent automatically
console.log('Tokens used:', response.usage);

​

Ausgabenbasierte Ratenstufen implementieren

1. Lebenslange Ausgaben erfassen: Höre auf payment.succeeded-Webhooks und addiere den Zahlungsbetrag in deiner Datenbank für den jeweiligen Kunden zu einem total_spend-Feld. Beträge werden in der kleinsten Währungseinheit angegeben, daher entsprechen 5000 $50.00.
2. Stufen definieren: Ordne Ausgabenbeträge Ratenlimits zu:
   • Stufe 1: $0 - $50 Ausgaben -> 3 RPM
   • Stufe 2: $50 - $250 Ausgaben -> 10 RPM
   • Stufe 3: $250+ Ausgaben -> 50 RPM
3. Limits durchsetzen: Ermittle in deiner API-Middleware die Stufe des Kunden und wende deren Ratenlimit an.

// db and the TIER_*_LIMITS constants are defined in your application.
async function getRateLimitForCustomer(customerId: string) {
  const customer = await db.customers.findUnique({ where: { id: customerId } });
  const totalSpend = customer.total_spend;

  if (totalSpend >= 25000) return TIER_3_LIMITS; // $250.00
  if (totalSpend >= 5000) return TIER_2_LIMITS;  // $50.00
  return TIER_1_LIMITS;
}

​

Vollständiges Implementierungsbeispiel: Der API-Proxy

import DodoPayments from 'dodopayments';
import OpenAI from 'openai';

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function handleApiRequest(req, res) {
  const { customerId, prompt, model } = req.body;

  try {
    // 1. Check credit balance
    const balance = await client.creditEntitlements.balances.retrieve(customerId, {
      credit_entitlement_id: 'cde_your_credit_entitlement_id',
    });

    if (Number(balance.balance) <= 0) {
      return res.status(402).json({ error: 'Insufficient credits. Please top up.' });
    }

    // 2. Call OpenAI
    const completion = await openai.chat.completions.create({
      model: model,
      messages: [{ role: 'user', content: prompt }],
    });

    const { prompt_tokens, completion_tokens } = completion.usage;

    // 3. Ingest usage events to Dodo
    await client.usageEvents.ingest({
      events: [
        {
          event_id: `req_${completion.id}_in`,
          customer_id: customerId,
          event_name: 'llm.input_tokens',
          timestamp: new Date().toISOString(),
          metadata: { model, tokens: prompt_tokens }
        },
        {
          event_id: `req_${completion.id}_out`,
          customer_id: customerId,
          event_name: 'llm.output_tokens',
          timestamp: new Date().toISOString(),
          metadata: { model, tokens: completion_tokens }
        }
      ]
    });

    // 4. Return response to user
    res.json(completion);

  } catch (error) {
    console.error('API Error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
}

​

Umgang mit Sonderfällen

​

Race Conditions

​

Latenz bei der Eventaufnahme

​

Umgang mit Rückerstattungen

​

Unterstützung mehrerer Modelle

1. Separate Meters: Erstelle einen Satz Meters pro Modell, zum Beispiel gpt-4o.input_tokens und gpt-4o-mini.input_tokens, jeweils mit eigenen Meter units per credit.
2. Gewichtete Events: Verwende einen Meter und multipliziere tokens vor dem Senden des Events mit einem Gewicht. Wenn GPT-4o beispielsweise zehnmal so viel kostet wie GPT-4o-mini, sende bei GPT-4o-Anfragen die zehnfache Tokenanzahl.

​

Architekturübersicht

​

Fazit

​

Verwendete Dodo-Funktionen