Modèle de facturation d'OpenAI

​

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

1. Revenus prévisibles et faible risque : en exigeant des crédits prépayés pour l’utilisation de l’API, OpenAI élimine le risque que les utilisateurs accumulent d’importantes factures qu’ils ne peuvent pas payer. Vous recevez l’argent à l’avance et l’utilisateur bénéficie du service au fur et à mesure de son utilisation.
2. Évolutivité pour les développeurs : un rechargement de 5 $ constitue une faible barrière à l’entrée. À mesure que leur application se développe, les développeurs peuvent automatiser les rechargements ou acheter des packs plus importants. La friction au démarrage est presque nulle, tandis que le potentiel de croissance est illimité.
3. Psychologie des utilisateurs : libeller les crédits en monnaie fiduciaire (USD), plutôt qu’en « tokens » ou « points » abstraits, rend leur valeur claire. Cela ressemble à un compte bancaire pour les services d’IA, ce qui renforce la confiance et facilite la budgétisation des entreprises.

​

Comment OpenAI facture

1. API (paiement à l’utilisation) : l’API utilise des crédits prépayés libellés en monnaie fiduciaire. Les utilisateurs rechargent leur compte de 5 $, 10$, 50 $ou davantage. Ces crédits affichent une valeur en dollars, mais n'ont aucune valeur monétaire en dehors d'OpenAI. OpenAI facture par token, avec des tarifs différents pour les tokens d'entrée et de sortie. Les crédits n'expirent jamais et lorsque le solde d'un utilisateur atteint 0$, ses appels d’API échouent immédiatement.
2. ChatGPT Plus, Team et Enterprise : il s’agit d’abonnements à tarif fixe. ChatGPT Plus coûte 20 $par mois, tandis que le forfait Team coûte 25$ par utilisateur et par mois. Ces forfaits disposent de plafonds d’utilisation souples : les utilisateurs passent à un modèle plus petit au lieu d’être bloqués.
3. Niveaux tarifaires fondés sur les dépenses : à mesure que vous dépensez davantage au fil du temps, vous débloquez des limites de débit d’API plus élevées. Il s’agit d’un système d’augmentation de l’accès fondé sur la confiance et directement lié à votre historique de facturation.

​

Ce qui le rend unique

• Crédits libellés en monnaie fiduciaire : les crédits ressemblent à de l’argent, car ils sont libellés en USD. La tarification est ainsi transparente et facile à comprendre pour les développeurs.
• Aucune expiration : les soldes qui n’expirent jamais réduisent la pression de « l’utiliser ou le perdre ». Les utilisateurs peuvent recharger des montants plus importants en toute confiance, sachant que leur valeur ne disparaîtra pas.
• Mesure multidimensionnelle : les tokens d’entrée et de sortie sont suivis séparément, mais déduits du même solde de crédits. OpenAI peut ainsi facturer différemment les tokens de sortie, plus coûteux, et les tokens d’entrée, moins chers.
• Niveaux de confiance : lier les limites de débit aux dépenses totales encourage les utilisateurs à rester sur la plateforme et récompense les clients de longue date par de meilleures performances.

​

Avantages stratégiques

​

Construire ceci 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: '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 (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,
});

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

​

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

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

​

Implémenter des niveaux tarifaires fondés sur les dépenses

1. Suivre les dépenses cumulées : écoutez les webhooks payment.succeeded et mettez à jour un champ total_spend dans votre base de données pour ce client.
2. Définir les niveaux : créez une correspondance entre les montants dépensés et les 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 à 250 $ -> 50 RPM
3. Appliquer les limites : dans votre middleware d’API, vérifiez le niveau du client et appliquez la limite de débit correspondante.

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 d’implémentation complet : le proxy d’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: '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. Compteurs distincts : créez des compteurs séparés pour chaque modèle (par exemple, gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Événements pondérés : utilisez un compteur unique, mais multipliez la valeur tokens par un coefficient avant de l’envoyer à Dodo. Par exemple, si GPT-4o est 10 fois plus cher que GPT-4o-mini, vous pouvez envoyer 10 fois plus de tokens pour les requêtes GPT-4o.

​

Vue d’ensemble de l’architecture

​

Conclusion

​

Principales fonctionnalités de Dodo utilisées