OpenAI-Abrechnungsmodell

​

Warum OpenAIs Modell der Standard ist

1. Vorhersehbare Einnahmen und geringes Risiko: Durch die Anforderung vorausbezahlter Guthaben für die API-Nutzung eliminiert OpenAI das Risiko, dass Nutzer riesige Rechnungen anhäufen, die sie nicht bezahlen können. Sie erhalten das Geld im Voraus und der Nutzer erhält den Service während der Nutzung.
2. Skalierbarkeit für Entwickler: Eine $5-Aufladung ist eine niedrige Einstiegshürde. Wenn ihre Anwendung wächst, können Entwickler Aufladungen automatisieren oder größere Pakete erwerben. Der Start ist nahezu reibungslos, aber die Wachstumsmöglichkeiten sind unbegrenzt.
3. Nutzerpsychologie: Die Nennung von Guthaben in Fiat-Währung (USD) anstelle abstrakter „Tokens“ oder „Punkte“ macht den Wert klar. Es fühlt sich wie ein Bankkonto für KI-Dienste an, was Vertrauen schafft und es Unternehmen erleichtert, zu budgetieren.

​

Wie OpenAI abrechnet

1. API (Pay-as-you-go): Die API verwendet vorausbezahlte, in Fiat-Währung denominierten Credits. Nutzer laden ihre Konten mit $5, $10, $50 oder mehr auf. Diese Credits zeigen einen Dollarwert an, haben aber außerhalb von OpenAI keinen Geldwert. OpenAI berechnet pro Token mit unterschiedlichen Tarifen für Eingabe- und Ausgabetoken. Guthaben verfallen nie, und wenn das Guthaben eines Nutzers $0 erreicht, schlagen seine API-Aufrufe sofort fehl.
2. ChatGPT Plus, Team und Enterprise: Dies sind Pauschalabonnements. ChatGPT Plus kostet $20 pro Monat, während der Team-Tarif $25 pro Nutzer und Monat beträgt. Diese Pläne haben weiche Nutzungslimits, bei denen Nutzer zu einem kleineren Modell herabgestuft werden, anstatt blockiert zu werden.
3. Ausgabenbasierte Tarifstufen: Mit zunehmenden Gesamtausgaben über die Zeit schalten Sie höhere API-Ratenlimits frei. Dies ist ein vertrauensbasiertes Zugangsskalierungssystem, das direkt an Ihre Abrechnungshistorie geknüpft ist.

​

Was es einzigartig macht

• In Fiat denominiertes Guthaben: Guthaben wirken wie Geld, weil sie in USD angegeben sind. Das macht die Preisgestaltung transparent und leicht verständlich für Entwickler.
• Keine Ablaufzeiten: Nie verfallende Kontostände reduzieren den „Nutze es oder verliere es“-Druck. Nutzer fühlen sich wohl dabei, größere Beträge aufzuladen, weil sie wissen, dass der Wert nicht verschwindet.
• Multidimensionale Messung: Eingangs- und Ausgangstoken werden separat verfolgt, aber vom gleichen Guthabenkonto abgezogen. Dadurch kann OpenAI teure Ausgangstoken anders bepreisen als günstigere Eingangstoken.
• Vertrauensebenen: Die Verknüpfung der Ratenlimits mit den Gesamtausgaben ermutigt Nutzer, auf der Plattform zu bleiben und belohnt langfristige Kunden mit besserer Performance.

​

Strategische Vorteile

​

Dies 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: 'prod_credit_pack_50', quantity: 1 }
  ],
  customer: { email: 'developer@example.com' },
  return_url: 'https://yourapp.com/dashboard'
});

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: 'credit_entitlement_id',
  });

  if (balance.available <= 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,
});

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: 'prod_plus_subscription', quantity: 1 }
  ],
  customer: { email: 'user@example.com' },
  return_url: 'https://yourapp.com/billing'
});

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';
}

​

Beschleunigen mit dem LLM Ingestion Blueprint

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',
});

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);

​

Umsetzung ausgabenbasierter Tarifstufen

1. Lebenszeitausgaben verfolgen: Hören Sie auf payment.succeeded-Webhooks und aktualisieren Sie ein total_spend-Feld in Ihrer Datenbank für diesen Kunden.
2. Stufen definieren: Erstellen Sie eine Zuordnung von Ausgabenbeträgen zu Ratenlimits.
   • Stufe 1: $0 - $50 Ausgaben -> 3 RPM
   • Stufe 2: $50 - $250 Ausgaben -> 10 RPM
   • Stufe 3: $250+ Ausgaben -> 50 RPM
3. Limits durchsetzen: Prüfen Sie in Ihrer API-Middleware die Stufe des Kunden und erzwingen Sie das entsprechende Ratenlimit.

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: 'credit_entitlement_id',
    });

    if (balance.available <= 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 Randfällen

​

Race Conditions

​

Latenz bei der Ereignisintegration

​

Rückerstattungsabwicklung

​

Unterstützung mehrerer Modelle

1. Separate Meters: Erstellen Sie separate Meters für jedes Modell (z. B. gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Gewichtete Ereignisse: Verwenden Sie einen einzigen Meter, multiplizieren Sie jedoch den tokens-Wert mit einem Gewicht, bevor Sie ihn an Dodo senden. Beispielsweise können Sie für GPT-4o, das 10-mal teurer ist als GPT-4o-mini, 10-mal so viele Tokens für GPT-4o-Anfragen senden.

​

Architekturüberblick

​

Fazit

​

Wichtige verwendete Dodo-Funktionen