Modelo de Cobrança da OpenAI

​

Por que o modelo da OpenAI é o padrão

1. Receita previsível e baixo risco: como o uso da API é pré-pago, os usuários não podem acumular contas que não conseguem pagar. A OpenAI recebe o dinheiro antecipadamente, e o usuário o gasta conforme utiliza o serviço.
2. Escalabilidade para desenvolvedores: uma recarga de $5 é uma barreira de entrada baixa. Conforme um aplicativo cresce, os desenvolvedores podem automatizar recargas ou comprar pacotes maiores. Começar é barato, e o uso pode crescer sem alterar o plano.
3. Psicologia do usuário: créditos denominados em dólares americanos, em vez de “tokens” ou “pontos” abstratos, tornam o valor claro. O saldo funciona como uma conta pré-paga para serviços de IA, o que facilita o orçamento das empresas.

​

Como a OpenAI cobra

1. API (Pay-as-you-go): A API usa créditos pré-pagos denominados em dólares. Os usuários adicionam $5, $10, $50 ou mais às suas contas. Os créditos exibem um valor em dólares, mas não podem ser usados fora da OpenAI. A OpenAI cobra por token, com tarifas diferentes para tokens de entrada e de saída. Os créditos adquiridos expiram um ano após a compra e não são reembolsáveis (Central de Ajuda da OpenAI). Quando o saldo chega a $0, as chamadas da API falham.
2. ChatGPT Plus, Business e Enterprise: Esses são planos de assinatura com preço fixo. O ChatGPT Plus custa $20 por mês, e o plano Business (anteriormente Team) custa $25 por usuário por mês quando cobrado mensalmente. Eles têm limites flexíveis de uso: usuários intensivos passam para um modelo menor em vez de serem bloqueados.
3. Níveis de tarifa baseados em gastos: À medida que o gasto total aumenta ao longo do tempo, a conta desbloqueia limites de taxa de API mais altos. O acesso aumenta de acordo com o histórico de cobrança.

​

O que o torna único

• Créditos denominados em moeda fiduciária: Os créditos são em dólares americanos, então parecem dinheiro. Os desenvolvedores podem ler diretamente o preço de uma solicitação.
• Validade longa: Os créditos adquiridos duram um ano, reduzindo a pressão de “use ou perca”. Os usuários se sentem confortáveis ao adicionar quantias maiores.
• Medição multidimensional: Os tokens de entrada e saída são rastreados separadamente, mas descontados do mesmo saldo. A OpenAI pode cobrar mais pelos tokens de saída, que são mais caros, do que pelos tokens de entrada.
• Níveis de confiança: Limites de taxa que aumentam com o gasto total recompensam clientes de longo prazo e os incentivam a permanecer.

​

Vantagens estratégicas

​

Crie isso com 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';
}

​

Acelere com o 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);

​

Implementando níveis de tarifa baseados em gastos

1. Acompanhe o gasto acumulado: Escute os webhooks payment.succeeded e adicione o valor do pagamento a um campo total_spend desse cliente no seu banco de dados. Os valores estão na menor unidade monetária, portanto 5000 equivale a $50,00.
2. Defina os níveis: Mapeie os valores de gasto para os limites de taxa:
   • Nível 1: gasto de $0 a $50 -> 3 RPM
   • Nível 2: gasto de $50 a $250 -> 10 RPM
   • Nível 3: gasto de $250 ou mais -> 50 RPM
3. Aplique os limites: No middleware da sua API, consulte o nível do cliente e aplique seu limite de taxa.

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

​

Exemplo completo de implementação: o proxy da 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' });
  }
}

​

Lidando com casos extremos

​

Condições de corrida

​

Latência de ingestão de eventos

​

Tratamento de reembolsos

​

Suporte a vários modelos

1. Medidores separados: Crie um conjunto de medidores por modelo, por exemplo gpt-4o.input_tokens e gpt-4o-mini.input_tokens, cada um com seu próprio Meter units per credit.
2. Eventos ponderados: Use um medidor e multiplique tokens por um peso antes de enviar o evento. Por exemplo, se o GPT-4o custar 10 vezes mais que o GPT-4o-mini, envie 10 vezes mais tokens para as solicitações do GPT-4o.

​

Visão geral da arquitetura

​

Conclusão

​

Principais recursos do Dodo usados