Modèle de facturation d'OpenAI

​

Pourquoi le modèle d’OpenAI est la référence

1. Revenus prévisibles et risques réduits : Comme l’utilisation de l’API est prépayée, les utilisateurs ne peuvent pas accumuler des factures qu’ils ne seraient pas en mesure de payer. OpenAI reçoit l’argent à l’avance, puis l’utilisateur le dépense au fur et à mesure de son utilisation du service.
2. Évolutivité pour les développeurs : Un rechargement de $5 constitue une barrière à l’entrée faible. À mesure qu’une application se développe, les développeurs peuvent automatiser les rechargements ou acheter des packs plus importants. Le démarrage est peu coûteux et l’utilisation peut augmenter sans changement de forfait.
3. Psychologie des utilisateurs : Des crédits libellés en dollars américains, plutôt qu’en « tokens » ou en « points » abstraits, rendent la valeur évidente. Le solde fonctionne comme un compte prépayé pour les services d’IA, ce qui facilite la gestion budgétaire des entreprises.

​

Comment OpenAI facture

1. API (Pay-as-you-go) : L’API utilise des crédits prépayés libellés en dollars. Les utilisateurs alimentent leur compte de 5 $, 10$, 50 $ou davantage. Les crédits affichent une valeur en dollars, mais ne peuvent pas être utilisés en dehors d'OpenAI. OpenAI facture chaque token, avec des tarifs différents pour les tokens d'entrée et de sortie. Les crédits achetés expirent un an après leur achat et ne sont pas remboursables ([Centre d'aide OpenAI](https://help.openai.com/en/articles/8264644-setting-up-and-managing-prepaid-api-billing)). Lorsque le solde atteint 0$, les appels API échouent.
2. ChatGPT Plus, Business et Enterprise : Il s’agit d’abonnements à tarif fixe. ChatGPT Plus coûte 20 $par mois, et l'offre Business (anciennement Team) coûte 25$ par utilisateur et par mois en cas de facturation mensuelle. Ces offres disposent de plafonds d’utilisation souples : les utilisateurs intensifs sont redirigés vers un modèle plus petit au lieu d’être bloqués.
3. Niveaux de tarification basés sur les dépenses : À mesure que les dépenses totales augmentent, le compte débloque des limites de débit API plus élevées. L’accès évolue avec l’historique de facturation.

​

Ce qui le rend unique

• Crédits libellés en monnaie fiduciaire : Les crédits sont exprimés en dollars américains, ce qui leur donne l’apparence d’une somme d’argent. Les développeurs peuvent lire directement le prix d’une requête.
• Expiration longue : Les crédits achetés restent valables pendant un an, ce qui réduit la pression du « à utiliser ou à perdre ». Les utilisateurs n’hésitent pas à ajouter des montants plus élevés.
• Mesure multidimensionnelle : Les tokens d’entrée et de sortie sont suivis séparément, mais déduits du même solde. OpenAI peut facturer les tokens de sortie coûteux plus cher que les tokens d’entrée.
• Niveaux de confiance : Les limites de débit qui augmentent avec les dépenses totales récompensent les clients fidèles et les encouragent à rester.

​

Avantages stratégiques

​

Reproduire ce modèle avec Dodo Payments

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

​

Accélérer avec le blueprint d’ingestion LLM

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

​

Mettre en œuvre les niveaux de tarification basés sur les dépenses

1. Suivre les dépenses cumulées : Écoutez les webhooks payment.succeeded et ajoutez le montant du paiement à un champ total_spend pour ce client dans votre base de données. Les montants sont exprimés dans la plus petite unité monétaire ; 5000 correspondent donc à 50,00 $.
2. Définir les niveaux : Associez les montants dépensés aux limites de débit :
   • Niveau 1 : dépenses de 0 $à 50$ -> 3 RPM
   • Niveau 2 : dépenses de 50 $à 250$ -> 10 RPM
   • Niveau 3 : dépenses supérieures ou égales à 250 $ -> 50 RPM
3. Appliquer les limites : Dans votre middleware API, recherchez le niveau du client et appliquez sa limite de débit.

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

​

Exemple complet d’implémentation : le proxy API

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

​

Gérer les cas particuliers

​

Conditions de concurrence

​

Latence d’ingestion des événements

​

Gestion des remboursements

​

Prise en charge de plusieurs modèles

1. Meters distincts : Créez un ensemble de meters par modèle, par exemple gpt-4o.input_tokens et gpt-4o-mini.input_tokens, chacun avec sa propre valeur Meter units per credit.
2. Événements pondérés : Utilisez un seul meter et multipliez tokens par un coefficient avant d’envoyer l’événement. Par exemple, si GPT-4o coûte 10 fois plus cher que GPT-4o-mini, envoyez 10 fois plus de tokens pour les requêtes GPT-4o.

​

Vue d’ensemble de l’architecture

​

Conclusion

​

Fonctionnalités clés de Dodo utilisées