Modelo de Cobrança do Midjourney

​

Como o Midjourney cobra

1. Camadas de preços: o Midjourney oferece quatro níveis de assinatura que variam de $10 a$120 por mês, cada um fornecendo uma quantidade definida de horas de GPU rápida.
2. Modo Relax: os planos Standard e superiores incluem gerações ilimitadas em uma fila de baixa prioridade assim que as horas rápidas acabam, garantindo que os usuários nunca encontrem um limite rígido de uso.
3. Horas extras de GPU: os usuários podem comprar tempo adicional de GPU Rápida por aproximadamente $4 por hora caso precisem de resultados imediatos após esgotar o valor mensal.
4. Medição em segundos de GPU: o uso é monitorado pelo tempo computacional real gasto nas gerações, o que significa que renderizações complexas custam mais do que rascunhos simples.
5. Loop da comunidade: usuários ativos podem ganhar horas de GPU bônus avaliando imagens na galeria, o que ajuda a treinar modelos enquanto recompensa a comunidade.

​

O que o torna único

• Cobrança por tempo de GPU alinha o custo ao uso de recursos, garantindo que renderizações complexas sejam precificadas de forma justa em comparação com rascunhos simples.
• Modo Relax oferece um fallback ilimitado que reduz o churn ao manter o acesso ao serviço mesmo após os limites mensais serem atingidos.
• A divisão Fast vs Relax incentiva upgrades ao oferecer processamento prioritário para usuários que valorizam velocidade e resultados imediatos.
• Horas extras de GPU fornecem uma opção flexível de recarga para usuários avançados que precisam de capacidade adicional de alta prioridade no meio do mês.

​

Construa isso com Dodo Payments

async function handleGenerationRequest(customerId: string, prompt: string) {
  const usage = await getCustomerUsage(customerId, 'gpu.fast_seconds');
  const subscription = await getSubscription(customerId);
  const threshold = getThresholdForPlan(subscription.product_id);
  
  if (usage.current >= threshold) {
    if (subscription.product_id === 'prod_basic') {
      throw new Error('Fast GPU hours exhausted. Upgrade to Standard for Relax Mode.');
    }
    
    // Relax Mode. Route to low-priority queue
    return await queueGeneration(customerId, prompt, {
      priority: 'low',
      mode: 'relax',
      model: 'standard'
    });
  }
  
  // Fast Mode. Priority processing
  return await queueGeneration(customerId, prompt, {
    priority: 'high',
    mode: 'fast',
    model: 'premium'
  });
}

import DodoPayments from 'dodopayments';

async function trackFastGeneration(customerId: string, gpuSeconds: number, jobId: string) {
  // Only track Fast mode generations. Relax mode is free and unlimited
  const client = new DodoPayments({
    bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  });

  await client.usageEvents.ingest({
    events: [{
      event_id: `gen_${jobId}`,
      customer_id: customerId,
      event_name: 'gpu.fast_seconds',
      timestamp: new Date().toISOString(),
      metadata: {
        gpu_seconds: gpuSeconds,
        resolution: '1024x1024',
        mode: 'fast'
      }
    }]
  });
}

// After customer purchases extra hours
const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'prod_extra_gpu_hour', quantity: 5 }
  ],
  customer: { customer_id: customerId },
  return_url: 'https://yourapp.com/dashboard'
});

const session = await client.checkoutSessions.create({
  product_cart: [
    { product_id: 'prod_mj_standard', quantity: 1 }
  ],
  customer: { email: 'artist@example.com' },
  return_url: 'https://yourapp.com/studio'
});

​

Acelere com o Blueprint de Ingestão por Faixa de Tempo

npm install @dodopayments/ingestion-blueprints

import { Ingestion, trackTimeRange } from '@dodopayments/ingestion-blueprints';

const ingestion = new Ingestion({
  apiKey: process.env.DODO_PAYMENTS_API_KEY,
  environment: 'live_mode',
  eventName: 'gpu.fast_seconds',
});

// Track generation time after a Fast mode job completes
const startTime = Date.now();
const result = await runGeneration(prompt, settings);
const durationMs = Date.now() - startTime;

await trackTimeRange(ingestion, {
  customerId: customerId,
  durationMs: durationMs,
  metadata: {
    mode: 'fast',
    resolution: '1024x1024',
  },
});

​

A arquitetura Fast vs Relax

1. Todas as requisições passam pela sua aplicação.
2. A aplicação verifica o medidor de uso do Dodo em relação ao limite gratuito do plano.
3. Se o uso estiver abaixo do limite, a requisição vai para a fila Fast e é metrificada.
4. Se o uso estiver acima do limite, a requisição vai para a fila Relax, que não é metrificada e tem prioridade menor.
5. O plano Basic não tem fallback de Relax, então as requisições são bloqueadas assim que o limite é atingido.

​

Principais recursos do Dodo usados