OpenAI:s faktureringsmodell

​

Varför OpenAI:s modell är standarden

1. Förutsägbara intäkter och låg risk: Eftersom API-användningen betalas i förskott kan användare inte samla på sig räkningar som de inte kan betala. OpenAI får pengarna i förskott och användaren förbrukar dem i takt med att tjänsten används.
2. Skalbarhet för utvecklare: En påfyllning på $5 är en låg tröskel för att komma igång. När en applikation växer kan utvecklare automatisera påfyllningar eller köpa större paket. Det är billigt att börja och användningen kan öka utan att planen behöver ändras.
3. Användarpsykologi: Krediter angivna i amerikanska dollar, i stället för abstrakta “tokens” eller “poäng”, gör värdet tydligt. Saldo fungerar som ett förbetalt konto för AI-tjänster, vilket gör det enklare för företag att budgetera.

​

Så fakturerar OpenAI

1. API (Pay-as-you-go): API:et använder förbetalda krediter denominerade i dollar. Användare fyller på sina konton med $5, $10, $50 eller mer. Krediterna visar ett dollarvärde men kan inte användas utanför OpenAI. OpenAI debiterar per token, med olika priser för input- och output-tokens. Köpta krediter upphör att gälla ett år efter köpet och återbetalas inte (OpenAI Help Center). När saldot når $0 misslyckas API-anrop.
2. ChatGPT Plus, Business, and Enterprise: Detta är abonnemang till fast pris. ChatGPT Plus kostar $20 per månad och Business-planen (tidigare Team) kostar $25 per användare och månad vid månadsvis debitering. De har mjuka användningsgränser: användare med hög användning flyttas till en mindre modell i stället för att blockeras.
3. Spend-based rate tiers: När de totala utgifterna ökar över tid låser kontot upp högre API-gränser. Åtkomsten utökas baserat på faktureringshistoriken.

​

Vad gör det unikt

• Fiat-denominerade krediter: Krediterna anges i amerikanska dollar, så de känns som pengar. Utvecklare kan läsa priset för en begäran direkt.
• Lång giltighetstid: Köpta krediter gäller i ett år, vilket minskar pressen att “använda eller förlora dem”. Användare känner sig trygga med att fylla på större belopp.
• Flerdimensionell mätning: Input- och output-tokens spåras separat men dras från samma saldo. OpenAI kan prissätta dyrare output-tokens högre än input-tokens.
• Förtroendenivåer: API-gränser som ökar med de totala utgifterna belönar långvariga kunder och uppmuntrar dem att stanna kvar.

​

Strategiska fördelar

​

Bygg detta med 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';
}

​

Snabba upp med 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);

​

Implementera spend-baserade gränsnivåer

1. Spåra totala utgifter: Lyssna efter webhookar från payment.succeeded och lägg till betalningsbeloppet i ett total_spend-fält för kunden i din databas. Belopp anges i den minsta valutaenheten, så 5000 motsvarar $50,00.
2. Definiera nivåer: Mappa utgiftsbelopp till API-gränser:
   • Nivå 1: $0–$50 i utgifter -> 3 RPM
   • Nivå 2: $50–$250 i utgifter -> 10 RPM
   • Nivå 3: $250+ i utgifter -> 50 RPM
3. Tillämpa gränser: Slå upp kundens nivå i ditt API-middleware och tillämpa dess gräns.

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

​

Fullständigt implementeringsexempel: API-proxyn

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

​

Hantera specialfall

​

Race conditions

​

Fördröjning vid händelseimport

​

Hantera återbetalningar

​

Stöd för flera modeller

1. Separata meters: Skapa en uppsättning meters per modell, till exempel gpt-4o.input_tokens och gpt-4o-mini.input_tokens, var och en med egna inställningar för Meter units per credit.
2. Viktade händelser: Använd en meter och multiplicera tokens med en vikt innan händelsen skickas. Om GPT-4o till exempel kostar tio gånger så mycket som GPT-4o-mini skickar du tio gånger så många tokens för GPT-4o-begäranden.

​

Arkitekturöversikt

​

Slutsats

​

Viktiga Dodo-funktioner som används