Modelo de Cobrança da OpenAI

​

Por que o modelo da OpenAI é o padrão

1. Receita previsível e baixo risco: Ao exigir créditos pré-pagos para o uso da API, a OpenAI elimina o risco de usuários acumularem faturas enormes que não conseguem pagar. Você recebe o dinheiro antecipadamente, e o usuário obtém o serviço conforme usa.
2. Escalabilidade para desenvolvedores: Um recarga de $5 é uma barreira de entrada baixa. Conforme a aplicação cresce, os desenvolvedores podem automatizar recargas ou comprar pacotes maiores. O atrito para começar é quase zero, mas o teto para crescimento é ilimitado.
3. Psicologia do usuário: Denominar créditos em moeda fiduciária (USD) em vez de “tokens” ou “pontos” abstratos torna o valor claro. Parece uma conta bancária para serviços de IA, o que gera confiança e facilita o planejamento financeiro para empresas.

​

Como a OpenAI cobra

1. API (pagamento conforme o uso): A API utiliza créditos pré-pagos denominados em moeda fiduciária. Os usuários recarregam suas contas com $5, $10, $50 ou mais. Esses créditos mostram um valor em dólares, mas não têm valor monetário fora da OpenAI. A OpenAI cobra por token com taxas diferentes para tokens de entrada e saída. Os créditos nunca expiram, e quando o saldo do usuário atinge $0, suas chamadas à API falham imediatamente.
2. ChatGPT Plus, Team e Enterprise: São assinaturas de valor fixo. O ChatGPT Plus custa $20 por mês, enquanto o plano Team custa $25 por usuário por mês. Esses planos têm limites de uso suaves, em que os usuários são rebaixados para um modelo menor em vez de serem bloqueados.
3. Camadas de tarifa baseadas em gastos: À medida que você gasta mais dinheiro total ao longo do tempo, desbloqueia limites de taxa de API mais altos. Esse é um sistema de escalonamento baseado em confiança vinculado diretamente ao seu histórico de cobrança.

​

O que o torna único

• Créditos denominados em moeda fiduciária: Os créditos parecem dinheiro porque são denominados em USD. Isso torna a precificação transparente e fácil de entender para os desenvolvedores.
• Sem expiração: Saldos que nunca expiram reduzem a pressão de “use ou perca”. Os usuários se sentem confortáveis em recarregar valores maiores porque sabem que o valor não vai desaparecer.
• Medidores multidimensionais: Tokens de entrada e saída são monitorados separadamente, mas deduzidos do mesmo saldo de créditos. Isso permite que a OpenAI precifique tokens de saída caros de forma diferente dos tokens de entrada mais baratos.
• Camadas de confiança: Vincular limites de taxa ao gasto total incentiva os usuários a permanecer na plataforma e recompensa clientes de longo prazo com melhor desempenho.

​

Vantagens estratégicas

​

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

​

Acelere com o Blueprint de Ingestão de LLM

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

​

Implementando camadas de tarifa baseadas em gasto

1. Monitore o gasto vitalício: Ouça os webhooks payment.succeeded e atualize um campo total_spend no banco de dados desse cliente.
2. Defina camadas: Crie um mapeamento de valores gastos para limites de taxa.
   • Camada 1: gasto de $0 a $50 -> 3 RPM
   • Camada 2: gasto de $50 a $250 -> 10 RPM
   • Camada 3: gasto acima de $250 -> 50 RPM
3. Aplique os limites: No middleware da sua API, verifique a camada do cliente e imponha o limite de taxa correspondente.

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

​

Lidando com casos de borda

​

Condições de corrida

​

Latência de ingestão de eventos

​

Tratamento de reembolsos

​

Suporte a múltiplos modelos

1. Medidores separados: Crie medidores separados para cada modelo (por exemplo, gpt-4o.input_tokens, gpt-4o-mini.input_tokens).
2. Eventos ponderados: Use um único medidor, mas multiplique o valor tokens por um peso antes de enviá-lo à Dodo. Por exemplo, se o GPT-4o for 10x mais caro que o GPT-4o-mini, você pode enviar 10x os tokens para as requisições GPT-4o.

​

Visão geral da arquitetura

​

Conclusão

​

Principais recursos da Dodo utilizados