OpenAI:s faktureringsmodell

​

Varför OpenAI:s modell är standarden

1. Förutsägbara intäkter och låg risk: Genom att kräva förbetalda krediter för API-användning eliminerar OpenAI risken att användare bygger upp enorma räkningar som de inte kan betala. Du får pengarna i förväg och användaren får tillgång till tjänsten efter hand.
2. Skalbarhet för utvecklare: En påfyllning på $5 är en låg tröskel för att komma igång. När applikationen växer kan utvecklare automatisera påfyllningar eller köpa större paket. Friktionen för att börja är nästan obefintlig, medan tillväxtpotentialen är obegränsad.
3. Användarpsykologi: Att ange krediter i fiatvaluta (USD) i stället för abstrakta “tokens” eller “poäng” gör värdet tydligt. Det känns som ett bankkonto för AI-tjänster, vilket bygger förtroende och gör det enklare för företag att planera sin budget.

​

Så fakturerar OpenAI

1. API (betala efter användning): API:et använder förbetalda krediter angivna i fiatvaluta. Användare fyller på sina konton med $5, $10, $50 eller mer. Krediterna visar ett dollarvärde men har inget penningvärde utanför OpenAI. OpenAI fakturerar per token med olika priser för input- och outputtokens. Krediter löper aldrig ut, och när en användares saldo når $0 misslyckas deras API-anrop omedelbart.
2. ChatGPT Plus, Team och Enterprise: Det här är abonnemang till fast pris. ChatGPT Plus kostar $20 per månad, medan Team-planen kostar $25 per användare och månad. Dessa planer har mjuka användningsgränser där användare i stället nedgraderas till en mindre modell än blockeras.
3. Förbrukningsbaserade prisnivåer: När du över tid spenderar mer pengar totalt låser du upp högre API-hastighetsgränser. Det här är ett förtroendebaserat system för åtkomstskalning som är direkt kopplat till din faktureringshistorik.

​

Vad gör den unik

• Fiatbaserade krediter: Krediter känns som pengar eftersom de anges i USD. Det gör prissättningen transparent och enkel för utvecklare att förstå.
• Ingen förfallotid: Saldon som aldrig förfaller minskar pressen att “använda eller förlora” värdet. Användare känner sig bekväma med att fylla på större belopp eftersom de vet att värdet inte försvinner.
• Flerdimensionell mätning: Input- och outputtokens spåras separat men dras från samma kreditsaldo. Det gör att OpenAI kan prissätta dyrare outputtokens annorlunda än billigare inputtokens.
• Förtroendenivåer: Genom att koppla hastighetsgränser till den totala förbrukningen uppmuntras användare att stanna på plattformen, samtidigt som långvariga kunder belönas med bättre prestanda.

​

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

​

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

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 förbrukningsbaserade prisnivåer

1. Spåra total förbrukning: Lyssna efter payment.succeeded-webhooks och uppdatera ett total_spend-fält i databasen för kunden.
2. Definiera nivåer: Skapa en mappning mellan förbrukningsbelopp och hastighetsgränser.
   • Nivå 1: $0–$50 i förbrukning -> 3 RPM
   • Nivå 2: $50–$250 i förbrukning -> 10 RPM
   • Nivå 3: $250+ i förbrukning -> 50 RPM
3. Tillämpa gränser: Kontrollera kundens nivå i API-mellanlagret och tillämpa motsvarande hastighetsgräns.

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: '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ändelseintag

​

Hantera återbetalningar

​

Stöd för flera modeller

1. Separata mätare: Skapa separata mätare för varje modell (t.ex. gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Viktade händelser: Använd en enda mätare men multiplicera värdet i tokens med en vikt innan du skickar det till Dodo. Om GPT-4o exempelvis är 10 gånger dyrare än GPT-4o-mini kan du skicka 10 gånger så många tokens för GPT-4o-begäranden.

​

Arkitekturöversikt

​

Slutsats

​

Viktiga funktioner i Dodo som används