OpenAI Billing Model

​

Why OpenAI’s Model is the Standard

1. Ricavi prevedibili e rischio ridotto: poiché l’utilizzo dell’API è prepagato, gli utenti non possono accumulare fatture che non sono in grado di pagare. OpenAI riceve il denaro in anticipo e l’utente lo spende man mano che utilizza il servizio.
2. Scalabilità per gli sviluppatori: una ricarica di $5 rappresenta una barriera d’ingresso ridotta. Quando un’applicazione cresce, gli sviluppatori possono automatizzare le ricariche o acquistare pacchetti più grandi. Iniziare è economico e l’utilizzo può crescere senza cambiare piano.
3. Psicologia degli utenti: i crediti denominati in dollari statunitensi, invece di “token” o “punti” astratti, rendono chiaro il valore. Il saldo funziona come un conto prepagato per i servizi di AI, facilitando la gestione del budget per le aziende.

​

How OpenAI Bills

1. API (Pay-as-you-go): l’API utilizza crediti prepagati denominati in dollari. Gli utenti ricaricano i propri account con $5, $10, $50 o più. I crediti mostrano un valore in dollari, ma non possono essere utilizzati al di fuori di OpenAI. OpenAI applica i costi per token, con tariffe diverse per i token di input e di output. I crediti acquistati scadono un anno dopo l’acquisto e non sono rimborsabili (OpenAI Help Center). Quando il saldo raggiunge $0, le chiamate API hanno esito negativo.
2. ChatGPT Plus, Business e Enterprise: sono abbonamenti a tariffa fissa. ChatGPT Plus costa $20 al mese, mentre il piano Business (precedentemente Team) costa $25 per utente al mese con fatturazione mensile. Prevedono limiti di utilizzo flessibili: gli utenti più assidui passano a un modello più piccolo invece di essere bloccati.
3. Fasce tariffarie basate sulla spesa: man mano che la spesa totale aumenta nel tempo, l’account sblocca limiti di velocità API più elevati. L’accesso cresce in base alla cronologia di fatturazione.

​

Cosa lo rende unico

• Crediti denominati in valuta fiat: i crediti sono espressi in dollari statunitensi, quindi vengono percepiti come denaro. Gli sviluppatori possono leggere direttamente il prezzo di una richiesta.
• Scadenza lunga: i crediti acquistati durano un anno, riducendo la pressione del tipo “usalo o perdilo”. Gli utenti si sentono tranquilli nel ricaricare importi maggiori.
• Misurazione multidimensionale: i token di input e di output vengono conteggiati separatamente, ma scalati dallo stesso saldo. OpenAI può applicare ai costosi token di output un prezzo più elevato rispetto ai token di input.
• Livelli basati sulla fiducia: i limiti di velocità che aumentano con la spesa totale premiano i clienti di lunga data e li incoraggiano a rimanere.

​

Vantaggi strategici

​

Crea questo modello con 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';
}

​

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

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

​

Implementazione delle fasce tariffarie basate sulla spesa

1. Monitora la spesa complessiva: ascolta i webhook payment.succeeded e aggiungi l’importo del pagamento a un campo total_spend per quel cliente nel database. Gli importi sono espressi nell’unità più piccola della valuta, quindi 5000 corrisponde a $50,00.
2. Definisci le fasce: associa gli importi spesi ai limiti di velocità:
   • Fascia 1: spesa da $0 a $50 -> 3 RPM
   • Fascia 2: spesa da $50 a $250 -> 10 RPM
   • Fascia 3: spesa superiore a $250 -> 50 RPM
3. Applica i limiti: nel middleware API, individua la fascia del cliente e applica il relativo limite di velocità.

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

​

Esempio completo di implementazione: il 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' });
  }
}

​

Gestione dei casi limite

​

Race condition

​

Latenza nell’acquisizione degli eventi

​

Gestione dei rimborsi

​

Supporto per più modelli

1. Meter separati: crea un set di meter per modello, ad esempio gpt-4o.input_tokens e gpt-4o-mini.input_tokens, ciascuno con il proprio valore Meter units per credit.
2. Eventi ponderati: usa un meter e moltiplica tokens per un peso prima di inviare l’evento. Ad esempio, se GPT-4o costa 10 volte più di GPT-4o-mini, invia un numero di token 10 volte maggiore per le richieste GPT-4o.

​

Panoramica dell’architettura

​

Conclusione

​

Funzionalità principali di Dodo utilizzate