Midjourney Billing Model

​

Comment Midjourney facture

1. Niveaux de tarification : Midjourney propose quatre niveaux d’abonnement, de $10 à $120 par mois. Chacun inclut une quantité définie de temps GPU Fast.
2. Relax Mode : les forfaits Standard et supérieurs incluent un nombre illimité de générations d’images dans une file d’attente à faible priorité une fois le temps Fast épuisé, afin que les utilisateurs ne soient pas bloqués.
3. Heures GPU supplémentaires : les utilisateurs peuvent acheter du temps GPU Fast supplémentaire pour $4 par heure lorsqu’ils ont besoin de résultats rapides après avoir utilisé leur allocation mensuelle.
4. Mesure en secondes GPU : l’utilisation est mesurée selon le temps GPU nécessaire à chaque génération, de sorte que les rendus complexes coûtent plus cher que les ébauches simples.
5. Boucle communautaire : les utilisateurs peuvent gagner du temps GPU gratuit en notant des images, ce qui contribue également à entraîner les modèles de Midjourney.

​

Ce qui le rend unique

• Facturation au temps GPU : les rendus complexes sont facturés plus cher que les ébauches simples, conformément à leur coût de calcul.
• Relax Mode est une solution de secours illimitée qui réduit le churn, car les utilisateurs conservent l’accès une fois l’allocation mensuelle épuisée.
• La distinction Fast/Relax encourage les mises à niveau en vendant un traitement prioritaire aux utilisateurs qui accordent de l’importance à la rapidité.
• Les heures GPU supplémentaires permettent aux utilisateurs intensifs d’acheter en cours de mois une capacité prioritaire supplémentaire.

​

Créer ce modèle avec Dodo Payments

// getCustomerUsage, getSubscription, getThresholdForPlan, and queueGeneration are
// your application's own functions. getCustomerUsage can sum this cycle's events
// from client.usageEvents.list() or read a counter your app maintains.
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 === 'pdt_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: 'pdt_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: 'pdt_mj_standard', quantity: 1 }
  ],
  customer: { email: 'artist@example.com' },
  return_url: 'https://yourapp.com/studio'
});

​

Accélérer avec le blueprint d’ingestion par plage temporelle

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

// runGeneration, prompt, settings, and customerId come from your application.
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',
  },
});

​

Architecture Fast vs Relax

1. Toutes les requêtes passent par votre application.
2. L’application compare l’utilisation Fast GPU du client au seuil gratuit du forfait.
3. Si l’utilisation est inférieure au seuil, la requête est envoyée vers la file Fast et comptabilisée.
4. Si l’utilisation dépasse le seuil, la requête est envoyée vers la file Relax, qui n’est pas comptabilisée et possède une priorité inférieure.
5. Le forfait Basic ne dispose d’aucune solution de secours Relax ; l’application bloque donc les requêtes une fois la limite atteinte.

​

Principales fonctionnalités de Dodo utilisées