Modello di fatturazione OpenAI

​

Perché il modello di OpenAI è lo standard

1. Entrate prevedibili e basso rischio: richiedendo crediti prepagati per l’utilizzo dell’API, OpenAI elimina il rischio che gli utenti accumulino bollette ingenti che non possono pagare. Ottieni i soldi in anticipo e l’utente ottiene il servizio mentre lo utilizza.
2. Scalabilità per gli sviluppatori: un top-up da 5 $ è una barriera di ingresso bassa. Man mano che l’applicazione cresce, gli sviluppatori possono automatizzare i ricarichi o acquistare pacchetti più grandi. La frizione per iniziare è quasi zero, ma il limite per la crescita è illimitato.
3. Psicologia dell’utente: denominare i crediti in valuta fiat (USD) invece di “token” o “punti” astratti rende il valore chiaro. Si percepisce come un conto bancario per i servizi AI, il che costruisce fiducia e rende più semplice il budgeting per le aziende.

​

Come fattura OpenAI

1. API (Pay-as-you-go): l’API utilizza crediti prepagati denominati in valuta fiat. Gli utenti ricaricano i propri conti con 5 $, 10 $, 50 $ o più. Questi crediti mostrano un valore in dollari ma non hanno valore monetario al di fuori di OpenAI. OpenAI fattura per token con tariffe diverse per i token in ingresso e in uscita. I crediti non scadono mai e quando il saldo dell’utente arriva a 0 $, le chiamate API falliscono immediatamente.
2. ChatGPT Plus, Team e Enterprise: sono abbonamenti a tariffa fissa. ChatGPT Plus costa 20 $ al mese, mentre il piano Team costa 25 $ per utente al mese. Questi piani hanno limiti di utilizzo morbidi in cui agli utenti viene assegnato un modello più piccolo invece di essere bloccati.
3. Fasce tariffarie basate sulla spesa: man mano che spendi più soldi nel tempo, sblocchi limiti di velocità API più elevati. Si tratta di un sistema di scalabilità dell’accesso basato sulla fiducia legato direttamente alla tua storia di fatturazione.

​

Cosa lo rende unico

• Crediti denominati in valuta fiat: i crediti si percepiscono come denaro perché sono espressi in USD. Questo rende i prezzi trasparenti e facili da comprendere per gli sviluppatori.
• Nessuna scadenza: saldi che non scadono mai riducono la pressione del “usali o li perdi”. Gli utenti si sentono a proprio agio nel ricaricare cifre maggiori perché sanno che il valore non scomparirà.
• Misurazione multidimensionale: i token in ingresso e in uscita vengono tracciati separatamente ma detratti dallo stesso saldo di credito. Questo permette a OpenAI di prezzi diversi per i token di uscita più costosi rispetto a quelli di ingresso più economici.
• Livelli di fiducia: collegare i limiti di velocità alla spesa totale incoraggia gli utenti a restare sulla piattaforma e premia i clienti a lungo termine con prestazioni migliori.

​

Vantaggi strategici

​

Costruisci questo 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: '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';
}

​

Accelera con il blueprint LLM Ingestion

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

​

Implementare fasce tariffarie basate sulla spesa

1. Monitora la spesa a vita: Ascolta i webhook payment.succeeded e aggiorna un campo total_spend nel tuo database per quel cliente.
2. Definisci le fasce: Crea una mappatura degli importi spesi ai limiti di velocità.
   • Fascia 1: spesa 0 $ - 50 $ -> 3 RPM
   • Fascia 2: spesa 50 $ - 250 $ -> 10 RPM
   • Fascia 3: spesa superiore a 250 $ -> 50 RPM
3. Applica i limiti: Nel middleware API, controlla la fascia del cliente e applica il limite di velocità corrispondente.

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 di implementazione completa: 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: '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' });
  }
}

​

Gestione dei casi limite

​

Condizioni di gara

​

Latenza nell’ingestione degli eventi

​

Gestione dei rimborsi

​

Supporto multi-modello

1. Contatori separati: crea contatori separati per ogni modello (ad esempio gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Eventi ponderati: usa un unico contatore ma moltiplica il valore tokens per un peso prima di inviarlo a Dodo. Ad esempio, se GPT-4o costa 10 volte più di GPT-4o-mini, potresti inviare 10 volte i token per le richieste GPT-4o. OpenAI utilizza internamente l’approccio dei contatori separati per mantenere registrazioni chiare dell’utilizzo per modello.

​

Panoramica architetturale

​

Conclusione

​

Principali funzionalità Dodo utilizzate

​

Conclusion

​

Key Dodo Features Used