Midjourney Billing Model

​

Comment Midjourney facture

1. Niveaux de tarification : Midjourney propose quatre niveaux d’abonnement allant de $10 à $120 par mois, chacun fournissant un nombre défini d’heures GPU rapides.
2. Relax Mode : Les plans Standard et supérieurs incluent des générations illimitées via une file à basse priorité une fois les heures rapides épuisées, garantissant que les utilisateurs ne rencontrent jamais de coupure brutale d’usage.
3. Heures GPU supplémentaires : Les utilisateurs peuvent acheter du temps GPU rapide additionnel pour environ $4 par heure s’ils ont besoin de résultats immédiats après avoir épuisé leur quota mensuel.
4. Mesure en secondes GPU : L’utilisation est suivie par le temps de calcul réel consacré aux générations, ce qui signifie que les rendus complexes coûtent plus que les brouillons simples.
5. Boucle communautaire : Les utilisateurs actifs peuvent gagner des heures GPU bonus en notant les images de la galerie, ce qui aide à entraîner les modèles tout en récompensant la communauté.

​

Ce qui le rend unique

• La facturation en temps GPU aligne le coût sur l’utilisation des ressources, garantissant que les rendus complexes sont tarifés équitablement par rapport aux brouillons simples.
• Relax Mode offre une solution de secours illimitée qui réduit le taux d’attrition en maintenant l’accès au service même après l’atteinte des limites mensuelles.
• La séparation Fast vs Relax incite aux montées en gamme en proposant un traitement prioritaire aux utilisateurs qui privilégient la rapidité et les résultats instantanés.
• Les heures GPU supplémentaires offrent une option de rechargement flexible pour les utilisateurs intensifs qui ont besoin de capacité prioritaire supplémentaire en cours de mois.

​

Reproduire cela avec 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'
});

​

Accélérez avec le blueprint Time Range Ingestion

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

​

L’architecture Fast vs Relax

1. Toutes les requêtes passent par votre application.
2. L’application compare le compteur d’usage Dodo au seuil gratuit du plan.
3. Si l’utilisation est inférieure au seuil, la requête est envoyée à la file Fast et est mesurée.
4. Si l’utilisation dépasse le seuil, la requête est dirigée vers la file Relax, qui n’est pas mesurée et a une priorité moindre.
5. Le plan Basic n’a pas de bascule Relax, donc les requêtes sont bloquées une fois la limite atteinte.

​

Fonctionnalités clés de Dodo utilisées